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

Question 1

Con el nuevo estándar, hay nuevas formas de hacer las cosas, y muchas son mejores que las antiguas, pero la forma antigua sigue estando bien. También está claro que el nuevo estándar no se desaprueba mucho oficialmente, por razones de compatibilidad con versiones anteriores. Entonces la pregunta que queda es:

¿Qué antiguas formas 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”.

Question 2

Clase final: C++11 proporciona la final especificador para evitar la derivación de clases
Las lambdas de C++11 reducen sustancialmente la necesidad de clases de objetos de función con nombre (funtores).
Constructor de movimiento: Las formas mágicas en las que std::auto_ptr las obras ya no son necesarias debido al soporte de primera clase para las referencias de rvalue.
bool seguro: Esto se mencionó anteriormente. Los operadores explícitos de C++11 obvian este modismo muy común de C++03.
Encoger para ajustar: Muchos contenedores STL de C++11 proporcionan una shrink_to_fit() miembro de la función, que debería eliminar la necesidad de intercambiar con un temporal.
Clase Base Temporal: Algunas bibliotecas antiguas de C++ utilizan este lenguaje bastante complejo. Con la semántica de movimiento ya no es necesario.
Escribir enumeración segura Las enumeraciones son muy seguras en C++11.
Prohibir la asignación de montones: Los = delete La sintaxis es una forma mucho más directa de decir que se niega explícitamente una funcionalidad en particular. Esto es aplicable para evitar la asignación de montones (es decir, =delete para miembro operator new), impidiendo copias, cesión, etc.
Definición de tipo con plantilla: Plantillas de alias en C++11 reduce la necesidad de typedefs con plantillas simples. Sin embargo, los generadores de tipos complejos aún necesitan funciones meta.
Algunos cálculos numéricos en tiempo de compilación, como Fibonacci, se pueden reemplazar fácilmente usando expresiones constantes generalizadas
result_of: Usos de la plantilla de clase result_of debe ser reemplazado con decltype. pienso result_of usos decltype cuando esté disponible.
Inicializadores de miembros en clase guarde la escritura para la inicialización predeterminada de miembros no estáticos con valores predeterminados.
En el nuevo código C++ 11 NULL debe redefinirse como nullptrpero mira Charla de STL para saber por qué decidieron no hacerlo.
Plantilla de expresión los fanáticos están encantados de tener la tipo de retorno final sintaxis de función en C++11. ¡No más tipos de devolución largos de 30 líneas!

¡Creo que me detendré allí!

Question 3

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

const A foo();
^^^^^

Esto era en su mayoría inofensivo en C++ 98/03, y es posible que incluso haya detectado algunos errores que se parecían a:

foo() = a;

Pero volviendo por const está contraindicado en C++ 11 porque inhibe la semántica de 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

Question 4

Tan pronto como puedas abandonar 0 y NULL a favor de nullptr¡hazlo!

En código no genérico, el uso de 0 o NULL no es gran cosa. Pero tan pronto como comienza a pasar constantes de puntero nulo en código genérico, la situación cambia rápidamente. cuando pasas 0 a un template<class T> func(T) T se deduce como un int y no como una constante de puntero nulo. Y no se puede volver a convertir en una constante de puntero nulo después de eso. Esto cae en cascada en un atolladero de problemas que simplemente no existirían si el universo usara solo nullptr.

C++ 11 no está en desuso 0 y NULL como constantes de puntero nulo. Pero deberías codificar como si lo hiciera.

Question 5

Idioma bool seguro → explicit operator bool().

Constructores de copias privadas (boost::noncopyable) → X(const X&) = delete

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

Question 6

Una de las cosas que evita 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 solo dices lo que quieres hacer usando count_if(), for_each() u otros algoritmos en lugar de tener que escribir los malditos bucles nuevamente.

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

¿Por qué?

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

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

Supongo que solo se debe pensar en los algoritmos de nivel superior ahora que tenemos algoritmos de nivel inferior para construir.

Question 7

Deberá implementar versiones personalizadas de swap con menos frecuencia. En C ++ 03, un no lanzamiento eficiente swap suele ser necesario para evitar copias costosas y tiradas, y dado que std::swap utiliza dos copias, swap a menudo tiene que ser personalizado. En C++, std::swap usos move, por lo que el enfoque cambia en la implementación de constructores de movimiento eficientes y que no lanzan y operadores de asignación de movimiento. Dado que para estos, el valor predeterminado a menudo está bien, será mucho menos trabajo que en C++ 03.

Por lo general, es difícil predecir qué modismos se usará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 “C++ 11 Coding Standards” solo en tres años porque aún no se cuenta con la experiencia necesaria.

Question 8

No sé su 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 la swap arriba.

¿Ha sido útil esta solución?