C++ 常量对象及常量成员函数

#include <stdexcept>
#include <iostream>

struct Vector2
{
    float x;
    float y;

    // 通过[0]或[1]访问x或y分量
    float& operator[](int index)
    {
        switch (index)
        {
            case 0: return x;
            case 1: return y;
            default:
                throw std::out_of_range("Invalid Vector2 index!");
        }
    }

    const float& operator[](int index) const
    {
        switch (index)
        {
            case 0: return x;
            case 1: return y;
            default:
                throw std::out_of_range("Invalid Vector2 index!");
        }
    }

	// 减法操作符
    Vector2 operator-(const Vector2 &other) const
    {
        return {x - other.x, y - other.y};
    }
};

在这个示例中，通过重载 operator[] 函数来实现索引器的功能。这个函数接受一个整数参数 index ，并根据其值返回相应的成员（ x 或 y ）的引用。如果index的值无效（不是0或1），它将抛出一个 std::out_of_range 异常。operator- 被声明为一个 const 成员函数，这样就可以在常量对象上调用它。

使用示例：

int main()
{
    Vector2 vec;
    vec[0] = 1.0f;
    vec[1] = 2.0f;

    std::cout << "x: " << vec[0] << ", y: " << vec[1] << std::endl;

	const Vector2 zero = {0.0f, 0.0f};
	Vector vec2 = zero - vec;

	std::cout << "x: " << vec2[0] << ", y: " << vec2[1] << std::endl;

    return 0;
}

在上面的示例中，首先创建了一个 Vector2 类型的对象 vec ，使用索引器将值赋给了x和y分量。然后，使用索引器获取了x和y分量的值并进行打印。接着，创建了一个名为 zero 的常量 Vector2 对象，它的 x 和 y 分量都是 0。使用减法操作符 Vector2 operator-(const Vector2 &other) const 将 zero 减去 vec，得到一个新的向量 vec2，然后打印了 vec2 的 x 和 y 分量的值。

float& operator[](int index) 和 const float& operator[](int index) const 是C++中的两个不同的函数签名，它们的区别在于是否允许在调用该函数时修改对象的成员。

const float& operator[](int index) const 和 Vector2 operator-(const Vector2 &other) const 是为了提供对常量对象的支持，它可以在常量对象上被调用，但只能读取成员，不能修改它们。

如果代码中不会出现对常量对象的索引操作，可以只保留非常量版本的 float& operator[](int index)，这样会简化代码并提供更直接的方式来访问和修改成员。

然而，如果代码可能会涉及到常量对象，那么保留两个版本会提供更大的灵活性，并且符合良好的编程实践，因为它允许你在不同的情况下以一致的方式使用索引器。

在C++中，"涉及到常量对象"指的是在代码中使用了一个被声明为 const 的对象，或者在一个 const 成员函数中操作对象。
例如，考虑以下情况：

struct Vector2
{
    float x;
    float y;

    const float& operator[](int index) const
    {
        switch (index)
        {
            case 0: return x;
            case 1: return y;
            default:
                throw std::out_of_range("Invalid Vector2 index!");
        }
    }
};

int main()
{
    const Vector2 vec = {1.0f, 2.0f};
    float value = vec[0]; // 这里涉及到了一个常量对象vec

    return 0;
}

在上面的例子中，vec 是一个 const Vector2 类型的对象，因此它被视为一个常量对象。当你在一个常量对象上调用 operator[] 时，编译器会使用 const 版本的operator[]，并且它只返回一个对成员的常量引用，不允许修改。

因此，在这个例子中，float value = vec[0]; 是合法的，因为它只是读取了 vec 的 x 分量，但是任何尝试修改 vec[0] 的行为将会导致编译错误。

在C++中，将一个成员函数声明为 const 的作用是告诉编译器，这个成员函数不会修改对象的状态。也就是说，在一个 const 成员函数内部，你不能修改对象的成员变量。

在括号 () 后面的 const 称为成员函数的常量修饰符。这是为了在对象的常量实例上调用该函数时，确保该函数不会修改对象的状态。

class MyClass {
public:
    void someFunction() const
    {
        // 在这里，可以读取成员变量，但不能修改它们
    }
    
    void someOtherFunction()
    {
        // 在这里，可以读取并修改成员变量
    }
};

如果在一个常量对象上调用了一个非常量成员函数，编译器将会报错。

const MyClass obj;
obj.someFunction(); // 合法，因为 someFunction 被声明为 const

obj.someOtherFunction(); // 编译错误，因为 someOtherFunction 没有被声明为 const

所以，const 在成员函数声明中的位置非常重要，它指定了这个函数是否可以在一个常量对象上被调用。

要注意，如果一个成员函数不会修改对象的状态，最好将其声明为 const，以便在需要时可以在常量对象上调用它。反之，如果一个成员函数会修改对象的状态，就不应该被声明为 const 。

在C++中，常量成员函数被设计成可以在常量对象上调用，也可以在非常量对象上调用。这是因为常量成员函数不会修改对象的状态，所以它们可以安全地在常量对象上执行。

例如：

class MyClass {
public:
    int getValue() const
    {
        return value;
    }

private:
    int value;
};

int main() {
    MyClass obj;
    obj.getValue(); // 在非常量对象上调用常量成员函数，是合法的

    const MyClass constObj;
    constObj.getValue(); // 在常量对象上调用常量成员函数，也是合法的

    return 0;
}

在上述示例中，getValue() 是一个常量成员函数，它可以在常量对象 constObj 上调用，也可以在非常量对象 obj 上调用。

所以，常量成员函数可以提供一种在对象的不同状态下执行相同操作的方法，而不必担心意外修改对象的状态。