#include <iostream>using namespace std;class A {public:    static int n;};int A::n=0;　　　　//要使用类成员限定来访问静态成员void show(){cout<<A::n<<"a \n";}int main(){    int i;    for(i=0;i<5;i++)    {        A::n++;            //访问静态成员变量n并对其进行自加操作............公有的可以直接访问①        show();                //调用全局函数show，该函数输出静态成员变量n的值    }    return 0;}

#include <iostream>using namespace std;class A {public:    void func(){cout<<A::x<<endl;;}     //定义公有成员函数func()，用该函数访问私有静态成员变量xprivate:    static int x;                 //将静态成员变量x声明为私有};int A::x=1000;                 //定义并初始化静态成员变量int main(){    A a;                          //创建一个对象    a.func();                         //用该对象访问公有成员函数func()    //cout << A::x <<endl;        //注意不能直接访问...............私有的不可以直接访问①    return 0;}

/*#include <iostream>using namespace std;class A{public:    void static show(){cout<<A::n;n++;}     //注意：静态成员函数不能访问某个对象的成员变量，因为他没有指向该对象的this指针。不过它可以访问该类的静态成员变量 ②private:    static int n;                      //声明私有静态成员变量n};int A::n=0;                             //定义私有静态成员变量nint main(){    int i;    for(i=0;i<5;i++)     {        A::show();                         //循环调用公有静态成员函数show()        cout<<endl;    }    return 0;}*//*//另外我们也可以通过对象来访问静态成员函数，如：#include <iostream>using namespace std;class A{public:    void static show(){cout<<A::n;n++;}private:    static int n;};int A::n=0;int main(){    A a,b,c;    a.show();    b.show();    c.show();    return 0;}*/#include <iostream>using namespace std;class A{public:    void show(int i){x=i;cout<<x;}    //void static show1(int j){x=j;cout<<x;}    //静态成员函数没有指向对象的this指针，所以不能访问对象的成员数据private:    int x;};int main(){    A a;    a.show(1);    //a.show1(2);     //不能通过静态成员函数访问自己的成员变量    return 0;}

#include <iostream>using namespace std;class aspl         //将阿司匹林声明为一个aspl类，那么每箱阿司匹林就是该类的一个对象      {public:    aspl(float p){price=p;TotalPrice=p+TotalPrice;}    //在构造函数中实例化该对象的私有成员变量price，这样就得到了一箱阿司匹林并且有了它的初始价格    ~aspl(){TotalPrice=TotalPrice-price;}     //析构函数销毁该对象并且将总价格减去该箱的价格，这样账面上就少了一箱阿司匹林，并且总价格也减去了该箱的价格    static float get(){return TotalPrice;}private:    float price;                //由于每箱阿司匹林都有价格，因此必须得有个成员变量来表示价格，这里在aspl这个类中声明一个私有成员变量price    static float TotalPrice;      //由于阿司匹林的总价格属于类的总价格，而不是某一箱阿司匹林的价格，因此我们要将总价格声明为静态成员变量，这里声明为TotalPrice};float aspl::TotalPrice=0;      //静态成员变量必须初始化void main(){    float f;    cout<<"阿司匹林的库存总价格为：";    cout<<aspl::get()<<endl;      //必须用类名限定符来调用静态成员函数    int i=0;    cout<<"请输入第"<<i+1<<"次购进的阿司匹林的单箱价格：";    cin>>f;    aspl *p[5];                  //定义了5个指向aspl类的数组指针p    p[i]=new aspl(f);           //购进一箱阿司匹林    cout<<"阿司匹林的库存总价格为：";    cout<<aspl::get()<<endl;      //输出总价格    i++;                          //i代表购进的次数，i++表示将要进行i+1次购进    cout<<"请输入第"<<i+1<<"次购进的阿司匹林的单箱价格：";  //提示用户输入i次购进    cin>>f;    p[i]=new aspl(f);          //输入的数值保存在i次购进的对象的成员变量中    cout<<"阿司匹林的库存总价格为：";    cout<<aspl::get()<<endl;     //输出当前的库存总价格    cout<<"请输入卖出的阿司匹林的编号,编号即第几次购进：";//提示用户要删除哪次购进    cin>>i;                        //将输入值保存在i变量中    delete p[i];                  //删除第i次创建的对象    cout<<"阿司匹林的库存总价格为：";    cout<<aspl::get()<<endl;      //再次输出销售一箱阿司匹林后的库存总价格}

//函数指针使用实例的程序代码如下：#include <iostream>#include <string>using namespace std;bool check(string str)     //检测是否是数字的函数，要注意该函数一定要放在调用函数的上面{   for(int i = 0;i<str.length();i++)   if((str[i]>‘9‘ || str[i]<‘0‘)&&(str[i]!=‘.‘))   return false;   return true;}float triangle(float &x,float &y){   return x*y*0.5;}float rectangle(float &x,float &y){   return x*y;}void Swap(float &x,float &y){   float n;   n=x;   x=y;   y=n;}void print(float &x,float &y){   cout<<"长为:"<<x<<"  "<<"宽为:"<<y<<endl;}void get(float &a ,float &b){   cout<<"请输入x的新值:";   string str1;cin>>str1;   while(!check(str1))     //调用检测数字函数，如果返回值为假，执行该循环，为真退出   {      cout<<"输入的不是数字,请重新输入!!!"<<endl;      cin>>str1;   }   a = atof(str1.c_str());         //将字符串转换为浮点数   cout<<"请输入y的新值:";   string str2;cin>>str2;   while(!check(str2)){      cout<<"输入的不是数字,请重新输入!!!"<<endl;      cin>>str2;   }   b = atof(str2.c_str());}int main(){   void(*p)(float &,float &);         //声明一个函数指针p，该指针指向一个返回void值并且带有两个float参数的函数   float(*fp)(float &, float &);        //声明一个函数指针fp，该指针指向一个返回float值并且带有两个float参数的函数   bool quit=false;   float a=2,b=3;                     //定义两个参数a和b的值   int choice;                           //声明选择参数choice   while(quit==false)   {      cout<<"(0)退出(1)设定长宽(2)三角形(3)矩形(4）交换长宽：";      cin>>choice;      switch(choice)                     //条件判断语句      {         case 1:            p=get;                        //用指针p来指向函数名get，该函数带有两个float参数并返回一个void值，与函数指针p的参数和类型相吻合            break;         case 2:            fp=triangle;                //用指针fp来指向函数名triangle，该函数带有两个float参数并返回一个float值，与函数指针fp的参数和类型相吻合            break;         case 3:            fp=rectangle;                //用指针fp来指向函数名rectangle，该函数带有两个float参数并返回一个float值，与函数指针fp的参数和类型相吻合            break;         case 4:            p=Swap;                       //用指针p来指向函数名swap，该函数带有两个float参数并返回一个void值，与函数指针p的参数和类型相吻合break;            default:            quit=true;            break;      }      if(quit)break;      if(choice==1||choice==4)            //假如选择了第1或者第4项      {         print(a,b);         p(a,b);                             //调用函数指针p所指向的函数，该指针指向的是一个返回值为void的函数，由于不同的选项中将不同的函数名赋给了指针p，因此选择不同则调用的函数也不同         print(a,b);      }      else if(choice==2||choice==3)        //假如选择了第2和第3项      {         print(a,b);         cout<<"面积为："<<fp(a,b)<<endl;    //调用函数指针fp所指向的函数，该指针指向的是一个返回值为float的函数，由于不同的选项中将不同的函数名赋给了指针fp，因此选择不同则调用的函数也不同      }   }   return 0;}

#include <iostream>using namespace std;void square(int &x,int &y){    x=x*x;    y=y*y;}void cube(int &x,int &y){    x=x*x*x;    y=y*y*y;}void Swap(int &x,int &y){    int z;    z=x;    x=y;    y=z;}void print(void(*p)(int &x,int &y),int &x,int &y)    //该函数有3个参数，第1个是一个函数指针p，它指向的函数带有两个参数，                                                    //并返回一个void值，另外还有两个int型引用x和y{    cout<<"执行函数前\n";    cout<<"x："<<x<<"\t"<<"y："<<y<<endl;    p(x,y);    cout<<"执行函数后\n";    cout<<"x："<<x<<"\t"<<"y："<<y<<endl;}int main(){    int a=2,b=3;    char choice;    bool quit=false;    void (*p)(int &,int &);    //声明的p为一个函数指针，它所指向的函数带有两个参数并返回 一个void值    while(quit==false)    {        cout<<"(0)退出(1)平方(2)立方(3)交换参数：";        cin>>choice;        switch(choice)        {        case ‘0‘:quit=true;        case ‘1‘:p=square;break;         //输入1，将函数名square的地址赋给p        case ‘2‘:p=cube;break;        //输入2，将函数名cube的地址赋给p        case ‘3‘:p=Swap;break;        //输入3，将函数名Swap的地址赋给p        default:p=0;break;        }        if(quit==true)break;        if(p==0)        {            cout<<"请输入0到3之间的数字\n";            continue;        }        print(p,a,b);                    //调用将函数指针作为参数的函数print    }    return 0;}

//typedef 可以简化代码 可以为现有类型创建一个新的名字，或者声明一个对象为某个新类型typedef void(*vp)(int &,int &);//#define f(x) x*x ≠ #define f(x) (x*x)  typedef要比#define要好，特别是在有指针的场合 再比如//　　    typedef char* pStr1;    //后面代替前面//        #define pStr2 char*        //没有分号，前面代替后面//　　    pStr1 s1, s2;        //定义了两个char* //  　　pStr2 s3, s4;        //定义了一个char* s3 一个char s4//#include <iostream>using namespace std;typedef void(*vp)(int &,int &);//typedef 将vp声明为一个函数指针类型，该类型的指针指向一个带有两个int型引用参数并返回void的函数void square(int &x,int &y){    x=x*x;    y=y*y;}void cube(int &x,int &y){    x=x*x*x;    y=y*y*y;}void Swap(int &x,int &y){    int z;    z=x;    x=y;    y=z;}void print(vp,int &,int &);            //print函数的声明部分，该函数有三个参数，一个vp类型的函数指针，两个int型引用。int main(){    vp p;    int a=2,b=3;    char choice;    bool quit=false;    while(quit==false)    {        cout<<"(0)退出(1)平方(2)立方(3)交换参数：";        cin>>choice;        switch(choice)        {        case ‘0‘:quit=true;        case ‘1‘:p=square;break;     //输入，将函数名square的地址赋给p        case ‘2‘:p=cube;break;      //输入，将函数名cube的地址赋给p        case ‘3‘:p=Swap;break;      //输入，将函数名Swap的地址赋给p        default:p=0;break;        }        if(quit==true)break;        if(p==0)        {            cout<<"请输入0到3之间的数字\n";            continue;        }        print(p,a,b);                    //调用这个将函数指针作为参数的函数    }    return 0;}void print(vp p,int &x,int &y)    //print函数的定义部分，函数头声明了3个接收参数，第1个是vp类型的函数指针p，它指向的函数带有两个参数并返回一个void值，另外还有两个int型引用x和y{    cout<<"执行函数前\n";    cout<<"x："<<x<<"\t"<<"y："<<y<<endl;    p(x,y);    cout<<"执行函数后\n";    cout<<"x："<<x<<"\t"<<"y："<<y<<endl;}

