std::vector<cItem*> cv;
 cv.insert( new cItem );

 std::vector<cItem*> cv;
 cv.insert( new cItem, std::vector::end() );

 cv.insert (cv.end(), new cItem );
или
 cv.push_back (new cItem);

cv[ 3 ]

//////////////////////////////////////////////////////////////////////////
// fast-allocating array
// uses chunk pool
template<typename _Ty>
class fast_array
{
	typedef std::vector<_Ty> super;
	typedef fast_array<_Ty> my_type;

	super stl_vector;

	static bool destroyed;

	static struct pool_t: public std::vector<super*> {
		~pool_t() {
			for(pool_t::iterator i=this->begin(), e=this->end(); i!=e; ++i)
				delete *i;
			destroyed=true;
		}

	} pool; 

	static size_t top;

	static void get_chunk(my_type* instance) {
		size_t sz=pool.size();
		if (top>=sz)
			pool.resize(top* 2 + 50 );

		super* chunk=pool[top];
		if (chunk==NULL) 
			chunk=pool[top]=new super();	// we don't need to deallocate chunks :)

		++top;
		instance->stl_vector.swap(*chunk);
	}

	static void put_chunk(my_type* instance) {
		 --top;
 
		pool[top]->swap(instance->stl_vector);
	}

public:
	fast_array() { get_chunk(this); stl_vector.resize( 0 ); }
	~fast_array() { if(!destroyed) put_chunk(this); }
};

template<class _Ty> bool fast_array<_Ty>::destroyed= 0 ;
template<class _Ty> size_t fast_array<_Ty>::top= 0 ;
template<class _Ty> typename fast_array<_Ty>::pool_t fast_array<_Ty>::pool;

//////////////////////////////////////////////////////////////////////////

typedef fast_array<char>	char_array;
typedef fast_array<int>	int_array;
typedef fast_array<size_t>	uint_array;
typedef fast_array<real>	real_array;