C++ 如何在if/else序列中定义未知类型的全局变量？

我有三门课：

class A
{
   //
};
class B
{
   //
};
class C
{
   //
};

如何定义类型等于其中一个类的变量q并使其成为全局变量

• 我只需要一个实例，而且只需要一次
• 所有这些类都有方法set（）和search（），它们对每个类的工作方式都不同
• 我从命令行获取“a”的值

例如，在我的定义中，q不是全局的

if (a == 1) {
    A q;
} else
if (a == 2) {
    B q;
} else
if (a == 3) {
    C q;
} else

---

您可能希望为a、B、C提供一个公共基类，并利用factory设计模式

class A : public Base
{
};

class B : public Base
{
};

class C : public Base
{
};

class ABCFactory
{
public:
 static Base* Create(int index)
 {
    switch (index) 
    {
      case 1:
    return new A;
      case 2:
    return new B;
      case 3:
    return new C;
    };
 }
};

//example usage:
std::unique_ptr<Base> p = ABCFactory::Create(1);

A类：公共基地
{
};
B类：公共基地
{
};
丙级：公共基地
{
};
ABC类工厂
{
公众：
静态基*创建（整数索引）
{
开关（索引）
{
案例1：
返回一个新的；
案例2：
返回新的B；
案例3：
返回新的C；
};
}
};
//用法示例：
std:：unique_ptr p=ABCFactory:：Create（1）；

如何定义类型等于其中一个类的变量q并使其成为全局变量

• 我只需要一个实例，而且只需要一次
• 所有这些类都有方法set（）和search（），它们对每个类的工作方式都不同

在此情况下，可以考虑使用预处理器通过程序

的编译时配置来实现这一点。

#define CHOOSE_CLASS 1 // Or use -D option for the compiler in the build system
#if (CHOOSE_CLASS == 1)
A q;
#else
#if (CHOOSE_CLASS == 2)
B q;
#else 
#if (CHOOSE_CLASS == 3)
C q;
#endif
#endif
#endif

或模板类包装器来选择其中一个

class A;
class B;
class C;

enum TypeSelector {
    CLASS_A ,
    CLASS_B ,
    CLASS_C ,
};

template <TypeSelector selection>
struct SelectFinal {
     typedef void FinalType;
};

template<>
SelectFinal<CLASS_A> {
     typedef A FinalType;
};

template<>
SelectFinal<CLASS_B> {
     typedef B FinalType;
};

template<>
SelectFinal<CLASS_C> {
     typedef C FinalType;
};

SelectFinal<CLASS_A>::FinalType q;

A类；
乙级;；
丙级;；
枚举类型选择器{
甲级，
B类，
C类，
};
模板
结构选择最终{
typedef void FinalType；
};
模板
最终选择{
typedef是最终类型；
};
模板
最终选择{
类型定义B最终类型；
};
模板
最终选择{
类型定义C最终类型；
};
选择Final:：FinalType q；

如果需要在运行时选择类类型，则需要使用另一个答案中描述的工厂模式。可能需要稍加修改：

class ABCFactory {
public:
    static std::shared_ptr<Base> Create(int index) {
        static std::shared_ptr<Base> theInstance;
        if(!theInstance.get()) {
             switch (index) {
             case 1:
                 theInstance = std::make_shared<A>();
                 break;
             case 2:
                 theInstance = std::make_shared<B>();
                 break;
             case 3:
                 theInstance = std::make_shared<C>();
                 break;
             }
         }
         return theInstance;
     }
 };

class abc工厂{
公众：
静态std:：共享的ptr创建（int索引）{
静态std：：共享\u ptr实例；
如果（！instance.get（））{
开关（索引）{
案例1：
instance=std:：make_shared（）；
打破
案例2：
instance=std:：make_shared（）；
打破
案例3：
instance=std:：make_shared（）；
打破
}
}
返回指令；
}
};

在这种情况下，您需要预处理器（

#ifdef

），或者使用接口和引用（由于

A

，

B

和

C

目前是不相关的。您能否更具体地了解您的实际用例？您在运行时是否只需要这些全局实例中的一个？它们更多，但只具有特定的类型？这些类在声明的成员函数和变量方面是否完全不同？请首先明确您的要求。请参阅我的回答作为回应。如果您确实不需要您请求的此功能的任何运行时配置支持，这可能会有所帮助。最后，如果您需要做出决定，或者在编译时或runt时

A

、

B

或

C

，您应该明确这一点ime。尽管有一点：请使用

std:：unique\u ptr

而不是原始指针和

new（）

。是的，在第一点上，我使用了Base*，因为我非常确定OP不能使用它，但后来，我决定编写正确的版本：）我只是想把它放在工厂类本身。但是很好，至少你提到了它。