从“foo”转换为到“const foo” - C++

Question

我有一个类似的函数（请不要关心通过引用返回临时值。这只是解释问题的示例），

const foo<const int>& get_const()
{
    foo<int> f;
    return f;
}

这显然无法编译。我正在寻找一种方法来确保调用者不会更改 foo 的 T 。我怎样才能确保这一点？

我已经看到 boost::shared_ptr 的类似行为。 shared_ptr 可转换为 const shared_ptr。我不明白它是如何做到这一点的。

任何帮助都会很棒。

Answer 1

编译器将 foo 和 foo 视为两个完全不同且不相关的类型，因此 foo 类需要支持这一点与任何其他转换一样显式地进行。如果您可以控制 foo 类，则需要提供复制构造函数或隐式转换运算符（或两者）。

template<typename T>
class foo 
{
 public: 

   // Regular constructor
   foo(T t) : t(t) {}

   // Copy constructor (works for any type S convertable to T, in particular S = non-const T if T is const)
   // Remember that foo<T> and foo<S> are unrelated, so the accessor method must be used here
   template<typename S> foo (const foo<S>& copy) : t(copy.getT()) {}

   // Accessor
   T getT() const { return t; }

   // Conversion operator
   operator foo<const T> () const { return foo<const T>(t); }

 private:

   T t;
};

Answer 2

假设 Foo 的定义如下：

template<typename T> class Foo
{
public:
    Foo(const T& value) : m_value(value) { }
    const T& getValue() const { return m_value; }
    void setValue(const T& value) { m_value = value; }
private:
    T m_value;
};

然后，为了确保 Foo 的客户端不会修改 m_value （我假设这就是“我正在寻找一种方法来确保调用者不会更改foo")，您需要对 Foo 对象而不是其模板参数进行 const 限定，即

Foo<int> x(1);
x.setValue(2); // OK
const Foo<int> y(1);
y.setValue(2); // does not compile

因此，您的 get_foo 函数应返回 const Foo&，而不是 const Foo< ;const T>&。

这是一个完整的、可编译的示例：

#include <iostream>

template<typename T> class Foo
{
public:
    Foo(const T& value) : m_value(value) { }
    const T& getValue() const { return m_value; }
    void setValue(const T& value) { m_value = value; }
private:
    T m_value;
};

template<class T> class Owner
{
public:
    Owner(const T& value) : m_foo(value) { }
    Foo<T>& getFoo() { return m_foo; }
    const Foo<T>& getConstFoo() const { return m_foo; }

private:
    Foo<T> m_foo;
};


int main(int argc, char** argv)
{
    Owner<int> x(1);
    x.getFoo().setValue(2);
    // x.getConstFoo().setValue(3); // will not compile
}

Answer 3

如果我没记错的话，boost::shared_ptr 实现有一个非显式构造函数，它接受 const T& 引用作为参数，然后使用 在 RHS 指针上使用 const_cast 来删除 const，从而允许它们之间的隐式转换。

像这样的事情：

shared_ptr(const shared_ptr<const T>& r) : ptr(const_cast<T*>(r.ptr)) {}

这是你要找的吗？

Answer 4

首先，您通过引用返回本地对象......这不好。

foo 和 foo 是两种不同的类型，因此您必须编写代码（转换构造函数）来显式转换它们。

为了得到你想要的，考虑一下：

template <typename T>
struct foo {T* t;};

const foo<int>& get_const(const foo<int>& f) {
    return f;
}

foo<int> f;
const foo<int>& cf = get_const(f);
f.t = 0; // ok, f is not const
*cf.t = 0; // ok because cf.t is const but what cf.t points to is not
cf.t = 0; // compiler error cf.t is const and cannot be lvalue

foo<int>& cf = get_const(f); // compiler error, cannot convert non-const to const without const_cast

如果你正确地完成了封装并且只访问带有 const getter 和非常量 setter 的成员，这对你来说应该足够了。请记住，如果人们真的想更改您的对象，他们总是可以 const_cast。常量正确性只是为了发现无意的错误。