C++ 使用C+；中的字符串从类名创建对象+；

我有一个

Base

课程：

class Base() {
public:
   Base(int, int);
   ~Base();
};

我有多个从

Base

继承的类：

class childA : public Base {
public:
  childA(int, int, string);
  ~childA();
};

childA::childA(int x, int y, string str) : Base (x, y)
{
// do something here
}

与

childB

、

childC

等相同

---

我想知道是否可以使用字符串创建

childA

、

childB

或

childC

。我听说过可变时间段，但我真的不知道如何使用它。

可变时间段段模板是一个模板，它可以接受任意数量的任何类型的模板参数。这两个函数都可以是可变的，因为C语言（例如printf函数），然后是宏和现在的模板

您可以这样声明：

template<typename... Arguments> class Variadic;

template<typename... Arguments> void SampleFunction(Arguments... parameters);

template<typename T> class moniker
{
public:
    moniker(const char* tname);
}

#define declare_moniker(type, name)  moniker<type> name(#type)

通常迭代依赖于函数重载，或者-如果函数一次只能选择一个参数-使用哑扩展标记：

template<typename... Args> inline void pass(Args&&...) {}

使用此“pass”函数是必要的，因为参数包的扩展是通过用逗号分隔函数调用参数来进行的，逗号与逗号运算符不同<代码>某些函数（参数）永远不会工作。此外，只有当某个函数的返回类型不是void时，上述解决方案才会起作用。此外，一些函数调用将以未指定的顺序执行，因为函数参数的求值顺序未定义。为了避免未指定的顺序，可以使用大括号内的初始值设定项列表，以保证严格的从左到右的求值顺序。为了避免使用not void返回类型，可以使用逗号运算符在每个扩展元素中始终生成1

  struct pass {
    template<typename ...T> pass(T...) {}
  };

  pass{(some_function(args), 1)...};

将生成代码（假设C++自动加入字符串文字）：

您可以声明如下内容：

template<typename... Arguments> class Variadic;

template<typename... Arguments> void SampleFunction(Arguments... parameters);

template<typename T> class moniker
{
public:
    moniker(const char* tname);
}

#define declare_moniker(type, name)  moniker<type> name(#type)

模板类名字对象
{
公众：
名字对象（const char*tname）；
}
#定义声明名字对象（类型、名称）名字对象名称（#类型）

可变宏定义和可变模板如何相互作用？我不确定。我手头的编译器失败了，但它不是C++11。如果有兴趣，试试看

可能支持typeid运算符，具体取决于编译器设置

const std:：type_info&ti1=typeid（A）

---

std:：type_info get method name（），但它返回的字符串取决于实现：

在c++14中，可以创建一些helper结构来确定编译时传递的字符串的每个字符，并将其转发给类型。但是，您传递的字符串需要存储在带有链接的变量中，以便编译器将其用作非类型模板参数：

#include <utility>
#include <type_traits>

template <char... Cs>
struct string_literal { };

template <class T, T &, class>
struct make_string_literal_impl;

template <class T, T &Cs, std::size_t... Is>
struct make_string_literal_impl<T, Cs, std::index_sequence<Is...>> {
    using type = string_literal<Cs[Is]...>;
};

template <class T, T &>
struct make_string_literal;

template <class T, std::size_t N, T (&Cs)[N]>
struct make_string_literal<T[N], Cs>: make_string_literal_impl<T[N], Cs, std::make_index_sequence<N>> {
};

struct Base {
   Base(int, int) { }
   ~Base() { }
};

template <class>
struct Child: Base { 
    using Base::Base;
};

constexpr char const str[] = "abc";

int main() {
    Child<make_string_literal<decltype(str), str>::type> c(1, 1);
}

#包括
#包括
模板
结构字符串_literal{}；
模板
struct make_string_literal_impl；
模板
结构make\u string\u literal\u impl{
使用type=string\u literal；
};
模板
struct make_string_literal；
模板
结构make\u string\u literal:make\u string\u literal\u impl{
};
结构基{
基（int，int）{}
~Base（）{}
};
模板
结构子项：基{
使用Base：：Base；
};
constexpr char const str[]=“abc”；
int main（）{
儿童c（1,1）；
}

---

编译时字符串还是运行时字符串？工厂方法正是如此。告诉我更多关于@seccpur使用字符串是什么意思？@LorenceHernandez我想用一个名为classty的字符串创建一个对象。对于这个解释，我比以前更了解它现在可以快速解释我如何创建吗我的对象使用字符串和可变模板，如果这样做是正确的it@Rifzy我不确定您想要实现什么，为什么需要类的名称（在模板的情况下，从技术上讲是一个包含所有参数的长字符串），以及在哪个组合中使用可变模板。您可以尝试使用typeid（this）.name（）？i创建一个game@Rifzy你需要做什么？确定对象在运行时的类型？有一些模式允许在不存储字符串的情况下执行此操作

#define printstring( x ) printf(#x "\n")

printstring( This a dumb idea );

printf("This a dumb idea \n")

template<typename T> class moniker
{
public:
    moniker(const char* tname);
}

#define declare_moniker(type, name)  moniker<type> name(#type)

#include <utility>
#include <type_traits>

template <char... Cs>
struct string_literal { };

template <class T, T &, class>
struct make_string_literal_impl;

template <class T, T &Cs, std::size_t... Is>
struct make_string_literal_impl<T, Cs, std::index_sequence<Is...>> {
    using type = string_literal<Cs[Is]...>;
};

template <class T, T &>
struct make_string_literal;

template <class T, std::size_t N, T (&Cs)[N]>
struct make_string_literal<T[N], Cs>: make_string_literal_impl<T[N], Cs, std::make_index_sequence<N>> {
};

struct Base {
   Base(int, int) { }
   ~Base() { }
};

template <class>
struct Child: Base { 
    using Base::Base;
};

constexpr char const str[] = "abc";

int main() {
    Child<make_string_literal<decltype(str), str>::type> c(1, 1);
}