类与对象(下)

安全感0.0

于 2024-09-11 17:58:55 发布

阅读量460

点赞数 10

文章标签： c++

本文链接：https://blog.csdn.net/m0_74402251/article/details/141967557

版权

目录标题

1.再谈构造函数
2.static成员
3.友元
- 3.1友元函数
- 3.2友元类
4.内部类
5.匿名对象
6.拷贝对象时的一些编译器优化

1.再谈构造函数

1.1构造函数体赋值

在创建对象的时候，编译器通过构造函数，给对象中各个成员变量一个合适的初始值。

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

虽然上述构造函数调用之后，对象中已经有一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称为初始化，因为初始化只能初始化一次，而构造函数体内可以多次赋值。

1.2初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个成员变量后面跟一个放在括号中的初始值或者表达式。
例1.

class Date
{
public:
	Date(int year,int month,int day)
		:n(1)
		,month(2)
	{
		//赋值修改
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year = 1;//如果这里初始化列表中没有包含对_year的初始化的话，这里声明会对_year进行初始化，如果初始化列表已经对
	//某一个成员进行过初始化的话，那么该变量的缺省值则没有作用
	int _month;
	int _day;
	const int _n;
};

int main()
{
	Date d1(2024,1,31);
	return 0;
}

例2.
初始化列表是每一个成员变量定义初始化的位置，因此能用初始化列表就建议用初始化列表进行初始化

class A
{
public:
	A(int a = 0,int b = 0)
		:_a(a)	
	{
		cout << "A(int a = 0)" << endl;
	}
private:
	int _a;
};
class Date{
public:
	Date(int year,int month,int day,int& x)
		:_year(year)
		,_month(month)
		,_day(day)
		,_n(1)
		,_ref(x)
		,_aa(1,2)//这里是调用自定义类型它的的默认构造
		,_p(malloc(10*sizeof int))//初始化列表也可以调用函数
	{}
private:
	int _year = 1;
	int _month = 1;
	int _day;
	
	//对于必须在初始化列表初始化的变量，就必须显示写
	//除了有默认构造函数的自定义类型变量
	const int _n;
	int& _ref;
	A _aa;//对于自定义类型变量，如果没有在初始化列表进行初始化的话
	//就会自动调用其默认构造函数进行初始化，如果没有默认构造函数就需要在初始化列表进行显示调用构造函数，否则就会报错
	int* _p;
};
int main()
{
	int x = 10;
	Date d1(2024,1,1,x);
	return 0; 
}

注意：
1.每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2.类中包含以下成员，必须放在初始化列表位置进行初始化：
引用成员变量
const成员变量
自定义类型成员(且该类中没有默认构造函数时)
3.尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型的成员变量，一定会先使用初始化列表初始化
4.成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的顺序无关

class A
{
public:
	A(int a)
		:_a1(a)
		,_a2(_a1)
	{}
	void Print(){
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2;
	int _a1;
}
int main()
{
	A aa(1);
	aa.Print();
	//这里会输出1 随机值
	//因为初始化列表初始化顺序是按照成员变量的声明顺序，先初始化_a2，由于_a1还没有初始化，所以_a2是随机值,_a1 = a =1
	return 0;
}

1.3explicit关键字

1.3.1explicit关键字是什么？

explicit是C++中的一个关键字，它用来修饰只有一个参数的类构造函数，以表用该构造函数是显式的，而非隐式的。当使用explicit修饰构造函数时，它将禁止类对象之间的隐式转换，以及禁止隐式调用拷贝构造函数。
接下来我们先了解一下类的构造函数的类型转换，进而深入了解explicit的含义。

1.3.2构造函数还具有类型转换的作用

单参数构造函数：

我们还是从日期类开始讲解

class Date
{
public:
	Date(int year)
		:_year(year)//初始化列表
	{}
private:
	int _year = 2024;
	int _month = 9;
	int _day = 1;
};
int main()
{
	//通过调试我们可以看出d1和d2都会调用构造函数
	Date d1(2024);

	Date d2 = 2024;
	return 0;
}

对于上面的d1一定是调用了有参构造进行初始化，不过对于d2来说，却是另一种构造方式

为什么[Date d2 = 2024]会调用构造函数呢？其实这都是有“隐式类型转换”的存在

隐式类型转换：

double a = 1.23;
int b = a;

对于类型转换而言，这里并不是将值直接赋值给左边的对象，而是在赋值的过程中会产生一个临时变量，以上述代码为例：右边的a会先构造一个临时变量，这个临时变量的类型是[int]，然后然后将它里面的值初始化为1，然后再通过拷贝构造将临时对象拷贝给b

那么对于日期类中的d2也是一样的，2024先去构造一个临时对象，这个临时对象的类型是[Date]，把它里面的year初始化为2024，然后在通过拷贝构造将临时对象拷贝给d2

拷贝构造的初始化(初始化列表的方式)

Date(const Date& d)
	:_year(d._year)
	,_month(d._month)
	,_day(d._day)
{}

拷贝构造也是属于构造函数的一种，也是会有初始化列表的

在隐式类型转换的过程中会产生一个临时对象，会调用构造函数和拷贝构造，但是通过VS调试会发现只调用了构造函数而没有调用拷贝构造，原因其实就是编译器在这里进行了优化，将构造+拷贝构造优化成了一个构造，因为编译器在这里觉得构造再加拷贝构造太费事了，所以就合二为一了

如果我们现在不是直接赋值，而是做一个引用的话，会发生什么呢？

Date& d3 = 2024

在这里插入图片描述
原因主要有两方面：
1.引用变量类型是Date类型，而2024是一个内置类型(int)的数据
2.产生的临时变量具有常性，它是通过Date类的构造函数构造出来的，同类型之间可以做引用，还有一点就是临时变量具有常性，所以应该给引用变量加一个const，同时也是为了防止权限的扩大

引出explicit关键字

如果我们不想让这种隐式类型转换发生应该怎么办？此时就可以使用到C++中的一个关键字叫做explicit

将explicit关键字加在构造函数的前面进行修饰，编译器就会禁止[隐式类型转换]

explicit Date(int year)
	:_year(year)
{}
//这样就不会产生临时对象了

多参构造函数

Date(int year,int month,int day = 31)
	:_year(year)
	,_month(month)
	,_day(day)
{}

对于一定要引入多参数进行构造的场景，这时候就要使用我们C++11的特性，在多参构造进行初始化的时候在外面加上一个{}就可以了，类似于数组的初始化。

Date d2 = {2024,9};

不仅如此，下面这种也同样适用，都是先调用构造去产生一个临时对象

const Date& d3 = {2024,10};

//多参构造函数
explicit Date(int year,int month,int day = 31)
	:_year(year)
	,_month(month)
	,_day(day)
{}

可以看多，加上explicit关键字作修饰，同样也可以禁止隐式类型转换

还有一种例外，除了第一个参数无默认值其余均有默认值的构造函数，那就是相当于单参数构造函数，explicit关键字依旧可以起到作用

explicit Date(int year,int month = 9,int day = 31)
	:_year(year)
	,_month(month)
	,_day(day)
{}

1.3.3为什么需要explicit关键字？

对于可读性不是很好的代码，可以使用explicit修饰构造函数，将会禁止构造函数的隐式转换

1.3.4怎么使用explicit关键字？

explicit关键字在C++中只能用于修饰类的构造函数，他用来修饰只有一个参数的类的构造函数，以表明该构造函数是显式的，而非隐式的。
只要构造构造函名前加上explicit就能禁止类对象之间的隐式转换，禁止隐式调用拷贝构造函数

2.static成员

2.1概念

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

2.2静态(static)成员变量

静态(static)成员变量：是指在类中声明时使用关键字static修饰的数据成员，静态成员变量可以是public也可以是private的。本质上就是一个全局变量，只不过受类作用域限定符和访问限定符的控制
怎样声明，定义静态成员变量？
在类中声明时使用static关键字修饰，一般在类外定义并初始化，类外定义时不需要加static。参考如下代码：

class Cname
{
public:
	static int _a;
private:
	static int _b;//静态成员变量的声明
};

int Cname::_a = 0;
int Cname::_b = 0;//静态成员变量的定义

静态成员变量的几个特点：

1.静态成员变量属于整个类，为所有类对象所共享，不属于某一个对象；
2.静态成员变量一般在类内声明，在类外定义，声明时加static修饰，定义时不加static；
3.静态成员变量定义后位于程序的全局数据区，并一直存在程序的整个生命周期中
4.静态成员变量可以是public或者private的
public的静态成员变量可以使用【类作用域+::】直接访问，private的静态成员变量只能在类内访问
public的静态成员变量可以使用类的对象的引用或者指针来访问
静态成员变量的类型可以是他所属的类类型，而非静态成员变量的类型只能是他所属类的指针或引用

#include <iostream>
using namespace std;
class CDate
{
public:
	CDate(int year,int month,int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{
		_a++;
		_b++;
	}

	static int _a;//类内声明静态成员变量
private:
	static int _b;//类内声明静态成员变量
	static CDate _Date;//静态成员变量可以是其所属类类型
	//CDate date;报错
	CDate * pDate;//非静态成员变量，只能声明成其所属类的指针或引用
	int _year;
	int _month;
	int _day;
};
//全局的静态变量
static int c = 0;
//类外定义静态成员变量
int CDate::_a = 0;
int CDate::_b = 0;
int main()
{
	CDate::_a = 0;  // public静态成员变量，，使用类名作用域直接访问
	//CDate::_b = 0;// private静态成员变量只能在类内访问
	cout <<"CDate::_a =" << CDate::_a << endl;
	CDate date(2024, 9, 7);
	date._a = 1;//  public静态成员可以用类对象的引用访问
	cout << "CDate::_a =" << CDate::_a << endl;

	CDate* pDate = &date;
	pDate->_a = 2;
	cout << "CDate::_a =" << CDate::_a << endl;
	cout << "count=" << (&c) << endl << "CDate::_a =" << &CDate::_a << endl;
	return 0;
}

2.2静态(static)成员函数

静态成员函数：是指在类中声明时使用关键字static修饰的成员函数。静态成员函数可以是public或者private的。
静态成员函数不包含this指针，所以也不能直接访问非静态成员变量。

怎样声明，定义静态成员函数？
在类中声明成员函数时使用static关键字修饰，如果该函数在类外定义则不需要加static。参考如下代码：

class CDate
{
public:
	static int _A();	//	类内声明静态成员变量
private:
	static int _B()
	{
		int n = 10;
		return n; 
	}
	...
};

//类外定义静态成员函数，省略static
int CDate::_A()
{
	int m = 20;
	return m;
}

静态成员函数的几个特点：

1.静态成员函数属于整个类，而不属于某个对象，所有对象共享静态成员函数；
2.静态成员函数在类内声明时加static，类外定义时不加static；
3.静态成员函数没有this指针，只能访问静态成员，不能访问非静态成员
4.静态成员函数可以是public或者private的
public的静态成员函数可以使用类名作用域直接访问，private的静态成员函数只能在类内访问；
public的静态成员函数可以使用类的对象的引用或者指针来访问；
成员函数可以直接使用静态成员变量，而不需要类作用域来访问

静态成员函数的演示如下：

#include <iostream>

using namespace std;
class CDate
{
public:
	CDate(int year, int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{
		_a++;
		_b++;
	}
	static int _a;	//	类内声明静态成员变量
	static int _Count();//	类内声明静态成员函数
private:
	static int _b;		//	类内声明静态成员变量
	static  CDate _Date; //  静态成员变量可以是其所属类类型

	CDate* pDate;	//	非静态成员变量只能是其所属类的指针或引用
	int _year;
	int _month;
	int _day;

	static int GetCountb()// 类内声明并定义静态成员函数
	{
		return _b;
	}
};


static int Count = 0;
//类外定义静态成员变量
int CDate::_a = 0;
int CDate::_b = 0;

int CDate::_Count()
{
	//cout << _year << endl;	//错误，静态成员函数没有this指针，只能访问静态成员变量，不能访问非静态成员变量
	return _a;
}
int main()
{

	CDate::_Count();	// public静态成员函数，使用类名作用域直接访问
	//	Date::GetCountb();	// 报错：private静态成员函数只能在类内访问

	CDate date(2024, 06, 14);
	date._Count();		// public静态成员函数，可以使用类的对象访问

	CDate rDate = date;
	rDate._Count();	// public静态成员函数，可以使用类的引用访问

	CDate* pDate = &date;
	pDate->_Count();	// public静态成员函数，可以使用类的指针访问
	return 0;
}

总结：类的静态成员是属于整个类的，与对象没有关联
静态成员在声明时加static，定义时不加static
共有的静态成员可以直接使用类名作用域访问，或者类的对象的指针，引用去访问，私有的只能在类内访问
静态成员函数没有this指针，故只能访问静态成员

3.友元

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

3.1友元函数

问题：去重载operator<<，然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但实际使用cout要是第一个形参对象，才能正常使用。所以要将operator重载成全局函数。但是又会导致类外没办法访问成员，此时需要友元来解决。operator同理。

错误示例：

class Date
{
public:
	Date(int year,int month,int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
	//因为非静态成员函数的第一个参数一定是隐藏的this指针，所以d1必须放在<<的左侧
	//即d1 << cout 这显然是不符合常规调用的
	ostream& operator<<(ostream& _cout)
	{
		_cout << _year << "-" << _month << "-" << _day << endl;
		return _cout;
	}
private:
	int _year;
	int _month;
	int _day;
};

正确示例(以重载>>和重载<<为例)：

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_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;
}
istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

int main()
{
	Date d1;
	cin >> d1;
	cout << endl;
	cout << "今天的日期：" << d1 << endl;
}

说明友元函数可以访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符的限制
一个函数可以是多个类的友元函数，则该函数可以访问其对应类的私有成员和保护成员
友元函数的调用与普通函数的调用原理相同
友元函数没有this指针，不是类的成员函数，和普通全局函数的调用没有区别

3.2友元类

class Time
{
	friend class Date;//声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 0,int minute = 0,int second = 0)
		:_hour(hour)
		,_minute(minute)
		,_second(second)
private:
	int _hour;
	int _minute;
	int _second;
}
class Date
{
public:
	Date(int year = 1900,int month = 1,int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
	voidSetTimeOfDate(int hour,int minute,int second)
	{
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

总结：

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非共有成员
友元关系是单向的不具有交换性。
比如上述的Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中的私有成员变量则不行
友元关系不能传递
如果C是B的友元，B是A的友元，则不能说明C是A的友元
同时友元关系不能继承

4.内部类

概念：如果一个类定义在另一个类的内部，这个类就叫做内部类。
内部类是一个独立的类，他不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类的所有成员。但是外部类不是内部类的友元

特性：
1.内部类可以定义在外部类的public，protected，private都是可以的
2.注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名
3.sizeof 外部类 == 外部类，与内部类没有关系

class A
{
private:
	static int k;
	int h;
public:
	class B
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;
			cout << a.h << endl;
		}
	}
};
int A::k = 1;
int main()
{
	A::B b;
	b.foo(A());//这里的A()会创建一个A类的匿名对象(临时对象)
	return 0;
}

5.匿名对象

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
 	}
private:
	int _a;
};

class Solution{
public:
	int Sum_Solution(int n)
	{
		return n;
	}
};

int main()
{
	A a1;
	A a2(2);

	//A aa1();不能这样子定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
	
	//我们可以这样子定义匿名对象，匿名对象的特点不用取名字，但是它的生命周期只有这一行，我们可以看到下一行就会自动调用析构函数
	
	A();
	A(10);
	//匿名对象在这样场景下就很好用。
	cout << Solution().Sum_Solution(10) << endl;
	return 0;
}

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

//了解：：
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;
};
A f3()
{
  A aa;
  return aa;
}
A f4()
{
	return A();
}
 int main()
 {
	f3();//理论上一个拷贝构造，一个构造

 	A ret1=f3();//一个构造，两个拷贝构造
	// 但是实际上由于编译器的优化，在f3函数结束之前，编译器直接将	
	// aa拷贝给ret1
	// 临时对象较大的话在两个函数栈帧之间，小的话在寄存器中
	// 所以编译器在这里将两个拷贝构造优化为一个拷贝构造

	 //构造+拷贝构造+拷贝构造->构造---直接构造出ret2
	 A ret2 =f4();
 
	 //A ret;
	 //ret=f4(); 
}

安全感0.0

关注

10
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
类与对象(下)

对于类型转换而言，这里并不是将值直接赋值给左边的对象，而是在赋值的过程中会产生一个临时变量，以上述代码为例：右边的a会先构造一个临时变量，这个临时变量的类型是[int]，然后然后将它里面的值初始化为1，然后再通过拷贝构造将临时对象拷贝给b。比如上述的Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中的私有成员变量则不行。内部类是一个独立的类，他不属于外部类，更不能通过外部类的对象去访问内部类的成员。
复制链接

扫一扫