C++ 成员变量别名？

Question

我很确定这是可能的，因为我很确定我已经看到它完成了。 我认为这很棒，但我很乐意接受“这是一个糟糕的主意，因为 ____”这样的答案。

假设我们有一个基本结构。

struct vertex
{
    float x, y, z;
};

现在，我想对这些变量实现别名。

vertex pos;
vertex col;
vertex arr;

pos.x = 0.0f; pos.y = 0.5f; pos.z = 1.0f;
col.r = 0.0f; col.g = 0.5f; col.b = 1.0f;
arr[0] = 0.0f; arr[1] = 0.5f; arr[2] = 1.0f;

理想情况下，第三种语法与数组没有区别。 也就是说，如果我将 arr 作为引用参数发送到一个函数，该函数需要一个浮点数组来存储数据（例如，许多 OpenGL glGet 函数），它会工作得很好。

你怎么认为？ 可能的？ 可能但很愚蠢？

Answer 1

正如其他人提到的，您可以通过工会获得此服务。 像这样将颜色和位置重载到相同的结构上可能不是一个好主意（例如，添加两种颜色通常意味着您想要饱和到 1.0，而添加向量是线性发生的），但是在它们上面覆盖一个 float[] ，就像这是非常好的并且是与 GL/DirectX/等交换数据的一种被广泛接受的方法。

不过，我建议您避免在同一函数作用域中通过不同别名引用同一成员，因为这会让您陷入称为加载命中存储的令人讨厌的硬件停顿。 特别是，如果可以的话，请避免这种情况：

vector foo; 
foo.x = 1.0f;
return foo[0] + foo[1];

Answer 2

以下结构将具有所请求的行为：

struct vertex
{
private:
    float data[3];
public:
    float &x, &y, &z;
    float &r, &g, &b;

    vertex() : x(data[0]), y(data[1]), z(data[2]), r(data[0]), g(data[1]), b(data[2]) {
    }

    float& operator [](int i) { 
        return data[i];
    }
};

Answer 3

我想你可以做一些宏观魔法来得到你想要的。
但这会看起来很难看。 为什么要对 3 种不同类型使用相同的结构、顶点？ 为什么不能定义颜色类别？
另请记住，顶点和颜色不同。 如果您更改顶点的某些内容，如果两者具有相同的类，这也会影响颜色。

Answer 4

我不确定我是否正确理解了这个问题。 但看起来您需要重载运算符[]以提供对结构/类的类似数组的访问。 请参阅此处提到的示例：运算符重载

Answer 5

我有一个模板和下面两个 Vector 类，一个疯狂，一个理智。 该模板实现了一个简单的在编译时固定的值数组。 它是为子类化而设计的，并使用受保护的数组变量来避免您必须跳过障碍才能访问数组。 （有些人可能不喜欢这样的设计。我说，如果你的子类调用重载的运算符，耦合可能是个好主意。）

疯狂的类允许你拥有名为 x、y、z 的成员变量，它的作用就像一个用于调用 glGetFloatV 的数组。 正常的只有访问器函数 x()、y()、z()，并且仍然可以与 glGetFloatV 一起使用。 您可以使用任一类作为可能传递给 OpenGL 库的其他矢量对象的基础。 尽管下面的类特定于点，但显然您可以通过搜索/替换将它们转换为 RGB 颜色类。

疯狂类之所以疯狂，是因为语法糖 vec.x 而不是 vec.x() 的成本是 3 个引用变量。 这可能会在大型应用程序中占用大量空间。 使用更简单的理智版本。

template <typename T, int N>
class FixedVector {
protected:
    T arr[N];
public:
    FixedVector();

    FixedVector(const T* a) {
        for (int i = 0; i < N; ++i) {
            arr[i] = a[i];
        }
    }

    FixedVector(const T& other) {
        for (int i = 0; i < N; ++i) {
            arr[i] = other.arr[i];
        }
    }

    FixedVector& operator=(const T& other) {
        for (int i = 0; i < N; ++i) {
            arr[i] = other.arr[i];
        }
        return *this;
    }

    T* operator&() { return arr; }
    const T* operator&() const { return arr; }

