二、隐式类型转换

1、概念

隐式类型转换是指当两个不同类型的变量之间进行运算时，编译器会自动将其中一个变量的类型转换为另一个变量的类型；在之前 C++引用 的常引用中我们也接触过，比如：

int main()
{
  int a = 0;
  double b = a;
  const double& rb = a;
    const int& c = 1;
}

如上，如果我们将 int 的 a 赋值给 double 的 b，则 a 不会被直接赋值给 b，编译器会先根据 a 创建一个 double 类型的临时变量 tmp，然后将 tmp 赋值给 b；

对于 rb 来说也是一样的，只不过 rb 是引用类型，而引用和指针需要考虑权限的问题，所以用引用类型的变量 rb 去引用 a 生成的临时变量 tmp 需要使用 const 修饰 (临时变量具有常性)；

对于最后一条语句来说也大同小异 – 由于数字 1 只存在于指令中，在内存中并不占用空间，所以当我们对其进行引用时，10会先赋给一个临时变量，然后我们再对这个临时变量进行引用；同时由于临时变量具有常性，所以我们需要使用 const 修饰；

上面这些知识在我前面 C++引用 的常引用部分有详细的介绍，如果有遗忘的小伙伴可以去复习一下；

2、构造函数的类型转换

在C++98中，单参数的构造函数也支持隐式类型转换，即对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，其具有类型转换的作用；比如下面这样：

