类和对象(三)

已于 2022-06-28 15:45:55 修改
阅读量151 收藏 1
点赞数 3
分类专栏： c++ 文章标签： c++ c语言 visual studio
于 2022-06-18 09:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52906742/article/details/125249073
版权

文章目录

运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型和参数列表与普通的函数类似。

  • 函数名：operator 运算符。
  • 参数：运算符有几个操作数就有几个参数。
  • 返回值：运算符运算后返回什么类型，就是什么。

注意：

  • 不能通过连接其他符号来创建新的操作符：比如operator@。
  • 重载操作符必须有一个类类型或者枚举类型的操作数。
  • 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义。
  • 作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的，操作符有一个默认的形参this，限定为第一个形参 。
  • .* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。 (第四个是三目运算符)

为什么要进行运算符重载？

运算符都是默认给内置变量类型用的，自定义类型想要使用就需要进行运算符重载。运算符重载的意思就是我们去写一个函数定义这里运算符行为。

重载日期类的=和<运算符。

class Date
{
public:
	//构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//重载等于号 ，只需要一个参数，因为类中成员函数有默认的this指针
	bool operator==(const Date& d2)
	{
		return _year == d2._year &&
			_month == d2._month &&
			_day == d2._day;
	}

	//重载小于号
	bool operator<(const Date& d2)
	{
		if (_year < d2._year)
		{
			return true;
		}
		else if(_year == d2._year && _month < d2._month)
		{
			return true;
		}
		else if (_year == d2._year && _month == d2._month && _day < d2._day)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
private:
	int _year;
	int _month;
	int _day;
};

//定义在全局，无法访问私有变量，否则会破坏封装
//bool operator==(const Date& d1, const Date& d2)
//{
//	return d1._year == d2._year &&
//		d1._month == d2._month &&
//		d1._day == d2._day;
//}

int main()
{
	Date d1(2022, 5, 15);
	Date d2(2021, 10, 1);
	d1 == d2;// == d1.operator(d2) == d1.operator(&d1, d2)
	return 0;
}
赋值运算符(=)重载

赋值运算符重载需要注意：

  1. 返回*this(进行连续赋值)。
  2. 注意检测是否自己给自己赋值。
  3. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝(浅拷贝)，同样的，需要注意指针类型的拷贝。和拷贝构造函数类似，内置类型成员值拷贝，自定义类型成员调用它的赋值重载。
class Date
{
public:
	//构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
    
	//赋值运算符重载
	/*void operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d2._year;
			_month = d2._month;
			_day = d2._day;
		}
	}*/

	//赋值运算符需要支持连续赋值，所以需要有返回值，利用引用返回，防止没必要的拷贝
	Date& operator=(const Date& d)
	{
		//防止自己赋值自己
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date d1(2022, 5, 15);
	Date d2(2021, 10, 1);
	Date d3(2020, 9, 20);
	d1 = d2;
	//连续赋值
	d1 = d2 = d3;
	return 0;
}
const成员函数

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

class Date
{
public:
	//构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}	
	void Print()
	{
		cout<<_year<<'/' << _month << '/' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 5, 15);
	const Date d2(2021, 10, 1);//用const修饰，所指向的内容不能被改变
	d1.Print();
	d2.Print();//这里会报错，why？
	return 0;
}

image-20220516190920612

这里存在权限放大的问题，用const修饰后，d2的权限是只读的，作为参数传到Print函数中，权限被放大了，所以会报错。

const的使用总结：

