二、隐式类型转化

提到隐式类型转化，你有没有想起什么？？（没有就去点击链接回顾一下，引用那块）

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静态成员函数，可以不用创建类就调用！