1

我有这样的结构：

Foo.h

template<class T>
class Foo {
public:
     // Public For Now While Constructing Class
     std::shared_ptr<T> m_p256[256];

private:
    static unsigned m_elementCount;
    std::vector<std::shared_ptr<Foo<T>>> m_foos;

public:
    Foo();
    ~Foo();

    void add( T object );
}; // Foo

Foo.inl

template<class T>
unsigned Foo<T>::m_elementCount = 0;

template<class T>
Foo<T>::Foo() :
m_p256{ nullptr } {
} // Foo

template<class T>
Foo<T>::~Foo() {
} // ~Foo 

template<class T>
void Foo<T>::add( T obj ) {
   m_elementCount++;

   if ( m_elementCount == 256 ) {
       // Save Current Instance To Our Vector       
       // Here Is Where I've Tried Several Things And Where I'm Currently Stuck

       m_foos.push_back( a shared_ptr of this instance );

       // Reset Element Count
       m_elementCount = 0;
       Foo<T>* fooPtr = new Foo<T>();
       fooPtr->add( obj );

   } else {
       std::shared_ptr<T> pT( new T( obj ) );
       m_p256[m_elementCount-1] = pT;
   }

} // add

基本上我想要做的是使用 add 函数传递任何相同类型的任意对象。一旦元素计数达到 256 个元素并且传入的该类型的智能指针的内部数组被填充，我想保存这个类的实例化对象的当前实例并将其推送到向量中，并且传入的下一个对象属于新的或创建的下一个实例，但是所有后续实例仍然是原始对象的一部分。因此，当每个 256 数组都被填充时，可以说它就像一个链表，但它更像是一种链接效应。我只是坚持保存此实例的当前状态。

4

0 回答 0