如果在类的上下文中使用它，是否有一种方法可以在不提及类名的情况下获取指向成员的指针

Question

下面的代码给出了以下编译错误：

main.cpp:5:48: error: invalid use of non-static data member 'id'
    static constexpr int Type::* mem_ptr_id = &id;
                                               ^~
main.cpp:5:34: error: default initialization of an object of const type 'int Type::*const'
    static constexpr int Type::* mem_ptr_id = &id;
                                 ^
                                            = nullptr
main.cpp:6:46: error: invalid use of non-static data member 'id'
    static constexpr auto mem_ptr_id_auto = &id;
                                             ^~
main.cpp:6:27: error: declaration of variable 'mem_ptr_id_auto' with deduced type 'const auto' requires an initializer
    static constexpr auto mem_ptr_id_auto = &id;
                          ^
4 errors generated.

这是意料之中的

#include <iostream>

struct Type {
    int id;
    static constexpr int Type::* mem_ptr_id = &id; // &Type::id required
    static constexpr auto mem_ptr_id_auto = &id; // &Type::id required
};

int main() {
    Type test;
    test.*Type::mem_ptr_id = 5; // same as test.id = 5
    test.*Type::mem_ptr_id_auto = 5; // same as test.id = 5
    std::cout << test.id << std::endl; // expected: 5
    return 0;
}

我需要一种方法来拥有我的类/结构的静态成员变量指针而不显式命名类型（类/结构）名称。有什么建议吗？

注意： 为了避免

auto

变成

int&

，我做了指向成员的包装器：

template<typename T, class E>
struct Pointer2Member {
    using var_t = T;
    using entity_t = E;
    using mem_ptr_t = T E::*;

    T E::* data;

    constexpr Pointer2Member() {}

    constexpr Pointer2Member(T E::* val) : data(val) {}

    constexpr operator T E::* () {
        return data;
    }
};

template<auto ptr>
struct Pointer2MemberOf;

template<typename T, class E, T E::* ptr>
struct Pointer2MemberOf<ptr> : Pointer2Member<T, E> {
    constexpr Pointer2MemberOf() : Pointer2Member<T, E>(ptr) {}

    constexpr operator Pointer2Member<T, E>() {
        return *this;
    }
};

struct Type {
    int id;
    static constexpr auto mem_ptr_id = Pointer2MemberOf<&id>(); // Pointer2MemberOf<&Type::id>() required
};

但它给出了同样的错误：

main.cpp:34:58: error: invalid use of non-static data member 'id'
    static constexpr auto mem_ptr_id = Pointer2MemberOf<&id>();
                                                         ^~
main.cpp:34:27: error: declaration of variable 'mem_ptr_id' with deduced type 'const auto' requires an initializer
    static constexpr auto mem_ptr_id = Pointer2MemberOf<&id>();
                          ^
main.cpp:40:17: error: no member named 'mem_ptr_id_auto' in 'Type'
    test.*Type::mem_ptr_id_auto = 5; // same as test.id = 5
          ~~~~~~^
3 errors generated.

注2：跟进评论“你需要这个做什么”：

不幸的是，这是非常复杂的可变参数模板解决方案，我不能谈论太多。

我想实现的是创建一个模板类

Result<...>

，它可以存储不同类的自定义成员变量。

Result<User::id, User::username, Post::id>

和

Result<User, Post::id>

都应该是可行的语法并且应该有

Result<User, Post::id>::get<PROPERTY>

应该能够同时具有

Result<User, Post::id>::get<User>

和

Result<User, Post::id>::get<User::id>

（是的，

User

，而不是

Post

）。

想象一下库中的

Result<...>

类将被初学者 C++ 程序员使用，所以我不想使用

&User::id

语法，因为它可能太复杂而无法理解。

此外，静态成员将通过像这样的宏自动生成

#define Member(TYPE, NAME) TYPE _##NAME; static constexpr auto NAME = Pointer2Member(&_##NAME)

struct User {
    Member(int, id);
    Member(std::string, username);
};

Result<User::id> result1;
result1.get<User::id>() = 5;

Result<User> result2;
result2.get<User::id>() = 6;
result2.get<User::username>() = "John";

Answer 1

是的，但不是静态的。通常，您可以用

Test

替换对类/结构名称的引用，例如

std::remove_reference_t<decltype(*this)>

，但前提是

this

可用。

例如，您可以将

decltype(&Test::somefunc)

替换为

decltype(&std::remove_reference_t<decltype(*this)>::somefunc)

，这在模板中很有用。

如果您将示例修改为类似这样的内容，那么它也会起作用：

#include <iostream>

struct Type {
    int id;
    int Type::* mem_ptr_id = &std::remove_reference_t<decltype(*this)>::id; // same as &Type::id
};

int main() {
    Type test;

    test.*test.mem_ptr_id = 5;

    int Type::* mem_ptr_id_local = &std::remove_reference_t<decltype(test)>::id;
    test.*mem_ptr_id_local = 5;

    auto mem_ptr_id_auto = &std::remove_reference_t<decltype(test)>::id;
    test.*mem_ptr_id_auto = 5;

    std::cout << test.id << std::endl; // expected: 5
    return 0;
}

如您所见，这些都不再是静态的（mem_ptr_id 具有默认初始化），并且访问

mem_ptr_id

有点尴尬。但否则是的，只要

this

可用，就可以通过这种方式实现，并且它对模板/宏非常有用。至少需要 C++14。

---

同样为了好玩，我将粘贴一个示例代码片段，它在实践中很有用：

template <typename T> struct getvfunc_wrapper_autotype;
template<typename T, typename RT, typename... Args>
struct getvfunc_wrapper_autotype<RT(T::*)(Args...)>
{
    typedef RT(__fastcall* FT)(PVOID, Args...);
    inline static FT get(const void* inst, size_t index, size_t offset = 0)
    {
        return reinterpret_cast<FT>(getvtable(inst, offset)[index]);
    }
};

#define DECLARE_VFUNC(index, return_type, fname, arg_types, arg_invokation) \
inline return_type fname arg_types \
{ \
    auto* _ = this; \
    return getvfunc_wrapper_autotype< decltype(&std::remove_reference_t<decltype(*this)>:: fname ) >::get(_, index) arg_invokation; \
}

class IVEngineClient
{
public:
    void* m_vtable;
    DECLARE_VFUNC(18, void, GetScreenSize, (int& wide, int& tall), (_, wide, tall)
    DECLARE_VFUNC(21, void, ClientCmd, (const char* szCmdString), (_, szCmdString))
};

正如我们所见，在上面的宏中，每次都必须手动将

IVEngineClient

作为参数之一传递是很烦人的。这个技巧可以很好地避免这种情况。