阅读本文章前建议先阅读博主C++专栏的前几篇文文章，以便更好的理解本文章。
目录
本文对类和对象的一些边角料知识点进行补充。
（1）构造函数续
前面C++类和对象------第二关-CSDN博客我们已经学习了造函数的一些知识点，这一节我们继续来补充其知识点。
初始化列表：
之前我们都是通过构造函数在函数体初始化成员变量，这里介绍新的初始化方法：初始化列表。
初始化列表：C++没有规定在定义变量（对象）的时候是否要初始化，一般我们没有初始化的话编译器会初始化随机分配一个值，所以每个类成员变量都要走初始化列表，或是我们自己显示实现的，或是编译器实现的。
怎样初始化呢？
当我们创建一个类的时候，其构造函数可以这样初始化成员变量：
构造函数()
:初始化成员变量1()
，初始化成员变量2()
，初始化成员变量3()
,初始化成员变量4()
,......()
{构造函数函数体}
具体看一下：
cpp
class Time
{
public:
Time(int hour = 0, int minute = 2, int second = 0)
//初始化列表：每个成员变量初始化定义的地方
:_hour(hour = 1)
,_minute(minute *= 2) //括号里面可以是表达式
,_second(second)
{
cout << "Time()" << endl;
}
void print()
{
cout << _hour << "：" << _minute << "：" << _second << endl;
}
private:
// 成员变量可以添加缺省值
int _hour = 1;
int _minute = 1;
int _second = 1;
};可能你会想，既然构造函数都可以初始化变量了为什么还需要初始化列表这些东西呢？
当我们在类中定义其他类型的变量的时候：定义引用和const成员变量是必须要初始化的，不然会报错。
cpp
class Person
{
public:
Person(int age = 1, int height = 2, int weight = 3, double shoesize = 41.5)
:_age(age = 10)
,_height(height = 180)
, _weight(130)
, _shoesize(shoesize)
{
cout << "Person()" << endl;
}
void print()
{
cout << _age << " " << _height << " " << _weight << endl;
}
private:
int _age;
int _height;
double& _shoesize; // 定义引用必须要初始化
const int _weight; // 定义const变量必须要初始化
};
那是不是每个变量都要初始化呢？
但我们不初始化前两个值的时候：
cpp
#include <iostream>
using namespace std;class Person
{
public:
Person(int age = 1, int height = 2, int weight = 3, double shoesize = 41.5)
//:_age(age = 10)
//,_height(height = 180)
: _weight(130)
, _shoesize(shoesize)
{
cout << "Person()" << endl;
}
void print()
{
cout << "年龄：" << _age << " 身高：" << _height << " 鞋码：" << _shoesize << " 体重：" << _weight << endl;
}
private:
int _age;
int _height;
double& _shoesize; // 定义引用必须要初始化
const int _weight; // 定义const变量必须要初始化
};
int main()
{
Person p;
p.print();
return 0;
}
系统会将没有初始化成员变量初始化成随机值。
我们在斜构造函数的时候，会写缺省值，那成员变量是不是也可以写缺省值呢？写了缺省值会怎么样呢？是的C++11支持成员变量加上缺省值。
还是上面的代码，我们将成员变量加上缺省值：
cpp
class Person
{
public:
Person(int age = 1, int height = 2, int weight = 3, double shoesize = 41.5)
//:_age(age = 10)
//,_height(height = 180)
: _weight(130)
, _shoesize(shoesize)
{
cout << "Person()" << endl;
}
void print()
{
cout << "年龄：" << _age << " 身高：" << _height << " 鞋码：" << _shoesize << " 体重：" << _weight << endl;
}
private:
int _age = 12;//加缺省值
int _height = 159;//加缺省值
double& _shoesize; // 定义引用必须要初始化
const int _weight; // 定义const变量必须要初始化
};
由此可见，成员变量是可以加缺省值的，当加上缺省值的时候，如果没有在初始化列表初始化成员变量的化，系统就会使用缺省值初始化成员变量。
在给成员变量缺省值的时候，后面给的也可以是一个表达式：
cpp
private:
int _age = 12*3;//表达式
int _height = 159;
double& _shoesize;
const int _weight;
};那我们写的构造函数的缺省值是干嘛的呢？
答案是：函数的缺省值是构造函数形参的缺省值，成员变量的缺省值，是初始化列表的缺省值。
每个类的成员变量都要走初始化列表，按声明顺序初始化，每个成员只能在初始化列表初始化一次（定义一次）。
跟每个对象都要走构造函数一样的。
总结：
⽆论是否显⽰写初始化列表，每个构造函数都有初始化列表；
⽆论是否在初始化列表显⽰初始化，每个成员变量都要⾛初始化列表初始化；
尽可能的在构造函数里面走初始化列表
（2）类类型转换：
定义和声明的区别：是否开空间。
cpp
#include <iostream>
using namespace std;
class B {
public:
/*explicit*/ B(int n = 12,int m = 0)
// 这里才是定义
:_n(n)
,_m(m)
{
cout << _n << " " << _m << endl;
}
private:
// 这里是声明
int _n;
int _m;
};
int main()
{
// 非类类型的类型转换
char str = 'A';
double x = 12;
int y = (int)str; // 显示类型转换，
// 类类型的隐式类型转换
B b = 12; // 加上exclicit之后就不可以隐式类型转换
B d(32); // 显示类型转换
return 0;
}所有的类型转换都是调用拷贝构造产生一个临时对象。
（3）staic成员
static成员函数：
- static没有this指针
- 只可以访问static成员变量，不可以访问其他变量（因为没有this指针）。但是普通函数可以访问static成员变量
static成员变量：
- 不可以有缺省值，不走构造函数初始化列表
- 需要在类外面初始化
- 和其他static成员变量一样，存在静态区，只不过是受类域限制罢了
code解释:
cpp
// Static成员
class A {
public:
A(int n = 1)
:_n(n)
{
cout << _n << endl;
}
// static成员函数不可以访问static成员变量以外的其他成员变量
static void Print()
{
//cout << _n << endl;
cout <<_m << endl;
}
// 普通成员函数可以访问static成员变量
void Get()
{
cout << "_m:" << _m << "_n:" << _n << endl;
}
//private:
int _n;
static int _m;
};
// static成员函数在类外面初始化
int A:: _m = 12;
int main()
{
A a(32);
a.Get();
return 0;
}（4）友元
友元函数：使用友元声明就可以访问类的所有成员变量,不受类访问限定符限制
。
- 友元函数声明可以放在类的任意位置，只需要函数前面加上关键字friend
- 一个函数可以是多个类的友元。
友元类：声明友元类之后，该类的成员函数就都是另一个类的友元函数
- 友元类关系不能传递，如果A是B的友元，B是C的友元，但是A不是C的友元
- 友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元。
code解释：
cpp
// friend友元函数
class B; // 需要前置声明一下B类，因为B类定义在了A类的下面，在A类中访问B类找不到
class A {
friend void GetPri(const A& a, const B& b);
public:
A(int w = 3, int u = 5)
:_w(w)
,_u(u)
{
cout << "A(int w = 3, int u = 5)" << endl;
}
private:
int _w;
int _u;
};
class B {
friend void GetPri(const A& a, const B& b);
friend class A;
public:
B(int n, int m)
:_n(n)
, _m(m)
{
cout << "B(int n, int m)" << endl;
}
private:
int _n;
int _m;
};
// 一个函数可以是多个类的友元函数
// 友元函数不是成员函数，定义在外面
void GetPri(const A& a, const B& b)
{
// 需要实例化对象才能访问对象里面的成员变量
cout << b._m << endl;
cout << a._u << endl;
}
int main()
{
B b(1,2);
A a;
GetPri(a, b);
return 0;
}（5）内部类
字面意思：类里面定义其他类，需要注意的点;
- 内部类默认是外部类的友元类
- 除了受访问限定符限制之外和其他类一样
code解释：
cpp
// 内部类
class A{
private:
static int _k;
int _h = 1;
public:
class B // B默认就是A的友元
{
public:
void foo(const A& a)
{
cout << _k << endl; //OK
cout << a._h << endl; //OK
}
};
};
int A::_k = 1;
// 内部类使用案例
class Solution {
// 内部类
class Sum
{
public :
Sum()
{
_ret += _i;
++_i;
}
};
static int _i;
static int _ret;
public:
int Sum_Solution(int n) {
// 变⻓数组
Sum arr[n];
return _ret;
}
};
int Solution::_i = 1;
int Solution::_ret = 0;
int main()
{
cout << sizeof(A) << endl;
A::B b;
A aa;
b.foo(aa);
return 0;
}（6）匿名对象
- 生命周期只在当前行，过了当前行就自动调用析构函数销毁了。
code解释：
cpp
// 匿名对象
class B {
public:
B(int n, int m)
:_n(n)
, _m(m)
{
cout << "B(int n, int m)" << endl;
}
private:
int _n;
int _m;
};
int main()
{
// 有名对象
// 不能这样定义对象：B bb(); 分不清是函数声明还是对象定义
B bb(12, 32);
//匿名对象
B(1, 2);
// 生命周期只在当前行，过了当前行就自动调用析构函数销毁了
return 0;
}如果对你有帮助，给个三连支持一下吧！！！！！！！！！！！！！！！！！！！！！！！！！！
