C++类与对象（下）

最新推荐文章于 2024-08-16 16:51:12 发布

风格的反弹和

最新推荐文章于 2024-08-16 16:51:12 发布

阅读量942

点赞数 29

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/2301_77125473/article/details/141066072

版权

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初始化列表

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

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.类中如果有以下成员，必须放在初始化列表中初始化：

>>> 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();
}
A. 输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机值

思考一道小题

这里就充分体现了注意4中的初始化列表的初始化顺序是变量声明的顺序。

下面是一个针对不同成员变量的初始化列表的使用：

#include <iostream>  

using namespace std;
class A
{
public:
	//A(int a = 0, int b = 1)
	A(int a, int b)
		:_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((int*)malloc(sizeof(4) * 10))
	{
		if (_p == nullptr)
		{
			perror("malloc fail");
		}

		for (size_t i = 0; i < 10; i++)
		{
			_p[i] = 0;
		}
	}

private:
	// 声明
	int _year;
	int _month;
	int _day;

	// 必须走初始化
	const int _n;
	int& _ref;
	A _aa;

	int* _p;
};
int main()
{
	// 对象实例化
	int x = 10;
	Date d1(2024, 1, 31, x);

	//A aa(2, 3);
 
	return 0;
}

1.3 explicit关键字

了解这个关键字之前先引入一个概念：【隐式类型转换】。构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

来一个我们熟悉的日期类：

class Date {
public:
	Date(int year)
		:_year(year)
	{}
private:
	int _year;
	int _month = 8;
	int _day = 10;
};

再来两个实例化对象：

int main() {
	Date d1(2024);
	Date d2 = 2024;
	return 0;
}

我们平常创建带参数的实例化对象都是像d1一样，怎么d2创建的怪怪的？

这就是发生了隐式类型转换，来个比喻：

int i = 1;
double d = i;

这里面的i是一个整形，d是一个浮点型，那么i怎么赋值给了d呢？其实这不是直接进行的赋值，而是借用了中间临时变量，i会先构造一个临时变量，并将1赋值给临时变量。这个临时变量是double类型的，然后再将临时变量拷贝构造给d.

d2也和左边的一样，2024先构造一个Date的临时对象，这个临时对象在初始化为2024，再拷贝构造给d2.

既然会发生拷贝构造那么加上这样一个拷贝构造，看会不会调用：

Date(const Date& dd) {
	cout << "const Date& dd" << endl;
}

可以看到什么都没有输出，欸？那刚刚不就说错了么，编译器根本没有调拷贝构造

其实，现在编译器已经很高级了，增添了许多优化，就例如这里【构造+拷贝构造】既然两个都是构造那就干脆直接优化成了一个构造，所以这里编译后并没有调用拷贝构造.

那如何确定他真的出现了临时变量？

为什么第一行的代码可以，引用不是必须是同类型的才可以么？所以这就体现出真的产生了临时变量，临时变量是2024拷贝构造出来的，所以于类型相同，且临时变量具有常性，经过const修饰后，就可以引用。下面的int与double也是如此.

这里把const去掉就会发生报错，原因就是临时变量具有常性.

那么隐式类型转换有什么用呢？

class Date {
public:
	Date(int year)
		:_year(year)
	{}
	Date(const Date& dd) {
		cout << "const Date& dd" << endl;
	}
private:
	int _year;
	int _month = 8;
	int _day = 10;
};

class Stack {
public:
	void Push(const Date& d) {
		//.....
	}
};

int main() {
	Date d1(2024);
	Date d2 = 2024;

	Stack st;
	//1
	Date d3(2024);
	st.Push(d3);
	//2
	st.Push(2024);

	return 0;
}

还是刚刚的日期类，如若我们有一个栈，栈中要插入的是自定义类型Date，那么我们之前要先构造一个d3的日期类，然后再将d3插入到栈中，而现在我们直接可以显示构造d3，直接插入2024，这就是隐式类型转换的便捷.

引出explicit关键字：【禁止隐式类型转换】

explicit Date(int year)
	:_year(year)
{}

当我们在构造函数前加上explicit就会禁止隐式类型转换，当然禁止其实很少见但是有可能特殊情况下也会用到.

多参数构造

class Date {
public:
	Date(int year,int month)
		:_year(year)
		,_month(month)
	{}
	Date(const Date& dd) {
		cout << "const Date& dd" << endl;
	}
private:
	int _year;
	int _month;
	int _day = 10;
};


int main() {
	Date d1(2024,8);
	Date d2 = { 2024, 8 };
	const Date& d3 = { 2024,8 };

	return 0;
}

当多参数进行隐式类型转换的时候，我们可以用花括号实现{...}，但是这个仅在C++11可以实现，C++98之前仅支持单参数的隐式类型转换。

这里我们在构造函数之前加上explicit关键字，依旧可以【禁止隐式类型转换】.