class Date
{
public:
  Date(int year)
    :_year(year)
  {
    cout << "Date 构造" << endl;
  };
  Date(const Date& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
    cout << "Date 拷贝构造" << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};

如上，对于具有单参构造函数的Date类，我们不仅可以使用构造和拷贝构造的方式来实例化对象，还可以通过直接赋值一个整数来实例化对象；

而这其实是隐式类型转换的结果：

对于d3来说，由于2022和d3的类型不同，所以编译器会进行类型转换，即先使用2022来构造一个临时的Date对象，然后用这个临时对象来对d3进行拷贝构造，所以d3是构造+拷贝构造的结果；

不过现在比较新版的编译器都对这种情况进行了优化，不再创建临时的Date对象，而是直接使用2022来构造d3，所以我们看到的现象是创建d3没有调用拷贝构造函数；而在老版的编译器下是会调用拷贝构造函数的，比如VC 6.0、VS2003等编译器；

对于d4来说，d4是Date对象的引用，所以编译器会先用2022来构造一个Date类型的临时对象，然后d4再对这个临时对象进行引用，所以只会调用一次构造函数；同时由于临时对象具有常性，所以需要使用const修饰；

注意：单参构造函数并不是指只能有一个参数，而是指在调用时只传递一个参数，所以半缺省和全缺省的构造函数也是可以的；

C++11对上述语法进行了拓展，支持多参数的构造函数，只是传递参数时多个参数之间需要使用花括号，如下：

3、explicit 关键字

explicit 关键字用于修饰构造函数，其作用是禁止构造函数的隐式类型转换，如下：

class Date
{
public:
  explicit Date(int year = 1970, int month = 1, int day = 1)
    :_year(year)
    , _month(month)
    , _day(day)
  {
    cout << "Date 构造" << endl;
  };
  Date(const Date& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
    cout << "Date 拷贝构造" << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};

4、类型转换的意义

构造函数的类型转换在一些特定的地方有着很大的意义，比如要在一个顺序表尾插一个元素，而这个元素是 string 类型的对象，如下：

int main()
{
  string s1("hello");
  push_back(s1);
  push_back("hello");
}

如上，有了隐式类型转换我们在插入一个 string 对象时就不必先去构造 s1，然后再传递 s1，而是直接使用 “hello” 做参数即可，其会自动转化为 string 类型；等等类似的情景还有非常多，具体的我们在后面遇到再说；

三、static 成员

1、概念

声明为 static 的类成员称为类的静态成员，其中用 static 修饰的成员变量，称之为静态成员变量，用 static 修饰的成员函数，称之为静态成员函数；下面我们以一个面试题来引出类的静态成员的相关知识点；

面试题：实现一个类，计算程序中创建出了多少个类对象；

我们知道，类创建对象一定会调用构造函数或者拷贝构造函数，所以我们只需要定义一个全局变量，然后在构造函数和拷贝构造函数中让其自增即可，如下：

int N = 0;
class A
{
public:
  A(int i = 0)
    :_i(i)
  {
    N++;
  }
  A(const A& a)
  {
    _i = a._i;
    N++;
  }
private:
  int _i;
};

虽然使用全局变量的方法可以十分简便的达到我们的目的，但是我们不建议使用全局变量，因为全局变量可以被任何人修改，十分不安全；所以我们需要使用另外一种比较安全的方法 – 静态成员变量；

2、static 成员变量

静态成员变量是指用 static 关键字修饰的成员变量，其特性如下：

• 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区；
• 静态成员变量必须在类外定义，定义时不添加 static 关键字，类中只是声明；
• 静态成员变量的访问受类域与访问限定符的约束；

接下来我们围绕这三点特性来展开说明：

1、由于静态成员变量在静态区 (数据段) 开辟空间，并不在对象里面，所以它不属于某单个对象，而是所有对象共享；

class A
{
public:
  A(int m = 0)
    :_m(m)
  {}
public:
  int _m;
  static int _n;
};
int A::_n = 0;

可以看到，当我们把类的静态成员变量设置为 public 并在类外进行定义初始化后，我们可以直接通过类名+域作用限定符或者通过一个空指针对象来访问，这说明_n并不存在于对象里面；

2、类的静态成员变量在类中只是声明，必须在类外进行定义且定义时需要指定类域，其不在初始化列表处进行定义初始化，因为新建对象并不会改变它的值；

tips：当我们的程序出现错误时，输出列表提供的错误信息是最准确的，且我们应该从第一个错误开始解决；

3、静态成员变量的访问受类域与访问限定符的约束；

如上，静态成员变量在访问时和普通的成员变量区别不大，同样受类域和访问限定符的约束，只是因为其不存在于对象中，所以我们可以通过 A:: 来直接访问；

注：可以看到，静态成员变量在定义声明的时候只受类域的限制，而没有受到访问限定符的限制，这是一个特例，大家记住即可；

学习了静态成员变量的相关知识以后，我们就可以换一种方式来统计对象的创建个数了：

class A
{
public:
  A(int i = 0)
    :_i(i)
  {
    _n++;
  }
  A(const A& a)
  {
    _i = a._i;
    _n++;
  }
private:
  int _i;
  static int _n;
};
int A::_n = 0;

但是这里出现了一个新的问题：为了保证类的封装性我们需要将成员变量设置为private，但是这样又使得我们无法在类外获取到它们，那该怎么办呢？针对这个问题，C++设计出了静态成员函数；

3、static 成员函数

静态成员函数是指用 static 关键字修饰的成员函数，其特性如下：

• 静态成员函数没有隐藏的this指针，不能访问任何非静态成员；
• 静态成员也是类的成员，同样受类域和访问限定符的约束；

由于静态成员函数没有隐藏的 this 指针，所以我们在调用的时候自然也就不需要传递对象的地址，即我们可以通过类名+域作用限定符直接调用，而不需要创建对象；但是相应的，没有了 this 指针我们也无法去调用非静态的成员变量与成员函数，因为非静态成员变量需要实例化对象来开辟空间，非静态成员函数的调用则需要传递对象的地址；

class A
{
public:
  A(int i = 0)
    :_i(i)
  {
    _n++;
  }
  A(const A& a)
  {
    _i = a._i;
    _n++;
  }
  static int GetN()
  {
    return _n;
  }
private:
  int _i;
  static int _n;
};
int A::_n = 0;

注意：虽然静态成员函数函数不可以调用非静态成员，但是非静态成员函数是可以调用静态成员的 (调用静态成员时编译器不传递对象地址即可)；

最后，让我们来做一道与静态成员相关的练习题：求1+2+3+…+n

求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

class Sum
{
public:
    Sum()
    {
        ++_i;
        _ret += _i;
    }
    static int GetRet()
    {
        return _ret;
    }
private:
    static int _i;
    static int _ret;
};
int Sum::_i = 0;
int Sum::_ret = 0;
class Solution {
public:
    int Sum_Solution(int n) {
        Sum arr[n];
        return Sum::GetRet();
    }
};