类成员指针

Posted 2021-03-05 xiaojianliu

数据成员指针

成员指针是指可以指向非静态成员的指针，成员指针指示的是类的成员，而非类的对象。类的静态成员不属于任何对象，因此无须特殊的指向静态成员指针，指向静态成员的指针与普通的指针没有什么区别。

class Screen
{
public:
    typedef std::string::size_type pos;
    char get_cursor() const { return contents[cursor]; }
    char get() const;
    char get(pos gt, pos wd) const;
private:
    std::string contents;
    pos cursor;
    pos height, width;
};

声明数据成员指针：

//@ pdata 可以指向一个常量(非常量) Screen 对象的 string 成员
const string Screen::*pdata;

常量对象的数据成员本身也是常量，因此将指针声明成指向 const string 成员的指针意味着 pdada 可以指向任何 Screen 对象的一个成员，而不管该 Screen 对象是否是常量。作为交换条件，只能使用 pdata 读取它所指的成员，而不能向它写入内容。

初始化陈冠指针或者向它赋值时，需指定它所指的成员：

pdata = &Screen::contents;

在 C++ 11中可以使用 auto 或者 decltype：

auto pdata = &Screen::contents;

使用数据成员指针

初始化一个成员指针或者尾为成员指针赋值时，该指针并没有指向任何数据。成员指针指定了成员而非该成员所属的对象，只有当解引用成员指针时才能提供对象的信息。

成员指针访问运算符：.* 和 ->*：

Screen myScreen, *pScreen = &myScreen;
//@ .* 解引用 pdata 以获得 myScreen 对象的 contents 成员
auto s = myScreen.*pdata;
//@ ->* 解引用 pdata 以获得 pScreen 所指对象的 contents 成员
s = pScreen->*pdata;

返回数据成员指针的函数

常规的访问控制规则对成员指针同样有效，例如 Screen 的 contents 成员是私有的，因此之前对于 pdata 的使用必须位于 Screen 类的成员或友元内部，否则程序将引发错误。

最好定义一个函数，令其返回值是指向该成员的指针：

class Screen
{
public:
    //@ data 是一个静态成员，返回一个成员指针
    static const std::string Screen::*data()
    {
        return &Screen::contents;
    }
};

从右向左阅读可知 data 函数返回的是一个指针，该指针指向 Screen 类的 const string 成员。

const string  Screen::*pdata = Screen::data();

成员函数指针

//@ pmf 是一个指针，它可以指向 Screen 的某个常量成员函数
//@ 前提是该函数不接受任何实参，并且返回一个 char
auto pmf = &Screen::get_cursor;

如果成员函数是 const 成员或者引用成员，则必须将 const 限定符或引用包含进来。

和普通的函数指针类似，如果成员存在重载的问题，则必须显式地声明函数类型以明确指出想要使用哪个函数：

char (Screen::*pmf2)(Screen::pos, Screen::pos) const;
pmf2 = &Screen::get;

上面 Screen::*pmf2 的括号是必不可少的，如果声明成：

//@ 错误，非成员函数不能使用 const 限定符
char Screen::*p(Screen::pos, Screen::pos) const;

上面的声明试图定义一个名为 p 的普通函数，并且返回 Screen 类的一个 char 成员。因为声明的是普通函数，所以不能使用 const 限定符。

和普通函数指针不同，在成员函数和指向该成员的指针之间不存在自动转换规则：

//@ pmf 指向一个 Screen 成员，该成员不接受任何实参并且返回类型是 char
pmf = &Screen::get;     //@ 必须显式地使用取地址运算符
pmf = Screen::get;      //@ 错误，在成员函数和指针之间不存在自动转换规则

使用成员函数指针

使用 .* 和 ->*运算符作用于指向成员函数的指针，以调用类的成员函数：

Screen myScreen, *pScreen = &myScreen;
//@ 通过 pScreen 所指的对象调用 pmf 所指的函数
char c1 = (pScreen->*pmf)();
//@ 通过 myScreen 对象将实参 0,0 传递给含有两个形参的 get 函数
char c2 = (myScreen.*pmf2)(0,0);

上面的代码如果不加括号：

myScreen.*pmf();

则等价于：

myScreen.*(pmf());

含义是调用一个名为 pmf 的函数，然后使用该函数的返回值作为指针指向成员运算符(.*) 的运算对象，但是 pmf 并不是一个函数，因此代码将出错。

使用成员指针的类型别名

//@ Action 是一个指向 Screen 成员函数的指针，它接受两个 pos 实参，并返回一个 char
using Action = char(Screen::*)(Screen::pos, Screen::po) const;

通过使用 Action 可以简化指向 get 的指针定义：

Action get = &Screen::get;  //@ get 指向 Screen 的 get 成员

可以将指向成员函数的指针作为某个函数的返回类型或形参类型，其中，指向成员的指针形参也可以拥有默认实参：

//@ action 接受一个 Screen 的引用，和一个指向 Screen 成员函数的指针
Screen& action(Screen&, Action = &Action::get);

