类和对象的深入主题

const成员

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

权限可以缩小，但不能被放大，如果Print函数参数中没有const修饰，那么d2是调不了的。加了const修饰后，d1也可以调用。

成员函数加const以后，普通对象和const对象都能调用，但是要修改的对象成员变量的函数不能加

初始化列表

在构造函数体中，对象中虽然已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为每个成员变量在初始化列表只能出现一次（初始化只能初始化一次），而构造函数体内可以多次赋值。

初始化列表是对象的成员变量定义的地方，而以下三种情况必须要在初始化列表初始化

1. const类型修饰的变量
2. 引用类型
3. 没有默认构造的自定义类型（也就是没有无参，全缺省，编译器自动生成的构造函数）

class A
{
public:
    A(int a)
     :_a(a)
     {}
private:
    int _a;
};

class B
{
public:
    B(int a, int& ref)
     :_aobj(a)
     ,_ref(ref)
     ,_n(10)
     {}
private:
    A _aobj; // 没有默认构造函数
    int& _ref; // 引用
    const int _n; // const
};

• 初始化列表的格式：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
• 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化
• 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关,但最好令构造函数初始值的顺序与类中成员声明的顺序一致

Static关键字

如果要统计一个类创建了多少个对象或者某个资源要被多个对象共享，那么要解决这个问题，要么就要在每个对象里面都创建一个资源，要么创建一个全局的资源为所有对象共享。而在函数或变量前加上static关键字就可以变成静态。

如果静态成员变量不受访问限定符的影响，那跟全局变量差不多。

全局变量的劣势：任何地方都可以更改。因此，要改变其劣势，就要对其进行封装

class A
{
public:
    A(){ 
     ++_scount; 
     }
    A(const A& t) 
    { 
      ++_scount; 
     }
    ~A() {
      --_scount; 
     }
    static int GetACount() {
     return _scount; }
private:
    static int _scount;
};

int A::_scount = 0;

void TestA()
{
   cout << A::GetACount() << endl;
   A a1, a2;
   A a3(a1);
   cout << A::GetACount() << endl;
}

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

      特性

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2.  静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3.  类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4.  静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5.  静态成员也是类的成员，受public、protected、private 访问限定符的限制

非静态成员函数可以调用静态成员函数，但反过来静态不能调用非静态，非静态成员函数调用需要this指针，而静态成员函数没有this指针 

static应用 

  1、类的析构函数调用一般按照构造函数调用的相反顺序进行调用，但是要注意static对象的存在， 因为static改变了对象的生存作用域，需要等待程序结束时才会析构释放对象

   2、全局对象先于局部对象进行构造

   3、局部对象按照出现的顺序进行构造，无论是否为static

   4、所以构造的顺序为 c a b d

   5、析构的顺序按照构造的相反顺序析构，只需注意static改变对象的生存作用域之后，会放在局部 对象之后进行析构

   6、因此析构顺序为B A D C

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

class Sum {
  public:
    Sum() {
        _ret += _i;
        ++_i;
    }

    static int sum1() {
        return _ret;
    }
  private:
    static int _i;
    static int _ret;
};
int Sum:: _i = 1;
int Sum:: _ret = 0;
class Solution {
  public:
    int Sum_Solution(int n) {
        Sum  a[n];//创建n个类对象
       return  Sum:: sum1();//将结果返回
    }
};

题目：设计一个类，只能在栈或堆上创建对象

class A
{
public:
	static A Getstackobj()//用静态的函数获取私有构造函数
	{
		A aa;
		return aa;
	}
	static A* Getheapobj()
	{
		return new A;
	}
private:
	A()//先把构造函数私有，那谁都创建不了
	{}
private:
	int _a;
	int _a2;
};
int main()
{ 
    A::Getstackobj();
    A::Getheapobj();
}

explicit关键字

作用：防止发生隐式类型转换

class A
{
public: 
	 A(int a)
		:_a(a)
	{}
private:
	int _a;
};
int main()
{
	A aa1(1);//构造
	//隐式类型转换，整形转换为自定义类型
	A aa = 2;//构造+拷贝构造，优化后直接构造

	//A& aa3 = 4;//报错
	const A& aa3 = 4;//构造的临时对象具有常性
	return 0;
}

如果想防止隐式类型转换：

explicit A(int a) //不允洗隐式类型转换添加explicit
                 :_a(a)
                 {}