Question

是否可以存储像

这样的模板化类

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

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

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

编辑：这样做的目的是我试图创建一个循环缓冲区，其中想要使用缓冲区的对象需要向缓冲区注册。缓冲区将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
            }

Answer 1

不，不是，因为STL容器是同质的，并且access1和access2具有完全不同的不相关类型。但是你可以将BufferAccessor类设为非模板，而将do-work成员作为模板，如下所示：

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

在这种情况下，您可以将BufferAccessors存储在容器中，但不能将成员模板功能设置为虚拟。

Answer 2

是的，您可以使用vector<BufferAccessor<void,int> >来存储BufferAccessor<void,int>个对象，使用vector<BufferAccessor<int,void> >来存储BufferAccessor<int,void>个对象。

你不能做的是使用相同的向量来存储BufferAccessor<int,void>和BufferAccessor<void,int>对象它不起作用的原因是因为BufferAccessor<void,int>和BufferAccessor<int,void>是两个不同的类

Note：可以使用相同的向量来存储BufferAccessor<int,void>和BufferAccessor<void,int>，但您必须使用void *将它们存储为shared_ptr<void> 。或者更好的是，您可以使用boost::variant

将模板化对象存储在Container中

2 个答案: