Преобразование из foo‹T› в const foo‹const T› - C++

Компилятор видит foo<T> и foo<const T> как два совершенно разных и не связанных между собой типа, поэтому класс 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;
};

Предполагая, что 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 (я предполагаю, что это то, что подразумевается под «я ищу способ гарантировать, что вызывающие абоненты не изменят T для foo»), вам нужно const- квалифицировать объект Foo, а не его параметр шаблона, т.е.

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

Следовательно, ваша функция get_foo должна возвращать const Foo<T>&, а не 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
}

Если я не ошибаюсь, реализация boost::shared_ptr имеет неявный конструктор, который принимает ссылку const T& в качестве аргумента, а затем использует const_cast в указателе RHS для удаления const, разрешая неявные преобразования между ними.

Что-то вроде этого:

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

Это то, что вы ищете?

Прежде всего, вы возвращаете локальный объект по ссылке... это нехорошо.

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_cast. Const-корректность предназначена только для обнаружения непреднамеренных ошибок.