【C++】运算符重载、this指针、 static成员

想变成自大狂

已于 2023-02-13 18:48:10 修改

阅读量1k

点赞数 3

分类专栏： # C++ 文章标签： c++ 开发语言

于 2022-11-23 10:49:39 首次发布

本文链接：https://blog.csdn.net/m0_55752775/article/details/127975698

版权

C++ 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

运算符重载

C++为了增强代码的可读性引入了运算符重载，在默认情况下，C++是不支持自定义类型对象使用运算符，为了能让自定义类型能够像内置类型一样去使用运算符，就引入了运算符重载。运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

注意：

不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
以下运算符不能重载：

. 成员访问运算符
.*, ->* 成员指针访问运算符
:: 域运算符
sizeof 长度运算符
?: 条件运算符（三目运算符）
# 预处理符号

重载 > 运算符，用于把两个 Date 对象比较大小
bool Date::operator>(const Date& d)

也可以写成 bool operator>(Date* const this,Date& d)，一般运算符重载有两个参数，但是一般会把this指针省略。

Date是一个日期类，属于自定义类型，不能直接加减或者相比较，需要把运算符重载。

    // 重载 > 运算符，用于把两个 Date 对象比较大小
	bool Date::operator>(const Date& d)//	bool operator>(Date* const this,Date& d)
	{
		if (_year > d._year)
		{
			return true;
		}
		else if (_year == d._year && _month > d._month)
		{
			return true;
		}
		else if (_year == d._year && _month == d._month && _day > d._day)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

赋值运算符重载

赋值运算符重载格式：

参数类型：const T&，传递引用可以提高传参效率，传值需要拷贝参数，对于自定义类型来说如果字节过大，效率可能会很低。

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

检测是否自己给自己赋值

返回*this ：要复合连续赋值的含义

Date类赋值运算符的重载（=）

//赋值运算符重载
	Date& Date:: operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;

		return *this;
	}

注意区分赋值运算符重载和拷贝构造函数

拷贝构造是一个已经存在的对象拷贝初始化一个马上创建实例化的对象。

        Date d1(2022, 11, 22);

        Date d2(d1); // 拷贝构造，将d1拷贝给d2
Date d3 = d1; // 拷贝构造

赋值运算符重载是两个已经存在的对象之间进行赋值拷贝。

        Date d1(2022, 11, 22);
        Date d2(2022, 11, 23);

//赋值运算符重载
        d1 = d2;        //d1.operator>(d2);

赋值运算符调用可以直接使用运算符，也可以调用函数。d1 = d2/d1.operator>(d2）。

class Date
{
public:
   Date(int year = 1900, int month = 1, int day = 1)
   {
       _year = year;
       _month = month;
       _day = day;
   }

   //拷贝构造函数
   Date(const Date& d)
   {
       _year = d._year;
       _month = d._month;
       _day = d._day;
   }
   //赋值运算符重载
   Date& operator=(const Date& d)
   {

//自己给自己赋值直接返回*this
       if (this != &d)
       {
           _year = d._year;
           _month = d._month;
           _day = d._day;
       }

       return *this;
   }
private:
   int _year;
   int _month;
   int _day;
};

赋值运算符只能重载成类的成员函数不能重载成全局函数

赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。

注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

class Time
{
public:
   Time()
   {
       _hour = 1;
       _minute = 1;
       _second = 1;
   }
   Time& operator=(const Time& t)
   {
       if (this != &t)
       {
           _hour = t._hour;
           _minute = t._minute;
           _second = t._second;
       }
       return *this;
   }
private:
   int _hour;
   int _minute;
   int _second;
};
class Date
{
private:
   // 基本类型(内置类型)
   int _year = 1970;
   int _month = 1;
   int _day = 1;
   // 自定义类型
   Time _t;
};
int main()
{
   Date d1;
   Date d2;
   d1 = d2;
   return 0;
}

编译器生成的默认赋值运算符重载函数可以完成字节序的值拷贝,但只是浅拷贝，对于像栈需要动态申请空间的使用默认的赋值运算符重载是不行的，栈的赋值是一个深拷贝，赋值运算符重载函数必须自己实现。

如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

前置++和后置++重载

前置++返回++之后的值，后置++返回++之前的值。

前置++

// 前置++返回+1之后的值
   Date& Date::operator++()
   {
       *this += 1;
       return *this;
   }

前置++this指向的对象函数结束后不会销毁，故以引用方式返回提高效率。

后置++

后置++为了跟前置++，进行区分，增加了参数占位，跟前置++构成函数重载。

后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递。

// 后置++
   Date Date::operator++(int)
   {
       Date ret(*this);
       *this += 1;
       return ret;
   }

后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后this+1，而temp是临时对象，因此只能以值的方式返回，不能返回引用。

this指针

C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量” 的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。

this指针的特性

1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。

2. 只能在“成员函数”的内部使用。

3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给 this形参。所以对象中不存储this指针。

4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

void Print() {

cout <<_year<< "-" <<_month << "-"<< _day <<endl;

}

//this指针

void Print(Date* this) {

cout <<this._year<< "-" <<this._month << "-"<< this._day <<endl;

}

我们自己在写代码一般是省略this的。

this指针一般存储在栈（形参），有些编译器会放到寄存器中。

代码一：

class A
{
public:
void Print() //A* const this
{
cout << "Print()" << endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->Print();
return 0;
}

代码二：

class A
{
public:
void PrintA() //A* const this
{
cout << _a << endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->PrintA();
return 0;
}

两段代码都给this指针传的是空指针，但是程序一不会报错，p虽然是空指针，但是p调用成员函数不会编译报错，空指针不是语法错误，编译器检查不出来。p作为实参传递给隐藏的this指针，代码一并没有对p解引用，所以不会出现空指针访问。

代码二对p解引用，出现了空指针访问。

static成员

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用 static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

实现一个类，计算程序中创建出了多少个类对象。

class A
{
public:
A() { ++_scount; }
A(const A & t) { ++_scount; }
~A() { --_scount; }
static int GetACount() { return _scount; }
private:
static int _scount;
};
int A::_scount = 0;
void TestA()
{
cout << A::GetACount() << endl;
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;
}

特性

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问

4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

友元函数

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

class Date
{
friend ostream& operator<<(ostream& _cout, const Date& d);
friend istream& operator>>(istream& _cin, Date& d);
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
_cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
_cin >> d._year;
_cin >> d._month;
_cin >> d._day;
return _cin;
}
int main()
{
Date d;
cin >> d;
cout << d << endl;
return 0;
}

友元函数可访问类的私有和保护成员，但不是类的成员函数

友元函数不能用const修饰友元函数可以在类定义的任何地方声明，不受类访问限定符限制一个函数可以是多个类的友元函数

友元函数的调用与普通函数的调用原理相同

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。友元关系是单向的，不具有交换性。友元关系不能传递。如果C是B的友元， B是A的友元，则不能说明C时A的友元。友元关系不能继承。

拷贝对象时的一些编译器优化

class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a = aa._a;
}
return *this;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
void f1(A aa)
{}
A f2()
{
A aa;
return aa;
}
int main()
{
// 传值传参
A aa1;
f1(aa1);
cout << endl;
// 传值返回
f2();
cout << endl;
// 隐式类型，连续构造+拷贝构造->优化为直接构造
f1(1);
// 一个表达式中，连续构造+拷贝构造->优化为一个构造
f1(A(2));
cout << endl;
// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
A aa2 = f2();
cout << endl;
// 一个表达式中，连续拷贝构造+赋值重载->无法优化
aa1 = f2();
cout << endl;
return 0;
}