const 正确性和返回值 - C++

Question

请考虑以下代码。

struct foo
{
};

template<typename T>
class test
{
public:   

    test() {} 

    const T& value() const
    {
        return f;
    }

private:
    T f;
};


int main()
{
    const test<foo*> t;
    foo* f = t.value();
    return 0;
}

t 是一个 const 变量，value() 是一个常量成员函数，它返回 const T&。 AFAIK，const 类型不能分配给非常量类型。但是 foo* f = t.value(); 如何编译良好。这是如何发生的以及如何确保 value() 只能分配给 const foo*？

编辑

我发现，这种情况发生在使用模板时。以下代码按预期工作。

class test
{
public:   

    test() {} 

    const foo* value() const { return f; }

private:
    foo* f;
};


int main()
{
    const test t;
    foo* f = t.value(); // error here
    return 0;
}

为什么使用模板时会出现问题？

Answer 1

因为您有两个间接级别 - 在主函数中，对 value 的调用返回对指向非 const foo 的 const 指针的引用。

这可以安全地复制到指向非常量 foo 的非常量指针中。

如果您使用 const foo * 实例化 test，那么情况就会不同。

const test<const foo*> t;
foo* f = t.value(); // error
const foo* f = t.value(); // fine
return 0;

更新

来自评论：

value() 返回 const T&这可以
只能分配给另一个 const
类型。但在这种情况下，编译器是
安全地允许转换。

const 数据只能读取。它无法被写入（“变异”）。不过复制一些数据也是读取的一种方式，所以也没关系。例如：

const int c = 5;
int n = c;

这里，我在c中有一些const数据，我将这些数据复制到一个非常量变量n中。没关系，只是读取数据而已。 c 中的值尚未修改。

现在，假设您的 foo 中有一些数据：

struct foo { int n; };

如果我有一个指向其中之一的非常量指针，我可以通过该指针修改 n 值。您要求 test 模板存储指向非常量 foo 的指针，然后创建 test 的 const 实例。因此，只有指针地址是恒定的。没有人可以更改 test 内部指针中存储的地址，因此无法使其指向另一个对象。但是，它指向的对象可以修改其内容。

更新 2：

当您制作该示例的非模板版本时，您犯了一个错误。为了得到正确的结果，您需要将 foo * 替换为每个有 T 的地方。

const T& value() const

请注意，您在那里有一个对 const T 的引用。因此返回值将是对 const 的引用：a foo *。只是指针地址不能修改。它指向的对象可以修改其内容。

在第二个示例中，您删除了引用部分，这改变了含义并使 const 修饰符应用于指针指向的对象，而不是应用于指针本身。

Answer 2

使用以下模板专门化：

template<typename T>
class test<T*>
{
public:

    test() {}

    const T* value() const
    {
        return f;
    }

private:
    T* f;
};

包含此后，g++ 会说：

d.cpp: In function ‘int main()’:
d.cpp:41: error: invalid conversion from ‘const foo*’ to ‘foo*’

Answer 3

您的代码中没有任何问题，对指针进行常量引用仅意味着您无法修改指针，但指向的对象仍然完全可变。如果在您的 main 函数中尝试更改 t 的 f 成员所指向的地址，您会发现不能：封装保存完好。

这与使以下代码有效的原理相同：

void foo(std::vector<int *> const & v)
{
    *v[0] = 0; // op. [] returns const & to int *
}

刚接触 C++ 的人通常会对这种行为感到惊讶，因为对他们来说 const 向量不应该允许修改其元素。事实上它不会，因为存储在向量中的指针不会改变（它保持指向相同的地址）。它是被修改的指向对象，但向量并不关心它。

唯一的解决方案是按照 Amit 所说的那样，为 T* 提供类的专门化。