Question

我正在尝试编写一个应该尽可能多样化的简单颜色类。这是它的样子：

class MyColor {
private:
uint8 v[4];
public:
uint8 &r, &g, &b, &a;

MyColor() : r(v[0]),  g(v[1]), b(v[2]), a(v[3]) {}
MyColor(uint8 red, uint8 green, uint8 blue, uint8 alpha = 255) : r(v[0]),  g(v[1]), b(v[2]), a(v[3]) {
    printf("%d, %d, %d, %d\n", red, green, blue, alpha);
    r = red;
    g = green;
    b = blue;
    a = alpha;
}
MyColor(uint8 vec[]) : r(v[0]),  g(v[1]), b(v[2]), a(v[3]) {
    MyColor(vec[0], vec[1], vec[2], vec[3]);
}
uint8 operator [](int i) {
    return v[i];
}
operator const GLubyte*() {
    return v;
}
};

这是我正在尝试的代码：

uint8 tmp[] = {1,2,3,4};
MyColor c(tmp);
printf("%d, %d, %d, %d\n", c.r, c.g, c.b, c.a);

（如果我能完成MyColor c = {1,2,3,4}我会喜欢它但我不确定当前规格是否可行？）

无论如何，它输出了这个：

1, 2, 3, 4
112, 22, 104, 89

所以它在第二个构造函数中得到的值是正确的，但是当它返回时......那些值是随机的？

r = red应该将r和v[0]都设置为red不应该吗？由于r只是对v[0]的引用，因此它们实际上共享相同的值，不是吗？我不是在做一些奇怪的重新分配对空间某处的引用吗？

Answer 1

不幸的是，您现在无法在C ++中进行构造函数转发。问题出在这里：

MyColor(uint8 vec[]) : r(v[0]),  g(v[1]), b(v[2]), a(v[3]) {
    MyColor(vec[0], vec[1], vec[2], vec[3]);
}

这实际上做的是将引用绑定到成员向量v，然后在构造函数的主体中创建一个临时的MyColor值，然后将其丢弃。

输出中的第二行是打印构造的MyColor的成员向量v的垃圾初始值。

我建议打破构造函数的值赋值部分，取4 uint8并从两个构造函数中调用它。

void AssignColorValues( uint8 red, uint8 green, uint8 blue, uint8 alpha)
{
    printf("%d, %d, %d, %d\n", red, green, blue, alpha);
    r = red;
    g = green;
    b = blue;
    a = alpha;
}

MyColor(uint8 red, uint8 green, uint8 blue, uint8 alpha = 255) : r(v[0]),  g(v[1]),     b(v[2]), a(v[3])
{
    AssignColorValues( red, green, blue, alpha );
}

MyColor(uint8 vec[]) : r(v[0]),  g(v[1]), b(v[2]), a(v[3])
{
    AssignColorValues(vec[0], vec[1], vec[2], vec[3]);
}

Answer 2

实际上，我相信你今天可以完成大部分工作。 boost :: array可以从常量表达式初始化，所以你也应该能够。但我相信你必须摆脱其他构造函数。如果有帮助，你可以保留赋值运算符。

引用没有正确分配的构造函数？

2 个答案: