赋值运算符重载函数，在工程里为什么总是私有private的？

96 阅读 0 评论 64 点赞

我是靠谱客的博主虚幻汽车，最近开发中收集的这篇文章主要介绍赋值运算符重载函数，在工程里为什么总是私有private的？，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

序
1.原因
2.问题举例
3.解决——显式定义私有赋值运算符重载
4.解决——形参使用const限定

正文

原因
在实际工程中，类对象经常作为函数参数实参传递出去，形参通使用引用接收。
当引用被再次赋值之后，虽然引用还是初始化时候的对象的引用，但赋值操作是相当将对象执行类默认的隐式赋值函数。
为了避免再次地对引用赋值，可以将赋值运算符重载为private，或者将形参引用限定为const，来避免这种意外的赋值。

问题举例
执行A.plusplus时，将B作为实参传入，形参p是B的引用。
但plusplus函数中执行了p=0（不希望发生的随手的误写），等价于B=0。即是将B成员赋值为默认初始值0。
程序输出：
mem:1
mem:2
mem:3
mem:0

#include <stdio.h>
using namespace std;
class Person {
    public:
        Person(int m) : mem(m) {}
        void printmem() {
            printf("mem:%dn", mem);
        }
        void plusplus(Person& p) { // p是B的引用
            mem = mem + p.mem;
            p = 0; //等价于将B = 0，此时mem = 0
        }
        int mem;
};
int main()
{
    Person A(1);
    A.printmem();
    Person B(2);
    B.printmem();

    A.plusplus(B);
    A.printmem();
    B.printmem(); //A.plusplus中B被赋值为0，导致B成员mem被改变
    return 0;
}

问题解决——显式定义私有赋值运算符重载
工程中很少出现整体对象之间赋值。多数请下会禁用赋值运算符，禁用方法是将赋值运算符重载为私有成员函数。

class Person {
    public:
        Person(int m) : mem(m) {}
        void printmem() {
            printf("mem:%dn", mem);
        }
        void plusplus(Person& p) { // p是B的引用
            mem = mem + p.mem;
            p = 0; //等价于将B = 0，此时mem = 0
        }
        int mem;
    private:
        Person& operator= (const Person&);
};

编译后会报错：
$ g++ -o run test2.cpp /tmp/ccZK6btr.o:test2.cpp:(.text$_ZN6Person8plusplusERS_[__ZN6Person8plusplusERS_]+0x38)：对‘Person::operator=(Person const&)’未定义的引用 collect2: 错误：ld 返回 1
解决：将p=0;一行删掉，则编译成功。

问题解决——形参使用const限定
被const限定的变量，无法进行再次赋值。

class Person {
    public:
        Person(int m) : mem(m) {}
        void printmem() {
            printf("mem:%dn", mem);
        }
        void plusplus(const Person& p) { // p是B的引用
            mem = mem + p.mem;
            p = 0; //等价于将B = 0，此时mem = 0
        }
        int mem;
};

编译后会报错：
$ g++ -o run test2.cpp test2.cpp: 在成员函数‘void Person::plusplus(const Person&)’中: test2.cpp:14:15: 错误：将‘const Person’作为‘Person& Person::operator=(const Person&)’的‘this’实参时丢弃了类型限定 [-fpermissive] p = 0; //等价于将B = 0，此时mem = 0
解决：将p=0;一行删掉，则编译成功。