  1. 成员函数加const变成const成员函数是有好处的，这样const和非const的对象都可以访问。
  2. 不是所有的成员函数都需要加const，要具体看函数的功能，如果成员函数是一个修改型的函数，就不能加，如果是只读型的，就最好加上。总之，要修改成员变量就不加，否则最好就加上。
初始化列表

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值,虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因初始化只能初始化一次，而构造函数体内可以多次赋值。

构造函数初始化自定义类型的不足：

class A
{
public:
	A(int a = 0)
	{
		_a = a;
	}
private:
	int _a;
};

class B
{
public:
    //不使用初始化列表来初始化，在给自定义类型赋值时，就特别麻烦
	B(int a, int b)
	{
		_b = b;
		_aa = A(a);//使用匿名对象来初始化_aa
	}
private:
	int _b;
	A _aa;
};

补充：匿名对象：匿名对象也称为临时对象，最重要的是它的生命周期，只在这一行，使用完立马被析构。

所以就有了初始化列表，用来初始化成员变量。初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一放在括号中的初始值或表达式。

class A
{
public:
    //构造函数
	A(int a)
	{
		_a = a;
	}
private:
	int _a;
};

class B
{
public:
    //初始化列表初始化
	B(int a, int b, int c, int& d)
		:_b(b)
        ,_c(c)
        ,_d(d)
		,_aa(a)
	{
		
	}
private:
	int _b;
    const int _c;
    int& _d;
	A _aa;
};

注意：

  1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次）。
  2. 类中包含以下成员，必须放在初始化列表位置进行初始化:
    • 引用成员变量。(引用必须在定义的时候初始化)
    • const成员变量。(const类型的成员必须在定义的时候初始化)
    • 没有默认构造函数的自定义类型成员。
  3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
  4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。(要按成员变量的定义顺序初始化)
expilicit关键字(禁止构造函数的隐式类型转换)
class A
{
public:
	A(int a)
		:_a(a)
	{
		
	}
	void Print()
	{
		cout << _a << endl;
	}
private:
	int _a;
};

int main()
{
	A aa1(10);
	A aa2 = 2;//这样写不会报错，本质上是一个隐式的类型转换
	aa1.Print();
	aa2.Print();
	return 0;
}

上面的代码aa2 = 2，其实存在一个隐式的类型转换。

image-20220516202744985

这里的编译器优化并不是所有的编译器都会优化，但是较新版的编译器应该都有，就不会进行两次拷贝构造，只会进行一次构造。

但是如果构造函数有多个参数，也可以这么写吗？实际上c++11之前的版本是不支持的，但是从c++11开始是支持的。

A(int a, int b)
    :_a(a)
    ,_b(b)
{

}

int main()
{
    A aa1(10, 20);
    A aa2 = {20, 30};//可以这样来初始化，注意用花括号
    return 0;
}

这种隐式类型的转换比较影响代码的可读性，如果不允许这样写，可以加在构造函数函数名前加explicit关键字。

static成员

声明为static的类成员称为类的静态成员。用static修饰的成员变量，称之为静态成员变量，用static修饰的成员函数，称之为静态成员函数。

静态成员变量

静态成员变量的特点：

  1. 静态成员变量为所有类对象所共享，不属于某个具体的实例。
  2. 静态成员变量必须在类外定义，定义时不添加static关键字。
  3. 类静态成员即可用类名::静态成员或者对象.静态成员(受访问限定符的限制)来访问。
  4. 静态成员变量也受访问限定符的限制
class A
{
public:
	
private:
	int _a; //存在某个对象中，属于某个对象
	static int _count; //存在静态区，属于整个类，也属于每个定义出来的类共享， 在计算类的大小时，静态成员变量不会计算进去
					   //跟全局变量比较，受类域和访问限定符的限制，更好的体现封装，不能轻易修改
    				  
};

//静态成员函数不能在构造函数初始化，必须在全局位置初始化，定义时不添加static关键字
int A::_count = 10;
静态成员函数

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

  2. 静态成员函数和类的普通成员函数一样，也有public、protected、private3种访问级别，也可以具有返回值。

  3. 非静态成员函数可以访问静态的成员函数，但是静态的成员函数无法访问非静态的成语函数，因为静态的成员函数不包含this指针。

class A
{
public:
	A(int a)
		:_a(a)
	{

	}
    //非静态成员函数
	void Print()
	{
		cout << _a << endl;
        //可以调用静态成员函数，不需要this指针来访问
		PrintC();
	}
    //静态成员函数
	static void PrintC()
	{
		cout << _count << endl;
        //无法访问，静态成员函数不包含this指针，无法访问非静态成员函数
        //Print();
	}
private:
	int _a; //存在某个对象中，属于某个对象
	static int _count; //存在静态区，属于整个类，也属于每个定义出来的类共享
					   //跟全局变量比较，受类域和访问限定符的限制，更好的体现封装，不能轻易修改
};

static用法总结：

