类和对象(下)

一.再谈构造函数

• 构造函数有构造函数体赋值实 现和初始化列表两种方式

1.构造函数体赋值

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

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

2.初始化列表

是对象的成员定义的位置

（1）语法结构

以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号{}中的初始值或表达式(构造函数体)。

class Myclass
{
public:
	Myclass(int x, int y)
		:member1(x)
		, member2(y)
	{
		//构造函数体
	}

private:
	int member1;
	int member2;
};

（2）特性

1.初始化列表只能初始化一次，多次会报错

2.编译器允许构造函数体赋值与初始化列表混用。初始化列表优先，初始化列表中成员变量初始化操作在构造函数体之前完成。

3.若在初始化列表和构造函数体中对同一个成员变量进行赋值，构造函数体内的赋值会覆盖初始化列表中的值。

4.引用成员变量 ，const成员变量 ，自定义类型成员(且该类没有默认构造函数时)必须放在初始化列表位置进行初始化。

这三种类型成员若在构造函数体内进行赋值初始化会报错


const成员变量、引用成员变量、没有默认构造函数的自定义类型成员变量必须在初始化列表内初始化的原因 ：

1**.初始化列表是对象的成员定义的位置**

2.const成员变量 ：一旦被赋值就不能被修改，必须在初始化列表中赋值，因为它们不能在构造函数体中被修改。

3.引用成员变量 ：必须在初始化列表中绑定，因为引用在声明时就必须绑定到一个有效的对象或变量上，不能重新绑定。

4.没有默认构造函数的自定义类型成员变量：必须通过初始化列表显示调用构造函数进行初始化，因为编译器无法自动完成。

5.尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

具有以下优点：
1.效率提升
避免默认构造 ：对于自定义类型若不使用初始化列表，默认情况下编译器会先调用默认构造函数创建对象，然后再进行赋值操作，使用初始化列表可以直接进行构造，避免了不必要的默认构造和复制操作。
减少复制操作 ：对于大型对象或容器，减少复制次数可以显著提高程序的允许效率。
2.必要性

在上述内容中已写明对那三种成员变量只能在初始化列表中进行初始化。
3.代码简洁性

当需要初始化多个成员变量时，使用初始化列表可增加可读性。而构造函数体内可能设计复杂的逻辑判断等条件。

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

为什么有随机数结果呢？

因为我们认为在初始化列表中先对a1进行初始化，再用a1的值对a2初始化，但实际上初始化的顺序是按照成员变量在类中的声明次序来的。所以先对a2初始化，这时a1未知所以结果是随机值，然后再对a1初始化为1.
所以建议初始化列表中变量声明顺序与在类中的声明顺序保持一致

3.默认构造函数的优化场景

假设有这么一个A类

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 Func1(A aa)
{
}
A Func5()
{
    A aa;
    return aa;
}

编译器会将同一行中连续调用的构造函数优化为一个构造函数。

由结果可知，ra2因为已被创建，再进行拷贝构造，所以没有优化

应该尽量将构造函数放在一起调用，这样优化后可以大大提高效率

A(1)是匿名对象作为Func1的参数调用，在Func1函数调用结束后就销毁。

Func1的参数为A aa，Func1(1)其中1发生隐式转换，由本来的先构造再拷贝构造优化为直接构造A(1)作为参数，此处为隐式转换类型作为参数场景。

二.explicit关键字

1.隐式类型转换

（1）内置类型的隐式类型转换

double e=y;并不是直接将y赋值给e，而是由y创建一份临时变量，再把临时变量的值给e，e改变的是临时变量的值而不是y的值。

若e采用引用的方式，前面必须加上const修饰，因为e不是y的引用，而是临时变量的引用，临时变量具有常性，若不加const会造成权限放大的问题。

（2）自定义类型的隐式类型转换

怎么发生隐式类型转换的呢？

先由2构造一个A的临时对象，临时对象再拷贝构造aa2.即先构造，再拷贝构造。但根据结果看出，编译器会进行优化(不允许对同一对象构造两次)，会直接调用A aa2(2)构造

与内置类型相同，涉及到含引用的隐式类型转换，必须加const修饰

2.禁止单参构造函数的隐式类型转换

构造函数不仅可以构造与初始化对象，对于接收单个参数的构造函数，还具有类型转换的作用。接收单个参数的构造函数具体表现：

1. 构造函数只有一个参数

2. 构造函数有多个参数，除第一个参数没有默认值外，其余参数都有默认值

3. 全缺省构造函数（比上图多一个缺省值，省略）

来看一个explicit使用场景

与自定义类型隐式转换代码相同，用explicit修饰构造函数，将会禁止构造函数的隐式转换

三.static成员

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

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

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;
void TestA()
{
	cout << __LINE__<<":"<<A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	cout << __LINE__ << ":" << A::GetACount() << endl;
}
 int main()
{
	cout <<__LINE__<<":"<< A::GetACount() << endl;  // 1
	A aa1;
	
	TestA();
	return 0;
}

该类通过记录调用构造函数和拷贝构造函数次数来计算创建了多少个类对象，通过记录调用析构函数来判断销毁了多少个类对象

该类的实现必须使用静态成员变量和静态成员函数原因在于：
成员变量 ：属于每一个类对象自身，存储在对象里面
静态成员变量：属于类，属于类的每个对象共享，存储在静态区

因为普通成员变量属于每个对象自身，无法在多个对象间共享信息来统计类对象创建总次数，而静态成员变量为类所拥有且被共享，所以能在每个类对象被创建调用默认构造函数时记录对象数量。
特性：

1. 静态成员为所有类对象所共享 ，不属于某个具体的对象，存放在静态区。相当于用类去封装全局变量。
2. 静态成员变量必须在类外定义 ，定义时不添加static关键字(定义的目的是为其分配实际的内存空间，而不是再次声明其静态属性)，类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问，即突破类域和访问限定符就可以访问。
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员，非静态成员可以访问静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制
   6.静态成员不能给缺省值，没有初始化列表，缺省值是给初始化列表的。

四：友元

概念：友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度(模块间的关联程度，越低越独立)，破坏了封装，所以友元不宜多用。友元分为：友元函数和友元类

1.友元函数

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

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin, Date& d);
public:
	Date(int year = 2025, int month = 1, int day = 19)
		: _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;
}

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

特性说明：

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

2.友元函数不能用const修饰 (没有this指针)

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

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

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

2.友元类

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

1.友元关系是单向的，不具有交换性 。

假如有Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

2.友元关系不能传递

如果B是A的友元，C是B的友元，则不能说明C时A的友元。

3.友元关系不能继承，在继承位置再给大家详细介绍。

五.内部类

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

比如上述一道oj题中，在Solution类中声明Sum类为其内部类，那么可以在Sum类中直接访问Solution类的私有成员变量，但想在Solution类中访问Sum类中私有的成员变量则不行。

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

特性：

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

六.匿名对象

C++中，匿名对象是一种没有显示命名的临时对象，它在创建后通常只在当前表达式中有效，一旦当前表达式执行完毕，匿名对象就会被销毁。

使用场景：

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

    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a;
};

class Solution {
public:
    Solution()
    {
        cout << " Solution()" << endl;
    }
    
    ~Solution()
    {
        cout << "~Solution()" << endl;
    }
    int Sum_Solution(int n) {
        cout << "Sum_Solution" << endl;
        //...
        return n;
    }
};

(1)匿名对象的创建

创建方式与普通对象类似，只是不进行命名。

A(2)就是一个匿名对象，当这行代码执行完毕后就会销毁。

（2）用于函数调用

Solution()是一个匿名对象，可以调用Sum_Solution函数,当函数执行完后就会销毁。

（3）特性

匿名对象与临时常量一样具有常性，使用引用要加const修饰。

匿名对象的使用场景：

1.临时数据处理：

当你只需对某个对象进行一次操作，而不需要保留该对象时，可以使用匿名对象。

2.链式调用

匿名对象可以用于链式调用，连续调用函数，每个方法的返回值都是下一个方法的调用者，使代码更简洁。