C++ 将模板化对象存储在容器中

是否可以像这样存储模板化类

template <typename rtn, typename arg>
class BufferAccessor {
  public:
    int ThreadID;
    virtual rtn do_work(arg) = 0;  
}; 

BufferAccessor<void,int> access1;
BufferAccessor<int,void> access2;

模板
类缓冲访问器{
公众：
int-ThreadID；
虚拟rtn工作（arg）=0；
}; 
缓冲存取器存取器1；
缓冲存取器存取器2；

在同一容器中，如向量或列表

编辑： 这样做的目的是，我试图创建一个循环缓冲区，其中要使用缓冲区的对象需要向缓冲区注册。缓冲区将向访问器对象存储boost:：shared_ptr，并生成对这些函数的回调，这些函数将向缓冲区推送或从缓冲区拉取数据。回调将用于我创建的一个通用线程工作函数中，该函数类似于线程池，它们需要访问共享内存对象。下面是我键入的一些代码，可能有助于说明我正在尝试做什么，但它还没有被编译，这也是我第一次使用bind、function和multi-threading

 typedef boost::function<BUF_QObj (void)> CallbackT_pro;
        typedef boost::function<void (BUF_QObj)> CallbackT_con;
        typedef boost::shared_ptr<BufferAccessor> buf_ptr;

        // Register the worker object
            int register_consumer(BufferAccesser &accessor) {
                mRegCons[mNumConsumers] = buf_ptr(accessor);
                return ++mNumConsumers;
            }

            int register_producer(BufferAccesser &accessor) {
                mRegPros[mNumProducers] = buf_ptr(accessor);
                return ++mNumProducers;
            }
                // Dispatch consumer threads
                for(;x<mNumConsumers; ++x) {
                    CallBack_Tcon callback_con = boost::bind(&BufferAccessor::do_work, mRegCons[x]);
                    tw = new boost:thread(boost::bind(&RT_ActiveCircularBuffer::consumerWorker, this, callback_con));
                    consumers.add(tw);
                }

                // Dispatch producer threads
                for(x=0;x<mNumProducers; ++x) {
                    CallBack_Tpro callback_pro = boost::bind(&BufferAccessor::do_work, mRegPros[x], _1);
                    tw = new boost:thread(boost::bind(&RT_ActiveCircularBuffer::producerWorker, this, callback_pro));
                    producers.add(tw);
                }
        // Thread Template Workers - Consumer
            void consumerWorker(CallbackT_con worker) {
                struct BUF_QObj *qData;

                while(!mRun)
                    cond.wait(mLock);

                while(!mTerminate) {
                    // Set interruption point so that thread can be interrupted
                    boost::thread::interruption_point();
                    { // Code Block
                        boost::mutex::scoped_lock lock(mLock);
                        if(buf.empty()) {
                            cond.wait(mLock)

                        qData = mBuf.front();
                        mBuf.pop_front(); // remove the front element
                    } // End Code Block

                    worker(qData); // Process data

                    // Sleep that thread for 1 uSec
                    boost::thread::sleep(boost::posix_time::nanoseconds(1000));
                } // End of while loop
            }

            // Thread Template Workers - Producer
            void producerWorker(CallbackT_pro worker) {
                struct BUF_QObj *qData;
                boost::thread::sleep(boost::posix_time::nanoseconds(1000));

                while(!mRun)
                    cond.wait(mLock);

                while(!mTerminate) {
                    // Set interruption point so that thread can be interrupted
                    boost::thread::interruption_point();

                    qData = worker(); // get data to be processed

                    { // Code Block
                        boost::mutex::scoped_lock lock(mLock);
                        buf.push_back(qData);
                        cond.notify_one(mLock);
                    } // End Code Block

                    // Sleep that thread for 1 uSec
                    boost::thread::sleep(boost::posix_time::nanoseconds(1000));
                } // End of while loop
            }

typedef boost:：函数CallbackT_pro；
typedef boost:：函数CallbackT_con；
typedef boost:：shared_ptr buf_ptr；
//注册工作对象
int寄存器\用户（缓冲存取器和存取器）{
mRegCons[mNumConsumers]=buf_ptr（存取器）；
回报消费者；
}
int寄存器_生产者（缓冲存取器和存取器）{
mRegPros[mNumProducers]=buf_ptr（访问者）；
return++mNumProducers；
}
//分派使用者线程
对于（；x否，不是这样，因为STL容器是同质的，并且access1和access2具有完全不同的不相关类型。但是您可以将类BufferAccessor设置为非模板，而将do work成员设置为模板，如下所示：

class BufferAccessor
{
   template<class R, class A>
   R doWork(A arg) {...}
};

类缓冲访问器
{
模板
R doWork（A arg）{…}
};

在这种情况下，您可以将缓冲访问器存储在容器中，但不能将成员模板函数设置为虚拟。不，不是这样，因为STL容器是同质的，access1和access2具有完全不同的不相关类型。但是您可以将类BufferAccessor设置为非模板，而将do work成员设置为模板，如t他的：

class BufferAccessor
{
   template<class R, class A>
   R doWork(A arg) {...}
};

类缓冲访问器
{
模板
R doWork（A arg）{…}
};

在这种情况下，您可以将缓冲访问器存储在容器中，但不能将成员模板函数设置为虚拟。
是的，您可以使用
vector
存储
BufferAccessor
对象和
vector
存储
BufferAccessor
对象

您不能使用相同的向量来存储
BufferAccessor
和
BufferAccessor
对象
它不工作的原因是因为
BufferAccessor
和
BufferAccessor
是两个不同的类

注意
：可以使用相同的向量来存储
缓冲存取器
和
缓冲存取器
，但是您必须使用
共享的ptr将它们存储为
无效*
。或者更好的是，您可以使用
boost:：variant
是的，您可以使用
向量
来存储
缓冲存取sor
对象和
向量
存储
缓冲访问器
对象

您不能使用相同的向量来存储
BufferAccessor
和
BufferAccessor
对象
它不工作的原因是因为
BufferAccessor
和
BufferAccessor
是两个不同的类

注意
：可以使用同一个向量来存储
缓冲存取器
和
缓冲存取器
，但您必须使用
共享ptr将它们存储为
无效*
。或者更好的是，您可以使用
boost:：variant
如果可能，您想如何调用
do\u work
这个类的要点是允许对象向循环缓冲区注册。一旦注册为生产者或消费者，缓冲区对象将创建do_work函数的回调，并将其传递到线程工作者函数中，以便填充和使用缓冲区。我不确定我是否遵循，但听起来可能您正在寻找对于
std:：function
/
boost:：function
，以及
std:：bind
或
boost:bind
。如果可能，您希望如何调用
do_work
？此类的要点是允许对象向循环缓冲区注册。一旦注册为生产者或消费者，缓冲区对象将创建callb确认do_work函数，并将其传递到线程工作者函数，以便填充和使用缓冲区。我不确定我是否遵循，但听起来您可能正在寻找
std:：function
/
boost:：function
，以及
std:：bind
或
boost:bind
。从中继承的最佳方式是什么当为dowork定义一个void返回和某种类型的对象返回时，该类function@Talguy：恐怕您必须重新表述您的问题。我不明白，对不起，我想继承BufferAccessor类，以便将对象定义为我的循环的生产者或消费者。我是否将功能保留在t中基类dowork函数为空，然后在派生类中定义功能。或者我应该为基类编写一些填充代码，比如cout@Talguy：老实说？我不知道：）当为dowork定义void返回和某种类型的对象返回时，从这个类继承的最佳方法是什么function@Talguy当前位置恐怕你得重新措辞你的问题。我不明白，很抱歉，我想从BufferAccessor类继承对象，以便将对象定义为循环的生产者或消费者。我只是将基类dowork函数中的功能保留为空，然后在派生类中定义该功能。或者我应该写一些填充物吗