在C ++ 11中结合使用std :: function和union

Question

I am trying to define a class that has functions with different numbers of parameters stored in a union. The class is initialized with a function object and necessary parameters. I am getting these compiler errors at the locations marked (1) and (2)

(1) Destructor of '_' is implicitly deleted because variant field 'f_V' has a non-trivial destructor

(2) Destructor of 'MyClass' is implicitly deleted because field 'functions' has a deleted destructor

I simply want to declare a union of different function objects, and depending on the parameters passed-in be able to pick the appropriate function and call it. Why am I getting these errors and how should I rewrite this code?

template<typename VARIABLE> struct MyClass {
    MyClass(VARIABLE *p, const std::function<void (VARIABLE&)>& f) {
        functions.f_V = f;
        ...
    }
protected:
    union _ {
        std::function<void (VARIABLE &)> f_V; // (1)
        std::function<void (const VARIABLE &, VARIABLE &)> f_vV;
        std::function<void (const VARIABLE &, const VARIABLE &, VARIABLE &)> f_vvV;
        std::function<void (const VARIABLE &, const VARIABLE &, const VARIABLE &, VARIABLE &)> f_vvvV;
    } functions; // (2)
    ...
 };

EDIT: I am trying to accomplish storage of lambda functions having variable argument lists in a container. Something like this:

std::vector<MyClass<MyVariable>> myContainerOfLambdas;
MyVariable A,B,TO;
auto lambda1 = [this](const MyVariable& a, MyVariable& to) { ... };
myContainerOfLambdas.push_back(MyClass<MyVariable>(A,TO,lambda1));
auto lambda2 = [this](const MyVariable& a, const MyVariable& b, MyVariable& to) { ... };
myContainerOfLambdas.push_back(MyClass<MyVariable>(A,B,TO,lambda2));
...
// iterate over the stored MyClass objects holding the lamda functions and the parameters
// to call them
for(MyClass<MyVariable> & e:myContainerOfLambdas) {
  e(); // here the appropriate lambda function will be invoked with the appropriate values
  // stored in MyClass
}

NOTE: For brevity I have omitted the definition of the () operator in MyClass, but it simply calls the right function object with the right parameters.

If you see a better design approach to this, fine, please direct me in the right direction. Thanks!

Answer 1

You can use the unrestricted unions feature of C++11 to do with you want. You will need to implement a custom constructor and destructor on the union that constructs/deletes the appropriate active member.