c++ - reales - manual android studio avanzado




¿Cuándo es preferible eliminar una creación de instancias de plantilla que eliminar una sobrecarga que no sea de plantilla? (3)

Esto podría dar una idea:

#include <iostream>

struct X
{
    template<typename T>
    void processPointer(T* ptr) {
        std::cout << "Template\n";
    }

    // error: explicit specialization in non-namespace scope ‘struct X’
    // template<>
    // void processPointer(void*) = delete;

    // Overload but no specialization
    // This will prevent lookup the specialization outside the class, when no
    // template argument is explicitly given.  However, with an explicit 
    // template argument the specialization is called.
    void processPointer(void*) = delete;
};

// Specialization outside the class body
template<>
void X::processPointer(void* ptr) {
    std::cout << "Specialization\n";
}

int main ()
{
    X x;
    //error: use of deleted function ‘void X::processPointer(void*)’
    //x.processPointer((void*)0);

    // Explicit template argument:
    x.processPointer<void>((void*)0);
}

Conclusión: La respuesta de @Casey sostiene.

Supongamos que tengo una plantilla que funciona con punteros en bruto:

template<typename T>
void processPointer(T* ptr);

No quiero que se llame con punteros void* . Parece que tengo dos opciones. Puedo eliminar una sobrecarga que no sea de plantilla:

void processPointer(void*) = delete;

O puedo eliminar una instancia de plantilla:

template<>
void processPointer<void>(void*) = delete;

La declaración de la sobrecarga sin plantilla es más fácil (no utilizar bloques con ángulo). ¿Hay razones por las que prefiero eliminar la creación de instancias de plantilla en su lugar?


No veo ninguna razón para ir a la plantilla aquí.

De hecho, al eliminar la sobrecarga sin plantillas puede salir de algunas llamadas ambiguas de caso extremo en las que no puedo pensar ahora, ya que las no plantillas tienen prioridad sobre las instancias de las plantillas. Y así hacer que funcione como se desea en la mayoría de los casos.


Aquí hay una razón para favorecer la versión de la plantilla: processPointer<void>(void*) aún se puede invocar directamente, evitando la otra sobrecarga.







overloading