c++ - ¿Qué cambios de última hora se introducen en C ++ 11?




5 Answers

El significado de la palabra clave auto cambió.

c++ c++11

Sé que al menos uno de los cambios en C ++ 11 hará que algunos códigos antiguos dejen de compilar: la introducción del explicit operator bool() en la biblioteca estándar, que reemplaza las instancias antiguas de operator void*() . Por supuesto, el código que se romperá es probablemente un código que no debería haber sido válido en primer lugar, pero aún así es un cambio importante: los programas que solían ser válidos ya no lo son.

¿Hay otros cambios de ruptura?




Algunas incompatibilidades básicas que no están cubiertas por la sección de incompatibilidades:

C ++ 0x trata el nombre de la clase inyectada como una plantilla, si el nombre se pasa como un argumento a un parámetro de plantilla de plantilla, y como un tipo si se pasa a un parámetro de tipo de plantilla.

El código válido de C ++ 03 puede comportarse de manera diferente si confía en que el nombre de la clase inyectada sea siempre un tipo en estos escenarios. Código de ejemplo tomado de mi clang PR

template<template<typename> class X>
struct M { };

template<template<typename> class X>
void g(int = 0); // #1

template<typename T>
void g(long = 0); // #2

template<typename T>
struct A {
  void f() {
    g<A>(); /* is ambiguous in C++0x */
    g<A>(1); /* should choose #1 in C++0x */
  }
};

void h() {
  A<int> a;
  a.f();
}

En C ++ 03, el código llama a la segunda g ambas ocasiones.

C ++ 0x hace que algunos nombres que eran dependientes en C ++ 03 ahora no sean dependientes. Y requiere la búsqueda de nombres para los nombres calificados no dependientes que se refieren a los miembros de la plantilla de clase actual para que se repitan en la instanciación, y requiere la verificación de que estos nombres busquen de la misma manera que se hace en el contexto de definición de la plantilla.

El código válido de C ++ 03 que depende de la regla de dominancia ya no se puede compilar debido a este cambio.

Ejemplo:

struct B { void f(); };

template<typename T>
struct A : virtual B { void f(); };

template<typename T>
struct C : virtual B, A<T> {
  void g() { this->f(); }
};

int main() { C<int> c; c.g(); }

Este código de C ++ 03 válido que llama a A<int>::f no es válido en C ++ 0x, porque la búsqueda de nombres al crear instancias encontrará A<int>::f en lugar de B::f , causando un conflicto con la búsqueda en definición.

En este punto, no está claro si eso es un defecto en el FDIS. El comité es consciente de esto y evaluará la situación.

Una declaración de uso donde la última parte es el mismo que el identificador en la última parte del calificador en el nombre calificado que denota una clase base, que utilizando la declaración ahora nombra al constructor, en lugar de miembros con ese nombre.

Ejemplo:

struct A { protected: int B; };
typedef A B;

struct C : B {
  // inheriting constructor, instead of bringing A::B into scope
  using B::B;
};

int main() { C c; c.B = 0; }

El código de ejemplo anterior está bien formado en C ++ 03, pero está mal formado en C ++ 0x, ya que A::B todavía es inaccesible en main .




¿Cómo es la introducción de operadores de conversión explícitos un cambio de ruptura? La versión anterior seguirá siendo tan "válida" como antes.

Sí, el cambio del operator void*() const al explicit operator bool() const será un cambio importante, pero solo si se usa de forma incorrecta dentro y fuera de sí mismo. El código de conformidad no se romperá.

Ahora, otro cambio importante es la prohibición de reducir las conversiones durante la inicialización agregada :

int a[] = { 1.0 }; // error

Edición : solo recordatorio, std::identity<T> se eliminará en C ++ 0x (vea la nota). Es una estructura de conveniencia para hacer tipos dependientes. Dado que la estructura realmente no hace mucho, esto debería arreglarlo:

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






Características del lenguaje

  1. Inicialización uniforme y general utilizando {}
  2. auto
  3. Prevención del estrechamiento.
  4. constexpr
  5. Rango basado en bucle
  6. nullptr
  7. clase de enumeración
  8. static_assert
  9. std :: initializer_list
  10. Referencias de valor (movimiento semántico)
  11. >>
  12. Lambdas
  13. Plantillas variables
  14. Alias ​​de tipo y plantilla
  15. Personajes unicode
  16. long long integer type
  17. alignas y alignof
  18. decltype
  19. Literales de cuerda cruda
  20. POD generalizado
  21. Sindicatos generalizados
  22. Clases locales como argumentos de plantilla
  23. Sintaxis de tipo de retorno de sufijo
  24. [[carry_dependency]] y [[noreturn]]
  25. especificador noexcept
  26. Operador noexcept.
  27. Características del C99:
    • tipos integrales extendidos
    • concatenación de cuerda estrecha / ancha
    • _ _ STDC_HOSTED _ _
    • _Pragma (X)
    • macros vararg y argumentos de macro vacíos
  28. _ _ func _ _
  29. Espacios de nombres en línea
  30. Constructores delegantes
  31. Inicializadores de miembros en clase
  32. predeterminado y eliminar
  33. Operadores de conversión explícita
  34. Literales definidos por el usuario
  35. Plantillas externas
  36. Argumentos de plantilla predeterminados para plantillas de función
  37. Heredando constructores
  38. anulación y final
  39. Regla SFINAE más simple y más general.
  40. Modelo de memoria
  41. thread_local

Componentes de la biblioteca estándar

  1. initializer_list para contenedores
  2. Mover la semántica para contenedores.
  3. forward_list
  4. Contenedores de hash
    • unordered_map
    • unordered_multimap
    • unordered_set
    • unordered_multiset
  5. Punteros de gestión de recursos
    • unique_ptr
    • shared_ptr
    • débil_ptr
  6. Soporte de concurrencia
    • hilo
    • exclusión mutua
    • cabellos
    • variables de condición
  7. Soporte de concurrencia de alto nivel
    • packaged_thread
    • futuro
    • promesa
    • asíncrono
  8. tuplas
  9. expresiones regulares
  10. Números al azar
    • uniform_int_distribution
    • distribución normal
    • random_engine
    • etc.
  11. Nombres de tipo entero, como int16_t, uint32_t e int_fast64_t
  12. formación
  13. Copiar y volver a emitir excepciones.
  14. error del sistema
  15. emplace () operaciones para contenedores
  16. funciones constexpr
  17. Uso sistemático de las funciones noexcept.
  18. función y enlace
  19. Cadena a conversiones de valor numérico
  20. Asignadores de ámbito
  21. Tipo de rasgos
  22. Utilidades de tiempo: duración y time_point
  23. proporción
  24. quick_exit
  25. Más algoritmos, como move (), copy_if () y is_sorted ()
  26. Recolección de basura abi
  27. atomística

Características en desuso

  1. Generación del constructor de copia y la asignación de copia para una clase con un destructor.
  2. Asignar un literal de cadena a un char *.
  3. Especificación de la excepción C ++ 98
    • Manejador sin excepción
    • set_unexpected
    • get_unexpected
    • inesperado
  4. Objetos de función y funciones asociadas.
  5. auto_ptr
  6. registro
  7. ++ en un bool
  8. exportar
  9. Moldes de estilo C



Related


Tags

c++   c++11