  • C：
    1. 修饰全局变量和全局函数，改变链接属性，只在当前文件可见。
    2. 修饰局部变量，改变生命周期。
  • C++:
    1. 修饰成员变量和成员函数，成员变量属于整个类，为所有对象共享，成员函数没有this指针。

上面在c中的这些特性，在c++中依旧可以使用，因为c++是兼容c的。

友元

友元分为：友元函数和友元类。
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

友元函数

介绍友元函数之前，先来看看这个问题，可不可以通过cout将整个对象中的一些元素输出呢？

可以试试运算符重载的方式。

class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{

	}
    
    //重载流插入运算符，通过cout输出Date类
	ostream& operator<<(ostream& out)
	{
		out << _year << '/' << _month << '/' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 5, 17);
	cout << d1;//这样写编译器会报错，why？
	d1 << cout;//这样写才可以达到效果，但是这样又不符合常规的写法。
	return 0;
}

因为作为类的非静态成员函数，this指针默认是在第一个参数位置，无法去改变。所以如果在类中重载的话，就只能这样写了。

那试试在类外面来写呢？问题显而易见，无法访问私有的成员变量，如果标记为公有的话，是可以的，但是会破坏类的封装。那么能不能在不破坏封装的同时也可以完成效果呢？

这样就需要用到友元了。

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

说明：

  1. 友元函数可访问类的私有和保护成员，但不是类的成员函数。
  2. 友元函数不能用const修饰。(const本质是修饰this指针，友元函数不是成员函数)
  3. 友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
  4. 一个函数可以是多个类的友元函数。
  5. 友元函数的调用与普通函数的调用和原理相同。
class Date
{
	//声明友元函数
	friend ostream& operator<<(ostream& out, const Date& d);
public:
	Date(int year, int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{

	}
private:
	int _year;
	int _month;
	int _day;
};

//重载流插入运算符
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << '/' <<d. _month << '/' << d._day << endl;
    //添加返回值，支持连续输出
	return out;
}

int main()
{
	Date d1(2022, 5, 17);
	Date d2(2022, 5, 18);
	cout << d1 << d2;
	return 0;
}

这也就可以实现使用cout来输出对象中的私有成员变量。同理，也可以使用cin来实现读入。

友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

  1. 友元关系是单向的，不具有交换性。
  2. 友元关系不能传递。如果C是B的友元，B是A的友元，则不能说明C是A的友元。
class Time
{
	//声明友元函数,Date类是Time类的友元，可以在Date类中访问Time类的私有成员
	friend class Date;
public:
	Time(int hour, int minute, int second)
		:_hour(hour)
		, _minute(minute)
		, _second(second)
	{

	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
	
public:
	Date(int year, int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{

	}
	void Print()
	{
		Time t1(12, 0, 3);
        //访问Time类的私有成员
		cout << t1._hour << t1._minute << t1._second << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
注意：内部类天生就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

  1. 内部类可以定义在外部类的public、protected、private都是可以的。
  2. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
  3. sizeof(外部类)=外部类，和内部类没有任何关系， 计算外部类的大小时不会将内部类的大小计算进去。

内部类就是完全产生出来专门给外部类服务的，在c++中用的很少。

class A
{
public:
	//内部类B
	class B
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;//OK
			cout << a.h << endl;//OK
		}
	};
private:
	static int k;
	int h;
};

int A::k = 1;

int main()
{
    //实例化内部类B的对象
	A::B b;
	b.foo(A());
	return 0;
}

独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
注意：内部类天生就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

  1. 内部类可以定义在外部类的public、protected、private都是可以的。
  2. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
  3. sizeof(外部类)=外部类，和内部类没有任何关系， 计算外部类的大小时不会将内部类的大小计算进去。

内部类就是完全产生出来专门给外部类服务的，在c++中用的很少。

class A
{
public:
	//内部类B
	class B
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;//OK
			cout << a.h << endl;//OK
		}
	};
private:
	static int k;
	int h;
};

int A::k = 1;

int main()
{
    //实例化内部类B的对象
	A::B b;
	b.foo(A());
	return 0;
}
lucas_dd
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值