短小精悍的小程序，留作以后放入库中

1.vector内存释放

template<typename T> void erasevt(vector<T>& vt)
{
    vector<T> temp;
    temp.swap(vt);
}

2.使用多态实现线性表，具有线性表的基本操作：插入、删除、测长

//抽象基类
template<typename T> struct Tcontainer
{
    virtual void push(const T&) = 0;
    virtual void pop() = 0;
    virtual const T& begin() = 0;
    virtual const T& end() = 0;
    virtual size_t size() = 0;
};

template<typename T>
struct tvector :public Tcontainer<T>
{
    static const size_t _step = 100;

    tvector():_size(0),_cap(_step),buff(NULL)
    {
        re_capacity(_cap);
    }

    ~tvector()
    {
        free buff;
    }

    virtual void push(const T& vt)
    {
        if (_size >= _cap)
        {
            re_capacity(_cap += _step);
        }
        buff[_size++] = v;
    }

    virtual void pop()
    {
        if (_size)
            _size--;
    }

    virtual const T& begin()
    {
        return buff[0];
    }

    virtual const T& end()
    {
        if (_size)
            return buff[_size - 1];
    }

    virtual size_t size()
    {
        return _size;
    }

    const T& operator[] (size_t n)
    {
        if (n >= 0 && n < _size)
            return buff[n];
    }

private:

    void re_capacity(const size_t n)
    {
        if (n <= 0) return;

        if (!buff)
        {
            buff = (T*)malloc(sizeof(T)*n);
        }
        else {
            buff = (T*)realloc(buff, sizeof(T)*n);
        }
    }

private:
    size_t _size; //实际元素个数
    size_t _cap;  //已分配容量
    T* buff;      //首地址
};

思路蛮巧妙的。

3.辗转相除法

//辗转相除法(求两个数字的最大公约数)
int gcd(unsigned int m, unsigned int n)
{
    if (m < n) //选取最小数字作为除数
    {
        int t = m;m = n;n = t;
    }
    if (m%n)
        return gcd(n, m%n);
    else return n;
}