C++ 对类内变量的引用

C++ 对类内变量的引用,c++,reference,constants,C++,Reference,Constants,基本上我想要一个常量--而不是常量引用-- 对类内变量的引用 class Foo { public: double x, y, z; double& a = x; double& b = y; double& c = z; } 如果我将x=3设置为a也设置为3 所以我想把a作为x的参考 使用double*a=&x 但我不想每次都去引用它 如果我编译此文件,我会收到以下消息: warning: non-static data member

基本上我想要一个常量--而不是
常量
引用--
对类内变量的引用

class Foo
{
public:
    double x, y, z;
    double& a = x;
    double& b = y;
    double& c = z;
}
如果我将
x=3
设置为
a
也设置为
3

所以我想把a作为x的参考 使用
double*a=&x
但我不想每次都去引用它

如果我编译此文件,我会收到以下消息:

warning: non-static data member initializers only available with -std=c++11 or -std=gnu++11 [enabled by default]
warning: non-static data member initializers only available with -std=c++11 or -std=gnu++11 [enabled by default]
warning: non-static data member initializers only available with -std=c++11 or -std=gnu++11 [enabled by default]
但这不是主要问题: 如果我现在尝试使用它们(
a、b、c
),如下所示:

Foo foo;
foo.x = 1.0;
foo.y = 0.5;
foo.z = 5.1;
printf("a: <%f> b: <%f> c: <%f>\n", foo.a, foo.b, foo.c);
foo.h:5是
double&a=x
foo.h:6是
double&b=y
foo.h:7是
double&c=z


所以我的错误是什么?

您不能通过赋值初始化引用。它们需要在构造函数的初始值设定项列表中初始化,如下所示:

class Foo
{
public:
    double x, y, z;
    double& a;
    double& b;
    double& c;
    Foo() : a(x), b(y), c(z) {}
    // You need an assignment operator and a copy constructor, too
    Foo(const Foo& rhs) : a(x), b(y), c(z), x(rhs.x), y(rhs.y), z(rhs.z) {}
    Foo& operator=(const Foo& rhs) { 
        x=rhs.x;
        y=rhs.y;
        z=rhs.z;
        return *this;
    }
};

这里的问题实际上是您试图在类型的定义中分配一个引用。这是行不通的,因为
a
x
将根据
Foo
对象的放置位置而具有不同的位置

您需要在创建
Foo
对象之后执行此操作,这意味着在构造函数中

Foo():a(x),b(y),c(z){}


请注意,在构造之后尝试初始化引用也是无效的-它必须在构造函数中完成,而不是其他任何操作

无法使用默认赋值运算符,因为您有引用成员。它与如何初始化它们或初始化它们的目的无关。这是因为引用不能“重新定位”


如果您发布导致问题的行,这将很有帮助。您必须有类似于
foo1=foo2。您的解决方案是编写自己的赋值运算符

嗯,现在我得到了
错误:非静态引用成员'double&Foo::a',无法使用默认赋值运算符
@Schnizel1337它对我来说运行得非常好()。是的,我看到了,但尝试将
Foo
设置为
Foo
的另一个实例,然后您会得到错误:请参见@Schnizel1337:是的,这就是解决问题的方法,但人们到底为什么要这样做?@Schnizel1337这是因为您没有添加赋值运算符()。
class Foo
{
public:
    double x, y, z;
    double& a;
    double& b;
    double& c;
    Foo() : a(x), b(y), c(z) {}
    // You need an assignment operator and a copy constructor, too
    Foo(const Foo& rhs) : a(x), b(y), c(z), x(rhs.x), y(rhs.y), z(rhs.z) {}
    Foo& operator=(const Foo& rhs) { 
        x=rhs.x;
        y=rhs.y;
        z=rhs.z;
        return *this;
    }
};