数据共享常用的方法全局变量有很大的局限性而且破坏了封装。静态成员作为类的一种数据成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不回破坏信息隐蔽的原则，保证了程序的安全性。
静态成员是属于类的，如果类中定义了静态成员，那么每个对象都可以操作它。
#include <iostream>


using namespace std; 
class CK{
double cunkuan;       //存款 
public:
static double lixi;  //定义静态数据成员lixi 
   CK(double);
   static void modlixi(double);//定义静态成员函数modlixi() 
   void callixi(int m=1);
   void set(double x){   //设置存款额 
    cunkuan=x;
   }
};


void CK::callixi(int m){
double x=0.0;
x=cunkuan*lixi/12;          //计算月利息 
cunkuan+=x*m;               //将利息加入到存款 
cout<<cunkuan<<endl;
}


void CK::modlixi(double x){  //更改年利率 

lixi=x;
}


CK::CK(double c){
//构造函数 
cunkuan=c;

}
//静态变量必须初始化 
double CK::lixi=0;
 
int main(int argc, char** argv) {
       
CK saver1(2000.0),saver2(3000.0);//实例化两个对象 

CK::modlixi(0.03);

cout<<"年利息为3%时 "<<endl;
cout<<"一个月后甲的存款余额为："<<endl;
saver1.callixi();
cout<<"一个月后乙的存款余额为："<<endl;
saver2.callixi();
saver1.set(2000.0);
saver2.set(3000.0);
cout<<"三个月后甲的存款余额为: "<<endl;
saver1.callixi(3);
cout<<"三个月后甲的存款余额为: " <<endl;
saver2.callixi(3);
return 0;
}




友元，由于类具有封装和信息隐藏的特征，使得其数据成员不能够被其他的成员函数所访问，友元就是为了解决如何让一个在类外部定义的函数访问类的私有成员的问题。


#include<iostream>


using namespace std;


class Integer{
int n;
public:
Integer(int x=0){
n=x;
}
friend int sum(Integer &a,Integer &b);
};
int sum(Integer &a,Integer &b){
     return a.n+b.n;
}
int main(){
    Integer x(25),y(37);
cout<<"sum(x,y)的结果为："<<sum(x,y)<<endl;
return 0;
}






#include<iostream>


using namespace std;


class Integer{
int n;
public:
Integer(int x=0 ){
n=x;
}
        friend class Operation; //声明友元类 
};


class Operation{
public :
int sum(Integer &x ,Integer &y){
return x.n+y.n;
}
int substract(Integer &x ,Integer &y){
return x.n-y.n;
}
int multilication(Integer &x ,Integer &y){
return x.n*y.n;
}
int division(Integer &x ,Integer &y){
return x.n/y.n;
}
};


int main(){
    Integer x(38),y(12);
    Operation z;
    cout<<"sum(x,y)的结果为："<<z.sum(x,y)<<endl;
    cout<<"substract(x,y)的结果为："<<z.substract(x,y)<<endl;
    cout<<"multilication(x,y)的结果为："<<z.multilication(x,y)<<endl;
    cout<<"division(x,y)的结果为："<<z.division(x,y)<<endl;
    return 0;
}






类Operation被定义为类Integer的一个友元函数，类Operation作为类Integer的一个友元类，其所有的成员函数都将是类Integer的友元函数，也就是说类Operation的所有成员函数都有权访问Integer的私有成员。




#include<iostream>


using namespace std;


class Trigon{
float a,b,c;
public:
Trigon(float x,float y,float z){
a=x;
b=y;
c=z;
}
friend float sum(Trigon &tri);
};
float sum(Trigon &tri){
return tri.a+tri.b+tri.c;
}


int main(){
    Trigon tri(3,4,5);
    cout<<"边长为3,4,5的三角形的周长： "<<sum(tri)<<endl;
 
    return 0;
} 




#include<iostream>


using namespace std;


class Trigon{
float a,b,c;
public:
Trigon(float x,float y,float z){
a=x;
b=y;
c=z;
}
friend class S;
};
class S{
public:
  float sum(Trigon &tri){
 
return tri.a+tri.b+tri.c;
  }
  float average(Trigon &tri){
  return (tri.a+tri.b+tri.c)/3.0;
  }
  float max(Trigon &tri){
          int m=tri.a;
          if(m<tri.b)
            m=tri.b;
          if(m<tri.c)
  m=tri.c;
  return m;
  }
};




int main(){
    Trigon tri(3,4,5);
    S z;
    cout<<"三个数3,4,5的和："<<z.sum(tri)<<endl;
cout<<"三个数3,4,5的平均值"<<z.average(tri)<<endl;
cout<<"三个数3,4,5的最大值"<<z.max(tri)<<endl;
    return 0;
} 




多态和虚函数，多态可以简单地概括为一个接口，多个方法。虚函数是动态联编的基础，总是先用自己的，如何过没有，在问你爹要。
纯虚函数只有函数声明，但没有具体实现函数的功能。纯虚函数没有函数体，具体功能要在派生类中实现。




抽象类  含有纯虚函数的类是抽象类，抽象类不能产生对象。


定义一个Figure类，包含一个纯虚函数area（）表示图形面积。


#include<iostream>


using namespace std;


class Figure{
public:
virtual void area()=0; //纯虚函数面积接口 
};


class  Rect:public Figure{
private:
   int a,b;
public:
Rect(int x,int y){
a=x;
b=y;
}
void area(){
cout<<"矩形的面积是"<<a*b<<endl;
}
}; 
class Circle:public Figure{
    double r;
   public:
    Circle(double x=1){
    r=x;
   
    }
    void area(){
    cout<<"圆的面积是"<<r*r*3.141<<endl;
    }
 
};
int main(){
Rect rect(9,8);
Circle circle(2);
Figure *p;
p=&rect;
p->area();
p=&circle;
p->area();
    return 0;
} 






多态，继承，重载构成了面向对象的三大编程特性；多态要通过虚函数实现。






#include<iostream>


using namespace std;


int main(){


    char *str="hello world!";
    cout.put(3);
     cout.put(3);
      cout.put(3);
    cout.write(str,10);
    cout.put('a');//put是插入单个字符 
    cout.flush();
    return 0;
} 


cin的成员函数get()和getline（）这两个函数都有3个参数；他们遇到终止符，默认是\n


getline()可以提取终止符


#include<iostream>


using namespace std;


int main(){


   cout<<"请输入字符串: "<<endl;
   char buf1[30],buf2[30];
  /* cin.get(buf1,30);
   cout<<buf1<<endl;
   cin.get(buf1,30);
   cout<<buf1<<endl;*/
   
   cin.getline(buf2,30);
   cout<<buf2<<endl;
    cin.getline(buf2,30);
   cout<<buf2<<endl;
   return 0;
}