Question

我有一个看起来像这样的课

class Foo 
{
public:
   template<class T> 
   A(T * ptr) { ptr_ = reinterpret_cast<void*>(ptr_);} 

   template<class T>
   T * get() { return reinterpret_cast<T*>(ptr_);}

private:
  void * ptr_;
};

在编译时，我确切地知道数组中将包含哪些元素。有没有一种方法可以对此类进行注释，以使Foo指针数组知道其应获取的类型？

基本上，我想调用Foo[i]<T>->apply()，而不必在运行时查找类型，因为它应该在编译时知道它是哪种对象。

P.S。请不要建议使用虚函数，我知道它们是一个有效的解决方案，但是我想知道这是否可行，因为我在编译时确实拥有所有类型信息。

Answer 1

我对您的问题的理解如下：

您想要某种表/数组，其中包含对象指针和指向相应对象的成员函数指针。稍后，您要在没有任何虚函数的情况下调用这些“对”。

也许您可以从这种方法开始：

struct A 
{
    void Foo() { std::cout << "A Foo" << std::endl; }
    void Bar() { std::cout << "A Bar" << std::endl; }
};

struct B 
{
    void Do() { std::cout << "B Do " << std::endl; }
    void Go() { std::cout << "B Go " << std::endl; }
};

    template < typename T, auto MEM_PTR >
void Call( void* obj)
{
    (((T*)obj)->*(MEM_PTR))();
}

using OBJ_FUNC_PAIR = std::pair< void* , void(*)(void*) >;

A a;
B b;

std::array< OBJ_FUNC_PAIR ,4 > arr
{
    {
        { (void*)&a, &Call<A, &A::Foo>},
            { (void*)&a, &Call<A, &A::Bar>},
            { (void*)&b, &Call<B, &B::Do > },
            { (void*)&b, &Call<B, &B::Go > }
    }
};

int main()
{
    for ( auto& pair: arr )
    {
        (*pair.second)( pair.first );
    }

}

在编译时创建一个数组

1 个答案: