C++ | 再谈构造函数 | Static成员 | 友元 | 内部类 | 匿名对象

再谈构造函数

上一篇文章中，讲了构造函数的初步认识，今天还有三个关于构造函数的知识点，我们一起来看一看吧~

先回忆一下，构造函数的基本特性吧~

构造函数的语法特性：

• 函数名与类名相同；
• 无返回值（不是void，而是返回值不用写）；
• 对象实例化时编译器自动调用对应的构造函数；
• 构造函数可以重载；

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

• 构造函数属于默认成员函数。如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数；如果显示定义，则编译器不自动生成；
• 编译器自动生成的构造函数对内置类型不做处理，对自定义类型成员调用它的默认成员函数；
• 默认构造函数可被认为有（以下三种只能出现一种）：无参的构造函数、全缺省构造函数、编译器默认生成的构造函数。建议使用全缺省构造函数。
• 声明和定义分开，全缺省构造函数中的缺省参数应该写在函数的声明部分，而定义部分不需要写
• 构造函数实例化时，可以直接 类名＋实例名（对应的实参）
• Date d1;
• 无参的构造函数，传参时不能带括号；
• C++规定，对象实例化时，必须调用构造函数。

构造函数赋值

• 构造函数体中的语句只能将其称为赋初值，不能被称为初始化。
• 初始化只能初始化一次，而构造函数体内可以多次赋值。

初始化列表

初始化列表概念

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

• 初始化列表就是每个成员变量定义初始化的位置。

//初始化列表
class Date
{
private:
	int _year;
	int _month;
	int _day;
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
};

初始化列表特性

初始化列表特性：

• 每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次）；
• 类中包含以下成员，必须放在初始化列表位置进行初始化：引用成员变量（引用必须在定义的时候初始化）、const成员变量（定义之后就不能修改）、自定义类型成员（且该类没有默认构造函数）；
• 尽量使用初始化列表初始化，因为不管是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化；
• 成员变量在类中声明次序就是其初始化列表中初始化顺序，与其在初始化列表中的先后次序无关；
• 如果没有默认构造，编译器会编不过，所有的成员变量都是先走初始化列表，再走函数体。走初始化列表，必须是调用默认构造。

初始化列表特性分析

• 成员变量在类中声明次序就是其初始化列表中初始化顺序，与其在初始化列表中的先后次序无关；

• private里面的是声明成员变量，初始化列表是定义。 
• 自定义类型定义调用它的默认构造。

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

• 类中包含以下成员有自定义类型成员（且该类没有默认构造函数）：必须放在初始化列表位置进行初始化

explicit关键字

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

• explicit修饰构造函数，禁止构造函数的隐式转化。

static成员

概念

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

特性

static成员特性：

• 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区；
• 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明；
• 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问；
• 静态成员函数没有隐藏的this指针，不能访问任何非静态成员；
• 静态成员也是类的成员，受public、protected、private访问限定符的限制。 

面试题：实现一个类，计算程序中创建出了多少个类对象

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;

A fouc()
{
	A a4;

	return a4;
}

void Test()
{
	A a1;
	A a2;

	fouc();
	cout << A::GetACount() << endl;
    cout << a1.GetACount() << endl;
    cout << a2.GetACount() << endl;
}

友元 

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

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

友元函数

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

友元函数语法及注意事项

友元函数语法

class A
{
	friend 返回类型 函数名(参数列表);
private:
	变量1; 变量2; ...;
};
//函数定义
返回类型 函数名
{
	//使用了A类中的私有成员
}

友元函数注意事项 

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

友元函数使用案例

operator<<重载

operator<<无法向其他重载函数在类中重载的原因

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

operator<<重载成全局函数代码

//使用友元函数
class Date
{
private:
	int _month;
	int _year;
	int _day;

public:
	Date(int year = 2009, int month = 2, int day = 6)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//参数的位置对应的是操作数的位置，cout<<_date<<endl;
	friend void operator<<(ostream& _cout, const Date& d);

};
void operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "年" << d._month << "月" << d._day << "日" << endl;
}

int main()
{
	Date d;//(1980, 6, 9);
	cout << d;
}

友元类

友元类语法及注意事项

友元类语法

class A
{
private:
	变量1; 变量2; ...;
public:
	函数1; 函数2; ...;
};
class B
{
	friend class 类名A;
};

友元类注意事项

• 友元类的所有成员函数都可以是一个类的友元函数，都可以访问另一个类中的非共有成员；
• 友元关系是单向的，不具有交换性；“他是我的朋友≠我是他朋友”
• 友元关系不能传递；“我是你的朋友，你是他朋友，不能说明我是他的朋友”
• 友元关系不能继承。

友元类使用案例

//使用友元类
class Time
{
private:
	int _hour;
	int _mintue;
	int _second;
	friend class Date;//谁需要被用 就在谁里面说明他的朋友是谁
public:
	Time(int hour=2,int mintue=56,int second=9)
	{
		_hour = hour;
		_mintue = mintue;
		_second = second;
	}
};
class Date
{
private:
	int _month;
	int _year;
	int _day;
	Time _t;
public:
	Date(int year = 2009, int month = 2, int day = 6)
		:_year(year)
		,_month(month)
		,_day(day)
	{}

	void SetTimeOfDate(int hour, int mintue, int second)
	{
		_t._hour = hour;
		_t._mintue = mintue;
		_t._second = second;
	}
};
int main()
{
	Date d;
}

内部类

如果一个类定义嵌套在了另一个类的内部，这个就叫做内部类。

内部类语法及特性

内部类语法

外部类
class OuterClass 
{
private:
    内部类
    class InnerClass 
    {
    public:函数1;函数2;...;
    private:变量1;变量2;...;
    };
};

int main() 
{
    // 访问内部类的公有方法

    外部类名::内部类名 内部类成员1;
    内部类成员.内部类成员函数();

    return 0;
}

内部类特性

• 内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员；
• 外部类对内部类没有任何优越的访问权限；
• 内部类就是外部类的友元类，但外部类不是内部类的友元；
• 内部类可以定义在外部类的public、protected、private都是可以的；
• 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象、类名；
• sizeof( 外部类 ) = 外部类，与内部类无关。

内部类使用案例

class A
{
private:
	static int k;
	int h;
public:
	class B//B天生就是A的友元
	{
	public:
		void Print(const A& a)
		{
			cout << k << endl;
			cout << a.h << endl;
		}
	};
};

int A::k = 1;
int main()
{
	A::B b;
	b.Print(A());
	return 0;
}

匿名对象

匿名对象，指在创建对象时没有为其命名。直接在表达式中使用临时对象。

匿名对象的语法及特性

匿名对象的语法

类名(构造函数参数);

匿名对象的特性

• 生命周期只有1行，下一行自动调用析构函数。

匿名对象使用案例

class A
{
private:
	int _a;
	int _aa;
public:
	A(int a = 9, int aa = 99)
		:_a(a)
		, _aa(aa)
	{
		cout << "A(int a = 9, int aa = 99)" << endl;
	}
	~A()
	{
		cout << "~A()"<< _a << endl;
	}
};

int main()
{
	A();
	A(56);
	A(8);
	return 0;
}

再次理解类和对象

现实生活中的实体计算机并不认识，计算机只认识二进制格式的数据。如果想要让计算机认识现实生活中的实体，用户必须通过某种面向对象的语言，对实体进行描述，然后通过编写程序，创建对象后计算机才可以认识。比如想要让计算机认识洗衣机，就需要：

1. 用户先要对现实中洗衣机实体进行抽象---即在人为思想层面对洗衣机进行认识，洗衣机有什么属性，有那些功能，即对洗衣机进行抽象认知的一个过程
2. 经过1之后，在人的头脑中已经对洗衣机有了一个清醒的认识，只不过此时计算机还不清楚，想要让计算机识别人想象中的洗衣机，就需要人通过某种面相对象的语言(比如：C++、Java、Python等)将洗衣机用类来进行描述，并输入到计算机中
3. 经过2之后，在计算机中就有了一个洗衣机类，但是洗衣机类只是站在计算机的角度对洗衣机对象进行描述的，通过洗衣机类，可以实例化出一个个具体的洗衣机对象，此时计算机才能洗衣机是什么东西。
4. 用户就可以借助计算机中洗衣机对象，来模拟现实中的洗衣机实体了。在类和对象阶段，大家一定要体会到，类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象。