если у вас есть полиморфный объект (указанный объект может быть более специализированным, чем переменная), я предлагаю вам создать виртуальный метод с именем clone(), который выделяет новый указатель с копией вашего объекта:

Base* A::clone() {
    A* toReturn = new A();
    //copy stuff
    return toReturn;
}

Если вы не можете изменить свой базовый класс, вы можете использовать RTTI, но я не буду подходить к этому решению в этом ответе. (Если вам нужны дополнительные сведения об этом решении, задайте вопрос о полиморфном клонировании с помощью RTTI).

Если у вас нет полиморфного объекта, вы можете выделить новый объект, вызвав конструктор копирования.

void YourVector::push_back(Base* obj) {
    Base* copy = new Base(obj);
}

Но кажется, что то, что вам действительно нужно, это shared_ptr, доступный в <tr1/memory> (или <memory>, если вы используете C++0x).

Обновление на основе комментариев

У вас также может быть два списка параметров шаблона:

template <typename T>
struct CopyConstructorCloner {
    T* operator()(const T& t) {
        return new T(t);
    }
}

template <typename T, typename CLONER=CopyConstructorCloner<T> >
class MyList {
    CLONER cloneObj;
public:
    // ...
    void push_back(const T& t) {
        T* newElement = cloneObj(t);
        // save newElemenet somewhere, dont forget to delete it later
    }
}

При таком подходе можно определить новую политику клонирования для таких вещей, как указатели.

Тем не менее, я рекомендую вам использовать shared_ptrs.

Я думаю, что для такого рода проблем лучше использовать умные указатели, например: boost::shared_ptr или любую другую эквивалентную реализацию.

Нет необходимости вызывать new для данного типа данных T. Реализация push_back должна (должна) вызывать конструктор копирования или оператор присваивания. Память должна была быть выделена для хранения тех элементов, которые вставляются. Начальное выделение памяти не должно вызывать CTOR типа T. Что-то вроде:

   T* pArray; 
   pArray = (T*) new  BYTE[sizeof(T) * INITIAL_SIZE);

А затем просто поместите новый объект в pArray, вызвав оператор присваивания.

Одним из решений является создание копии конструкции:

MyClass *p = new MyClass();
MyVector<MyClass*> v;
v.push_back(new MyClass(*p));

Обновление: из вашего обновленного вопроса вы определенно можете переопределить push_back

template<typename T>
class MyVector {
public:
  void push_back (T obj); // general push_back
  template<typename TYPE>  // T can already be a pointer, so declare TYPE again
  void push_back (TYPE *pFrom)
  {
    TYPE *pNew = new TYPE(*pFrom);
    // use pNew in your logic...
  }
};

Что-то вроде этого:

template<typename T>
class MyVector
{
    T*     data;          // Pointer to internal memory
    size_t count;         // Number of items of T stored in data
    size_t allocated;     // Total space that is available in data
                          // (available space is => allocated - count)

    void push_back(std::auto_ptr<T> item) // Use auto pointer to indicate transfer of ownership
    /*void push_back(T* item) The dangerous version of the interface */
    {
        if ((allocated - count) == 0)
        {    reallocateSomeMemory();
        }

        T*   dest = &data[count];  // location to store item

        new (dest) T(*item);       // Use placement new and copy constructor.
        ++count;
    }

    // All the other stuff you will need.
};

Изменить на основе комментариев:

Чтобы вызвать его, вам нужно сделать это:

MyVector<Plop>    data;

std::auto_ptr<Plop>   item(new Plop());   // ALWAYS put dynamically allocated objects
                                          // into a smart pointer. Not doing this is bad
                                          // practice.
data.push_back(item);

Я использую auto_ptr, потому что указатели RAW — это плохо (т.е. в реальном коде на C++ (в отличие от C) вы редко видите указатели, они скрыты внутри умных указателей).