C++ C++；调用驻留在多个类中的函数

我想实现这样的功能

#define classAnum 2;
#define classBnum 3;

class Base
{
  virtual int open()=0;
  virtual int close()=0;
}
class A:public Base
{
 virtual int open();
 virtual int close();
};

class B:public Base
{
 virtual int open();
 virtual int close();
}

int main()
{
    A classA[classAnum];
    B classB[classBnum];

openAnyClass(1);
CloseAnyClass(2);   
}

这两个函数应该能够从类A和类B中调用open（）和close（）

openAnyClass（1）将调用classA或classB数组中第一个对象的open（）函数

open（）-->在类A和类B中有不同的实现。可以从多个客户端调用类A中的open（），并定义了客户端的最大数量

一次只调用任何classA或classB中的一个open（）。我不想要同一代码的多个副本

只需要一个函数，我就可以调用任意类A和任意客户端的open（）

例如：在下面的语句中，我想调用client1的类A的open（）。openAnyClass（int）的参数表示客户端Id。这也可能意味着

classB[1]。open（）

做这件事的最佳方法是什么？
这就是为什么要有一个派生自的命令基类；这样，您就可以拥有一个指向类的指针或引用，并通过虚函数在派生类中调用open/close方法

所以如果你有

'openAnyClass(1) = classA[1].open();'

泛型\u类\u指针->open（）将调用类A中定义的代码

您尝试使用两个存储对象的数组（一个用于类A，一个用于类B）执行的操作不是必需的，您可以使用一个数组来引用Base类型的类，并通过该数组进行访问

原始代码并不是一种很好的工作方式，最好是通过列表（例如）

Base*class_存储[StorageSize]；
int openAnyClass（int id）
{
if（id<0 | | id>=StorageSize | | class|u存储[id]==0）
返回0；//或其他错误指示
其他的
返回类_存储[id]->open（）；
}
int CloseAnyClass（int id）
{
if（id<0 | | id>=StorageSize | | class|u存储[id]==0）
返回0；//或其他错误指示
其他的
返回类_存储[id]->close（）；
}
int main（）
{
memset（class_存储，0，sizeof（class_存储））；
类_存储[1]=新的A（）；
class_存储[2]=新的B（）；
openAnyClass（1）；
封闭式（2）；
}

上面的代码不是一个完整的解决方案，例如，原始代码没有虚拟析构函数，这是一个经常使用的好方法，以防派生类需要进行清理

此外，在我的示例中，不会释放对分配到类存储中的对象的删除。在全局级别上这并不重要，因为它们将在退出时被释放，但是大多数情况下，您需要管理通过
new（）
获取的所有内容，否则将导致内存泄漏。
因此classA是A的数组，classB也是如此。调用openAnyClass（1）意味着对A的所有实例调用open（），而closeAnyClass（）意味着对B类的所有实例调用close（）。如果是这样的话，问题真的很复杂

无论如何，没有现成的方法可以做到这一点。您必须迭代数组的所有元素并调用open（）或close（）。或者，您可以使用boostforeach
或者实现您自己的foreach方法
如果我正确理解您的问题，您希望调用纯虚拟函数的不同实现。假设您已经提供了类A和类B的实现，那么您应该能够从指向基的指针/引用而不是A或B使用并调用open（）/close（）

您可以只创建一个基指针数组，而不是为A和B创建两个数组

例如：

Base* class_storage[StorageSize];

int openAnyClass(int id)
{
    if (id < 0 || id >= StorageSize || class_storage[id] == 0)
        return 0; // or other error indication
    else
        return class_storage[id]->open();
}
int CloseAnyClass(int id)
{
    if (id < 0 || id >= StorageSize || class_storage[id] == 0)
        return 0; // or other error indication
    else
        return class_storage[id]->close();
}


int main()
{
    memset(class_storage,0,sizeof(class_storage));

    class_storage[1] = new A();
    class_storage[2] = new B();

    openAnyClass(1);
    CloseAnyClass(2);   
}

与其使用全局变量存储对象并传递索引，不如将对象的指针/引用传递给函数，函数将调用相应的方法（无论是a方法还是B方法）。
不可能对同一方法有不同的实现-多个open（）有什么意义？如果在调用openAnyClass时将指针/引用传递给Base（从类A或类B的实例中向上浇铸），那么您将能够对该指针/引用调用open或close，并“自动”调用正确的方法（A:：open（）或B:：open（），具体取决于“实”类）@user1511617
openAnyClass（）
和
closeAnyClass（）
的参数是什么意思？因此classA是A的数组，classB也是。调用openAnyClass（1）意味着对A的所有实例调用open（），而closeAnyClass（）意味着对B类的所有实例调用close（）。如果是这样的话，问题真的很复杂。@user1511617为什么
openAnyClass（1）
调用
classA[1]。open（）
而不是
classB[1]。open（）
？不，我正在将一个int参数传递给openAnyClass（），这表示我要打开的实例。类似地，我可以传递要调用其open（）的对象。memset调用是多余的，因为全局数组的元素是自动默认初始化的。尽管如此，
基类存储[StorageSize]={0}最好还是呈现给新手。如果您需要使用
new
分配对象，请记住删除它们，或者使用智能指针来管理它们。他们几乎肯定也需要虚拟析构函数；在本例中，调用class_storage[1]->open（…）时会发生什么；如果你使用这种方法，最好创建一个
向量基
而不是C样式的数组，并修改
delete
-循环以在
i时迭代
Base *generic_class_pointer = new class A();

generic_class_pointer->open();

Base* class_storage[StorageSize];

int openAnyClass(int id)
{
    if (id < 0 || id >= StorageSize || class_storage[id] == 0)
        return 0; // or other error indication
    else
        return class_storage[id]->open();
}
int CloseAnyClass(int id)
{
    if (id < 0 || id >= StorageSize || class_storage[id] == 0)
        return 0; // or other error indication
    else
        return class_storage[id]->close();
}


int main()
{
    memset(class_storage,0,sizeof(class_storage));

    class_storage[1] = new A();
    class_storage[2] = new B();

    openAnyClass(1);
    CloseAnyClass(2);   
}

Base* base[basenum];

void openAnyClass( const int i )
{
   if( i < basenum && i >=0 && base[i] != NULL )
       base[i]->open();
}

int main(void)
{
   base[0] = new A();
   base[1] = new B();
   ...
   openAnyClass(1);
   closeAnyClass(2);

   for( int i = 0 ; i < basenum ; i++ )
      delete base[i];
}

void openAnyClass( Base& base );
void closeAnyClass( Base& base );