引用嵌套成员的安全方式

Question

我有一个struct和其他一些struct作为成员。外部结构和内部结构都是StandardLayout(甚至可以假设内部结构是普通的旧数据(。类似这样的东西：

struct Inner1 {
int a = 0, b = 0;
};
struct Inner2 {
int c = 0, d = 0;
};
struct Outer {
Inner1 x;
std::string s;
Inner2 y;
};

我想写一些函数，它接受Outer&和某种类型的对象T，可以返回任何嵌套字段的值，具体取决于参数：

int get(Outer& o, T field);

如果Outer是一个平面结构，那么指向成员的指针正是我所需要的，但它不是平面的。

琐碎的方法是使T成为所有字段的enum，并编写一个switch，但我认为这不是有效的。更快的方法是使T偏移并写入

int get(Outer& o, size_t field) {
return *reinterpret_cast<int*>(reinterpret_cast<char*>(o) + field);
}

然后将其称为CCD_ 11。它有效，但我不确定它是否保证有效——像这样求和偏移量是否正确，按偏移量取成员值是否安全。

那么，问题是：这条路安全吗？如果没有，有安全的方法吗？构造T的值可以是任意复杂的，但是使用它们应该很快。

动机：我需要将一些嵌套字段中的值按某种顺序排列，在启动时已知，但在编译时不知道。我想在启动时创建一个T的数组，然后在获取特定对象时，使用这个预先创建的数组。

[UPD]：所以它将被这样使用：

void bar(int);
void foo(Outer& o, vector<T>& fields) {
for (auto& field : fields) {
bar(get(o, field));
}
}

Answer 1

您可以这样做。

/* main.cpp */
#include <string>
#include <iostream>
using namespace std;
struct Inner1 {
int a = 0, b = 0;
};
struct Inner2 {
int c = 0, d = 0;
};
struct Outer {
Inner1 x;
std::string s;
Inner2 y;
};
struct OuterMember
{
int (*getter)(Outer &obj);
};
inline int get(Outer &obj,OuterMember field) { return field.getter(obj); }
template <auto Ptr1,auto Ptr2>
auto GetInnerMember(Outer &obj) { return (obj.*Ptr1).*Ptr2; }
inline constexpr OuterMember OuterMemberA = { GetInnerMember<&Outer::x,&Inner1::a> } ; 
inline constexpr OuterMember OuterMemberB = { GetInnerMember<&Outer::x,&Inner1::b> } ; 
inline constexpr OuterMember OuterMemberC = { GetInnerMember<&Outer::y,&Inner2::c> } ; 
inline constexpr OuterMember OuterMemberD = { GetInnerMember<&Outer::y,&Inner2::d> } ; 
/* main() */
int main()
{
Outer obj;
obj.x.a=1;
obj.x.b=2;
obj.y.c=3;
obj.y.d=4;
cout << "a = " << get(obj,OuterMemberA) << endl ;
cout << "b = " << get(obj,OuterMemberB) << endl ;
cout << "c = " << get(obj,OuterMemberC) << endl ;
cout << "d = " << get(obj,OuterMemberD) << endl ;
return 0;
}

Answer 2

我确实认为这是安全的(因为没有违反严格的别名(。

然而，该语言确实有一个更好的机制来实现这一点：指向数据成员的指针，这些成员基本上可以编译为偏移量。

需要注意的是，您必须对Inner1和Inner2进行单独的过载

int get(Outer& o, int Inner1::* m) {
return o.x.*m;
}
int get(Outer& o, int Inner2::* m) {
return o.y.*m;
}
int foo() {
Outer tmp;
return get(tmp, &Inner1::a) + get(tmp, &Inner2::d);
}

Answer 3

您可以使用函数模板专业化来实现相同的功能，请参阅下面的示例代码

#include <iostream>
using namespace std;
struct Inner1 {
int a = 1, b = 2;
};
struct Inner2 {
int c = 3, d = 4;
};
struct Outer {
Inner1 x;
std::string s;
Inner2 y;
};
template<typename T>
int get(Outer&o);
template<>
int get<Inner1>(Outer& o)
{
return o.x.a;
}
template<>
int get<Inner2>(Outer& o)
{
return o.y.c;
}
int main()
{
Outer out;
std::cout << get<Inner1>(out)  << std::endl;
std::cout << get<Inner2>(out)  << std::endl;
return 0;
}

我希望这能有所帮助！。更有趣的是，这是类型安全的。