    T& operator[](int ofs) { 
        assert(ofs >= 0 && ofs < N);
        return arr[ofs];
    }
    const T& operator[](int ofs) const { 
        assert(ofs >= 0 && ofs < N);
        return arr[ofs];
    }
};

class CrazyPoint :  public FixedVector<float, 3> {
public:
    float &x, &y, &z;

    CrazyPoint()
      : x(arr[0]), y(arr[1]), z(arr[2])
    { arr[0] = arr[1] = arr[2] = 0.0; }

    CrazyPoint(const float* a)
      : x(arr[0]), y(arr[1]), z(arr[2])
    {
        arr[0] = a[0];
        arr[1] = a[1];
        arr[2] = a[2];
    }

    CrazyPoint(float a, float b, float c) 
      : x(a), y(b), z(c)
    {
        arr[0] = a;
        arr[1] = b;
        arr[2] = c;
    }
};

class SanePoint : public FixedVector<float, 3> {
public:
    float& x() { return arr[0]; }
    float& y() { return arr[1]; }
    float& z() { return arr[2]; }

    SanePoint() { arr[0] = arr[1] = arr[2] = 0.0; }
    SanePoint(float a, float b, float c) 
    {
        arr[0] = a;
        arr[1] = b;
        arr[2] = c;
    }
};

// usage
SanePoint normal;
glGetFloatV(GL_CURRENT_NORMAL, &normal);

Answer 6

您可以尝试添加对变量的引用，如下所示：

struct test {
        float x, y, z;
        float &r, &g, &b;

        test() : r(x), g(y), b(z) {}
    };

但是您的结构会变得更大（从 12 字节到 40 字节）。

要在其上使用 []，请使用运算符 [] 的重载，如前所述。

Answer 7

在我看来，至少对于给出的示例来说，这是一个坏主意：缺点是，对于任何解决方案，您可能都能够自由地将“rgb”实例分配给“xyz”实例，或者从“xyz”实例分配“rgb”实例，这可能很少是明智或正确的。 即你可能会放弃一些有用的类型安全性。

就我个人而言，对于您给出的示例，我将从基本 boost::array 或类似类型中继承 rgb 和 xyz 类型。 因此它们都继承了operator[]，可以传递给需要数组的函数，并以更多的类型安全性传递给需要颜色/坐标的东西。 您经常希望将 xyz 或 rgb 视为数组，但很少希望将 xyz 视为 rgb，反之亦然。 （rgb IS-A 数组：好的。xyz IS-A 数组：好的。rgb IS-A xyz ???？我不这么认为！）

当然，这意味着访问 x,y,z & r,g,b 需要通过访问器（转发到适当的operator[](...)）而不是直接到成员。 （为此您需要 C# 的属性）。

Answer 8

只是关于使用指向值成员的引用成员的警告。 如果您复制这样的对象（例如按值传输它），您需要定义一个复制构造函数（可能还需要定义赋值运算符）。 默认的复制构造函数将为您留下一个副本，其引用成员指向原始对象的值成员，而不是新对象的值成员。 这当然不是你想要的。

考虑到您最终也会得到更大的对象，正如已经指出的那样，我认为使用访问器方法优于引用成员。

Answer 9

我认为发帖人正在寻找一些非常简单的东西，没有性能开销 - 正如您所希望的 3D 矢量类之类的东西。 因此，添加虚拟函数（vtable 间接成本）、附加成员（内存成本）、联合（每个新名称可能需要所有用户重新编译），甚至预处理器魔法（增加程序大小、跨类型等效性）都是不可取的。

现实世界的用例是采用模板化的 Vector3 类（可以是基于双精度或基于浮点的），并以用户友好的方式将其应用到其他场景。 它可能是用 [x, y, z] 成员定义的，但如果您想将其用于旋转，您可能需要 [psi, theta, phi]，用于速度 [dx, dy, dz] 等。

对于整个类型，您可以在编译时使用以下内容为其指定别名：
使用 Rotation3 = Vector3;

但似乎没有什么比为基础变量别名化更简单或更高效的事情了，对吧？

Answer 10

在工作中遇到类似的问题，但无法更改原始数据类型。
采用这个解决方案：

struct Vec3
{
    int x;
    int y;
    int z;
};

