通用 var c++

Question

我想创建一个通用变量，它可以来自一个类或另一个类。

在此代码示例中，我希望 var aa 是通用的，因此在我的代码中我可以访问 A 类或 B 类的代码。

但 aa 必须是全局的。

你可以帮帮我吗？

class MyClass
{
public:
    MyClass() {} //contructor padrão, não deve ser utilizado isoladamente

    static MyClass* getInstance()
    {
        static MyClass *instance = 0;
        if (!instance) instance = new MyClass();
            return instance;
    }
};

class A : public MyClass
{
public:
    int a() { return 1; }
};

class B : public MyClass
{
public:
    int b() { return 1; }
};

template <class TAIT> class AIT
{
public:
    static TAIT& Instance()
    {
        static TAIT instance;
        return instance;
    }
};

AIT aa;

void main()
{
    aa.Instance().a(); // or
    aa.Instance().b(); // aa could be class
                       // A or class B. So I could access
                       // function a or function b (not at same
                       // time, of course)

    return;
}

Answer 1

简短的回答：

C++ 模板为您提供编译时通用性，而不是运行时通用性。

模板本身在您的程序中不存在（即作为具体的二进制可执行文件）。 仅当通过显式或隐式指定其参数进行实例化时，它们才会最终作为生成的代码。

因此，这不会声明一个变量：

AIT aa;

这声明了一个变量：

AIT<A> aa;

如果您需要运行时通用性，则必须使用运行时调度机制：

• 要么使用 switch case 手动执行。
• 或者更好地使用公共基类的内置继承+一些虚拟方法。

Answer 2

如果我理解正确，我认为您只需要正确声明 aa 即可：

AIT<A> aa;
aa.Instance().a();

AIT<B> bb;
bb.Instance().b();

如果这不是您的意思，请编辑您的问题并澄清您正在尝试的内容去做。

Answer 3

在基类中声明纯虚函数，在派生类中重载它。

class MyClass {
public:
   virtual int a() = 0;
};

class DerivedA : public MyClass {
public:
   virtual int a() { return 1; }
};

两个派生类都将具有同名的方法，您将根据对象类型自动解析要调用的方法。 您必须重写 GetInstance() 方法的创建部分，才能知道要创建哪个类实例。

Answer 4

如果您不希望在 getInstance 方法之外调用构造函数，则可以将其设为私有。 例如

class MyClass
{
private:
    MyClass() {} //contructor padrão, não deve ser utilizado isoladamente
public:
    static MyClass* getInstance()
    {
        static MyClass *instance = 0;
        if (!instance) instance = new MyClass();
            return instance;
    }
};

现在

MyClass* a = new MyClass();

会导致编译错误，因为你的构造函数是私有的

Answer 5

这是解决这个问题的好方法吗？

类我的类{
民众：
MyClass() {} //构造函数，不可用
伊索拉达门特
虚拟 int a() = 0; 虚拟 int b() = 0;

 int c() { return b();   } 

     静态 MyClass* getInstance() 
     { 
        静态 MyClass *实例 = 0;   // if (!instance) 实例 
  

= new MyClass();
返回实例；
} };

A 类：公共 MyClass { 公共：
int a() { 返回 1; } int b() {
返回1； } int d() { 返回 1; } };

B 类：公共 MyClass { 公共：
int a() { 返回 1; } int b() {
返回1； } int e() { 返回 1; } };

C 类：公共 A，公共 B { 公共：
一个ca； B cb;

枚举 TIPO { A, B }; TIPO 蒂波；

C(TIPO 蒂波) { Tipo = 蒂波; }

int a() { switch(Tipo) { case
答：返回ca.a(); 休息; 案件
B：返回cb.b()； 休息;
默认：中断； } }

};

void main() { //MyClass* A =
MyClass::getInstance(); //我的班级* B
= MyClass::getInstance();

C c(C::B)； ca();
// aa.Instance().a();
// aa.Instance().b();

返回； }

Answer 6

这绝对是令人讨厌的，但也许这里的解决方案是使用 void 指针。 在 C 和 C++ 中，声明为 void* 的指针被定义为没有类型。 您可以传递此指针，然后将其转换为您想要的任何数据类型的指针。 显然，非常仔细地确保变量实际上具有正确的类型至关重要，但是如果您正在设计一个不知道返回类型的接口，那么这可能很有用。 下面是接口类的示例：

class InterfaceClass {
  public:
     virtual void* someInterface() = 0;
}

然后，您可以创建另一个类来实现该接口并执行您想要的任何有趣的操作：

class DerivedClass: public InterfaceClass {
  public:
     virtual void* someInterface() {
        //do some stuff
        return (void*) somePointer;

}

只要您拥有的任何代码了解要执行的操作，您就可以传回任何类型的指针你要。 如果您在 Google 中搜索 void 指针，将会得到更多信息。 当心。