C++ 从作为模板参数传递给构造函数的类继承

我想要这样的东西：

样板 类MyClass:公共参数 { MyClass/*一些参数*/ { } } //安娜接着说： MyClass/*一些参数*/ 我想用Base1或其他的方法，使用他的方法

我知道这段代码不起作用，但你有什么办法吗？

这很好用：

struct Base1
{};
struct Base2
{};
struct Base3
{};

template<class... Args>
struct MyClass : public Args...
{};

MyClass<Base1, Base2, Base3> mc;

没有必要在你的构造函数中使用，你缺少了。。。在公共Args之后，您缺少一个；在类定义的末尾

这很好用：

struct Base1
{};
struct Base2
{};
struct Base3
{};

template<class... Args>
struct MyClass : public Args...
{};

MyClass<Base1, Base2, Base3> mc;

---

没有必要在你的构造函数中使用，你缺少了。。。在公共Args之后，您缺少一个；在类定义的末尾

根据您的要求，让我向您展示一些工作示例：

#include<iostream>

class B1 {
private:
int *m;
public:
B1() { m = new int;}
~B1() { delete m;}
void SetM(int a) { *m = a;}
int GetM() { return *m;}
};

class B2 {
private:
std::string str;
public:
B2() { str = "";}
~B2() {}
void SetStr(std::string a) { str = a;}
std::string GetStr() { return str;}
};

class B3 {
private:
float f;
public:
B3() { f = 0.0 ;}
~B3() {}
void SetF(float a) { f = a;}
float GetF() { return f;}
};

template<class... Args>
class MyClass : public Args... {
};

int main () {
MyClass<B1,B2,B3> l;
l.SetM(1);
if (auto a = dynamic_cast<B1*>(&l)) {
    std::cout<<" " << a->GetM() <<"\n";
} else {
    std::cout<<"ERROR:\n";
}

}

希望这有帮助， 谢谢

---

Rajkumar

让我根据您的要求向您展示一些工作示例：

#include<iostream>

class B1 {
private:
int *m;
public:
B1() { m = new int;}
~B1() { delete m;}
void SetM(int a) { *m = a;}
int GetM() { return *m;}
};

class B2 {
private:
std::string str;
public:
B2() { str = "";}
~B2() {}
void SetStr(std::string a) { str = a;}
std::string GetStr() { return str;}
};

class B3 {
private:
float f;
public:
B3() { f = 0.0 ;}
~B3() {}
void SetF(float a) { f = a;}
float GetF() { return f;}
};

template<class... Args>
class MyClass : public Args... {
};

int main () {
MyClass<B1,B2,B3> l;
l.SetM(1);
if (auto a = dynamic_cast<B1*>(&l)) {
    std::cout<<" " << a->GetM() <<"\n";
} else {
    std::cout<<"ERROR:\n";
}

}

希望这有帮助， 谢谢

拉吉库马尔

我知道这个代码不起作用，但是你有什么办法吗

要让它发挥作用，你必须

1添加省略号。。。继承参数

2使MyClass成为结构或公开构造函数

3删除定义构造函数的部分它是隐式的

4添加一些如下内容

   Args const & ... as

对于构造函数参数

5添加一个分号来结束类或结构

现在，下面的代码可以工作了

struct Base1 {};
struct Base2 {};
struct Base3 {};

template<class... Args>
struct MyClass : public Args...
 {
   MyClass (Args const & ...)
    { }
 };

int main()
 {
   MyClass<Base1, Base2, Base3>(Base1{}, Base2{}, Base3{});

   MyClass(Base1{}, Base2{}, Base3{});  // C++17 only
 }

仅适用于C++17，因为它使用了新的C++17:演绎指南

在您的例子中，有一个隐式的推断指南，允许从传递给构造函数的参数类型推断类的模板类型

另一个使用更有用的例子？可能是

MyClass  mc{ Base1{}, Base2{}, Base3{} };

我知道这个代码不起作用，但是你有什么办法吗

要让它发挥作用，你必须

1添加省略号。。。继承参数

2使MyClass成为结构或公开构造函数

3删除定义构造函数的部分它是隐式的

4添加一些如下内容

   Args const & ... as

对于构造函数参数

5添加一个分号来结束类或结构

现在，下面的代码可以工作了

