【C++初阶】四、类和对象（下）

Clumsy、笨拙

已于 2023-04-04 21:16:41 修改

阅读量746

点赞数 16

分类专栏： C++ 文章标签： c++

于 2023-03-21 01:59:25 首次发布

本文链接：https://blog.csdn.net/m0_58124165/article/details/127917211

版权

C++ 专栏收录该内容

13 篇文章 48 订阅

订阅专栏

文章目录

一、再谈构造函数
二、Static成员
三、友元
- 友元函数
- 友元类
四、内部类
五、匿名对象
六、拷贝对象时的一些编译器优化

一、再谈构造函数

构造函数体赋值

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

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

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

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;//第一次赋值
		_year = 2001;//第二次赋值
		_year = 2022;//第三次赋值
		//.....
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

初始化列表

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

如以下形式：

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

上述是一个简单的日期类构造函数的初始化列表写法，当遇到一个比较复杂的类时，初始化列表和函数体内初始化可以混着来

比如栈：

class Stack
{
public:
	/*Stack(int capacity = 4)
		:_a((int*)malloc(sizeof(int)*capacity))	//可以在初始化列表写
		, _top(0)
		, _capacity(capacity)
	{
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
	}*/

	// 初始化列表和函数体内初始化可以混着来
	Stack(int capacity = 4)
		: _top(0)
		, _capacity(capacity)
	{
		_a = (int*)malloc(sizeof(int) * capacity);	//可以在函数体内写
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memset(_a, 0, sizeof(int) * capacity);
	}
private:
	int* _a;  // 声明
	int _top;
	int _capacity;
};

我们知道，一个类在没有实例化之前，类中的成员变量都只是声明，而一旦对象实例化出来则是类的整体定义，那对象的每个成员是什么时候定义呢？- - - 初始化列表 （c++的定义，没有为什么）

而类中有以下三种成员变量，必须放在初始化列表位置进行初始化：

1. 引用成员变量
我们在学习引用的时候知道，引用类型的变量在定义时就必须给其一个初始值。

int a = 10;
int& b = a;// 创建时就初始化

由于对象的成员是在初始化列表位置定义的，所以我们只能在初始化列表定义引用成员变量

class B
{
public:
	B(int ref)
		: _ref(ref)
	{}
private:
	int& _ref;  // 引用
};

2. const成员变量
被const修饰的变量也必须在定义时就给其一个初始值。

const int a = 10;//correct 创建时就初始化
const int b;//error 创建时未初始化

所以也必须使用初始化列表进行初始化。

class B
{
public:
	B()
		:_n(10)
	{}
private:
	const int _n; // const 成员变量
};

3. 自定义类型成员(且该类没有默认构造函数时)
若一个类中存在类对象时，且该类对象的类没有默认构造函数。那么我们在实例化该类对象时就需要传参对其进行初始化，所以实例化没有默认构造函数的类对象时必须使用初始化列表对其进行初始化。
在这里再声明一下，默认构造函数是指不用传参就可以调用的构造函数：
1. 我们不写，编译器自动生成的构造函数。
2. 无参的构造函数。
3. 全缺省的构造函数。

class A //该类没有默认构造函数 
{
public:
	A(int val) //注：这个不叫默认构造函数（需要传参调用）
	{
		_val = val;
	}
private:
	int _val;
};

class B
{
public:
	B()
		:_a(2022) //必须使用初始化列表对其进行初始化
	{}
private:
	A _a; //自定义类型成员（该类没有默认构造函数）
};

所以这就是为什么要有初始化列表存在的原因了。

使用初始化列表注意事项：

一、每个成员变量在初始化列表中只能出现一次
因为初始化只能进行一次，所以同一个成员变量在初始化列表中不能多次出现。

二、类中包含以下成员，必须放在初始化列表位置进行初始化：(在总结一下)

引用成员变量
const成员变量
自定义类型成员(且该类没有默认构造函数时）

class A
{
public:
	A(int val)
		:_val(val)
	{}
private:
	int _val;
};
class B
{
public:
	B(int a, int ref)
		:_a(a)//必须在初始化列表传参初始化
		, _ref(ref)
		, _n(10)
	{}
private:
	A _a;// 没有默认构造函数
	int& _ref;  // 引用
	const int _n; // const 
};

三、尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，
一定会先使用初始化列表初始化。
因为初始化列表实际上就是当你实例化一个对象时，该对象的成员变量定义的地方，所以无论你是否使用初始化列表，都会走这么一个过程（成员变量需要定义出来）。

class Time {
public:
	Time(int hour = 0)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};
 
class Date {
public:
	Date(int day)
	{}
private:
	int _day;
	Time _t;
};
 
int main()
{
	Date d(1);
}

四、成员变量在类中声明的次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后顺序无关
举个例子：

class A
{
public:
	//由于先声明的是_a2在声明_a1，所以编译器先初始化_a2，在初始化_a1。
	//而_a1一开始是随机值，所以_a2是随机值，_a1是1
	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  随机值

在这里插入图片描述

整体总结：

对象每个成员在初始化列表的时候定义；
每个成员都要走初始化列表，就算不显示在初始化列表写，也会走；
如果在初始化列表显示写了就用显示写的初始化；
如果没有在初始化列表显示初始化：

在定义时就必须进行初始化的变量类型，就必须放在初始化列表进行初始化。

引用成员变量
const成员变量
自定义类型成员(且该类没有默认构造函数时)

内置类型，有缺省值用缺省值，没有就用随机值
自定义类型，调用默认它的默认构造函数，如果没有默认构造就必须在初始化列表传参初始化，否则就报错。

explicit关键字

一、隐式类型转换：
实际上，我们早就接触了隐式类型转换(在讲解传值返回和传引用返回中也讲到过)，以下代码也叫隐式类型转换：

double d = 1.1;
int i = d;//隐式类型转换

在这里插入图片描述
在这个过程中，编译器会先构建一个int类型的临时变量接收d的值，然后再将该临时变量的值赋值给i。

因为临时变量具有常属性，所以我们若是进行引用的操作时，需要加const，因为这里涉及到了权限的问题（只有指针和引用才会考虑权限的问题）。
在这里插入图片描述

二、explicit关键字介绍

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值
的构造函数，还具有类型转换的作用。

一、单参数或只需传一个参数值：

#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year = 0) //单个参数的构造函数
		:_year(year)
	{}

	
	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
	 //Date(int year, int month = 1, int day = 1)
	 //: _year(year)
	 //, _month(month)
	 //, _day(day)
	 //{}
 
	void Print()
	{
		cout << _year << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	//隐式类型转换
	Date d1 = 2021; //支持该操作
	d1.Print();
	return 0;
}

在语法上，代码中Date d1 = 2021等价于以下两句代码：

Date tmp(2021); //先构造
Date d1(tmp); //再拷贝构造

在早期的编译器中，当编译器遇到Date d1 = 2021这句代码时，会先构造一个临时对象，再用临时对象拷贝构造d1；但是现在的编译器已经做了优化，当遇到Date d1 = 2021这句代码时，会按照Date d1(2021)这句代码处理，这就叫做隐式类型转换。

二、多参数构造

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

	
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1 = { 2022, 10, 12 };
	// 等价于
	Date d2(2022, 10, 12 );

	const Date& d3 = { 2022, 10, 12 };//引用，必须加const,临时变量具有常属性
	
	return 0;
}

**注意：**多参数构造的隐式类型转换是C++11才支持的，C++98不支持，只支持单参数构造的隐式类型转换。

对于Date d1 = 2021这种代码的可读性不是很好，我们若是想禁止单参数构造函数的隐式转换，可以用关键字explicit来修饰构造函数。

class Date {
public:
	explicit Date(int year)
		: _year(year)
	{}
 
private:
	int _year;
};

在这里插入图片描述

二、Static成员

引入- 计算类中创建了多少个类对象

如果我们要计算一个类中创建了多少个类对象，我们可以用 count 计算一下

int N = 0;  // 全局变量

class A {
public:
	A(int a = 0)
		: _a(a)
	{
		++N;
	}
	A(const A& aa)
		: _a(aa._a)
	{
		++N;
	}

private:
	int _a;
};

void f(A a)
{}

int main(void)
{
	A a1;
	A a2 = 1;//隐式类型转换
	f(a1);

	cout << N << endl;

	return 0;
}

在这里插入图片描述
由于我们的N定义的是全局变量，这样我们可以在任意位置进行修改，如果我们进行恶意修改的话，我们的出来的数据就不是准确的了。

int main()
{
	A a1;
	A a2 = 1;
	f(a1);
 
	cout << cnt << endl;
    count++;   // 我可以修改它 
	return 0;
}

有没有办法可以把 N和类贴合起来呢？让这个N专门用来计算我 A 这个类的。
我们先试着把它定义成 —— 成员变量：

class A {
public:
	A(int a = 0)
		: _a(a)
	{
		++_N;
	}
	A(const A& aa)
		: _a(aa._a)
	{
		++_N;
	}

private:
	int _a;
	int _N // 定义成成员变量
};

但是这样还是不行！这样的话每个对象里面都有一个 count，我们是希望的是每个对象创建的时候去++的是同一个变量，而不是每个对象里面都有一个。
那该怎么办呢？

类里面可以定义静态成员，在成员变量前面加一个 static，就是静态成员。

我们接着往下看：

概念

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

class A {
public:
	A(int a = 0)
		: _a(a)
	{
		++_N;
	}
	A(const A& aa)
		: _a(aa._a)
	{
		++_N;
	}
private:
	int _a;
	static int _N
	// 静态成员变量属于整个类，所有对象，生命周期在整个程序运行期间
};

特性

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

#include <iostream>
using namespace std;
class Test
{
private:
	static int _n;
};
int main()
{
	cout << sizeof(Test) << endl;
	return 0;
}

结果计算Test类的大小为1，因为静态成员_n是存储在静态区的，属于整个类，也属于类的所有对象。所以计算类的大小或是类对象的大小时，静态成员并不计入其总大小之和。

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

class Test
{
private:
	static int _n;//声明
};
// 静态成员变量的定义初始化
int Test::_n = 0;

3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问 - - 在下方详细讲解。

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

class Test
{
public:
	//没有this指针，只能访问静态成员
	static void Fun()
	{
		cout << _a << endl; //error不能访问非静态成员
		cout << _n << endl; 
	}
private:
	int _a; //非静态成员
	static int _n; //静态成员
};

5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制。- - - 生命周期是全局的，作用域受类域影响。

静态成员函数的访问

1.当静态成员变量为公有时，我们就可以在类外对它进行访问，有以下几种访问方式：

class A {
public:
	A(int a = 0)
		: _a(a)
	{
		++_N;
	}
	A(const A& aa)
		: _a(aa._a)
	{
		++_N;
	}

private:
	int _a;

public:
	static int _N;
};

// 静态成员变量的定义初始化
int A::_N = 0;

void f(A a)
{}

int main(void)
{
	A a1;
	A a2 = 1;//隐式类型转换
	f(a1);
	/* 这里不是说是在 a1 里面找，这里只是帮助他突破类域罢了 */
	cout << a1._N << endl;
	cout << A::_N << endl; //2.通过类名突破类域进行访问
	return 0;
}

2.当静态成员变量为私有时:

我们可以提供一个公有的成员函数。我们写一个公有的 GetN成员函数，让它返回_N的值，这样我们就可以在类外调用该函数，就可以访问到它了。

还有没有更好的方式？让我不用对象就可以访问到它呢？

静态成员函数：

static int GetN() {
    return _N;
}

class A {
public:
	A(int a = 0)
		: _a(a)
	{
		++_N;
	}
	A(const A& aa)
		: _a(aa._a)
	{
		++_N;
	}
	// 没有this指针，只能访问静态成员
	static int GetN()
	{
		return _N;
	}
private:
	int _a;

public:
	static int _N;
};

// 静态成员变量的定义初始化
int A::_N = 0;

void f(A a)
{}

int main(void)
{
	A a1;
	A a2 = 1;//隐式类型转换
	f(a1);

	cout << a1._N << endl;//1.通过对象调用成员函数进行访问
	cout << A::GetN() << endl; //2.通过类名调用静态成员函数进行访问

	return 0;
}

三、友元

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

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

友元函数

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

我们在上一篇实现日期类的时候，对输入输出的运算符进行了重载: operator<<与operator>>。
我们知道，对流提取和流插入操作符是不能重载成类的成员函数的。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置：this指针默认是第一个参数，即左操作数，但是实际使用中cout需要是第一个形参对象才能正常使用。

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;
};

所以我们要将operator<<重载为全局函数，但是这样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。（operator>>同理）

所以，我们若是想让<<和>>也自动识别我们的日期类，就需要我们自己写出对应的运算符重载函数。

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;
}

注意： 其中cout是ostream类的一个全局对象，cin是istream类的一个全局变量，<<和>>运算符的重载函数具有返回值是为了实现连续的输入和输出操作。

友元函数说明：

友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同

友元类

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

class A
{
	// 声明B类是A类的友元类，所以B类中的所有成员函数都可以是A类的友元函数
	friend class B;
public:
	A(int n = 0)
		:_n(n)
	{}
private:
	int _n;
};
class B
{
public:
	void Test(A& a)
	{
		// B类可以直接访问A类中的私有成员变量
		cout << a._n << endl;
	}
};

友元类说明：

友元关系是单向的，不具有交换性。
例如上述代码中，B是A的友元，所以在B类中可以直接访问A类的私有成员变量，但是在A类中不能访问B类中的私有成员变量。
友元关系不能传递
如果C是B的友元， B是A的友元，则不能说明C时A的友元。
友元关系不能继承，在继承位置再给大家详细介绍。

四、内部类

概念： 如果一个类定义在另一个类的内部，这个内部类就叫做内部类。
注意：

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

特性：

内部类可以定义在外部类的public、protected、private都是可以的。
注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
sizeof(外部类)=外部类，和内部类没有任何关系。

// 相当于两个独立的类
// B类的访问受A的类域和访问限定符的限制
class A
{
private:
	int _a;
	static int k;

public: // B天生就是A的友元
	class B
	{
		int _b;

		void foo(const A& a)
		{
			cout << k << endl;//OK
			cout << a._a << endl;//OK
		}
	};
};

int A::k = 1;

int main()
{
	cout << sizeof(A) << endl;
	A aa;
	cout << sizeof(aa) << endl;
	A::B bb;

	return 0;
}

在这里插入图片描述

五、匿名对象

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;
	}
};
A F()
{
	//A ret(10);
	//return ret;
	return A(10);
}
int main()
{
	// 有名对象
	A aa0;
	A aa1(1);
	A aa2 = 2;

	//A aa3();

	// 匿名对象 --声明周期当前这一行
	A();
	A(3);

	//Solution so;
	//so.Sum_Solution(10);

	Solution().Sum_Solution(10);

	return 0;
}

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

请看以下代码：

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;
}

A f3()
{
	/*A aa(10);
	return aa;*/

	return A(10);
}


int main()
{
	// 优化场景1
	A aa1 = 1;  // A tmp(1) + A aa1(tmp) -> 优化 A aa1(1)

	
	//优化场景2
	f1(A(1));  // 构造 + 拷贝构造  -> 优化 构造
	f1(1);  // 构造 + 拷贝构造  -> 优化 构造
	
	//优化场景3
	f2();	  // 构造+拷贝构造
	A ret = f2(); // 构造+拷贝构造+拷贝构造 ->优化 构造+拷贝构造

	//优化场景4
	A ret = f3();  //  构造+拷贝构造+拷贝构造 -> 优化 -> 构造


	return 0;
}

优化场景1：

A aa1 = 1;  // A tmp(1) + A aa1(tmp) -> 优化 A aa1(1)
//构造 + 拷贝构造 ->优化 构造

优化场景2：

f1(A(1));  // 构造 + 拷贝构造  -> 优化 构造
f1(1);  // 构造 + 拷贝构造  -> 优化 构造

优化场景3：

f2();	  // 构造+拷贝构造
A ret = f2(); // 构造+拷贝构造+拷贝构造 ->优化 构造+拷贝构造

在这里插入图片描述

优化场景4：

A ret = f3();  //  构造+拷贝构造+拷贝构造 -> 优化 -> 构造

在这里插入图片描述

Clumsy、笨拙

关注

16
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
12
评论
【C++初阶】四、类和对象（下）

若一个类中存在类对象时，且该类对象的类没有默认构造函数。那么我们在实例化该类对象时就需要传参对其进行初始化，所以实例化没有默认构造函数的类对象时必须使用初始化列表对其进行初始化。
复制链接

扫一扫

专栏目录