Question

C ++中有没有办法收集不同类型的类并调用它们的方法？我想做的是如下，

template<namespace T>
class A
{
    A method_A1(T a)
    {
        ...
    }

    void method_A2(int aa)
    {
        ...
    }

        ...
};

class B
{
    ...
};

class C
{
    ...
};

class D
{
    ...
};

A<B> *b;
A<C> *c;
A<D> *d;

b -> method_A2(3);
c -> method_A2(5);

在这个代码对象b，c，d中它们是完全不同的对象，对吗？不相关的。但我想用数组绑定它们，所以......

z[0] = b;
z[1] = c;
z[2] = d;

像这样。我找到了一些解决方案，但解决方案仅用于收集不同类型。（对继承对象使用void *数组或向量）我也想访问他们的方法。

z[0] -> method_A2(3);
z[1] -> method_A3(5);

像这样。在这种情况下我该怎么办？

提前致谢。

Answer 1

typedef boost::variant<A<B>, A<C>, A<D>> AVariant;
std::array<AVariant, 3> z;

z[0] = *b;
z[1] = *c;
z[2] = *d;

然后，您可以根据需要检查每个元素的类型，或使用boost::static_visitor“访问”它们，如下所示：http://www.boost.org/doc/libs/release/doc/html/variant.html

Answer 2

为什么不使用继承和多态性。我已经发布了一个可以解决问题的例子。请参阅main功能：

#include <iostream>

class weapon {

 public:
  int fireRate;
  int bulletDamage;
  int range;
  int activeBullet;

 public:
  virtual void fire(void) {std::cout << "machine " << '\n';}
  virtual ~weapon() {std::cout << "destructor is virtual" << '\n';}
};

class machineGun: public weapon {
 public: 
  void fire(void) {std::cout << "machine gun firing" << '\n';}
  ~machineGun(void) { std::cout << "machine gun destroyed" << '\n';}
};

class flamer: public weapon {
 public: 
  void fire(void) {std::cout << "flamer firing" << '\n';}
  ~flamer(void) {std::cout << "flamer destroyed" << '\n';}
};

int main(void)
{
    const int count = 2;
    weapon *weapons[count];

    machineGun *a = new machineGun();
    flamer     *b = new flamer();

    weapons[0] = a;
    weapons[1] = b;

    weapons[0]->fire();
    weapons[1]->fire();

    delete a;
    delete b;

}

Answer 3

如果你不想改变你的课程＆＃39;层次结构，您可以尝试拥有一组可调用对象。类似的东西：

#include <iostream>
#include <functional>
#include <array>

class A
{
    public:
    void Foo(int a)
    {
        std::cout << "Foo " << a << std::endl;
    }
};

class B
{
    public:
    void Bar(int a)
    {
        std::cout << "Bar " << a << std::endl;
    }
};

int main()
{
   using namespace std::placeholders;

   A a;
   B b;

   auto a_func = std::bind(&A::Foo, a, _1);
   auto b_func = std::bind(&B::Bar, b, _1);

   std::array<std::function<void(int)>, 2> arr = {
     std::bind(&A::Foo, a, _1),
     std::bind(&B::Bar, b, _1)
   };

   arr[0](1);
   arr[1](2);

   return 0;
}

顺便说一句，这只有在你使用完全支持C ++ 11的编译器时才有效。

收集不同类型的类并在c ++中调用它们的方法

3 个答案: