二、隐式类型转化
提到隐式类型转化，你有没有想起什么？？（没有就去点击链接回顾一下，引用那块）
int i = 0;
double d = i;(隐式类型转换），不同类型之间会产生一个临时变量
const double& rd = i; 给i起别名，但类型不同，产生临时变量，这时rd是临时变量的别名，临时变量具有常性，不加const会扩大权限。
1.单参数的构造函数支持隐式转换（C++98才支持）
class Date { public: Date(int year = 1, int month = 1, int day = 1) : _year(year) , _month(month) , _day(day) {} private: int _year; int _month; int _day; }; int main() { Date d1(2022); //调用一次构造函数 // 隐式类型的转换 Date d2 = 2022; //调用一次构造函数，再调用一次拷贝构造 const Date& d5 = 2022; //临时变量具有常性，加const避免扩大权限 Date d3(d1); Date d4 = d1; }
把2022传参，调用构造函数创建临时变量，再把创建好的临时变量通过拷贝构造创建d2.
这样就会浪费资源，每创建一个对象，就调用两个函数，若是栈类，得浪费多大内存空间！！
优化：直接变成一个构造函数（后面会讲解）
2.多参数的构造函数的类型转化
class Date { public: // 多参数构造 //Date(int year, int month=2, int day=2) Date(int year, int month, int day) : _year(year) , _month(month) , _day(day) {} private: int _year; int _month; int _day; }; int main() { Date d1(2022,10,20);//构造函数 Date d2={2022,10,20};//构造加拷贝 const Date& d3={2022,10,20};//const防止扩大临时变量权限（拷贝加构造） }
他们的过程不一样，但结果是相同的。
3.explicit关键字
explicit修饰构造函数，禁止类型转换，explicit去掉之后，代码可以通过编译。
class Date { public: // 多参数构造 explicit Date(int year, int month, int day) , _month(month) , _day(day) {} private: int _year; int _month; int _day; }; int main() { Date d1(2022, 10, 20); Date d2 = {2022,10,20 }; return 0; }
当然，单参数和多参数的构造函数隐式类型转化加explicit是一样的，加了之后，就不会支持隐式类型转化了。
三、static修饰的静态成员
1.static修饰公有成员变量
如果我想解决一个问题，就是统计一个类到底创建了多少个对象，应该怎么办呢？？
首先想到的是，全局变量？在每创建一个类，count++；但是全局变量不好的地方在于他是公开的，随便别人去修改，这会非常的不好，导致致命错误，不建议使用。
那么就想到了静态变量：静态局部变量，静态全局变量，类静态变量
静态局部变量在函数内定义，但不象自动变量那样，当调用时就存在，退出函数时就消失。静态局部变量始终存在着，也就是说它的生存期为整个源程序。
静态局部变量的生存期虽然为整个源程序，但是其作用域仍与自动变量相同，即只能在定义该变量的函数内使用该变量。退出该函数后，尽管该变量还继续存在，但不能使用它。
静态局部变量，静态全局变量，类静态变量：从始至终都存在，且只存在当前文件。且作用域不同。
类中的静态变量存储在 静态区，且作用域是类，属于每一个类的对象，我们访问它可以通过创建类，通过类去访问，也可以使用访问限定符A::N来访问。（前提是静态成员变量）
我们来计算创建了多少对象：
class A { public: A(int a = 0) :_a(a) { ++N; } A(const A& aa) :_a(aa._a) { ++N; } static int N; private: int _a; }; int A::N=0;//静态成员变量只能在类外定义初始化，在类内则会频繁初始化，一直改变值。 int main() { A aa1(1); //构造函数 A aa2 = 2; //构造加拷贝 优化为一个构造函数 A aa3 = aa1;//拷贝 cout<<A::N<<endl; }
静态成员变量只能在类外定义初始化，在类内则会频繁初始化，一直改变值。
也验证了，编译器对于隐式类型转换的拷贝构造+默认构造会优化为一个拷贝构造。（如果没有优化就是四个），那我们再试传值返回，传引用返回，返回值，返回引用：
void f1(A aa) { } A f2(A aa) { A b = aa; return b; } int A::N = 0; int main() { A aa1(1); A aa2 = 2; A aa3 = aa1; f1(aa2); f2(aa2); cout << A::N << endl; }
答案是：7，说明传值传参确实会调用一次拷贝构造，返回值也会创建临时变量去调用一次拷贝构造。
2.static修饰私有成员变量
为私有成员变量时：我们在类外使用，则需要通过类内的成员函数才可以访问到：
class A { public: A(int a = 0) :_a(a) { ++N; } A(const A& aa) :_a(aa._a) { ++N; } int GetN() { return N; } private: int _a; static int N; // 声明 }; int main() { A aa(); cout<<aa.GetN()<<endl; }
那么访问静态私有变量就需要创建一个对象，可不可以不创建就访问呢？
通过定义静态成员函数，就可以不定义对象直接调用，静态成员变量是没有this指针的，所以也不能调用其他成员变量。静态成员函数不需要this指针，是因为静态成员变量是类的所有对象共享的
只有那么一个，所以不管哪个对象调用返回的是同一个。所以静态不能访问非静态，所以静态成员函数是跟静态成员变量配合起来用的。
class A { public: ...... static int GetN() { return N; } private: int _a; static int N; // 声明 }; int main() { cout<<A::GetN()<<endl; }
当然，私有变量只能获取，不能修改。
当限定了类创建的存储区域时：规定只能存储在栈区，那么创建在堆区等等的创建方式就不可以使用，但是只要创建类，就会调用类的构造函数，为了把对象创建在栈区，就需要把构造函数设置为私有，通过成员函数来访问。但是通过公有的成员函数访问私有构造函数，进而在成员函数中创建类，返回类。
class A { public: static A GetObj(int a = 0) { A aa(a); return aa; } private: A(int a = 0) :_a(a) {} private: int _a; }; int main() { //static A aa1; //静态区 //A* ptr = new A; //堆区 //A aa2; //栈区 //A aa3=Getobj(10); 错误 A aa3 = A::GetObj(10); return 0; }
但是最重要的一个问题是：你要调用函数，你就得创建对象，你要创建对象，你就得先调用函数，这不是？？？完了！！
那么这时，static作用就大了，因为设置为static静态成员函数，可以不用创建类就调用！
