0

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

在此代码示例中，我希望 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;
}
4

6 回答 6

7

简短的回答：

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

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

因此，这不会声明变量：

AIT aa;

这声明了一个变量：

AIT<A> aa;

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

  • 要么用开关盒手动完成。
  • 或者更好地使用公共基类的内置继承+一些虚拟方法。
于 2009-06-26T14:20:49.473 回答
2

如果我对您的理解正确，我认为您只需要aa正确声明即可，并且您已设置：

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

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

如果这不是您的意思，请编辑您的问题并阐明您要做什么。

于 2009-06-26T14:13:45.400 回答
1

在基类中声明一个纯虚，在派生类中重载它。

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

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

两个派生类都有一个同名的方法，您将根据对象类型自动解析要调用的方法。您将不得不重写 GetInstance() 方法的创建部分，以便它知道要创建什么类实例。

于 2009-06-26T14:13:40.003 回答
0

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

class MyClass { public: MyClass() {} //constructor padrão, não deve ser utilizado isoladamente virtual int a() = 0; 虚拟 int b() = 0;

  int c()         {           return b();         }

   static MyClass* getInstance()
   {
      static MyClass *instance = 0; //          if (!instance) instance

= 新的 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 {公共：A ca; B CB;

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

C(TIPO Tipo) { Tipo = Tipo; }

int a() { switch(Tipo) { case A: return ca.a(); 休息; 案例 B：返回 cb.b()；休息; 默认值：中断；} }

};

void main() { //MyClass* A = MyClass::getInstance(); //MyClass* B = MyClass::getInstance();

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

返回; }

于 2009-06-29T15:16:19.850 回答
0

这绝对是令人讨厌的，但也许这里的解决方案是使用 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 指针，将会有更多信息。当心。

于 2009-07-02T06:37:00.047 回答
0

如果您不希望在 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();

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

于 2009-06-26T14:36:01.020 回答