¿Hay casos donde un typedef es absolutamente necesario?

Question

Considere el siguiente extracto de la safe bool idiom:

typedef void (Testable::*bool_type)() const; 
operator bool_type() const; 

¿Es posible declarar la función de conversión sin el typedef? Lo siguiente no se compila:

operator (void (Testable::*)() const)() const; 

Answer 1

Ah, acabo de recordar la identity meta-función. Es posible escribir

operator typename identity<void (Testable::*)() const>::type() const; 

con la siguiente definición de identity:

template <typename T> 
struct identity 
{ 
    typedef T type; 
}; 

Se podría argumentar que identity todavía utiliza un typedef, pero esta solución es "buena" suficiente para mí.

Answer 2

Mi análisis dice que no es posible sin el uso de typedef. El compilador ve ( como el primer token y supone que está sobrecargando () operator, que no debería tener ningún argumento (los argumentos vendrían en el siguiente conjunto de paréntesis). Poner cualquier par de paréntesis adicionales tampoco ayudaría, pero en realidad confundiría al compilador y, por lo tanto, provocaría más errores.

La mayor parte del código STL está en la parte superior de typedef initions, ¡y debemos/debemos usarlos!

Answer 3

A typedef no es una macro, su segundo ejemplo no es equivalente al primero. En el primer caso, su typedef está definiendo un functor y luego usando ese tipo en un operador de conversión del tipo de functor. En el segundo, el operador está utilizando una sintaxis mala ya que no se ha especificado ningún operador porque no hay ningún tipo. No estoy seguro de cómo escribirlo, pero por lo general hay una manera.

Los typedefs no son realmente necesarios, excepto para hacer código legible para humanos en TMP e incluso eso depende del tipo de humano que sea.

Como no puedo encontrar la sintaxis alternativa, tal vez los typedefs sean necesarios en algunos casos. Solo pensé en otro posiblemente. Supongamos que tenía una plantilla con especializaciones que contenía un método estático con un tipo de retorno, como a continuación:

template <typename T> 
struct WhateverHandler 
{ 
    typedef T rType; 
    static rType Whatever() { return rType(); } 
}; 

template <> 
struct WhateverHandler<std::string> 
{ 
    typedef std::string rType; 
    static rType Whatever() { return rType(); } 
}; 

creo que en este caso también se podría necesitar el typedef con el fin de llamar al método estático independientemente de su especialización como de lo contrario el método podría confundir al compilador porque los tipos de devolución diferirían pero no sería una sobrecarga adecuada.

template <typename T> 
struct WhateverUser 
{ 
    typename WhateverHandler<T>::rType DoWhatever() 
    { 
     return WhateverHandler<T>::template Whatever(); 
    } 
}; 

Answer 4

Uno de los casos (no relacionada con su pregunta), donde se requiere un typedef es cuando se utiliza el

va_arg() macro. Citando el estándar C99 (7.15.1.1):

tipo * va_arg (va_list ap, tipo);

...

El parámetro tipo será un nombre tipo especificado de tal manera que el tipo de un puntero a un objeto que ha puede obtenerse del tipo especificado simplemente por postfixing una * a tipo

Answer 5

contestar el "¿hay casos en que sea absolutamente necesario un typedef?"Del título de la pregunta, aquí es un ejemplo de dónde se necesita un typedef:

f(unsigned char()); // compiler error! 
typedef unsigned char Byte; 
f(Byte());   // fine! 

Ver los resultados aquí:. http://ideone.com/JPUra

Answer 6

Parece que la gramática exige el uso de un typedef en su caso, la conversión A -función-id debe ser de la forma operadorconversión de tipo-id. el tipo de conversión-id no puede contener paréntesis. Por lo que debe utilizar typedef al convertir a un tipo puntero a función o a un tipo de función de puntero a miembro .

Answer 7

En C++ 11, puede hacerlo de esta manera (gcc 4.5.2):

operator decltype((void (Testable::*)() const)(0))() const ; 

No estoy diciendo que es bastante ...

Answer 8

yo sólo encontré con este tema, con el sonido metálico ++:

foo.cpp:17:8: error: must use a typedef to declare a conversion to 'void (*(int))()' 

y hay una plantilla STL C++ 11 que cubre la identidad <T> funcionalidad:

#include <type_traits> 
… 
struct foo { 
    void bar() const { } 
    operator std::common_type<void(foo::*)()const>::type() { return &foo::bar; } 
};