static 和 const

类的静态成员：

1.静态数据成员：

如果某个属性为整个类所有，不属于任何一个具体对象，则采用static关键字声明为静态成员。静态成员在每个类中只有一份拷贝，由类的各个对象共同维护，保证了该数据成员的共享。静态数据成员具有静态生存期，由于静态数据成员不属于任何一个对象，通过类名来访问它。

一个恰当的例子：如果把类比作一个工厂，那么对象是工厂生产的产品，静态数据成员是属于工厂的，而不是属于产品的

#include <iostream>using namespace std;#include <cstdio>#include <cstdlib>class Point{      public:             Point(int xx = 0,int yy = 0){x = xx; y = yy;cntP++;}             Point(Point &p);             ~Point(){cntP--;}             int getx(){return x;}             int gety(){return y;}             void getc(){cout << "object id = " << cntP << endl;}      private:             int x,y;             static int cntP;  //  声明 };Point :: Point(Point &p){      x = p.x;      y = p.y;      cntP++;      }int Point::cntP = 0; // 定义 int main(){    Point A(4,5);    cout << "Point A," << A.getx() <<"," << A.gety();    A.getc();    Point B(A);    cout << "Point B," << B.getx() <<"," << B.gety();    B.getc();    system("pause");}

如果 通过  Point :: getc();   会发现出现编译错误，因为访问类的普通成员函数必须通过对象访问，如果把getc 设置为statci void  getc（） 类就可以访问了，运行结果如下：

静态 成员函数可以直接访问该类的静态数据和成员函数，而访问非静态数据必须通过参数传递方式得到对象名，然后通过对象名访问。

class A{      public:             static void f(A a);      private:              int x;    };static void f(A a){      cout << x << endl;   // 对x引用是错误的，不能直接访问       cout << a.x << endl;      //  正确}

2.const

共享数据的保护：对于需要共享，又需要防止改变的数据应该声明为常量.

1）常引用（引用的对象不能被更新）

#include <iostream>using namespace std;#include <cstdio>#include <cstdlib>void display(const double &r){  // d与r共用存储单元     cout << r << endl;}int main(){    double d(9.6);    display(d);    system("pause");}

const 理解为只读更为合适，如果代码改成

void display(const double &r){  // d与r共用存储单元      (1)  r = 7.2      (2)  double s = 0.1;      (2)  r = s;       cout << r << endl;}

上面的（1）和（2）方案由于都对常引用r做了写处理，所以都会报下面的错误

2）常对象

常对象必须进行初始化，而且不能被更新

class A{      public:             A(int i,int j){x = i; y = j;}      private:             int x, y;};const A a(3,4);  // a 是常对象，不能被更新

常对象不能调用普通的成员函数，只能调用常函数，一般对象可以调用常函数，当然也可以调用普通函数

3)常成员函数

第一，const在定义函数的时候要加入该关键字

第二，const函数不能修改对象的数据成员，也不能调用没有用const修饰的成员函数

第三，const 对象只能调用const函数

第四，const可以用于对重载函数的区分

#include <iostream>using namespace std;#include <cstdio>#include <cstdlib>class R{      public:             R(int r1,int r2){                   R1 = r1;                   R2 = r2;             }             void print();             void print()const;       private:             int R1,R2;      };void R::print(){     cout << R1 << ":" << R2 << endl;     }void R:: print()const{          cout << R1 << ":" << R2 << endl;     }int main(){    R a(5,4);    a.print();    const R b(20,52);    b.print();    system("pause");} 

void R::print(){     R1 = 2;     R2 = 4;     cout << R1 << ":" << R2 << endl;     }

如果print() 这样修改，运行结果如下，运行结果说明不带const的修饰符可以更改对象的数据成员

如果更改void  print() const 函数如下：

void R:: print()const{     R1 = 2;     R2 = 4;     cout << R1 << ":" << R2 << endl;     }

那么报错误如下，出现了read-only的关键字，所以不能运行：

4）常数据成员

类的成员数据数据可以是常量和常引用，使用const说明的数据都是常数据成员

如果在一个类中声明了常数据成员，那么任何其他函数都不能对其进行赋值

构造函数对该数据成员进行初始化，就只能通过初始化列表.(不能通过构造函数函数体)

#include <iostream>using namespace std;#include <cstdio>#include <cstdlib>class A{      public:             A(int i);             void print();             const int &r;      private:             const int a;             static const int b;};const int A::b = 10;A::A(int i):a(i),r(a){}void A::print(){     cout << a << ":" << b << ":" << r << endl;     } int main(){    A a1(100),a2(0);    a1.print();    a2.print();    system("pause");}

A::A(int i){      a = i;      r = a;}

这个是赋值，不是初始化，所以报错如下：

使用引用时注意以下问题：
声明一个引用时，必须同时对它进行初始化，使它指向一个已经存在的对象

一旦一个引用被初始化后，就必须确定是哪个变量的别名，而且只能始终作为这一个变量的别名