建议使用C ++的“const”关键字

Question

I am writing classes for Vector3 and Quaternion. Here is my code:

// .h file
Quaternion operator * (const Vector3& v) const;

// .cpp file
Quaternion Quaternion::operator * (const Vector3& v) const
{
    float s = -(m_v.dot(v));
    Vector3 vt = (v*m_s) + m_v.cross(v);
    return Quaternion(s, vt.getX(), vt.getY(), vt.getZ());
}

I got errors with "return" line because I declared inside Vector3.h like this:

float&  getX();
float&  getY();
float&  getZ();

I figured out I could pass this case by declaring like here:

const float&    getX() const;
const float&    getY() const;
const float&    getZ() const;

I also saw I would not use this anymore:

Vector3 v(1.0f, 2.0f, 3.0f);
v.getX()++;
// or v.getX() += 1; => coz I feel writing code like this is more readable.

And must write code like this:

float x = v.getX();  // I dont like this coz it will waste memory
                     // if it's not an "float" but a big object
x += 1;
v.setX(x);

So, my questions:

1. Is there any way to satisfy both of these cases, or it,simply, is a trade-off of choise?
2. Is it a good practice for C++ programmer to use "const" keyword often?

Answer 1

What you can do is provide two different versions of the function.

class Vector {
    public:
        float getX() const;
        float & getX();
};

void foo(const Vector & const_v, Vector & v) {
    v.getX() += 1;
    const_v.getX() += 1; // Won't work.
}

Note that if your Vector is simply a container for data, it is more simple to just declare it a struct and allow direct access to all members. You should use getters and setters only when there is a non-zero chance that access to private fields should be regulated somehow (for example, you want that a Vector is constantly normalized so any writing to a field should alter all of them in a very specific way).

Answer 2

First of all, in the general case, you should mark everything as const if possible. Doing so can save you a lot of debugging or documentation reading later on, because the compiler can help diagnosing logical problems.

For returning references to private members, the C++ standard library uses the approach of having two duplicate versions, one declared const and the other not. This can be your approach as well.

But in your specific case you can just make these public. A lot of books tell you to always declare members as private and use getters and setters because that is how "OOP works", but it is not true. If a class simply holds data and provides no other abstraction, then there is nothing to gain by making these fields private.

Lastly, if you are super concerned about efficiency, you should return a float whenever you don't actually need a float& . The latter also requires memory or register allocation, possibly larger than the memory taken by a plain float . Accessing a float& also requires indirection, which is rather costly.

Answer 3

在get函数中使用const是一种很好的编程习惯，因为get函数应该只具有读取数据的权限，而不是修改数据。