设计一个模板类，某个成员变量是在调用的时候才能知道其具体类型。设计重载运算符=。

需要特别重视的是：
Vec<int> 与Vec<float> 是不同的类型，不同类型之间的赋值，会默认调用类型转换函数。

---

模板类

// undefied behavior for 0 > _len 
template<class _T>
class Vec{
public:
    Vec() : _len(0), _dat(NULL) {}
    Vec(const int32_t len) {
        _len = len;
        _dat = new _T[len];
    }
    Vec(const int32_t len, const _T &val) {
        _len = len;
        _dat = new _T[len];
        for (int32_t i = 0; i < _len; i++){
            _dat[i] = val;
        }
    }
    template<class CT>
    Vec(const Vec<CT> &obj){
        _len = obj.get_len();
        if (0!=_len){
            _dat = new _T[_len];
        }
        for (int32_t i = 0; i < _len; i++){
            _dat[i] = (_T)(obj.get_dat()[i]);
        }       
    }

    ~Vec(){
        if (_dat){
            delete[] _dat;  _dat = NULL;
        }
        _len = 0;
    }

public:
    Vec<_T>& operator=(const Vec<_T> &B){
        if (_dat){
            delete[] _dat;
        }
        _len = B._len;
        if (0!=_len){
            _dat = new _T[B._len];
        }
        for (int i = 0; i < _len; i++){
            _dat[i] = B._dat[i];
        }
        return *this;
    }

public: // utilities
    template<class T>
    friend std::ostream& operator<<(std::ostream &output, Vec<T> &am);

    int32_t get_len() const{
        return _len;
    }
    _T* get_dat() const {
        return _dat;
    }
private:
    int32_t _len;
    _T* _dat;
};

template<class T>
std::ostream& operator<<(std::ostream &output, Vec<T> &am){
    output << am._dat << " : ";
    for (int32_t i = 0; i < am._len; i++){
        cout << am._dat[i] << " ";
    }
    return output;
}

---

测试

Vec<int16_t>  A(10, 2);
Vec<int32_t> B;
B = A; 
cout << A << endl;
cout << B << endl;

其中一次输出结果：

01409C88 : 2 2 2 2 2 2 2 2 2 2
0140BA18 : 2 2 2 2 2 2 2 2 2 2

---

B=A 首先 调用 Vec<int32_t>(A)构造一个临时的Vec<int32_t>的对象， 对应被调用的构造函数是Vec<int16_t>(const Vec<int16_t>&). 然后，以被构造的临时对象为右参数调用Vec<int32_t>& operator=(const Vec<int32_t>&). 最后，将临时构造的对象给析构。