写到前面的话:
作者从毕业开始一直从事游戏开发,提供大量游戏实战模块代码及案例供大家学习与交流,希望以下知识可以带来一些帮助,如有任何疑问，请加群641792143交流与学习
/******************************************************************
*

• 类std::vector 的动态数组类，封装了部分接口，也尽量与std::vector 接近.
• 注意：可指定最小的内存数量，默认是16，每次扩展是翻倍
• 但是手动申请的内存要手动释放 没有采用引用计数的原理

*****************************************************************/

  #include <assert.h>
    #include <iostream>
    
    using namespace  std;
    
    template < typename T, int ONE_TIME_NUM = 16 >
    class Vector
    {
    public:
    	Vector()
    	{
    		data_ptr_ = NULL;
    		max_size_ = 0;
    		count_ = 0;
    	}
    
    	virtual ~Vector()
    	{
    		empty();
    	}
    
    	inline int count() const
    	{
    		return count_;
    	}
    	inline int size() const
    	{
    		return count_;
    	}
    	inline int max_size() const
    	{
    		return max_size_;
    	}
    
    	void insert(const int index, const T& data)
    	{
    		assert(index > -1 && index <= count_);
    
    		if (count_ >= max_size_)
    			reserve((max_size_ > 0) ? max_size_ * 2 : ONE_TIME_NUM);
    
    		if (index < count_)
    		{
    			memmove(data_ptr_ + index + 1, data_ptr_ + index, sizeof(T) * (count_ - index));
    		}
    
    		data_ptr_[index] = data;
    		count_++;
    	}
    	int add(const T& data)
    	{
    		if (count_ >= max_size_)
    			reserve((max_size_ > 0) ? max_size_ * 2 : ONE_TIME_NUM);
    
    		memcpy(data_ptr_ + count_, &data, sizeof(data));
    		count_++;
    		return count_ - 1;
    	}
    
    	int push_back(const T& data)
    	{
    		return add(data);
    	}
    
    	inline const T& get(const int index) const
    	{
    		assert(index > -1 && index < count_);
    		return data_ptr_[index];
    	}
    
    	inline void set(const int index, const T& item)
    	{
    		assert(index > -1 && index < count_);
    		data_ptr_[index] = item;
    	}
    
    	int index(const T& data) const
    	{
    		int i;
    
    		for (i = count_ - 1; i > -1; --i)
    		{
    			if (data_ptr_[i] == data)
    			{
    				return i;
    			}
    		}
    
    		return -1;
    	}
    
    	void remove(const int index)
    	{
    		assert(index > -1 && index < count_);
    
    		remove(index, 1);
    	}
    
    	void remove(const int index, const int count)
    	{
    		assert(index + count <= count_);
    
    		if (count > 0)
    		{
    			memmove(data_ptr_ + index, data_ptr_ + index + count, sizeof(data_ptr_[0]) * (count_ - index - count));
    			count_ -= count;
    		}
    	}
    
    	virtual void empty()
    	{
    		clear();
    		max_size_ = 0;
    
    		if (data_ptr_)
    		{
    			free(data_ptr_);
    			data_ptr_ = NULL;
    		}
    	}
    
    	inline void clear()
    	{
    		count_ = 0;
    	}
    
    	inline void trunc(const int count)
    	{
    		assert(count > -1 && count <= max_size_);
    		count_ = count;
    	}
    
    	virtual void reserve(int count)
    	{
    		if (count > count_ && count != max_size_)
    		{
    			max_size_ = count;
    			data_ptr_ = (T*)realloc(data_ptr_, sizeof(T) * count);
    		}
    	}
    
    	inline void addList(const Vector<T>& list)
    	{
    		addArray((T*)list, list.count_);
    	}
    
    	inline void addArray(T* data, int length)
    	{
    		if (count_ + length > max_size_)
    			reserve(count_ + length);
    
    		memcpy(data_ptr_ + count_, data, length * sizeof(T));
    		count_ += length;
    	}
    
    	inline int push(const T& data)
    	{
    		return add(data);
    	}
    
    	inline T pop()
    	{
    		if (count_ > 0)
    		{
    			count_--;
    			return data_ptr_[count_];
    		}
    
    		throw "stack was empty";
    	}
    
    	inline operator T* () const
    	{
    		return data_ptr_;
    	}
    
    protected:
    	T*	data_ptr_;
    	int	max_size_;
    	int	count_;
    };
    
    int main()
    {
    	Vector<int> vec;
    	vec.push_back(2);
    
    	for (int i = 0; i < vec.size(); i++)
    		cout << vec[i] << "  ";
    
    	cout << endl;
    	system("pause");
    	return 0;
    }