¿Qué modismos de C ++ están en desuso en C ++ 11?

Con el nuevo estándar, hay nuevas formas de hacer las cosas, y muchas son más agradables que las viejas, pero la vieja forma todavía está bien. También está claro que el nuevo estándar no se desprecia oficialmente mucho, por razones de compatibilidad con versiones anteriores. Entonces la pregunta que queda es:

¿Qué formas antiguas de codificación son definitivamente inferiores a los estilos de C ++ 11, y qué podemos hacer ahora en su lugar?

Al responder esto, puede omitir las cosas obvias como "usar variables automáticas".

1. Clase final : C ++ 11 proporciona el finalespecificador para evitar la derivación de clase
2. Las lambdas de C ++ 11 reducen sustancialmente la necesidad de clases de objeto de función con nombre (functor).
3. Move Constructor : las formas mágicas en que las std::auto_ptrobras ya no son necesarias debido al soporte de primera clase para las referencias de valor.
4. Safe bool : Esto se mencionó anteriormente. Los operadores explícitos de C ++ 11 obvian este lenguaje muy común de C ++ 03.
5. Encogimiento : muchos contenedores STL C ++ 11 proporcionan unshrink_to_fit() función miembro, que debería eliminar la necesidad de intercambiar por una temporal.
6. Clase base temporal : algunas bibliotecas antiguas de C ++ usan este lenguaje bastante complejo. Con la semántica de movimiento ya no se necesita.
7. Las enumeraciones de tipo Safe Enum son muy seguras en C ++ 11.
8. Prohibir la asignación de almacenamiento dinámico : la = deletesintaxis es una forma mucho más directa de decir que una funcionalidad particular se niega explícitamente. Esto es aplicable para evitar la asignación del montón (es decir, =deletepara el miembro operator new), evitar copias, asignación, etc.
9. Typedef con plantillas : plantillas de alias en C ++ 11 reducen la necesidad de los typedefs simples con plantilla. Sin embargo, los generadores de tipo complejo aún necesitan funciones meta.
10. Algunos cálculos numéricos en tiempo de compilación, como Fibonacci, se pueden reemplazar fácilmente mediante expresiones constantes generalizadas
11. result_of: Los usos de la plantilla de clase result_ofdeben reemplazarse por decltype. Creo que result_ofusa decltypecuando está disponible.
12. Los inicializadores de miembros en clase guardan la escritura para la inicialización predeterminada de miembros no estáticos con valores predeterminados.
13. En el nuevo código C ++ 11 NULLdebe redefinirse como nullptr, pero vea la charla de STL para saber por qué decidieron no hacerlo.
14. Los fanáticos de las plantillas de expresión están encantados de tener la sintaxis de la función de tipo de retorno final en C ++ 11. ¡No más tipos de devolución de 30 líneas!

¡Creo que me detendré allí!

En un momento dado se argumentó que uno debería regresar por constvalor en lugar de solo por valor:

const A foo();
^^^^^

Esto fue mayormente inofensivo en C ++ 98/03, e incluso puede haber detectado algunos errores que parecían:

foo() = a;

Pero regresar constestá contraindicado en C ++ 11 porque inhibe la semántica del movimiento:

A a = foo();  // foo will copy into a instead of move into it

Así que relájate y codifica:

A foo();  // return by non-const value

¡Tan pronto como pueda abandonar 0y NULLen favor nullptr, hágalo!

En el código no genérico, el uso de 0o NULLno es tan importante. Pero tan pronto como comience a pasar constantes de puntero nulo en código genérico, la situación cambia rápidamente. Cuando pasa 0a un template<class T> func(T) Tse deduce como un inty no como un puntero nulo constante. Y no se puede convertir de nuevo a un puntero nulo constante después de eso. Esto cae en un atolladero de problemas que simplemente no existen si el universo solo se usa nullptr.

C ++ 11 no se desprecia 0y NULLcomo constantes de puntero nulo. Pero debe codificar como si lo hiciera.

Safe bool idiom → explicit operator bool().

Constructores de copia privada (boost :: noncopyable) → X(const X&) = delete

Simulando la clase final con destructor privado y herencia virtual →class X final

Una de las cosas que simplemente hace que evite escribir algoritmos básicos en C ++ 11 es la disponibilidad de lambdas en combinación con los algoritmos proporcionados por la biblioteca estándar.

Los estoy usando ahora y es increíble la frecuencia con la que dices lo que quieres hacer usando count_if (), for_each () u otros algoritmos en lugar de tener que volver a escribir los malditos bucles.

Una vez que está utilizando un compilador de C ++ 11 con una biblioteca estándar completa de C ++ 11, ya no tiene una buena excusa para no usar algoritmos estándar para construir su propio . Lambda acaba de matarlo.

¿Por qué?

En la práctica (después de haber utilizado esta forma de escribir algoritmos yo mismo), es mucho más fácil leer algo que está construido con palabras sencillas que significan lo que se hace que con algunos bucles que hay que descifrar para saber el significado. Dicho esto, hacer que los argumentos lambda se deduzcan automáticamente ayudaría mucho a que la sintaxis sea más fácilmente comparable a un bucle sin formato.

Básicamente, los algoritmos de lectura hechos con algoritmos estándar son mucho más fáciles ya que las palabras ocultan los detalles de implementación de los bucles.

Supongo que solo debemos pensar en algoritmos de nivel superior ahora que tenemos algoritmos de nivel inferior para construir.

Deberá implementar versiones personalizadas con swapmenos frecuencia. En C ++ 03, a swapmenudo es necesario un no-lanzamiento eficiente para evitar costosas y tirar copias, y dado que std::swapusa dos copias, a swapmenudo tiene que ser personalizado. En C ++, std::swaputiliza move, y por lo tanto, el enfoque cambia en la implementación de constructores de movimientos y operadores de asignación de movimientos eficientes y no arrojables. Dado que para estos el valor predeterminado es a menudo correcto, será mucho menos trabajo que en C ++ 03.

En general, es difícil predecir qué expresiones idiomáticas se utilizarán, ya que se crean a través de la experiencia. Podemos esperar un "C ++ 11 efectivo" tal vez el próximo año, y un "Estándares de codificación C ++ 11" solo en tres años porque la experiencia necesaria aún no existe.

No sé el nombre, pero el código C ++ 03 a menudo usaba la siguiente construcción como reemplazo de la asignación de movimiento faltante:

std::map<Big, Bigger> createBigMap(); // returns by value

void example ()
{
  std::map<Big, Bigger> map;

  // ... some code using map

  createBigMap().swap(map);  // cheap swap
}

Esto evitó cualquier copia debido a la elisión de copia combinada con lo swapanterior.

Cuando noté que un compilador que usa el estándar C ++ 11 ya no falla el siguiente código:

std::vector<std::vector<int>> a;

por supuestamente contener operador >>, comencé a bailar. En las versiones anteriores habría que hacer

std::vector<std::vector<int> > a;

Para empeorar las cosas, si alguna vez tuvo que depurar esto, ya sabe lo horrendos que son los mensajes de error que salen de esto.

Yo, sin embargo, no sé si esto fue "obvio" para usted.

El retorno por valor ya no es un problema. Con la semántica de movimiento y / o la optimización del valor de retorno (dependiente del compilador), las funciones de codificación son más naturales sin gastos generales o costos (la mayoría de las veces).