作者:chlorine
专栏:c++专栏
目录
🚩再谈构造函数
我们之前学了构造函数，对成员函数体内成员变量赋初值------构造函数体赋值。
这一章我们要学习对成员变量初始化------初始化列表
🎓构造函数体赋值
构造函数体赋值：在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。 虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化， 构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
🎓初始化列表
初始化列表：以一个 冒号:开始 ，接着是一个以 逗号,分隔的数据成员列表 ，每个 " 成员变量 " 后面跟一个 放在括 号中的初始值或表达式。
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成员变量
成员变量实际上是在声明，在main函数中创建对象B bb(10,1)其实就是定义的过程，但是这个定义对所有的成员变量都定义了，没有给单个成员变量定义
那在哪对成员进行定义呢？？
那么我们就衍生了初始化列表：对象的成员定义的位置。（记住：有且仅一次初始化）
class B { public: //初始化列表：对象成员定义的地方 B(int a, int ref) :_n(1) ,_ref(ref) { } private: //声明 const int _n; // const int& _ref; // 引用 }; int main() { //对象整体定义 B bb(10, 1); return 0; }
- 自定义类型成员(且该类没有默认构造函数时)
我们之前就学过了，自定义类型成员会自动调用默认构造函数，内置类型不会进行处理，会给个随机值
我们也可以给内置成员变量打个补丁，int x=1;这里的1是缺省值，缺省值是给初始化列表的
如果我们给x初始化，那么编译器就不会用缺省值，缺省值在大部分学c++的人叫成备胎，初始化了那么就不需要缺省值，没有初始化就需要缺省值。
如果自定义类型的成员没有默认构造函数，那么自定义类型的成员就会报错，没有合适的构造函数可用，这就需要给自定义类型的成员初始化了。
在没有默认构造函数给初始值，我们就需要在初始化列表进行定义
如果有默认构造，我们能不能再初始化列表中定义呢？------当然可以
只不过初始化列表优先处理。其实本质上默认构造里的参数也是缺省参数，如果我们给了缺省参数 ，但是初始化列表初始化了，就不需要缺省值来初始化了。所以默认构造函数(隐式）或者初始化列表(显式)都是一种初始化，但是在后来的初始化都是利用初始化列表进行初始化。
3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
自定义类型是一定要调用构造函数的，有默认构造函数没有初始化列表，就会调用默认构造函数，没有默认构造函数，就必须要使用初始化列表初始化。
所以这里的自定义类型成员变量前提是没有默认构造函数，则一定要用初始化列表初始化。
注意：初始化列表是构造函数的一部分，初始化列表严格说替代了构造函数体内赋值，以后我们就可以开始用初始化列表来初始化了。
但是我们要知道，初始化列表并不能完成初始化所有的内容，比如我们要开辟一个空间，malloc，可以这样写 :a((int*)malloc(capacity*sizeof(int)） 但是我们是不是得检查一下是否开辟空间成功？Stack(int capacity=10) :_a((int*)malloc(capacity*sizeof(int))) ,_top(0) ,_capacity(capacity) { if(_a==nullpter) { perror("malloc fail\n"); return -1; } }所以我们需要在函数内进行检查，初始化列表能帮我们完成95%的内容，但是还剩5%是初始化列表无法完成，上面的例子就是。
还有给数组初始化一下，我们就需要memset，calloc也需要检查.....等等
还有更多复杂的过程，就无法让初始化列表来完成的。
函数体分工就是初始化列表不方便做的。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. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
为什么选D呢？按照上面的特点，声明的次序就是初始化列表中的初始化顺序，成员变量就是声明的过程，所以先声明_a2，那么就先初始化_a2为_a1,那么_a1就是1，_a2就是随机值了。
就比如在上面对_a开辟空间之后，里面的_capacity就是一个随机值，随后的声明的是_capacity就会变得很大，导致了程序的崩溃，所以我们必须以后声明顺序和初始化顺序相同。
🚩explicit关键字
class A
{
public:
A(int a)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
private:
int _a;
};
int main()
{
A aa1(1);//拷贝构造
A aa2 = 2;
return 0;
}
我们看看上面一段代码，A aa2=2,运行成功，并且还调了构造函数。
看下面一段代码，隐式类型转换，我们根据前面所学的知识，我们知道有隐式类型转换的过程中会自动生成一个临时变量，b是int类型，b的值给与d类型相同的临时变量，然后进行赋值。所以这里的编译成功。
int b=10;
double d=b;
那么这里的int型隐式类型转换成自定义类型，是不是也是会在其中默认生成一个临时变量。------是的。其过程就是2创造一个A的临时对象，临时对象再拷贝构造aa2，再近代我们的编译对其进行优化，2直接构造了。所以我们的运行成功，调用了拷贝构造函数。
所以下面的表达式经历了------创建临时变量------拷贝构造------优化 ------三大过程。
A aa2=2;
那我们接下来看看下面的代码
这里A&aa3=2，就无法进行构造了。因为2在赋值的时候不是直接赋值，而是我们在中间创建的临时变量是具有常性的，是const类型，是不可以改变的，而中间创建的临时变量的对象是A类，而且是const的A类，然后我们要进行拷贝构造的时候，也需要拷贝给相同类型的对象，所以也要在之前加个const。
构造函数不仅可以构造与初始化对象， 对于单个参数或者除第一个参数无默认值其余均有默认值的构造函 数，还具有类型转换的作用 。如果我们禁止类型转换，我们该如何操作呢？
------ 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 << A::GetACount() << endl;
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;
}
这里就很好理解，a1,a2俩个对象，然后拷贝构造又创建一个对象，总共三个对象。
int _scount = 0;
class A
{
public:
A() { ++_scount; }
A(const A& t) { ++_scount; }
~A() { --_scount; }
private:
//static int _scount;
};
A aa0;
A Func(A aa)
{
cout << __LINE__ << ":" << _scount << endl;
return aa;
}
int main()
{
cout << __LINE__ << ":" << _scount << endl;
A aa1;
static A aa2;
Func(aa1);
cout << __LINE__ << ":" << _scount << endl;
return 0;
}
那上面的这段代码怎么统计呢？
我们来分析一下：aa0是全局创建的一个对象，那么25行就只创建了一个对象，这样也说明了，静态局部变量不会提前初始化，等到了它才存在。然后19行，我创建了aa0，aa1，和静态成员对象aa2，三个对象，然后调用函数的时候，我们传参的时候也创建一个对象，那么总共四个对象。
然后出了作用域之后对象就销毁，29行就只有3个对象。
那我们再来感受一下？
int _scount = 0;
class A
{
public:
A() { ++_scount; }
A(const A& t) { ++_scount; }
~A() { --_scount; }
private:
//static int _scount;
};
A aa0;
void Func()
{
static A aa2;
cout << __LINE__ << ":" << _scount << endl;
}
int main()
{
cout << __LINE__ << ":" << _scount << endl;
A aa1;
Func();
Func();
return 0;
}
如果有相同函数调用多次，静态区的变量只定义一次。所以最后的对象是3次。
但是我们有没有发现_scount的值是可以随意修改的，这是全局变量的劣势：任何地方都是可以修改的。
那么如何让_scount封装一下呢？------就是再类中封装
我们首先要区分一下成员变量和静态成员变量的区别。
- 成员变量：属于每一个类的对象，存储在对象里面
int _a1 = 1;
int _a2 = 2;
- 静态成员变量------属于类，属于类的每一个对象共享。----存储在静态区
static int _scount;
静态成员变量不像成员变量一样，成员变量可以在类中定义，但是静态成员变量不能再类中定义，要再类外面定义。
那我们这里就不能直接获取_scount了，一般静态成员变量和静态成员函数是成套出现的，所以我们就声明定义了一个静态成员函数来获取对象个数。
静态成员函数------没有this指针，指定类域和访问限定符就可以访问
所以静态成员函数不能访问成员，因为访问成员需要this指针，而静态成员函数没有this指针是无法访问的。
///int _scount = 0;
class A
{
public:
A() { ++_scount; }
A(const A& t) { ++_scount; }
~A() { --_scount; }
//没有this指针，指定类域和访问限定符就可以访问
static int GetACount() { return _scount; }
private:
//成员变量：属于每一个类的对象，存储在对象里面
int _a1 = 1;
int _a2 = 2;
//静态成员变量------属于类，属于类的每一个对象共享。----存储在静态区
static int _scount;
};
//全局位置，类外面定义
int A::_scount = 0;
A aa0;
void Func()
{
static A aa2;
cout << __LINE__ << ":" <<A::GetACount()<< endl;
}
int main()
{
cout << __LINE__ << ":" << A::GetACount() << endl;
A aa1;
Func();
Func();
return 0;
}
相比全局变量，静态成员就是用类来封装，让数据更规范一些。
🎓特性
- 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
- 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
- 类静态成员即可用 类名**::**静态成员**或者 对象.****静态成员**来访问
- 静态成员函数没有隐藏的this****指针，不能访问任何非静态成员
- 静态成员也是类的成员，受public、protected、private 访问限定符的限制
- 6.静态成员变量是不能设置缺省值的，为什么成员变量可以设置缺省值，因为成员变量有初始化列表来接收，要么初始化列表来初始化，要么缺省值给初始化然后给初始化列表，而静态成员变量没有初始化列表，所以不能给缺省值。
【问题】(非)静态调用(非)静态
- 1. 静态成员函数可以调用非静态成员函数吗？
我们知道，非静态的成员函数需要 this指针，静态的成员函数没有this指针，所以不能调用。
2. 非静态成员函数可以调用类的静态成员函数吗？
我上面说过了 静态成员函数的特性是：没有this指针，指定类域和访问限定符限定就可以访问。
【1】非静态成员函数在类中调用类的静态成员函数：
因为在类中，类里面不受类域和访问限定符的限制，类里面就是一个大家庭，所以调用静态是完全可以的。
【2】非静态成员函数在类外调用类的静态成员函数：
这里用 指定类域和访问限定符限定进行访问。就可以调用静态成员函数
学了上面的知识我们可以看看这个题目：很好的复习了静态成员变量和静态成员函数的知识。
【题目】累加
求 1+2+3+...+n ，要求不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字及条件判断语句（ A? B:C点击链接练一下吧
大家看见这个题目肯定很熟悉，但是我们学习了c++并且学习了静态成员变量和静态成员函数，我们就可以利用我们现在所学的知识进行解题，题目也多加限制了条件，出题者就是想让我们用（sttic成员)来解题。
**思路：**我们累加到n，那么我们就创建一个类Sum,然后我们创建n个Sum类对象，都知道，出了作用域数据就会被销毁，全局变量可以随意修改，那么我们就可以用静态成员变量来记录值。 记住：成员变量在类里声明，在类外定义。但是由于静态成员变量是私有的，我们就需要一个静态成员函数来获取该值。所以这就照应了为什么静态成员变量和静态成员函数是成套出现的，因为静态成员变量需要静态成员函数来获取。
为什么需要静态成员函数？
静态成员函数属于类，而不是对象。
由于私有静态成员无法类外访问。
有了静态成员函数之后。
在访问私有静态成员时，可以在创建对象前，通过类的静态成员函数访问静态成员
类里面不受类域和访问限定符的限制，类里面就是一个大家庭，所以调用静态是完全可以的或者访问私有函数也是可以的，所以我们就需要静态成员函数来调用了。
class Sum
{
public:
Sum()
{
_ret+=_i;
_i++;
}
//因为 _ret是私有的，那么我们就要用静态成员函数获取_ret的值
static int Getret()
{
return _ret;
}
private:
static int _i;
static int _ret;
};
//静态变量在类里声明，类外定义
int Sum::_i=1;
int Sum::_ret=0;
class Solution {
public:
int Sum_Solution(int n) {
Sum a[n];
return Sum::Getret();
}
};
🚩友元
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度(耦合度是俩者的关系），破坏了封装，所以友元不宜多用。为什么呢？我们往下学就知道了。
友元分为：友元函数和友元类
🎓友元函数
我们为什么有友元函数呢？
问题：现在尝试去重载 operator<< ，然后发现没办法将 operator<< 重载成成员函数。 因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置 。 this 指针默认是第一个参数也就是左操作数了。但是实际使用中cout 需要是第一个形参对象，才能正常使用。所以要将 operator<< 重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>> 同理。
我们看下面一段代码，就知道上面的一段话是什么意思了。
我们来分析一下这段代码，ostream是cout的类，我们给ostream创建一个对象_cout，我们需要_cout<<d1，那么我们要先传的形参是_cout是cout输出流对象,第二个参数是_d1,但是上面的代码中，我们知道operator<<重载成全局函数是非静态的成员函数，而C++编译器给每个"非静态的成员函数"增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有"成员变量"的操作，都是通过该指针去访问。所以this指针和cout输出流对象争夺位置，但是第一个参数还是this指针(指针指向的当前对象),然后第二个参数就成了cout输出流,导致形成了d1<<cout，不符合常规调用。
所以我们该如何改进呢？------如果我们要将operator重载成全局函数，这是非静态成员函数，那么无法访问到类中的私有成员，所以这时候我们就引入了友元的知识了。
class Date
{
friend ostream& operator<<(ostream& _cout, const Date& d);
public:
Date(int year, int month, int day)
: _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 << endl;
return _cout;
}
int main()
{
Date d1(2003, 10, 5);
cout << d1 << endl;
return 0;
}
友元函数 可以直接访问 类的私有 成员，它是定义在类外部 的普通函数 ，不属于任何类，但需要在类的内部声明，声明时需要加friend 关键字。
说明 :
- 友元函数可访问类的私有和保护成员，但不是类的成员函数
- 友元函数不能用const修饰
- 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
- 一个函数可以是多个类的友元函数
- 友元函数的调用与普通函数的调用原理相同
🎓友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
-
友元关系是单向的，不具有交换性。 比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time 类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
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 = 1900, int month = 1, int day = 1)
: _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类可以访问。
友元关系不能传递。 比如如果B是A的友元，C是B的友元，则不能说明C时A的友元。
- 友元关系不能继承，在继承位置再给大家详细介绍。
🚩内部类
概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。（就可以相较于一个工程师给画了一个图纸，工程师给另一个家庭一个福利我可以在图纸里画一下你的家里构造，不占据空间）
注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
class A
{
private:
static int k;
int h;
public:
class B // B天生就是A的友元
{
public:
void foo(const A& a)
{
cout << k << endl;//OK
cout << a.h << endl;//OK
}
};
};
int A::k = 1;
int main()
{
A::B b;
b.foo(A());
return 0;
}
特性：
- 1. 内部类可以定义在外部类的public、protected、private都是可以的。 但是如果定义在public中可以用A::访问限定符给B类创建对象，然后访问其中的私有成员，但如果内部类定义在private中是完全不可以访问任何成员变量和成员函数的，是死死封装住的。
特性一🍭内部类定义在public中：
内部类是定义在public中的
class A
{
private:
static int k;
int h;
public:
class B // B天生就是A的友元
{
public:
B()
:m(1)
,n(1)
{
}
void foo()
{
cout << m << "-" << n << endl;
}
private:
int m;
int n;
};
};
int A::k = 1;
int main()
{
A::B b;
b.foo();
return 0;
}
特性一🍭内部类定义在private中
是完全不能访问的，是任何对象都不可以访问的
- 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
- 3. sizeof(外部类)=外部类，和内部类没有任何关系。
特性三🍭类大小
class A
{
private:
static int k;
int h;
public:
class B // B天生就是A的友元
{
public:
void foo()
{
}
};
};
int A::k = 1;
int main()
{
cout << sizeof(A) << endl;
return 0;
}
c++很少用内部类，但是java经常用。
🚩匿名对象
匿名对象可以理解为没有名字的对象。
特性一🍭生命周期
有名对象 -- 生命周期在当前函数局部域 匿名对象 -- 生命周期在当前行
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) {
cout << "Sum_Solution" << endl;
//...
return n;
}
};
int main()
{
A aa(1);//有名对象
A(2);//匿名对象
Solution s1;
s1.Sum_Solution(2);//有名调用函数
Solution().Sum_Solution(3);//匿名调用函数
return 0;
}
我们可以调试看看
调试完32行之后，我们发现构造和析构都调用了，说明匿名对象生命周期在当前行，即构造即析构。
有名对象的生命周期在局部域内。
特性二🍭匿名对象具有常性
A &ra=A(1);
大家看看ra能不能引用匿名对象？
报错，是不可以的，因为（ 匿名对象是具有常性的）
这样就成功了
const A&ra=A(1);
但是加上const不仅仅只是给匿名对象进行引用，也会出现一个神奇的结果。
我们上面看到了这里并没有即构造即析构。这里我就要解析一下了。
结论：const引用延长匿名对象的生命周期，生命周期在当前函数局部域
我们可以这样理解匿名对象没有人用它那么就即用即销毁，那么引用的话，有人ra需要引用这个匿名对象，所以延长了匿名对象的生命周期。（通俗易懂的说法）
🚩拷贝对象时一些编译器优化
在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。
比如：
- 一个表达式中，连续构造+拷贝构造，可以优化为一个构造
- 隐式类型中：连续构造+拷贝构造，优化为直接构造
- 连续拷贝构造+拷贝构造，优化为一个拷贝构造
- 一个表达式中，连续拷贝构造+赋值重载，无法优化
你的大部分时间投入到哪里，你大概率就会成为怎样的人!