调用 action 函数：

Screen myScreen;
//@ 等价的调用
action(myScreen);               //@ 使用默认参数
action(myScreen,get);           //@ 使用之前定义的变量 get
action(myScreen,&Screen::get);  //@ 显式地传入地址

成员指针函数表

对于普通函数指针和指向成员函数的指针来说，一种常见的用法是将其存入一个函数表当中。如果一个类含有几个相同类型的成员，则这样一张表可以帮助从这些成员中选择一个。假定 Screen 类含有几个成员函数，每个函数负责将光标向指定的方向移动：

class Screen
{
public:
    Screen& home();
    Screen& forward();
    Screen& back();
    Screen& up();
    Screen& down();
};

我们定义一个 move 函数，使其可以调用上面任意 一个函数：

class Screen
{
public:
    using Action = Screen& (Screen::*)();
    enum Directions {HOME,FORWARD,BACK,UP,DOWN};
    Screen& move(Directions);
private:
    static Action Menu[];   //@ 函数表
};

数组 Menu 依次保存每个光标移动函数的指针，这些函数将按照 Directions 中枚举对应的偏移量存储：

Screen& Screen::move(Directions cm)
{
    return (this->*Menu[cm])(); //@ Menu[cm] 指向一个成员函数
}

move 中函数调用的原理是：首先获取索引值为 cm 的 Menu 元素，该元素是指向 Screen 成员函数指针根据 this 所指的对象调用该元素所指的成员函数。

Screen& Screen::move(Directions cm)
{
    return (this->*Menu[cm])(); //@ Menu[cm] 指向一个成员函数
}

Screen myScreen;
myScreen.move(Screen::HOME);
myScreen.move(Screen::DOWN);

Screen::Action Screen::Menu[] = {
    &Screen::home,
    &Screen::forward,
    &Screen::back,
    &Screen::up,
    &Screen::down,
};

将成员函数用作可调用对象

要想通过一个指针成员函数的指针进行函数调用，必须首先利用 .* 运算符或 ->* 运算符将该指针绑定到特定的对象上。

成员指针不是一个可调用对象，这样的指针不支持函数调用运算符。因为成员指针不是可调用对象，所以不能直接将一个指向成员函数的指针传递给算法：

例如，想在一个 string 的 vector 中找到第一个空的 string：

auto fp = &string::empty;   //@ fp 指向 string 的 empty 函数
//@ error,必须使用 .* 或 ->* 调用成员指针
find_if(svec.begin(), svec.end(), fp);

find_if 算法需要一个可调用对象，fp 是一个成员函数指针，非可调用对象。

使用 function 生成一个可调用对象

从指向成员函数指针获取可调用对象的一种方法是使用标准库模板 function ：

function<bool(const string&)> fcn = &Screen::empty;
find_if(svec.begin(), svec.end(), fcn);

提供给 function 的形式必须指明对象是否是以指针或引用的形式传入：

vector<string*> pvec;
function<bool(const string*)> fp = &Screen::empty;
//@ fp 接受一个指向 string 的指针，然后使用 ->* 调用 empty
find_if(pvec.begin(), pvec.end(), fp);

使用 mem_fn 生成一个可调用对象

通过使用标准库功能 mem_fn 来让编译器负责推断成员类型。mem_fn 也定义在 function 头文件中，并且可以从成员指针生成一个可调用对象：和 function 不同的是，mem_fn 可以根据成员指针的类型推断可调用对象的类型，而无须显式地指定：

find_if(svec.begin(), svec.end(), mem_fn(&string::empty));

使用 mem_fn(&string::empty) 生成一个可调用对象，该对象接受一个 string 实参，返回一个 bool 值。

mem_fn 生成的可调用对象可以通过对象调用，也可以通过指针调用：

auto f = mem_fn(&string::empty);    //@ f 接受一个 string 或者 string*
f(*svec.begin());   //@ ok，传入一个 string 对象，f 使用 .* 调用 empty
f(&svec[0]);        //@ ok，传入一个 string 的指针，f 使用 ->* 调用 empty

实际上可以认为 mem_fn 生成的可调用对象含有一对重载的函数调用运算符：

• 一个接受 string*。
• 一个接受 string&。

使用 bind 生成有一个可调用对象

可以使用 bind 从成员安徽省农户生成一个可调用对象：

//@ 选择范围中的每个 string，并将其 bind 到 empty 的第一个隐式实参上
auto it = find_if(svec.begin(), svec.end(), bind(&string::empty, _1));

和 function 类似的地方，使用 bind 函数时，必须将函数中用于表示执行对象的隐式形参转换成显示的。

和 mem_fn 类似的地方，bind 生成的可调用对象的第一个实参既可以是 string 的指针，也可以是 string 的引用：

auto f = bind(&string::empty, _1);
f(*svec.begin());   //@ ok，传入一个 string 对象，f 使用 .* 调用 empty
f(&svec[0]);        //@ ok，传入一个 string 的指针，f 使用 ->* 调用 empty