智能指针作为多态的类成员

我是智能指针的新手，如果有人能给我一个提示，我处理智能指针作为类成员的方式是否正确，我将非常感激。更准确地说，我想要实现的解决方案是在类多态性上下文中，并且应该是理想的异常安全的。

给定一个异构对象的容器(std::vector<shared_ptr<CBase> > my_vector)，通常添加元素的方法是:my_vector.push_back( shared_ptr<CBase>(new CChild(1)))，这样以后就可以调用特定派生类的成员函数:my_vector[0]->doSomething() .

1. 我想要实现的是将堆栈对象添加到向量中，并且仍然能够做多态性。直觉上类似于:CChild<float> obj1(1); my_vector.push_back(obj1)。为了解决这个问题，我现在使用虚拟构造函数的习惯用法:CChild obj1(1); my_vector.push_back(obj1.clone()); .
   注意，在some的派生类中，我有创建对象的静态成员函数，例如:CChild<float> obj1 = CChild<float>::initType2(1);

2. 因为需求问题，也有一个干净的接口，我现在有一个新的类CFoo<T>，作为数据成员CBase<T>类的智能指针。
   这个想法是除了包含其他新的私有成员，这个类封装/处理指向派生对象的智能指针，这样我就可以做这样的事情:
   CFoo<float> myfoo(CChild<float>::initType2(1)); my_vector.push_back(myfoo);。这意味着容器现在是vector<CFoo<T> >类型而不是vector<shared_ptr<CBase> >类型

在这种情况下，我想知道如何实现smart pointers作为类成员的类的构造函数?那么遵循拷贝交换习惯的operator =的实现如何呢?下面，我给出了我的类设计的一些插图:

template < typename T >
class CBase{
    public:
        CBase(){};
        virtual ~CBase(){};
        ...
        virtual CBase<T> * clone() const = 0;
        virtual CBase<T> * create() const = 0;
};
template < typename T >
class CChild1 : public CBase{
    public:
        ...
        CChild1<T> * clone() const  { return new CChild1<T>(*this); }
        CChild1<T> * create() const { return new CChild1<T>(); }
        static CChild1 initType1(double, double);
        static CChild1 initType2(int);
};
template < typename T >
struct type{
    typedef std::tr1::shared_ptr<T> shared_ptr;
};
template < typename T >
class CFoo{
    public:
        CFoo();
        CFoo( const CBase<T> &, int = 0 );
        CFoo( const CFoo<T> & );
        void setBasePtr( const CBase<T> & );
        void swap( CFoo<T> & );
        CFoo<T> & operator = ( CFoo<T> );
        ...
        ~CFoo();
    private:
        typename type<CBase<T> >::shared_ptr m_ptrBase;
        int m_nParam;
};
template < typename T >
CFoo<T>::CFoo()
    :m_nParam(0)
// How shall I handle here the "m_ptrBase" class member? e.g point it to NULL?
{
}
template < typename T >
CFoo<T>::CFoo(const CBase<T> & refBase, int nParam)
    :m_ptrBase(refBase.clone()), // Is this initialization exception-safe?
    m_nParam(nParam)
{
}
template < typename T >
CFoo<T>::CFoo(const CFoo<T> & refFoo)
    :m_ptrBase(refFoo.m_ptrBase),
    m_nParam(refFoo.m_nParam)
{
}
template < typename T >
void CFoo<T>::setBasePtr( const CBase<T> & refBase ){
    // ??? I would like to do sth. like: m_ptrBase(refBase.clone())
}
template < typename T >
CFoo<T>::~CFoo(){
    // The memory is going to be freed by the smart pointer itself and therefore
    // the destructor is empty, right?
}
template < typename T >
void CFoo<T>::swap( CFoo<T> & refFoo ){
//does this here makes sense?
    using std::swap;
    swap(m_ptrBase, refFoo.m_ptrBase);
    swap(m_nParam, refFoo.m_nParam);
}
template < typename T >
CFoo<T> & CFoo<T>::operator = ( CFoo<T> copyFoo ){
    copyFoo.swap(*this);
    return (*this);
}

下面是我想直观实现的一个例子。首先，我用CFoo<float>对象填充容器，这些对象除了包含另一个整数类成员外，还包含指向派生类的智能指针(注意，所有这些都只是举例说明)。

std::vector<CFoo<float> > my_bank;
for (int b=0; b < 3; b++){
   float x = b*sqrt(2);
   my_bank.push_back( new CFoo<float>( CChild1<float>::initType2(x), b) );
}
for (double s= 1.0; s<= 8.0; s *= 2.0){
    my_bank.push_back( new CFoo<float>( CChild2<float>::initType2(x), 0) );
 }

一旦容器被填满，我想做一些操作，调用virtual函数，例如doSomething，它在每个派生类中都是特化的。

for (int i=0; i < (int)my_bank.size(); i++){
    int b = my_bank[i].m_nParam;
    CBase<float>* myChild = my_bank[i].m_ptrBase;
    myChild->doSomething( param1, param2, param3, ..., b);
}