目录
初始化列表
初始化列表就是类成员初始化的地方
函数有它声明和定义的地方，变量也有，类成员也有
先来看看日期类的默认构造函数
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 7, 15);
return 0;
}
在类里面显示出来的成员我们把它叫做声明
如果你认为我们就这样把_year，_month，_day给初始化了，那就错了
这并不是初始化，这是赋值
如果我们要初始化类成员的话应该这样做
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
:_year(year)
,_month(month)
,_day(day)
{}
private:
int _year;
int _month;
int _day;
};
这一块就是初始化列表
先是一个冒号开始，然后以逗号分隔，成员变量后面跟初始值或者表达式
这样我们就完成了一个成员的定义和初始化
那么这两种写法有什么区别呢？
这两种写法给我们带来的效果都是一样的，但是无论怎么写我们的成员变量都要经过初始化列表一遍，就算没有写初始化列表也会！所以这里建议尽量使用初始化列表初始化
如果我们不知道初始化列表怎么给，我们可以在声明的地方给一个缺省值，例如：
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
:_year(year)
,_month(month)
,_day(day)
{}
private:
int _year = 1900;
int _month = 1;
int _day = 1;
};
这样就算我们没有写初始化列表也会给我们自动初始化上这些值
注意：
const成员变量，带引用的成员变量，只有一次初始化的机会！那就是在初始化列表中！
class A
{
public:
A(int a = 1)
{
_a = a;
}
private:
const int _a;
};
因为const常量不能被赋值，只能在初始化的地方被初始化，正确代码如下：
class A
{
public:
A(int a = 1)
:_a(a)
{}
private:
const int _a;
};class A
{
public:
A(int a = 1)
:_a(a)
{}
private:
int& _a;
};初始化列表的特点
如果我们没有在声明的地方给缺省值，也没有写初始化列表，那么值由编译器决定
如果我们给了缺省值没有写初始化列表，那么会根据缺省值初始化
如果我们即给了缺省值也给了初始化列表，那么根据初始化列表的值初始化
注：上述行为于构造函数内部行为无关
初始化列表中按照成员在类中声明的定义来初始化，于初始化列表中出现的先后顺序无关
例如：
class A
{
public:
A()
:_a(1)
, _b(_a)
{}
//private:
int _b;
int _a;
};
int main()
{
A a;
cout << a._a << endl;
cout << a._b << endl;
return 0;
}输出结果：
我们可以看到_a的值为1，_b的值为随机值s
这是因为类声明是先声明的_b，才声明的_a，所以初始化列表会先初始化_b，再初始化_a，而不是因为_a在初始化列表中初始化就初始化_a
类型转换、explicit
隐式类型转换
什么是隐式类型转换？通过下面的例子我想你就明白了
int main()
{
double d = 3.14;
int i = d;
cout << i << endl;
return 0;
}
double类型的d为什么能赋值给int类型的i？
在 i = d 的时候这里会构造出一个临时对象，d会先构造给这个临时变量，然后临时变量才会将值拷贝构造给i
回到正题
class A
{
public:
A(int a)
:_a(a)
{}
private:
int _a;
};
int main()
{
A a = 1;
return 0;
}这里将1拷贝构造给A类型a就是隐式类型转换，将int类型转换成A类型
explicit关键字
如果我们想要编译器再严格一点，只能同类型转换，那么我们可以在构造类型前面加上关键字explicit
class A
{
public:
explicit A(int a)
:_a(a)
{}
private:
int _a;
};
int main()
{
A a = 1;
return 0;
}此时我们就运行不了我们的代码了
static成员
静态成员变量
用static修饰的成员变量，称为静态成员变量，静态成员变量必须要在类外初始化！
它的作用和C语言中一样，不属于某个具体的对象，存放在静态区中，生命周期跟全局变量一致
类内初始化：
class A
{
public:
A(int a)
:_a(a)
{}
void Print()
{
cout << _a << endl;
}
private:
static int _a;
};
int main()
{
A a;
a.Print();
return 0;
}
类外初始化：
class A
{
public:
//A(int a)
// :_a(a)
//{}
void Print()
{
cout << _a << endl;
}
private:
static int _a;
};
int A::_a = 5;
int main()
{
A a;
a.Print();
return 0;
}
静态成员函数也收public、private、protected访问限定符约束
class A
{
public:
//A(int a = 1)
// :_a(a)
//{}
void Print()
{
cout << _a << endl;
}
private:
static int _a;
};
int A::_a = 5;
int main()
{
A a;
cout << A::_a << endl;
return 0;
}
静态成员函数
用static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针！
静态成员函数中可以访问静态成员，但是不能访问成员函数，因为没有this指针
class A
{
public:
A(int a = 1)
:_a(a)
{}
static void Print()
{
cout << _a << endl;
}
private:
int _a;
};
非静态成员函数可以访问任意的静态成员变量和静态成员函数（毕竟是全局的）
友元
友元分为友元函数和友元类
友元函数
class A
{
public:
A(int a = 1)
:_a(a)
{}
private:
int _a;
};
void Print(const A& a)
{
cout << a._a << endl;
}
正常这样Print函数是无法访问到A类里面的private成员变量的，但是如果它是A类的朋友就可以了
class A
{
friend void Print(const A& a);
public:
A(int a = 1)
:_a(a)
{}
private:
int _a;
};
void Print(const A& a)
{
cout << a._a << endl;
}
友元函数仅仅是一种声明，他不是类的成员函数
把函数的第一行写一遍，然后前面加上friend，这样Print就是A的朋友了，这样就不会报错了
可以看出，外部友元函数是可以访问类中的私有成员的，当然保护和共有也不例外
友元类
class A
{
public:
A(int a = 1)
:_a(a)
{}
void Print()
{
B b;
cout << b._b << endl;
}
private:
int _a;
};
class B
{
friend class A;
public:
B(int b = 0)
:_b(b)
{}
private:
int _b;
};正常来说A类中的Print函数是不能访问b中private的_b
但是这时候，B声明了A是我的朋友，那么A中就可以访问B类中的私有了
但是要注意：友元类关系不能传递
B说A是我的朋友，但是不代表A的朋友是B
class A
{
public:
A(int a = 1)
:_a(a)
{}
void Print()
{
B b;
cout << b._b << endl;
}
private:
int _a;
};
class B
{
friend class A;
public:
B(int b = 0)
:_b(b)
{}
void Print()
{
A a;
cout << a._a << endl;
}
private:
int _b;
};
A是B的友元，但是B可不是A的友元！
友元和面向对象封装的思想有些相反了，破坏了这种封装
友元会增加耦合度，但是破坏了封装，所以不宜多用
内部类
如果一个类定义在另一个类的内部，那么这个类叫做内部类
class A
{
public:
A(int a = 1)
:_a(a)
{}
class B
{
public:
void func(const A& a)
{
cout << a._a << endl;
}
};
private:
int _a;
};
int main()
{
A a;
A::B b;
b.func(a);
return 0;
}
这里的B类就是定义在A类中，此时B就是A的友元，可以访问A类中的私有
A类的实现就是专门为B准备的
匿名对象
先来看个代码
class A {
public:
int func(int n) {
//...
return n;
}
};
int main()
{
A a;
a.func(1);
return 0;
}如果要调用func函数我们可以先定义一个A类对象，然后再使用func
那还有什么更好的调用方式吗？
我们可以使用匿名对象来调用这个func函数
class A {
public:
int func(int n) {
//...
return n;
}
};
int main()
{
A().func(1);
return 0;
}这里的A()就是一个匿名对象，它的生命周期只有这一行，这一行之后就会结束，所以目的也就只是想调用func函数不那么麻烦且少一点空间
编译器优化
class A {
public:
A(int a = 1)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& a)
:_a(a._a)
{
cout << "A(const A& a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
int main()
{
A a1(10);
A a2 = a1;
return 0;
}
明明有两个成员变量a1、a2，怎么才调用一次构造函数呢？
这里就是由于编译器的优化，由于A a2 = a1这个表达式做了两件事情，一件就是构造，另一件就是拷贝构造，所以编译器优化成了只有拷贝构造即可
越是新版本的编译器优化的会越狠
将Debug模式换成Release也会有更多的优化
这些都是为了加快代码运行的效率
完