#include <iostream>using namespace std;class human                                 //抽象类human{public:    virtual void run()=0;                    //纯虚函数run    virtual void eat()=0;                    //纯虚函数eat};class mother:public human                 //派生类mother从抽象类human继承{public:    void run(){cout<<"母亲跑百米要花二十秒\n";}    //覆盖纯虚函数run    void eat(){cout<<"母亲喜欢吃零食\n";}    //覆盖纯虚函数eat};class father: public human                 //派生类father从抽象类human继承{public:    void run(){cout<<"父亲跑百米要花十秒\n";}    //覆盖纯虚函数run    void eat(){cout<<"父亲不喜欢吃零食\n";}    //覆盖纯虚函数eat};class uncle:public human                 //派生类uncle从抽象类human继承{public:    void run(){cout<<"舅舅跑百米要花十一秒\n";}    //覆盖纯虚函数run    void eat(){cout<<"舅舅喜欢偷吃零食\n";}        //覆盖纯虚函数eat};int main(){    void(human::*pf)()=0;                    //声明一个成员函数指针pf，该指针属于抽象类human    human* p=0;                             //声明一个指向抽象类human的指针p，并将它的内存地址赋为0    char choice1,choice2;                    //声明两个字符变量，用来保存两次用户输入的字符    bool quit=false;                         //声明一个布尔变量quit作为while循环的条件    while(quit==false)                        //当quit为真时退出循环    {        cout<<"(0)退出(1)母亲(2)父亲(3)舅舅:";    //选择菜单        cin>>choice1;                        //将用户的第1次选择保存在choice1中        switch(choice1)                        //将该选择作为判断的依据        {            case ‘0‘:quit=true;break;            //假如输入了字符0，那么将quit的值赋为真，然后退出switch循环            case ‘1‘:p=new mother;break;        //假如输入了字符1，那么创建mother类的新对象，并将p指向它,然后退出switch循环            case ‘2‘:p=new father;break;        //假如输入了字符2，那么创建father类的新对象，并将p指向它,然后退出switch循环            case ‘3‘:p=new uncle;break;        //假如输入了字符3，那么创建uncle类的新对象，并将p指向它,然后退出switch循环            default:choice1=‘q‘;break;        //将字符q赋给choice1,然后退出switch循环        }        if(quit)                                //假如quit的值为真            break;                                //退出while循环        if(choice1==‘q‘)                        //假如choice1的值为字符q        {    cout<<"请输入0到3之间的数字\n";            continue;        } //输出警告并跳转到while循环的开始处继续执行        cout<<"(1)跑步(2)进食\n";                //输出选择菜单        cin>>choice2;                                //将第2次用户的选择保存在choice2中        switch(choice2)                        //将用户的第2次选择作为判断的依据        {            case ‘1‘:pf=&human::run;break;        //假如输入了字符1，那么将基类human的虚函数run的内存地址赋给成员函数指针，然后退出switch循环。注意，这里的&号是取human类成员函数run的地址            case ‘2‘:pf=&human::eat;break;        //假如输入了字符2，那么将基类human的虚函数eat的内存地址赋给成员函数指针，然后退出switch循环            default:break;                        //退出switch循环        }        (p->*pf)();                            //通过指针p来访问对象，通过*pf来访问该对象的成员函数        delete p;                                //删除p指针，因为*pf指向的不是对象而是该对象的成员函数，所以没有必要删除pf    }    return 0;}

#include <iostream>using namespace std;class paper{public:    void read(){cout<<"纸上面的字可以读\n";}    void write(){cout<<"纸可以用来写字\n";}    void burn(){cout<<"纸可以用来点火\n";}};typedef void(paper::*p)(); //利用typedef声明一个成员函数指针类型p，该类型的指针指向paper类的成员函数，该函数不具返回值且没有参数int main(){    //成员函数指针指向三个成员函数    p func[3]={&paper::read,&paper::write,&paper::burn};//用类型p来声明一个func成员函数指针数组，并将它的成员函数指针初始化为它们所指向的函数的内存地址。                                                        //与普通数组元素一样，成员函数指针数组的每个成员函数指针也会拥有一个编号，该编号从0开始    paper* pp=0;                    //声明一个指向paper类的普通指针    char choice[1];                //声明一个只保存一个字符的char型数组choice    bool quit=false;                //声明一个布尔变量quit并将它的值赋为false    while(quit==false)                //当quit的值为false时    {        cout<<"(0)退出(1)读(2)写(3)点火：";      //输出选择菜单        cin>>choice[0];                   //将用户的选择保存在字符数组choice中        if(choice[0]>‘3‘ || choice[0]<‘0‘) //判断该字符是否在0到3之间，假如不是        {            cout<<"请输入从0~3之间的数字\n";     //提示用户输入        }        //否则，假如输入的字符在0~3之间        else if (choice[0]==‘0‘)      //再判断该字符是否等于‘0‘        {            quit=true;                    //等于的话将quit赋为true，那么while条件不成立，退出循环        }        else         {            int n;                       //定义一个整型变量用来接收被转换为整型的字符串            pp=new paper;                  //新构造一个paper类对象，用pp来指向它            n=atoi(choice);    //将choice转换为整型后再赋给n            (pp->*func[n-1])();        // pp指针访问新对象的成员函数，由该对象调用func 指针数组中下标为n-1的指针指向的成员函数，这里要注意数组的下标，n是用户输入的选项值，由于数组元素从0开始，所以要n减1,后面的()表示函数无参数            delete pp;                //删除pp指针指向的新对象        }    }    return 0;}