c++学习-特殊类成员

静态变量：

#include<iostream>
#include<string>
#include <typeinfo>
using namespace std;

class A{

public:

    A(){ total++; }
    static int total;

};

//@warn 静态成员变量必须在全局进行定义
int A::total = ; 

void main()
{
    A a1;
    A a2;

    cout << a1.total<< endl;
    cout << a2.total<< endl;
　　cout << A::total << endl;

}

静态成员函数：

#include<iostream>
#include<string>
#include <typeinfo>
using namespace std;

class A{

public:
    A(){ total++; }
    static void show()
    {
        cout << total << endl;
    }

    void echo()
    {
        cout << total << endl;
    }

private:
    static int total;
    int a;
};

int A::total = ; 

void main()
{
    A::show();

    A a1;
    a1.echo();

A a1,a2;
a1.echo();
a1.show();//也可以通过对象调用静态函数

}

继承后静态成员函数和方法仍旧可用：

#include<iostream>
#include<string>
#include <typeinfo>
using namespace std;

class A{

public:
    A(){ total++; }
    static void show()
    {
        cout << total << endl;
    }

    void echo()
    {
        cout << total << endl;
    }

private:
    static int total;
    int a;
};

class B :public A{

};

int A::total = ; 

void main()
{
    A::show();
    B::show();

}

静态成员函数不能说明为虚函数

int(*fun)(int);//声明一个函数指针，指向的函数的参数为int，返回值为int
int*fun(int);//声明一个函数，函数的参数为int，返回值为int型指针

函数指针使用：

#include<iostream>
#include<string>
#include <typeinfo>
using namespace std;

int test1(int x,int y){
    return x + y;
}

int test2(int x, int y){
    return x * y;
}

void main()
{
    int(*p)(int, int);
    p = test1;
    cout << p(, )<< endl;

    p = test2;
    cout << p(, ) << endl;

}

函数指针数组：

#include<iostream>
#include<string>
#include <typeinfo>
using namespace std;

int test1(int x,int y){
    return x + y;
}

int test2(int x, int y){
    return x * y;
}

void main()
{
    int(*p[])(int, int) = { test1, test2 };

    cout << p[](,) << endl;
    cout << p[](, ) << endl;

}

函数指针做参数：

#include<iostream>
#include<string>
#include <typeinfo>
using namespace std;

int test1(int x,int y){
    return x + y;
}

int test2(int x, int y){
    return x * y;
}

void show(int(*p)(int, int), int x,int y)
{
    cout << p(x,y) << endl;
}

void main()
{
    show(test1, ,);
    show(test2, , );
}

typedef来简化定义：

#include<iostream>
#include<string>
#include <typeinfo>
using namespace std;

typedef int(*p)(int, int); // p代表 int(*p)(int, int);

int test1(int x,int y){
    return x + y;
}

int test2(int x, int y){
    return x * y;
}

void show(p vp, int x,int y)
{
    cout << vp(x, y) << endl;
}

void main()
{
    show(test1, ,);
    show(test2, , );
}

成员函数指针：

#include<iostream>
#include<string>
#include <typeinfo>
using namespace std;

class A{
public:
    int show(int x, int y){ return x*y; }
};

int(A::*p)(int, int);

void main()
{
    p = &A::show;

    A a1;
    (a1.*p)(, ); //调用

}

多态和成员函数指针：

#include<iostream>
#include<string>
#include <typeinfo>
using namespace std;

class human{
public:
    virtual void say() = ;
};

class father :public human{
public:
    void say(){ cout << "father say:" << endl; }
};

class mother :public human{
public:
    void say(){ cout << "mother say:" << endl; }
};

void main()
{
    void (human::*fun)()=;
    fun = &human::say;

    human *p;
    p = new father;
    (p->*fun)();

    p = new mother;
    (p->*fun)();

}