Присвоение значения переменной vector of tuple

    Elevator::current_floor = 8;
    std::get<1>(loaded_users[0])=  Elevator::current_floor; 
    Elevator::current_floor = 17;
 
    for (const auto &i : loaded_users)
        std::cout<< std::get<1>(i) << std::endl;

....while ()
 
int Elevation::Loaded_Pass_to_Dest(std::vector< std::tuple<int, int, int> >& active_users, int dst_floor_end)
{
    int *ucf = &std::get<1>(active_users[0]);
    
    
    
    for (int j=0;j<active_users.size();j++)
    {   
    int *u_begin[k] = &std::get<1>(active_users[k]);    
    int *u_dest[k] = &std::get<2>(active_users[k]);
    }
    
//  while (Elevator::current_floor!=dst_floor_end) {....
    
    
    if (Elevator::current_floor > dst_floor_end)
    {
        direction= DOWN;
        El_Move(direction); // set dir 
    }
    
    if (Elevator::current_floor < dst_floor_end) // set dir
    {   direction= DOWN;
        El_Move(direction);
    }
    
    
        for (int k=0;k<active_users.size();k++)
    {   
       if (Elevator::current_floor==&std::get<1>(active_users[k])) 
           {
       El_Move(LOAD);    
     [B]  // std::get<1>(active_users[k]=& Elevator::current_floor;[/B]
 
       
       
       Elevator::loaded.push_back({ std::get<0>(active_users[k]),std::get<1>(active_users[k]),std::get<2>(active_users[k) });
           }
            if (Elevator::current_floor==&std::get<2>(active_users[k])) 
           {
       El_Move(UNLOAD);    
       &std::get<1>(active_users[k]=Elevator::current_floor;
       Elevator::loaded.push_back({ std::get<0>(active_users[k]),std::get<1>(active_users[k]),std::get<2>(active_users[k) });
           }
           
    }
    }
    int Elevation:: El_Move(direction dir, & active_users )
 
{
    switch (dir)
    {
    case UP:
        Elevator::current_floor = Elevator::current_floor++;
        std::cout << "Elevator moves to " << Elevator::current_floor << std::endl;
        timer = timer + 5;
        break;
    case DOWN:
        Elevator::current_floor = --Elevator::current_floor;
        std::cout << "Elevator moves to " << Elevator::current_floor << std::endl;
        timer = timer + 5;
        break;
    case LOAD:
        Elevator::User_Open_Door_Load();
        timer = timer + 6;
        
        break;
    case UNLOAD:
        Elevator::User_Open_Door_UnLoad();
        timer = timer + 6;
        break;
    }
    return Elevator::current_floor;
}

//где-то 
loaded_users[10];
////////////////
////////////////
int current_floor = 8;
loaded_users[0]=current_floor;
current_floor = 17;

#include <iostream>
#include <vector>
#include <tuple>
#include <functional>
using namespace std;
int main()
{
 tuple<int, int, int> tupa[]{{1,2,3}, {4,5,6}};
 vector<reference_wrapper<tuple<int, int, int>>> tupV(begin(tupa), end(tupa));
get<0>(tupa[0])=345;
 tuple<int, int, int> &tupo=tupV[0];
 cout<<get<0>(tupo);
 cout<<endl;
get<0>(tupa[0])=456;
 cout<<get<0>(tupo);
 
cin.get();
return 0;
}

    while (Elevator::current_floor != * dst_floor_end)
    {
    El_to_Pass_to_Dest( * dst_floor_end, active_users);
 
    };
El_to_Pass_to_Dest содержит Loaded_Pass_to_Dest
 
int Elevation::Loaded_Pass_to_Dest(std::vector< std::tuple<int, int, int> >& active_users, int dst_floor, direction dx)
{
 
    El_Move(dx); // just floor increment and timer counter inc
 
    for (int k = 0; k < active_users.size(); k++)
    {
 
        if (Elevator::current_floor ==  std::get<1>(active_users[k]))
        {
 
            Elevator::loaded.push_back({ std::get<0>(active_users[k]) });
        
        }
 
        if (Elevator::current_floor == std::get<2>(active_users[k]))
        {
        
            for (int j=0;j< Elevator::loaded.size();j++)
                if (std::get<0>(active_users[k]) == (Elevator::loaded[j]))
 
                {
                    Elevator::loaded.erase(Elevator::loaded.begin() + j);
 
                }           
        }
 
    }
    return Elevator::current_floor;
}

void Elevation::Move_Call(std::vector< std::tuple<int, int, int> > &passengers)
{
    int *dst_floor_end = NULL;
    int  ucf = std::get<1>(passengers[0]);
    int dst_floor = std::get<2>(passengers[0]);
    std::vector <direction> direct;
 
    for (int k = 0; k < passengers.size(); k++)
    {
        int userid = std::get<0>(passengers[k]);
        int cur_fl_queue = std::get<1>(passengers[k]);
        int dst_queue = std::get<2>(passengers[k]);
        if (cur_fl_queue > dst_queue) d1 = DOWN;
        if (cur_fl_queue < dst_queue) d1 = UP;
        direct.push_back(d1);
 
        if (direct[k] == direct[0])
        {
            if ((direct[k] == UP)  & (cur_fl_queue >= ucf) & (cur_fl_queue <= dst_floor))
            {
                Elevation::active_users.push_back({ userid,cur_fl_queue,dst_queue });
                //passengers.erase(passengers.begin() + k);
                auto level_floor = &std::get<2>(*std::max_element(active_users.begin(), active_users.end(),
                    [](auto& l, auto& r) {return std::get<2>(l) < std::get<2>(r); }));
                dst_floor_end = level_floor;
            }
 
            if ((direct[k] == DOWN)  & (cur_fl_queue <= ucf) & (cur_fl_queue >= dst_floor))
            {
                Elevation::active_users.push_back({ userid,cur_fl_queue,dst_queue });
            //  passengers.erase(passengers.begin() + k);
                auto level_floor = &std::get<2>(*std::min_element(active_users.begin(), active_users.end(),
                    [](auto& l, auto& r) {return std::get<2>(l) < std::get<2>(r); }));
                dst_floor_end = level_floor;
            }
        }
    }