C++重点知识回顾三

静态成员函数的意义，不在于信息共享，数据沟通，而在于管理静态数据成员，完成对静态数据成员的封装。static 修饰成员函数，仅出现在声明处，不可以在定义处。静态成员函数只能访问静态数据成员，因为：非静态成员函数，在调用时this指针被当作参数传入，而静态成员函数属于类，不属于对象，没有this指针。

#include <iostream>
using namespace std;

class Server
{
public:
    Server(char name)
        :_name(name){}

    void serverOne()
    {
        if(_openFlag && _lastServedIdx < _turnCount)
        {
            _lastServedIdx++;
            cout<<"Server: "<<_name<<" is serving "<<_lastServedIdx<<endl;
        }
        if(_lastServedIdx >= _turnCount)
                _openFlag = false;
    }
    static int getTurn()
    {
        ++_turnCount;
        return _turnCount;
    }
    static bool stillOpen()
    {
        return _openFlag;
    }
private:
    char _name;
    static int _turnCount;
    static int _lastServedIdx;
    static bool _openFlag;
};

int Server::_turnCount = 0;
int Server::_lastServedIdx = 0;
bool Server::_openFlag = true;

int main()
{
    Server s1('A'),s2('B');
    int num;
    cout<<"How many in your groups"<<endl;
    cin>>num;
    cout<<"your turns are"<<endl;
    for(int i = 0; i<num; i++ )
    {
        cout<<Server::getTurn()<<endl;
    }
    do
    {
        s1.serverOne();
        s2.serverOne();
    }while(Server::stillOpen());
    cout<<"now closing server"<<endl;
    return 0;
}

3.3 static const 类型

如果一个类的成员，既要实现共享，又要实现不可改变，那就用 static const 组合模式来修饰。修饰数据成员，必须要类内初始化。如下例

#include <iostream>
using namespace std;
class A
{
public:
    const static int dis()
    {
        cout<<i<<endl;
        return i;
    }
private:
    const static int i = 100;
};

int main()
{
    A::dis();
    return 0;
}

4.指向类成员的指针

4.1 指向类数据成员的指针

指向类数据成员的指针，是类层面的指针，而不是对象层面的指针。

指向非静态数据成员的指针在定义时必须和类相关联，在使用时必须和具体的对象相关联。

由于类不是运行时存在的对象。因此，在使用这类指针时，首先需要指定一个类的对象，然后，通过对象来引用指针所指向的成员。

指向类成员的指针，本质存放的不是地址，存放的是偏移量。

声明

<数据类型> <类名> :: *<指针名>

初始化

<数据类型> <类名> :: *<指针名> [= &<类名>::<非静态数据成员>]

解引用

<类对象名>.*<指向非静态数据成员的指针>

<类对象指针>->*<指向非静态数据成员的指针>

#include <iostream>
using namespace std;

class Student
{
public:
    Student(string n, int nu):name(n),num(nu){}
    string name;
    int num;
};

int main()
{
    Student s1("zhangsan",23);
    Student s2("lisi",25);
    // string *ps = &s.name;// 跟封装相违背
    // cout<<*ps<<endl;
    string Student::*pn = &Student::name;
    cout<<s1.*pn<<endl;
    cout<<s2.*pn<<endl;

    Student *ps = new Student("zhaoliu",35);
    cout<<ps->*pn<<endl;
    return 0;
}

4.2 指向类函数成员的指针

定义一个指向非静态函数成员的指针必须在三个方面与其指向的成员函数保持一致；参数列表要相同、返回类型要相同、所属的类名要相同。

由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定类的一个对象，然后，通过对象来引用指针所指向的成员。

声明

<数据类型> (<类名> :: *<指针名>) (<参数列表>)

初始化

<数据类型> (<类名> :: *<指针名>) (<参数列表>) [= &<类名>::<非静态函数成员>]

解引用

(<类对象名>.*<指向非静态函数成员的指针>) (<参数列表>)

(<类对象指针>->*<指向非静态函数成员的指针>) (<参数列表>)

#include <iostream>
using namespace std;

class Student
{
public:
    Student(string n, int nu):name(n),num(nu){}
    void dis()
    {
        cout<<"name:"<<name<<" num:"<<num<<endl;
    }
private:
    string name;
    int num;
};

int main()
{
    Student s1("zhangsan",23);
    Student s2("lisi",25);
    Student *ps = new Student("zhaoliu",35);

    void (Student::*pf)() = &Student::dis;
    (s1.*pf)();
    (s2.*pf)();
    (ps->*pf)();
    return 0;
}

4.3 指向类静态成员的指针

指向静态成员的指针的定义和使用与普通指针相同，在定义时无须和类相关联，在使用时也无需和具体的对象相关联。

#include <iostream>
using namespace std;

class A
{
public:
    static void dis();
    static int data;
};

void A::dis()
{
    cout<<data<<endl;
}

int A::data = 100;

int main()
{
    int *pa = &A::data;
    cout<<*pa<<endl;

    void (*pf)() = A::dis;
    pf();
    return 0;
}

4.4 应用

4.4.1 更加统一的接口

#include <iostream>
using namespace std;

struct Point
{
    int plus(int x, int y)
    {
        return x+y;
    }
    int minus(int x, int y)
    {
        return x-y;
    }
    int mul(int x, int y)
    {
        return x*y;
    }
    int div(int x, int y)
    {
        return x/y;
    }
};

int oper(Point & point, int (Point::*pf)(int x, int y), int x, int y)
{
    return (point.*pf)(x,y);
}

typedef int (Point::*PF)(int x, int y);

int main()
{
    Point pt;
    PF pfun = &Point::plus;
    cout<<oper(pt,pfun,4,5);
    return 0;
}

4.4.2 更加隐蔽的接口

#include <iostream>
using namespace std;

class Game
{
public:
    Game()
    {
        pf[0] = &Game::f;
        pf[1] = &Game::g;
        pf[2] = &Game::h;
        pf[3] = &Game::i;
    }

    void select(int i)
    {
        if(i>=0&&i<=3)
            (this->*pf[i])(i);
    }
private:
    void f(int idx){cout<<"void f(int idx)"<<idx<<endl;}
    void g(int idx){cout<<"void g(int idx)"<<idx<<endl;}
    void h(int idx){cout<<"void h(int idx)"<<idx<<endl;}
    void i(int idx){cout<<"void i(int idx)"<<idx<<endl;}

    enum{
        nc = 4
    };

    void (Game::*pf[nc])(int idx);
};

int main()
{
    Game g;
    g.select(1);
    g.select(2);
    g.select(3);
    return 0;
}