forward_as_tuple을 사용하여 레거시 함수 시그너처에 매개 변수 팩 전달

Question

내 앱에서 레거시 함수 시그너처를 통해 매개 변수 팩을 전달하고 값을 변경하고자합니다. 내 시도를 코멘트로 묘사 한 코드는 다음과 같습니다.

#include <tuple> 
#include <cassert> 

void LegacySignature(void* param); 

template< typename... ArgsT > 
// using ???; // attempt: can 'template alias' or 'using declaration' make the pack's type visible so I can use it inside the LegacyFunction? 
void MyFunc(ArgsT&... args) 
{ 
    auto userArgsTuple = std::forward_as_tuple< ArgsT&... >(args...); 

    LegacySignature(&userArgsTuple); 
} 

void LegacySignature(void* param) 
{ 
// auto userArgsTuple = reinterpret_cast<???>(param); // attempt: how can I get the parameter pack's type declared so I can use it here? 

    // do something with the params like change num to 44 and tf to true; 
    //userArgsTuple->num = 44; // desired functionality 
    //userArgsTuple->tf = true; // desired functionality 
} 

int main() 
{ 
    int num { 33 }; 
    bool tf { false }; 
    MyFunc(num, tf); 
    assert(num == 44 && tf == true); 

    return 0; 
} 

매개 변수 팩을 선언 가능한 왼쪽 값으로 만드는 방법이 있습니까?

Answer 1

아래 코드는 샘플 코드를 수정하여 forward_as_tuple을 사용하여 레거시 함수 서명에 매개 변수 팩을 전달하는 방법에 대한 질문에 대답합니다.

#include <tuple> 
#include <cassert> 
#include <memory> 
#include <functional> 

#define ARGSET int, bool 

void LegacySignature(long* param); // ie, LPARAM 

template< typename... ArgsT > 
struct MyParams 
{ 
    MyParams(ArgsT... args) : rvalRefs { std::forward_as_tuple(args...) } {} // The resulting forward_as_tuple tuple has rvalue reference data members 
    std::tuple<ArgsT...> rvalRefs; 
}; 


void LegacySignature(long* legSigParam) 
{ 
    auto userArgsTuple(reinterpret_cast< MyParams<ARGSET>* >(legSigParam)); 

    // do something with the params like change num to 44 and tf to true; 
    std::get<0>(userArgsTuple->rvalRefs) = 44; // index types can probably be worked out using enums 
    std::get<1>(userArgsTuple->rvalRefs) = true; 
} 

int main() 
{ 
    int num { 33 }; 
    bool tf { false }; 
    MyParams<ARGSET> myParams(num, tf); 

    std::unique_ptr< MyParams<ARGSET> > legSigParamPtr = std::make_unique< MyParams<ARGSET> >(myParams); 
    LegacySignature((long*)legSigParamPtr.get()); 
    assert(std::get<0>(legSigParamPtr->rvalRefs) == 44 && std::get<1>(legSigParamPtr->rvalRefs) == true); 

    return 0; 
} 

Answer 2

내가 원하는 것은 기존 서명에 대한 함수 포인터입니다.

다음은 C++ 11 접근 방식입니다.

template<class Sig, class F> 
struct magic_callback_t; 

template<class R, class...Args, class F> 
struct magic_callback_t<R(Args...), F> { 
    F f; 
    void* pvoid() const { return this; } 
    using result_sig = R(*)(void*, Args...); 
    result_sig pfunc() const { 
    return [](void* pvoid, Args...args)->R{ 
     auto* self = static_cast<magic_callback_t*>(pvoid); 
     return (self->f)(std::forward<Args>(args)...); 
    }; 
    } 
}; 
template<class Sig, class F> 
magic_callback_t<Sig, F> magic_callback(F&& f) { 
    return {std::forward<F>(f)}; 
} 

이제 우리는이 작업을 수행 :

auto callback = magic_callback([&](){ 
    // use whatever as if we where in the enclosing scope 
}); 

void(*)(void*) legacy_ptr = callback.pfunc(); 
legacy_ptr(callback.pvoid()); 

는 magic_callback에 전달 된 람다를 호출합니다.

튜플로 물건을 저장하려는 경우 할 수 있습니다. 람다에서 튜플을 캡처 한 다음 std::get을 사용하여 람다 본문에 액세스하십시오. 변경할 수 있으려면 mutable을 사용하십시오.