C++类与对象（下）【详析】

类与对象（下）

一、再谈构造函数

1.构造函数体赋值

在“类与对象（中）”，我们了解到在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值，如下：

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

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

因此在次我们引入了初始化列表

2.初始化列表

定义：

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

特点：

①每个成员变量都要走初始化列表，就算不显示写初始化列表，也会走初始化列表；

②如果不显示写初始化列表，声明处给了缺省值就会使用缺省值初始化，如果显示写了初始化列表，即使给了缺省值也不会使用

步骤如下：

1.对于内置类型，优先使用初始化列表；没显示写初始化列表，有缺省值用缺省值，没有就用随机值；

2.自定义类型，调用它的默认构造函数，如果没有默认构造就报错。

---

那么，对于我们熟知的Date类，其初始化列表如下：

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成员变量
• 自定义类型成员(且该类没有默认构造函数时)

其实对于const和引用，只有一次初始化的机会，就只能在定义的时候进行初始化

例如：

class A
{
public:A(int a):_a(a){}
private:int _a;
};class B
{
public:B(int a, int ref):_aobj(a), _ref(ref), _n(10){}
private:A _aobj;    // 没有默认构造函数int& _ref;  // 引用const int _n; // 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、尽量使用初始化列表初始化；
2、一个类尽量提供默认构造（推荐提供全缺省）；

3.explicit关键字

引入：

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

// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用Date(int year):_year(year){}

// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用Date(int year, int month = 1, int day = 1): _year(year), _month(month), _day(day){}

void Test()
{//隐式类型的转换int i=0;double d=i;const double& rd=i;//单参数构造函数Date d1(2022);Date d2=2022;const Date& d5=2022;//拷贝构造Date d3(d1);Date d4=d1;
}    

这里发生了隐式类型的转换：从int类转换为了Date类，会涉及到中间开辟一个临时对象/变量，再会用这个临时对象来拷贝构造它（通常编译器优化后即为直接构造了）

若不想发生类型转换，即可使用explicit关键字

explicit：

用explicit修饰构造函数，将会禁止构造函数的隐式转换：

---

若是多参数构造，C++11支持，即：

Date d1={2023,3,1};
//等价于：
Date d2(2023,3,1);

注意，这里的等价于只是说明它们的功能结果相同，而实际意义却不同：第一种方式即为多参隐式构造，而第二种方式是直接构造

二、 static成员

回顾：static作用

1、在函数体内，一个被声明为静态的变量在这一函数被调用的过程中维持其值不变（维持着上次函数调用后的值，而不是每次函数调用后，值都重新进行声明）

2、在模块内(但在函数体外)，一个被声明为静态的变量可以被模块内所有函数访问，但不能被模块外其他函数访问。它是一个本地的全局变量

3、在模块内，一个被声明为静态的函数只可被这一模块内的其他函数调用。也就是，这个函数被限制在声明它的模块的本地范围内使用

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

引入：面试题

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

class A
{
public://构造函数A(){++_count;}//拷贝构造A(A& _a){++_count;}//析构函数~A(){++_count;}//定义静态变量_countstatic int GetCount(){return _count;}
private:static int _count;
};
//在类外声明静态成员变量，并给予初始化
int A::_count = 0;  //静态成员变量定义初始化void test()
{cout << A::GetCount() << endl;A a1;A a2;A a3;cout << A::GetCount() << endl;
}

首先，这里可以用全局变量来实现我们的目标要求：

那为何我们要把它设为static呢？原因是全局变量容易被更改，不安全！

特征：

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

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

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

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

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

因此由于static具有如上特性，它的定义方法如下：

可以注意到，首先在类外定义，不加static关键字；在类中声明变量，由于它由private限定，因此我们再提供它的Get方法；而在使用时：

我们用get方法得到它的值，再用类名::静态成员的方式对它进行访问，用于输出它的值

---

【问题一】静态成员函数可以调用非静态成员函数吗？

静态成员函数没有隐含的this指针，不能访问任何非静态成员，并且静态成员函数属于类而不是某个对象。

【问题二】非静态成员函数可以调用类的静态成员函数吗？

非静态成员函数可以调用类的静态成员函数。

三、友元

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

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

例如，在“面向对象（中）”我们写到的流插入和流提取就用到了友元函数：

//友元声明（类中的任意位置）friend inline ostream& operator<<(ostream& out, const Date& d);friend inline istream& operator>>(istream& in, Date& d);

// 流插入的重载
inline ostream& operator<<(ostream& out, const Date& d)
{out << d._year << "年" << d._month << "月" << d._day << "日" << endl;return out;
}// 流提取的重载
inline istream& operator>>(istream& in, Date& d)
{in >> d._year >> d._month >> d._day;return in;
}

说明：

友元函数：

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

友元函数不能用const修饰

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

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

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

友元类：

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

友元关系是单向的，不具有交换性；比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接 访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

友元关系不能传递：如果C是B的友元， B是A的友元，则不能说明C时A的友元

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

四、内部类(了解)

所谓内部类，即是类中嵌套了类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元

例如：

class A
{
private:static int k;int h;
public:class B // B天生就是A的友元{public:void func(const A& a){cout << k << endl;   //OKcout << a.h << endl; //OK}};
};
int A::k = 1;       //B天生是A的友元体现
int main()
{cout << sizeof(A) << endl;A aa;A::B bb;        //指定域才能访问
}

---

五、匿名对象

引入：

我们构造一个类的对象，通常有多种方式：

对于以下类：

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();            //匿名对象A aa2(2);       //有名对象A aa3 = 2;      //有名对象return 0;
}

注意：不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义；

A aa1();

但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数：

---

作用：

那么匿名对象有什么作用呢？

// 匿名对象在这样场景下就很好用，当然还有一些其他使用场景；
Solution().Sum_Solution(10);

正常应该是：

Solution so;
so.Sum_Solution(10);

这里我们采用创建匿名对象调用函数

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

在传值和传返回值的过程中，一般C++编译器会做一些优化，减少对象的拷贝，这个在一些场景下是非常有用的

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;
}
int main()
{// 传值传参A aa1;f1(aa1);cout << endl;// 传值返回f2();cout << endl;// 隐式类型，连续构造+拷贝构造->优化为直接构造f1(1);// 一个表达式中，连续构造+拷贝构造->优化为一个构造f1(A(2));cout << endl;// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造A aa2 = f2();cout << endl;// 一个表达式中，连续拷贝构造+赋值重载->无法优化aa1 = f2();cout << endl;return 0;
}

【场景一】

一个表达式中，连续构造+拷贝构造，编译器会优化为一个构造

【场景二】
一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造

【场景三】
一个表达式中，连续拷贝构造+赋值重载->无法优化。

再次理解面向对象

对现实世界的映射！——描述世界