Create a templated variable within a templated class of a different type

Question

I'm not sure what I am asking for is possible.

I have a templated class called Controller. This is a variadic template class which takes multiple classes and can set their values as such.

Controller<ClassA,ClassB,ClassC>* myController = new Controller<ClassA,ClassB,ClassC>(*a,*b,*c); 
myController->setValues(32);

This takes a bunch of different classes together and allows me to to set their values at the same time. setValues is a templated function which allows any type to be passed in. However, right now I am trying to modify my class so that I can set a value within the controller itself for easy retrieval. However this is the part that is proving difficult.

template<typename...Classes>
class Controller
{
  public:
    Controller(Classes&...objects) : objects(objects...){}
    Controller(std::tuple<Classes&...> tup) : objects(tup){}

    template<typename T>
    void setValues(T value)
    {
      std::apply([&](auto&...x) { x.updateValue(value),...);}, objects); //calls the updateValue function for each class
    }

  private:
    std::tuple<Classes&...> objects;
};

I want to add the following as a private variable T controllerValue; However, I know that I cannot simply declare T because we cannot define member templates and the compiler has no idea what to expect. Which then I tried to create a private struct:

template<typename T>
struct ControllerValue { T value; };

However, I cannot define a struct underneath that, because the same problem occurs. The compiler has no idea what type ControllerValue is. What I would like is something like this:

template<typename...Classes>
class Controller
{
  public:
    Controller(Classes&...objects) : objects(objects...){}
    Controller(std::tuple<Classes&...> tup) : objects(tup){}

    template<typename T>
    void setValues(T value)
    {
      thisValue.value = value;
      std::apply([&](auto&...x) { x.updateValue(value),...);}, objects); //calls the updateValue function for each class
    }

    template<typename T>
    T getValue() const { return thisValue.value }

  private:
    std::tuple<Classes&...> objects;

    template<typename T>
    struct ControllerValue { T value; };

    ControllerValue thisValue;
};

This will not compile at all for the same reason that the compiler has no idea what type ControllerValue should be. And this is where I am stuck. Is this even possible to do? If not, what is another way that I can make this work?

To clear up confusion, the use case would be something like this:

Controller<ClassA,ClassB,ClassC>* myController = new Controller<ClassA,ClassB,ClassC>(*a,*b,*c); 
myController->setValues(32);
int commonValue = myController->getValue();

or

Controller<ClassA,ClassB,ClassC>* myController = new Controller<ClassA,ClassB,ClassC>(*a,*b,*c); 
myController->setValues(32.3);
double commonValue = myController->getValue();

Answer 1

I think solving this exact problem is impossible in C++ (and still very cumbersome in languages with runtime generics). You can very easily create a polymorphic class that can only store any value:

class PolymorphicBase
{
public:
    virtual ~PolymorphicBase() = default;
};

template <class T>
class PolymorphicObject : public PolymorphicBase
{
    T value;

public:
    PolymorphicObject(T value) : value(std::move(value))
    {

    }
};

A member of std::unique_ptr<PolymorphicBase> can sufficiently store any value, but how would such a value be retrieved? Probably the easiest is to expose the reference to PolymorphicBase and use dynamic type checks to see if the type is compatible with something you know, but what if you need the code to work for any type?

This is what lambdas with auto parameters are useful for. However, you would have to be able to pass such a lambda to a method on PolymorphicBase and implement that method in PolymorphicObject. This is impossible, since you cannot override a method template (it needs to be a template to accept a lambda) – that's where the compile-time and runtime parts of C++ clash. And there is simply no type in C++ that represents a function accepting any parameter (and knowing its type), which is a template by itself.

You can partially solve this by making the type of the lambda known to PolymorphicBase:

template <class Retriever>
class PolymorphicBase
{
public:
    virtual void retrieve(Retriever func) = 0;
    virtual ~PolymorphicBase() = default;
};

template <class Retriever, class T>
class PolymorphicObject : public PolymorphicBase<Retriever>
{
    T value;

public:
    PolymorphicObject(T value) : value(std::move(value))
    {

    }

    void retrieve(Retriever func) override
    {
        func(value);
    }
};

auto lambda = [](auto arg)
{
    std::cout << arg << std::endl;
};

PolymorphicObject<decltype(lambda), int> obj(6);
PolymorphicBase<decltype(lambda)> &ptr = obj;
ptr.retrieve(lambda);

This is useful if you ever have only a single way to retrieve the value.

---

I don't think this is needed in most cases anyway. Usually you use a fixed set of types as the values, so you can use a variant there, or they all implement a common interface, or (as you've pointed out in the comments) you actually meant to move the type parameter from the method to the class (which allows you to check that all the types actually support the value earlier than originally).

However, I agree that in languages with generics/templates it is somewhat hard to have a method that can actually choose its result type in a generic fashion, without being controlled by outside parameters.