C++：tuple

sdb::status_t CDidInterface::sdbSubscibeSignal(const sdb::registerId_t &registerId)
{
    sdb::registerId_t regId = registerId;
    sdb::status_t subscribeResult = sdb::status_t::E_SDB_ERROR_INVALID_ARGUMENT;
    sdb::status_t getSignalsResult = sdb::status_t::E_SDB_ERROR_INVALID_ARGUMENT;

    std::vector<std::tuple<sdb::status_t, sdb::signalName_t, sdb::SignalInfo>> signals_data;
    std::vector<sdb::signalName_t> signalNameList;

    uint32_t pkt_size = PKT_MAX_SIZE;
    uint32_t nItem = 0;

    while( nItem < registerSignals.size() )
    {
        pkt_size = (registerSignals.size() - nItem) > PKT_MAX_SIZE ? PKT_MAX_SIZE : (registerSignals.size() - nItem);

        SPAM("registerPktSignals: %d/%d/%d\n",nItem, nItem + pkt_size, registerSignals.size());

        std::vector<sdb::SignalRegister> registerPktSignals(registerSignals.begin() + nItem, registerSignals.begin() + nItem + pkt_size);

        subscribeResult = SdbApiIf::getClient().subscribe_signals(registerPktSignals, regId, onSubscribe);

        if (subscribeResult != sdb::status_t::E_SDB_ERROR_NONE)
        {
            ERR("Failed, incomplete subcription(%d): %d/%d/%d\n", subscribeResult, nItem, nItem + pkt_size, registerSignals.size());
            return subscribeResult;
        }
        else
        {
            (void)usleep(100000); // wait 100ms between subscription blocks
            INFO("signals: %d/%d/%d success\n",nItem, nItem+pkt_size, registerSignals.size());
        }

        signalNameList.clear();
        for(unsigned int i = 0; i < registerPktSignals.size(); i++)
        {
            signalNameList.push_back(registerPktSignals[i].signalName);
        }

        signals_data.clear();
        getSignalsResult = SdbApiIf::getClient().get_signals(signalNameList, signals_data);

        if(getSignalsResult != sdb::status_t::E_SDB_ERROR_NONE)
        {
            ERR("Failed to get signals value. Result value: %d\n", getSignalsResult);
        }
        else
        {
            std::vector<std::pair<sdb::signalName_t, sdb::SignalInfo>> signals;
            std::pair<sdb::signalName_t, sdb::SignalInfo> signal_pair;

            for(auto const& signal_data : signals_data)
            {
                if(std::get<0>(signal_data) == sdb::e_SDB_Error_t::E_SDB_ERROR_NONE)
                {
                    signal_pair.first = std::get<1>(signal_data);
                    signal_pair.second = std::get<2>(signal_data);
                    signals.push_back(signal_pair);
                    INFO("%s signal name: %s\n", __PRETTY_FUNCTION__, signal_pair.first.c_str());
                }
            }

            onSubscribe(signals, regId);
        }

        regId++;
        nItem += pkt_size;
    }

    return subscribeResult;
}