在不同类型的模板化类中创建模板化变量

如何解决在不同类型的模板化类中创建模板化变量

我不确定我要的是什么。

我有一个名为window.addEventListener("wheel",(e) => scrollToSection(e),{ passive: false,}); const scrollToSection = (e) => { e.preventDefault(); window.scrollTo({ top: value,left: value,behavior: "smooth",}); }; 的模板化类。这是一个可变参数模板类，它具有多个类，可以这样设置它们的值。

Controller

这将一堆不同的类放在一起，并允许我同时设置它们的值。 Controller<ClassA,ClassB,ClassC>* myController = new Controller<ClassA,ClassC>(*a,*b,*c); myController->setValues(32); 是一个模板化函数，它允许传入任何类型。但是，现在，我正在尝试修改我的类，以便可以在控制器本身内设置一个值以便于检索。但这是很难证明的部分。

setValues

我想将以下内容添加为私有变量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; }; ，但是我知道我不能简单地声明T controllerValue;，因为我们无法定义成员模板，并且编译器也不知道会发生什么。然后我尝试创建一个私有结构：

T

但是，我无法在其下定义结构，因为会发生相同的问题。编译器不知道template<typename T> struct ControllerValue { T value; }; 是什么类型。我想要的是这样的：

ControllerValue

由于编译器不知道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; }; 应该是哪种类型，因此完全不会编译。这就是我被困住的地方。这有可能吗？如果没有，我可以通过什么其他方式进行这项工作？

为消除混乱，用例将如下所示：

ControllerValue

或

Controller<ClassA,*c); 
myController->setValues(32);
int commonValue = myController->getValue();

解决方法

我认为解决这个确切的问题在C ++中是不可能的（在具有运行时泛型的语言中仍然非常麻烦）。您可以很容易地创建一个多态类，该类只能存储任何值：

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

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

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

    }
};

std::unique_ptr<PolymorphicBase>的成员可以充分存储任何值，但是如何检索该值？可能最简单的方法是公开对PolymorphicBase的引用，并使用动态类型检查来查看该类型是否与您所知道的东西兼容，但是如果您需要代码可用于任何类型呢？

这是带有auto参数的lambda有用的地方。但是，您将必须能够将这样的lambda传递给PolymorphicBase上的方法，并在PolymorphicObject中实现该方法。这是不可能的，因为您不能覆盖方法模板（它必须是接受lambda的模板）–这是C ++的编译时和运行时部分冲突的地方。而且在C ++中，根本没有任何类型表示可以接受 any 参数（并知道其类型）的函数，而该参数本身就是模板。

您可以通过使PolymorphicBase知道lambda的类型来部分解决此问题：

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);

如果您只有一种方法来检索值，这将很有用。

---

我认为大多数情况下都不需要这样做。通常，您使用一组固定的类型作为值，因此可以在其中使用一个变体，或者它们都实现一个公共接口，或者（实际上，您已经在注释中指出）实际上是要从类的方法（允许您检查所有类型实际上是否比原始类型早支持该值）。

但是，我同意在具有泛型/模板的语言中，很难有一种方法能够以泛型的方式实际选择其结果类型，而不受外部参数的控制。