Блог

Я наткнулся на этот код (упрощенная версия здесь):

     template<typename T>
    class SmartPtr;

    template<typename T>
    struct SmartPtr<const T>
    {
        const Tamp; operator*() const { return *_ptr; }
        const T* operator->() const { return _ptr; }
        const T* _ptr;
        // more member data and functions here
        // ...
    };

    template<typename T>
    struct SmartPtr : public SmartPtr<const T>
    {
        Tamp; operator*() const { return *const_cast<T*>(_ptr); }
        T* operator->() const { return const_cast<T*>(_ptr); }
    };
 

Я впервые вижу шаблонный класс, производный таким образом. Кто-нибудь может помочь мне понять, чего можно достичь с помощью этого? Мне кажется, что общая версия ведет себя так же, как и специализация, если она создается с помощью a const T , и специализация не требуется. Я что-то упускаю?

Общее поведение SmartPtr<T> и SmartPtr<const T> действительно идентично, и никакой специализации не потребовалось бы просто для обработки const и неконстантных версий T.

Однако ответ на ваш вопрос заключается в том, что эта конструкция допускает неявное преобразование из SmartPtr<T> в SmartPtr<const T> .

Например, функция, определенная для SmartPtr<const foo> , также может быть вызвана с помощью a SmartPtr<foo> , и, таким образом, вам не нужны две перегрузки для обработки обоих случаев:

 void HandleFoo(SmartPtr<foo> ptr);
void HandleConstFoo(SmartPtr<const foo> ptr);
void dotask()
{
    SmartPtr<foo> fooptr = new foo ...;
    ...
    HandleFoo(fooptr);
    HandleConstFoo(fooptr); // implicit conversion
}
 

Простое определение одного класса SmartPtr<T> не допускает неявного преобразования из SmartPtr<T> в SmartPtr<const T> .

Для неявного преобразования между различными типами вы обычно добавляете дополнительные функции-члены, но в этом случае для одного и того же класса из неконстантного в const вы столкнетесь с проблемами. Специализация с const T базовым классом — один из способов избежать этих проблем.

Мне кажется, что общая версия ведет себя так же, как и специализация, если экземпляр создается с помощью const T

Если экземпляр создается с помощью a const T , основная версия шаблона вообще не используется. Будет использоваться специализация.

Если экземпляр создается с неконстантным T значением, то первичный просто повторно использует код из специализации, изменяя возвращаемые типы, чтобы иметь смысл для указателя на неконстантную часть данных.

Это также способ получить «ожидаемое» поведение между SmartPtr специализациями (вести себя так, как ведут себя стандартные необработанные указатели в отношении квалификационных преобразований). Конечно, мы можем добавить конструкторы преобразования, но не все случаи охватываются этим подходом. Рассмотрим это

 template<class U>
void frombulate(SmartPtr<const U>) {
}
 

Можем ли мы вызвать frombulate с помощью a SmartPtr<int> ? В этой реализации мы можем (поскольку преобразования производных в базовые разрешены при вычитании аргументов шаблона). Но конструктор преобразования не позволил бы нам этого, поскольку общие преобразования при выводе аргументов шаблона могут не учитываться.