Quais idiomas C ++ foram descontinuados no C ++ 11?

Com o novo padrão, existem novas maneiras de fazer as coisas, e muitas são mais agradáveis ​​que as antigas, mas a antiga ainda é boa. Também está claro que o novo padrão não obsoleta muito, por motivos de compatibilidade com versões anteriores. Portanto, a questão que resta é:

Quais formas antigas de codificação são definitivamente inferiores aos estilos C ++ 11 e o que podemos fazer agora?

Ao responder isso, você pode pular as coisas óbvias como "usar variáveis ​​automáticas".

1. Classe Final : C ++ 11 fornece o finalespecificador para impedir a derivação de classe
2. As lambdas do C ++ 11 reduzem substancialmente a necessidade de classes de objeto de função nomeado (functor).
3. Mova o construtor : as maneiras mágicas pelas quais os std::auto_ptrtrabalhos não são mais necessários devido ao suporte de primeira classe para referências de rvalor.
4. Bool seguro : Isso foi mencionado anteriormente. Operadores explícitos do C ++ 11 evitam esse idioma C ++ 03 muito comum.
5. Encolher para ajustar : Muitos contêineres STL C ++ 11 fornecem umashrink_to_fit() função de membro, que deve eliminar a necessidade de troca por um temporário.
6. Classe base temporária : algumas bibliotecas C ++ antigas usam esse idioma bastante complexo. Com a semântica de movimentação, não é mais necessário.
7. Enumeração segura do tipo Enumerações são muito seguras no C ++ 11.
8. Proibindo a alocação de heap : A = deletesintaxe é uma maneira muito mais direta de dizer que uma funcionalidade específica é explicitamente negada. Isso é aplicável para impedir a alocação de heap (ou seja, =deletepara membro operator new), impedir cópias, atribuição, etc.
9. Typedef com modelo : os modelos de alias no C ++ 11 reduzem a necessidade de typedef com modelo simples. No entanto, geradores de tipos complexos ainda precisam de meta-funções.
10. Alguns cálculos numéricos de tempo de compilação, como Fibonacci, podem ser facilmente substituídos usando expressões constantes generalizadas
11. result_of: Os usos do modelo de classe result_ofdevem ser substituídos por decltype. Eu acho que result_ofusa decltypequando está disponível.
12. Os inicializadores de membros da classe salvam a digitação para a inicialização padrão de membros não estáticos com valores padrão.
13. No novo código C ++ 11 NULLdeve ser redefinido como nullptr, mas veja a palestra da STL para saber por que eles decidiram contra.
14. Os fanáticos do modelo de expressão têm o prazer de ter a sintaxe da função de tipo de retorno à direita no C ++ 11. Não há mais tipos de retorno longo de 30 linhas!

Eu acho que vou parar por aí!

Em um determinado momento, argumentou-se que se deveria retornar por constvalor, em vez de apenas por valor:

const A foo();
^^^^^

Isso foi principalmente inofensivo no C ++ 98/03 e pode até ter detectado alguns bugs parecidos com:

foo() = a;

Mas retornar por consté contra-indicado no C ++ 11, porque inibe a semântica de movimentos:

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

Então, basta relaxar e codificar:

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

Assim que você puder abandonar 0e a NULLfavor nullptr, faça-o!

No código não genérico, o uso 0ou NULLnão é tão importante. Mas assim que você começa a passar constantes nulos de ponteiro no código genérico, a situação muda rapidamente. Quando você passa 0para a template<class T> func(T) Té deduzido como uma intconstante de ponteiro e não como nula. E não pode ser convertido novamente em um ponteiro nulo constante depois disso. Isso se transforma em uma confusão de problemas que simplesmente não existem se o universo fosse usado apenas nullptr.

O C ++ 11 não é preterido 0e NULLcomo constantes de ponteiro nulo. Mas você deve codificar como se fosse.

Idioma seguro do bool → explicit operator bool().

Construtores de cópias privadas (boost :: noncopyable) → X(const X&) = delete

Simulando a classe final com destruidor privado e herança virtual →class X final

Uma das coisas que apenas o impede de escrever algoritmos básicos no C ++ 11 é a disponibilidade de lambdas em combinação com os algoritmos fornecidos pela biblioteca padrão.

Estou usando esses agora e é incrível quantas vezes você apenas diz o que deseja fazer usando count_if (), for_each () ou outros algoritmos, em vez de precisar escrever os malditos loops novamente.

Depois de usar um compilador C ++ 11 com uma biblioteca padrão completa do C ++ 11, você não tem mais uma boa desculpa para não usar algoritmos padrão para criar os seus . Lambda apenas mate-o.

Por quê?

Na prática (depois de ter usado essa maneira de escrever algoritmos), é muito mais fácil ler algo que é construído com palavras diretas que significam o que é feito do que com alguns loops que você precisa criptografar para saber o significado. Dito isso, deduzir automaticamente os argumentos lambda ajudaria muito a tornar a sintaxe mais facilmente comparável a um loop bruto.

Basicamente, os algoritmos de leitura feitos com algoritmos padrão são muito mais fáceis, pois as palavras escondem os detalhes da implementação dos loops.

Suponho que apenas algoritmos de nível superior precisam ser pensados ​​agora que temos algoritmos de nível inferior para construir.

Você precisará implementar versões personalizadas com swapmenos frequência. No C ++ 03, swapmuitas vezes é necessário um não lançamento eficiente para evitar cópias caras e de lançamento, e como std::swapusa duas cópias, swapmuitas vezes precisa ser personalizado. No C ++, std::swapusa movee, portanto, o foco muda na implementação de construtores de movimento eficientes e não arremessadores e operadores de atribuição de movimento. Como para esses o padrão geralmente é bom, isso será muito menos trabalhoso do que no C ++ 03.

Geralmente, é difícil prever quais idiomas serão usados, pois são criados através da experiência. Podemos esperar um "C ++ 11 efetivo" talvez no próximo ano e um "Padrões de codificação C ++ 11" apenas em três anos, porque a experiência necessária ainda não existe.

Não sei o nome, mas o código C ++ 03 costumava usar a seguinte construção como um substituto para a atribuição de movimentação ausente:

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

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

  // ... some code using map

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

Isso evitou qualquer cópia devido ao elision da cópia combinado com o swapacima.

Quando notei que um compilador usando o padrão C ++ 11 não falha mais o seguinte código:

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

por supostamente conter o operador >>, comecei a dançar. Nas versões anteriores, seria preciso fazer

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

Para piorar as coisas, se você já teve que depurar isso, sabe como as mensagens de erro são horríveis.

Eu, no entanto, não sei se isso era "óbvio" para você.

Retorno por valor não é mais um problema. Com a semântica de movimentação e / ou as funções de codificação de otimização do valor de retorno (dependentes do compilador) são mais naturais, sem custos indiretos ou custos (na maioria das vezes).