C/C++ 类成员函数指针 类成员数据指针

普通函数指针:  "return_type (*ptr_name)(para_types) "

类成员函数指针: "return_type (class_name::*ptr_name)(para_types)"

类数据成员指针: "type class_name::* ptr_name";

C/C++:

class Demo
{
public:
    Demo():data(100)
    {

    }
    int data;
    int show(int a,int b)
    {
        return a+b;
    }
};



int main(int argc, char **argv)
{
    Demo A;
    Demo* B=new Demo;
    //完成声明和赋值
    int Demo::* int_ptr=&Demo::data;
    //赋值完后没有数据信息,需要对象解引用获得数据
    std::cout<<A.*int_ptr<<std::endl;
    std::cout<<B->*int_ptr<<std::endl;

    
    //类成员函数指针
    int (Demo::*ptr)(int,int)=&Demo::show;
    std::cout<<(A.*ptr)(1,2)<<std::endl;

    return 0;
}

STL算法有时需要使用类成员的函数,然而类成员函数指针不是可调用对象,functor<> bind mem_fn 各自方式不一，但是内部都是隐式传递this指针通过解引用来获取数据或调用函数

C/C++扩展:

//成员函数指针使用

class Screen
{
public:
    enum ACTION
    {
        Up_, Down_, Left_, Right_
    };

    Screen() = default;

    Screen &Move(ACTION para)
    {
        return (this->*Menu[para])();
    }

private:
    using Action=
    Screen &(Screen::*)();


    static Action Menu[];

    Screen &Up()
    {
        std::cout << "Up" << std::endl;
        return *this;
    }

    Screen &Down()
    {
        std::cout << "Down" << std::endl;
        return *this;
    }

    Screen &Left()
    {
        std::cout << "Left" << std::endl;
        return *this;
    }

    Screen &Right()
    {
        std::cout << "Right" << std::endl;
        return *this;
    }

};

Screen::Action Screen::Menu[]{&Screen::Up, &Screen::Down, &Screen::Left, &Screen::Right};


int main()
{
    Screen obj;
    obj.Move(Screen::Up_);
    obj.Move(Screen::Down_);
    obj.Move(Screen::Left_);
    obj.Move(Screen::Right_);
    obj.Move(Screen::Right_);


    return 0;
}



#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
#include <string>

//类成员函数指针不是可调用对象,一般STL算法需要包装类成员函数指针为可调用对象
//这三种封装方式都是内部通过获得容器返回的对象, ".*" / "->*" 来调用;
//1.std::function<成员函数类型(第一个参数设置为对象本身类型)> fcn=&std::xxxx::xxx;   区别: 第一个参数是传入对象类型,根据容器是引用还是指针选择(.* / ->*)
//2.std::bind(&std::string::empty,std::placeholders::_1) 区别:可通过指针或者对象执行成员函数;
//3.std::mem_fn(&std::string::empty)  C++11, 区别:可通过指针和对象执行成员函数
//4.可使用lamda调用;


class Str
{
public:
    std::string str;

    Str(const std::string &str_) : str(str_)
    {

    }

    Str(const char *str_) : str(str_)
    {

    }

    bool empty() const noexcept
    {
        return str.empty();
    }
};


int main()
{

    std::vector<Str> str_vec{"xa", "sad", "", "", "", "qqewhegr", "aqdq"};


    std::function<bool(const Str &)> fn = &Str::empty;

    std::size_t empty_size_function=std::count_if(str_vec.begin(),str_vec.end(),fn);

    std::size_t empty_size_bind=std::count_if(str_vec.begin(),str_vec.end(),std::bind(&Str::empty,std::placeholders::_1));

    std::size_t empty_size_mem_fn=std::count_if(str_vec.begin(),str_vec.end(),std::mem_fn(&Str::empty));


    std::cout << empty_size_function << std::endl;
    std::cout << empty_size_bind << std::endl;
    std::cout << empty_size_mem_fn << std::endl;



    std::size_t size = std::count_if(str_vec.begin(), str_vec.end(), [](const Str& str) { return str.empty(); });
    std::cout << size << std::endl;


    return 0;
}