Question

我想在我的类中构建一个包含指向成员函数的指针的表。 MS C ++（Visual Studio 2015）编译器抱怨类中_requests表的初始化程序以及std :: bind的用法。编译器的错误消息非常有用：

1＆gt; d：\ temp \ win32project1 \ win32project1 \ source1.cpp（59）：错误C3867：   ＆＃39; tlv :: parse_read＆＃39 ;:非标准语法;使用＆＃39;＆amp;＆＃39;创建指针   构件

1＆gt; d：\ temp \ win32project1 \ win32project1 \ source1.cpp（62）：错误C3867：   ＆＃39; tlv :: parse_write＆＃39 ;:非标准语法;使用＆＃39;＆amp;＆＃39;创建指针   成员

1＆gt; d：\ temp \ win32project1 \ win32project1 \ source1.cpp（40）：错误C2440：   ＆＃39;初始化＆＃39;：无法转换为＆＃39; std :: _ Binder＆amp;＆gt;＆＃39;至   ＆＃39;的std ::函数＆＃39;

1＆GT; d：\ temp \ win32project1 \ win32project1 \ source1.cpp（40）：注意：不   构造函数可以采用源类型或构造函数重载   决议是模糊的

在表格中的例程名称前放置＆符只会将错误更改为绑定成员函数上的非法操作

#include <cstdint>
#include <functional>
#include <vector>
#include <iostream>

using namespace std;

enum TLV_TYPE : uint32_t
    {
    tlv_type_read,
    tlv_type_write
    };

typedef struct
    {
    TLV_TYPE    type;
    uint32_t     length;
    } TLV_RECORD, *pTLV_RECORD;

typedef function <uint32_t (const TLV_RECORD& Record)> pTLV_PARSER;

typedef struct
    {
    TLV_TYPE            type;
    pTLV_PARSER         parse_routine;
    } TABLE, *pTABLE;

class tlv
    {
    public:
        tlv ()
            {
            };
        ~tlv ()
            {
            };

        uint32_t start_parse (const TLV_RECORD& Record)
            {
            pTLV_PARSER parser = std::bind (_requests [0].parse_routine, this, placeholders::_1);
            parser (Record);
            return 0;
            };

    protected:

        uint32_t parse_read (const TLV_RECORD& Record)
            {
            cout << "parse read: type " << Record.type << endl;
            return 0;
            }

        uint32_t parse_write (const TLV_RECORD& Record)
            {
            cout << "parse write: type " << Record.type << endl;
            return 0;
            }

        const TABLE _requests [2] =
            {
                {tlv_type_read, parse_read},
                {tlv_type_write, parse_write},
            };

    };  // End of class tlv

int main ()
    {
    tlv         foo;
    TLV_RECORD  rec = {tlv_type_read, 4};

    foo.start_parse (rec);
    return 0;
    }

Answer 1

您在tlv::_requests初始值设定项中有效尝试的操作是将指向成员的指针转换为std::function，但没有隐式转换。

看起来正确的解决方案是将您的TABLE.parse_routine成员更改为指向成员的指针而不是std::function（您不需要{{1}你正在做什么）：

std::function

（为了让编译器接受这个，你需要在定义uint32_t (tlv::*parse_routine)(const TLV_RECORD &);结构之前通过添加tlv来转发声明class tlv;类。）

您还需要调整获取成员指针的语法：

TABLE

应该是：

            {tlv_type_read, parse_read},
            {tlv_type_write, parse_write},

然后，在调用此功能时，您根本不需要使用{tlv_type_read, &tlv::parse_read}, {tlv_type_write, &tlv::parse_write},，只需执行以下操作：

std::bind

Answer 2

一种方法是在tlv的构造函数初始化列表中初始化_requests，以便有一个可以绑定的this指针。我还建议使用lambda函数而不是std :: bind，因为它们通常更快。

tlv () :
    _requests{
        {tlv_type_read,  [this](const TLV_RECORD& Record){ return parse_read(Record); }},
        {tlv_type_write, [this](const TLV_RECORD& Record){ return parse_write(Record); }}
    }
{
}

uint32_t start_parse (const TLV_RECORD& Record)
{
    pTLV_PARSER parser = _requests[0].parse_routine;
    parser (Record);
    return 0;
};

const TABLE _requests [2];

如何在类初始化程序中声明指向成员函数的指针并调用这些指针？

2 个答案: