C++ 模板类=设计 or template class operator=

最新推荐文章于 2025-06-03 21:39:46 发布

aban-mtd

最新推荐文章于 2025-06-03 21:39:46 发布

阅读量2.7k

点赞数

CC 4.0 BY-SA版权

分类专栏： C/C++ 文章标签： c语言 class 模板构造函数

本文链接：https://blog.youkuaiyun.com/bendanban/article/details/51762017

C/C++ 专栏收录该内容

63 篇文章

订阅专栏

本文介绍了如何在C++模板类中设计并重载赋值运算符=，强调了不同类型的赋值操作可能涉及类型转换函数的使用。通过实例展示了模板类中创建临时对象、调用构造函数、赋值操作和析构的过程，并提供了经过测试的有效代码片段。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

需要特别重视的是：
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>&). 最后，将临时构造的对象给析构。

补充

经测试，以下代码也是可以的

// 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;
        }
    }
    ~Vec(){
        if (_dat){
            delete[] _dat;  _dat = NULL;
        }
        _len = 0;
    }

public:
    template<class T2>
    Vec<_T>& operator=(const Vec<T2> &B){
        if (_dat){
            delete[] _dat;
        }
        _len = B.get_len();
        if (0!=_len){
            _dat = new _T[B.get_len()];
        }
        for (int i = 0; i < _len; i++){
            _dat[i] = B.get_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;
};