especificar el tipo de parámetro de función, pero no variables

Question

he visto código de ejemplo como esto antes

class C 
{ 
    C(); 
    ~C(); 
    foo(T1, T2); 
} 

C::foo(T1, T2) 
{ 
    //not using T1/T2 
} 

frente código convencional como esto

class D 
{ 
    D(); 
    ~D(); 
    bar(T1 t1, T2 t2); 
} 

D::bar(T1 t1, T2 t2) 
{ 
    //using t1 and t2 
} 

y me pregunto cuál es el propósito de no definir su tipo de variables para la usabilidad? ¿La mayoría de las personas hace esto solo para insinuar que esos parámetros de la API no están actualmente en uso, sino para garantizar la compatibilidad con versiones anteriores en el futuro?

Posiblemente sea para RTTI, o haciendo referencia a variables estáticas (aunque las diversas muestras que he visto no lo estaban usando para este propósito, ni siquiera eran funciones de plantilla, las variables simplemente no se usaban). Intenté buscar esta característica, pero ni siquiera estoy seguro de cómo se llama ni de qué buscar.

Básicamente, ¿cuáles son las razones/ventajas/desventajas para usar este enfoque?

Answer 1

Esto se hace comúnmente para suprimir las advertencias del compilador sobre las variables no utilizadas. Cuando no crea un nombre de variable, el compilador no le advertirá que la variable no se está utilizando en la función.

Al igual que usted declaró, por lo general su que los parámetros no están siendo utilizados para la implementación particular:

class an_iface 
{ 
public: 
    an_iface(); 

    virtual int doSomething(int valNeeded)=0; 
} 

#define NOT_SUPPORTED -1 
class something : public an_iface 
{ 
public: 
    something(); 
    int doSomething (int) { return NOT_SUPPORTED; } 
} 

class somethingMore : public an_iface 
{ 
public: 
    somethingMore(); 
    int doSomething(int stuff) { return stuff * 10; } 
} 

Answer 2

parámetros están diseñados antes de que los implementos en más casos que afectaron por la arquitectura más directamente

parámetros pueden estar sin usar debido a que:

1. sobrecarga una función virtual que tiene más parámetros que se necesitan en clase derivada
Existen
2. Parámetros para la razón de la historia, y no quieren cambiar la API todavía
3. tener en cuenta para la necesidad del futuro

Answer 3

Aparte de lo @dag ha mencionado, una definición de función sin nombre del parámetro encuentra su uso en la especialización de plantilla. Sé que ha mencionado que no hay plantillas en el ejemplo que ha publicado, pero para completar, me gustaría publicar este caso de uso:

Suponga que ha definido una función erase para los contenedores std. Pero desea erase_helper diferente para hacer el trabajo real en función del tipo de contenedor. Una práctica común y aceptable es usar traits.

// Tags for containers 
struct vector_tag {}; 
struct map_tag {}; 

// Trait class 
template <typename C> struct container_traits; 

// Specialization of trait class 
template <typename T, typename A> 
    struct container_traits<std::vector<T, A>> 
    { 
    typedef vector_tag category; 
    }; 

template <typename K, typename V, typename C, typename A> 
    struct container_traits<std::map<K, V, C, A>> 
    { 
    typedef map_tag category; 
    }; 

// Helper function 
template <typename Container, typename X> 
    void erase_helper(Container& c, const X& x, vector_tag) // <-- no param name 
    { 
    // Erase element from vector 
    } 

template <typename Container, typename X> 
    void erase_helper(Container& c, const X& x, map_tag) // <-- no param name 
    { 
    // Erase element from map 
    } 

// Function interface 
template <typename Container, typename X> 
    void erase(Container& c, const X& x) 
    { 
    erase_helper(c, x, typename container_traits<Container>::category()); 
    } 

Se puede ver aquí, tiene erase_helper tercer parámetro sin nombre. El tipo de parámetro le dice al compilador que elija la función correcta en la fase de creación de instancias de la plantilla.