struct Color : public Vec3
{
    Color(Vec3){};
    int& r() {return x;}
    int& g() {return y;}
    int& b() {return z;}
};
    
int main()
{
    Vec3 a = {1,2,3};
    auto& b = static_cast<Color&>(a);
    std::cout << a.x << "\n";
    auto& red = b.r();
    red += 10;
    std::cout << red << " " << a.x << "\n";
    return 0;
}

Answer 11

我要做的是制作访问器：

struct Vertex {
    float& r() { return values[0]; }
    float& g() { return values[1]; }
    float& b() { return values[2]; }

    float& x() { return values[0]; }
    float& y() { return values[1]; }
    float& z() { return values[2]; }

    float  operator [] (unsigned i) const { return this->values_[i]; }
    float& operator [] (unsigned i)       { return this->values_[i]; }
    operator float*() const { return this->values_; }

private:
    float[3] values_;
}

Answer 12

联合中的无名嵌套结构不是标准 C++。 然而，这应该有效：

struct Vertex
{
private:
   typedef float Vertex::* const vert[3];
   static const vert v;

public:
   typedef size_t size_type;
   float x, y, z;

   const float& operator[](size_type i) const {
      return this->*v[i];
   }

   float& operator[](size_type i) {
      return this->*v[i];
   }

};

const Vertex::vert Vertex::v = {&Vertex::x, &Vertex::y, &Vertex::z};

编辑：更多信息。 该结构使用 3 个指向数据成员的指针的数组来访问重载的 [] 运算符中的数据。

“typedef float Vertex::* const vert”行表示 vert 是指向 Vertex 结构的 float 成员的指针。 [3] 意味着它是一个由 3 个这样的数组组成的数组。 在重载的operator[]中，该数组被索引，指向数据成员的指针被取消引用并返回值。

此外，无论打包问题如何，此方法都应该有效 - 编译器可以随意填充顶点结构，但它仍然可以正常工作。 如果浮点数的包装方式不同，匿名联合将会遇到问题。

Answer 13

使用工会？

union vertex
{
    struct { float x, y, z; };
    struct { float r, g, b; };
    float arr[3];
};

我不会推荐它——它会导致混乱。

---

添加：

正如 Adrian 在他的回答中指出的，ISO C++ 不支持这种与匿名结构成员的联合。 它在 GNU G++ 中工作（有人抱怨当您打开“-Wall -ansi -pedantic”时不受支持）。 它让人想起标准之前的 C 时代（K&R 1st Edn 之前），当时结构元素名称在所有结构中必须是唯一的，并且您可以使用收缩符号来获得结构内的偏移量，并且您可以使用其他结构类型的成员名称 - 一种无政府状态。 当我开始使用 C 时（很久以前，但在 K&R1 之后），这已经是历史用法了。

C11 (ISO/IEC 9899:2011) 支持匿名联合成员（对于两个结构）显示的表示法，但早期版本的 C 标准不支持。 ISO/IEC 14882:2011 (C++11) 第 9.5 节规定了匿名联合，但 GNU g++ (4.9.1) 不接受使用 -pedantic，标识“警告：ISO C++ 禁止匿名结构 [-Wpedantic]”。

由于这个想法会导致混乱，所以我并不特别担心它不标准； 我不会使用该机制来完成此任务（并且我对在联合中使用匿名结构持谨慎态度，即使它是有益的）。

---

有人提出了一个担忧：

三者（xyz、rgb 和数组）不一定对齐。

它是三个要素的结合； 这三个元素从同一地址开始。 前两个是包含 3 个浮点值的结构。 没有继承，也没有虚函数来提供不同的布局等。结构将通过三个连续元素进行布局（实际上，即使标准允许填充）。 该数组也从相同的地址开始，并且在结构中“无填充”的情况下，元素与两个结构重叠。 我真的不认为会有问题。

Answer 14

参考？

template<typename T>
struct vertex {
    vertex() :
        r(data[0]), g(data[1]), b(data[2]),
        x(data[0]), y(data[1]), z(data[2])
    {
    }

    T *operator *() {
        return data;
    }

    const T *operator *() const {
        return data;
    }

    T data[3];
    T &r, &g, &b;
    T &x, &y, &z;
};