您当前的位置:首页 > 计算机 > 编程开发 > VC/VC++

C++重载=(赋值运算符)

时间:01-10来源:作者:点击数:

和普通变量一样,对象之间也可以相互赋值。赋值运算符=可以用来将一个对象拷贝给另一个已经存在的对象。对象之间的赋值是将成员变量依次拷贝,而不是将整个对象的内存按位拷贝。

一般情况下,默认的=就能满足对象之间的赋值需求,请看下面的例子:

#include <iostream>
using namespace std;
class Demo{
private:
    int m_a;
    int m_b;
public:
    Demo(): m_a(0), m_b(0){ }
    Demo(int a, int b): m_a(a), m_b(b){ }
    void display(){ cout<<m_a<<", "<<m_b<<endl; }
};
int main(){
    Demo obj1(10, 20);
    Demo obj2 = obj1;  //对象之间的赋值
   
    obj1.display();
    obj2.display();
    return 0;
}

运行结果:

10, 20
10, 20

但是当一个类中包含指针类型的成员变量时,可能会带来问题,请看下面的代码:

#include <iostream>
using namespace std;
class Book{
private:
    double m_price;  //书的价格
    int *m_bookmark;  //书签
    int m_num;  //书签的数量
public:
    Book(): m_price(0.0), m_bookmark(NULL), m_num(0){}
    Book(double price, int *bookmark, int num);
    void setBookmark(int, int);  //修改书签
    void display();
};
Book::Book(double price, int *bookmark, int num): m_price(price), m_num(num){
    int *bmTemp = new int[num];
    for(int i=0; i<num; i++){
        bmTemp[i] = bookmark[i];
    }
    this->m_bookmark = bmTemp;
}
void Book::setBookmark(int page, int index){
    if(index >= m_num-1){
        cout<<"Out of bound!"<<endl;
    }else{
        m_bookmark[index] = page;
    }
}
void Book::display(){
    cout<<"price: "<<m_price<<endl;
    cout<<"bookmarks: ";
    for(int i=0; i<m_num; i++){
        if(i == m_num-1){
            cout<<m_bookmark[i]<<endl;
        }else{
            cout<<m_bookmark[i]<<", ";
        }
    }
}
int main(){
    int m_bookmark[] = { 1, 49, 56, 290 };
    Book java, cpp(68.5, m_bookmark, 4);
    cpp.display();
    java = cpp;  //对象之间赋值
    java.setBookmark(100, 2);
    cpp.display();
    return 0;
}

运行结果:

price: 68.5
bookmarks: 1, 49, 56, 290
price: 68.5
bookmarks: 1, 49, 100, 290

这段代码定义了一个 Book 类,表示一本书,书有价格,也有书签。书签是我们所标记的页码,这些页码中往往包含重要的知识点,记录下这些页码能够方便以后查阅。书签可以有多个,所以需要将它放在数组中。setBookmark() 函数用来修改某个书签,display() 函数用来展示书签和价格。

Book 类的构造函数中不是直接接收参数的值,而是根据参数所指向的数组,再创建一个新的数组。这样做的好处是对象有属于自己的数组,在其他地方修改实参所指向的数组不会影响该数组,能够很好的隔离。

在 main() 函数中,我们创建了两个对象 java 和 cpp,并用 cpp 给 java 赋值。两次调用 display() 的结果不同表明,调用 java 对象的 setBookmark( ) 函数影响到了 cpp 对象。这是因为,执行java = cpp;语句时会将 cpp.m_bookmark 的值复制给 java.m_bookmark,不同对象的成员变量指向同一个数组,当然会相互影响。

要解决这个问题,就需要重载赋值运算符,如下所示:

Book & Book::operator=(const Book &b){
    if( this != &b){
        this->m_price = b.m_price;
        this->m_num = b.m_num;
        //为bookmark赋值
        int *bmTemp = new int[b.m_num];
        for(int i=0; i<b.m_num; i++){
            bmTemp[i] = b.m_bookmark[i];
        }
        this->m_bookmark = bmTemp;
    }
    return *this;
}

将这个函数放入 Book 类中,再执行java = cpp;语句时,会转换为:

java.operator=(cpp);

在函数体中,this 就指向 java 对象。这样 java 对象也会拥有属于自己的数组,两个对象之间不会再相会影响。

可以发现,重载赋值运算符时,函数的参数和返回值类型都必须是对象的引用。以 Book 类为例来说,赋值运算符重载函数一般有两种原型:

Book & operator=( Book &b );
Book & operator=( const Book &b );

返回值和参数都是 Book 类对象的引用。下面一种原型则规定在赋值时不能修改原来的对象。

赋值运算符重载函数除了能有对象引用这样的参数之外,也能有其它参数。但是其它参数必须给出默认值。如下所示:

Book & operator=(const Book &b, a = 10);
方便获取更多学习、工作、生活信息请关注本站微信公众号城东书院 微信服务号城东书院 微信订阅号
推荐内容
相关内容
栏目更新
栏目热门