struct Base1 {};
struct Base2 {};
struct Base3 {};

template<class... Args>
struct MyClass : public Args...
 {
   MyClass (Args const & ...)
    { }
 };

int main()
 {
   MyClass<Base1, Base2, Base3>(Base1{}, Base2{}, Base3{});

   MyClass(Base1{}, Base2{}, Base3{});  // C++17 only
 }

仅适用于C++17，因为它使用了新的C++17:演绎指南

在您的例子中，有一个隐式的推断指南，允许从传递给构造函数的参数类型推断类的模板类型

另一个使用更有用的例子？可能是

MyClass  mc{ Base1{}, Base2{}, Base3{} };

---

首先，您使用的是无效语法。使用可变模板时，您需要“解包”正确的术语：使用时“展开参数包”：

template<typename... Args>
class MyClass : public Args ...
//                          ^^^
{ };

在构造函数中，您可以完全跳过模板参数，但如果指定它们，则需要再次“解包”：

MyClass<Args ...>(/*some parameters*/);
//     ^^^^^^^^^^   optional

定义类后，您可以像指定经典模板一样指定模板参数，只是数量可以不同：

MyClass<Base1> c1;
MyClass<Base1, Base2> c2;
MyClass<Base1, Base2, Base3> c3;

由于使用了C++17和适当的构造函数，您甚至可以推导类模板参数：

template<typename... Args>
class MyClass : public Args ...
{
public:
    MyClass(Args const&... args)
        : Args(args)... // call base class copy constructors!
                        // (note the unpacking again)
    { }
    MyClass(Args&&... args)
        : Args(std::forward(args))... // call base class move constructors!
                                      // (note the unpacking again)
    { }
};

MyClass c0;
MyClass c1(Base1());
MyClass C2(Base1(), Base2());

std::cout << std::is_same_v<decltype(c0), MyClass<>> << std::endl;
std::cout << std::is_same_v<decltype(c1), MyClass<Base1>> << std::endl;
std::cout << std::is_same_v<decltype(c2), MyClass<Base1, Base2>> << std::endl;

---

请注意，继承在这里是一种转移注意力的方法，没有继承也可以。请参阅。

首先，您使用的语法无效。使用可变模板时，您需要“解包”正确的术语：使用时“展开参数包”：

template<typename... Args>
class MyClass : public Args ...
//                          ^^^
{ };

在构造函数中，您可以完全跳过模板参数，但如果指定它们，则需要再次“解包”：

MyClass<Args ...>(/*some parameters*/);
//     ^^^^^^^^^^   optional

定义类后，您可以像指定经典模板一样指定模板参数，只是数量可以不同：

MyClass<Base1> c1;
MyClass<Base1, Base2> c2;
MyClass<Base1, Base2, Base3> c3;

由于使用了C++17和适当的构造函数，您甚至可以推导类模板参数：

template<typename... Args>
class MyClass : public Args ...
{
public:
    MyClass(Args const&... args)
        : Args(args)... // call base class copy constructors!
                        // (note the unpacking again)
    { }
    MyClass(Args&&... args)
        : Args(std::forward(args))... // call base class move constructors!
                                      // (note the unpacking again)
    { }
};

MyClass c0;
MyClass c1(Base1());
MyClass C2(Base1(), Base2());

std::cout << std::is_same_v<decltype(c0), MyClass<>> << std::endl;
std::cout << std::is_same_v<decltype(c1), MyClass<Base1>> << std::endl;
std::cout << std::is_same_v<decltype(c2), MyClass<Base1, Base2>> << std::endl;

---

请注意，继承在这里是一种转移注意力的方法，没有继承也可以。请参阅。

您的意思是类MyClass:public Args…？@hshsvagen请注意，对于构造函数，您不必指定模板参数。您可能需要的是：。这是新的，可能是从C++17开始的。您的意思是类MyClass:public Args…？@hshsvagen请注意，对于构造函数，您不必指定模板参数，也可以指定您所要的参数：。这是新的，可能是因为C++17。为什么是新的？没什么特别的，我想展示一下dynamic_cast的用法，仅此而已。据我所知，我们需要虚拟方法来使用dynamic_cast，为什么是新的？没什么特别的，我想展示dynamic_cast的用法，仅此而已。据我所知，我们需要虚拟方法在这里使用动态_cast