作用：主要是在可读性不是很好的代码中，我们常常用explicit来禁止一部分隐式类型转换.

2、Static成员

2.1概念

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

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

class A {
public:
	A() {
		++n;
	}
	A(const A& a) {
		++n;
	}
//private:
	static int n;//不定义只声明
};
int A::n = 0;//类外定义


int main() {
	A aa1;
	A aa2;
	cout << A::n << endl;
	cout << aa1.n << endl;
	cout << aa2.n << endl;

	return 0;
}

这是上面是将静态成员变量给公有了。如若我们把private给放开，那就无法在类外进行访问.

那该怎么办呢？我们可以写一个静态成员函数来访问静态成员变量：

class A {
public:
	A() {
		++n;
	}
	A(const A& a) {
		++n;
	}
    //静态成员函数
	static int GetN() {
		return n;
	}
private:
	static int n;
};
int A::n = 0;


int main() {
	A aa1;
	A aa2;
    //静态成员函数还可以用类名进行访问
	cout << A::GetN() << endl;
	cout << aa1.GetN() << endl;

	return 0;
}

2.2 特性

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

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

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

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

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

2.3 作用

想要一个 全局变量但是又想要进行封装，就可以定义一个静态成员.

3、友元

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

友元分为： 友元函数 和 友元类

3.1 友元函数

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

class Date {
public:
	Date(int year,int month,int day)
		:_year(year)
		,_month(month)
		,_day(day)
		{}
    //d1 << cout -> d1.operator<<(&d1,cout) 这不符合想实现，有点倒反天罡
    //因为成员函数的第一个参数一定是隐藏的this指针，所以d1必须放在<<的左侧
	ostream& operator<<(ostream& _cout) {
		_cout << _year << "-" << _month << "-" << _day << endl;
		return _cout;
}
private:
	int _year;
	int _month;
	int _day;
};

上面的注释所言怎样解决？首先我们想到那就放到类外，不让this占据第一个参数，可是问题又来了，放到类外就无法访问类中的私有成员变量了.

于是引出了友元函数，友元函数可以访问类中的私有成员，他是定义在类外的普通函数，不属于任何类，但是需要在类中声明，声明时需要在前面加上friend.

class Date {
public:
	Date(int year,int month,int day)
		:_year(year)
		,_month(month)
		,_day(day)
		{}
	friend ostream& operator<<(ostream& _cout, const Date& d);
	
private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& _cout, const Date& d) {
	_cout << d._year << "-" << d._month << "-" << d._day << endl;
	return _cout;
}

注意：

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

2.友元函数 不能用 const 修饰（因为没有this指针）

3.友元函数 可以在类定义的任何地方声明， 不受类访问限定符限制

4.一个函数可以是多个类的友元函数

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

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,int month,int day)
		:_year(year)
		,_month(month)
		,_day(day)
		{}
	void SetTimeOfDate(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 {// B天生就是A的友元
 public:
     void fun(const A& a){
         cout << k << endl;//OK
         cout << a.h << endl;//OK
     }
 };
};
int A::k = 1;
int main(){
    A::B b;
    b.fun(A());
    
    return 0; 
}

5、匿名对象

#include<iostream>
using namespace std;
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 aa1;
	// 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
	//A aa1();
	// 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
	// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
	A();
	A aa2(2);
	// 匿名对象在这样场景下就很好用，我们仅想调用一下函数，所以就没必要创建一个对象
	Solution().Sum_Solution(10);
	return 0;
}

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

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还

是非常有用的。

#include<iostream>
using namespace std;
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) {

}
void f2(const A& aa) {

}

int main() {
	A aa1 = 2;//构造 + 拷贝构造 => 构造
	const A& aa2 = 2;//没有优化，只有一个构造

	f1(aa1);//会发生拷贝构造：aa1拷贝给aa.这里也不会发生优化，因为aa1在之前已经被创建出来了，只有连续的构造编译器才会优化
	f1(A(2));//传匿名对象虽说是构造+拷贝构造，但是编译器会因为连续优化成一个构造
	f2(aa2);//不会发生拷贝构造，因为是引用
	
	return 0;
}

这些都是编译器的一些优化，当然不同的编译器会有不同的优化。

风格的反弹和

关注

29
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
C++类与对象（下）

在类与对象的最开始的时候我们学了构造函数，构造函数在初始化成员变量时会进行赋值。上述代码中，通过构造函数调用后，变量已经得到了初始值，但是这仅仅是对成员变量的赋值，因为变量的【初始化只能赋值一次】而构造函数的【赋值可赋值多次】，所以不能称其为初始化。初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。注意：思考一道小题这里就充分体现了注意4中的初始化列表的初始化顺序是变量声明的顺序。下面是一个针对不同成员变量的初始
复制链接

扫一扫