C + + 11 recursos (C++ moderno)
Este documento descreve os recursos do novo padrão - C++ também conhecido como C++11-that é implementado em Visual C++.
Visual C++ 2010 implementou vários recursos na especificação da linguagem principal de C++0x, a qual é o precursor C++11, e Visual C++ no Visual Studio 2012 em que expande para incluir muitos recursos C++11.Os seguintes recursos de linguagem principal de listas C++11 da tabela e seu status da implementação em Visual C++ 2010 e em Visual C++ no Visual Studio 2012.
VC10 |
VC11 |
|
---|---|---|
v2.0 |
v2.1* |
|
Não |
Não |
|
Não |
Não |
|
Não |
Não |
|
Não |
Não |
|
Sim |
Sim |
|
v1.0 |
v1.0 |
|
Sim |
Sim |
|
v1.0 |
v1.1 |
|
v1.0 |
v1.1 ** |
|
Sim |
Sim |
|
Não |
Não |
|
Não |
Não |
|
Não |
Não |
|
Sim |
Sim |
|
Sim |
Sim |
|
Parcial |
Sim |
|
Não |
Sim |
|
Não |
Não |
|
Não |
Não |
|
TR1 |
Parcial |
|
Não |
Não |
|
Não |
Não |
|
Não |
Não |
|
Não |
Não |
|
Não |
Não |
|
Não |
Não |
|
Não |
Não |
|
Não |
Não |
|
Não |
Sim |
|
Não |
Não |
|
Sim |
Sim |
|
Não |
Não |
|
Não |
Não |
|
Não |
Não |
|
Sim |
Sim |
|
Não |
Sim |
|
Parcial |
Sim |
|
Sim |
Sim |
|
Não |
Não |
Recursos de linguagem principal C++11: Concorrência |
VC10 |
VC11 |
---|---|---|
N/A |
N/A |
|
Não |
Sim |
|
Não |
Sim |
|
Não |
Sim |
|
N/A |
N/A |
|
Não |
Sim |
|
Não |
Não |
|
Sim |
Sim |
|
Não |
Não |
|
Não |
Não |
|
Parcial |
Parcial |
|
Não |
Não |
Recursos de linguagem principal C++11: C99 |
VC10 |
VC11 |
---|---|---|
Parcial |
Parcial |
|
Parcial |
Parcial |
|
Sim |
Sim |
|
N/A |
N/A |
Aqui está um guia rápido para informações nas tabelas.
N1610 “limpar classe de inicialização de objetos por rvalues” uma tentativa foi inicial de ativar a semântica de movimentação sem referências de rvalue.Para esta discussão, vamos chamá-la “rvalue referencia v0.1”. Foi substituído por referências v1.0de “rvalue”. “Rvalue referencia v2.0”, que é o que o trabalho em Visual C++ 2010 foi baseado em, proíbe referências de rvalue de associação a lvalues e assim de corrigir um problema de segurança principal. “Referências v2.1de Rvalue “redutoras esta regra.Considere vector<string>::push_back(), que possui sobrecargas push_back(const string&) e push_back(string&&), e a chamada v.push_back("strval").A expressão "strval" é uma cadeia de caracteres literal, e é um lvalue.Outros literais (por exemplo, o inteiro 1729, é rvalues, mas os literais de cadeias de caracteres são especiais porque são arrays.) As regras de referências v2.0 de rvalue disseram, string&& não pode associar a "strval" porque "strval" é um lvalue, e como consequência, push_back(const string&) é a única sobrecarga viável.Isso deve criar std::stringtemporário, copie o vetor, e destrói-o em std::stringtemporário.Isso não era muito eficiente.As regras de referências v2.1 de rvalue reconhecem que string&& associar a "strval" deve criar std::stringtemporário, e que temporário é um rvalue.Como consequência, push_back(const string&) e push_back(string&&) são viáveis, e push_back(string&&) seja preferencial.std::string temporário é construído, e movido no vetor.Isso é mais eficiente.
“Das referências v3.0Rvalue” adicionar novos regras para gerar os construtores de animação e para mover automaticamente sob certas condições operadores de atribuição.No entanto, isso não é implementado em Visual C++ no Visual Studio 2012, devido às restrições de tempo e de recurso.
Cuidado |
---|
Os v0.1, v1.0, v2.0, v2.1, designações v3.0 são inventados para maior clareza e exibir a evolução de C++11. |
Depois que funções lambda foi votado no documento de trabalho (versão 0,9) e os lambdas mutáveis foram adicionados (versão 1,0), o comitê de normalização revisou o texto.Isso gerou lambdas versão 1,1.Isso ocorreu muito tarde para ser inserido em Visual C++ 2010, mas está em Visual C++ no Visual Studio 2012.O texto de lambdas v1.1 para o que deve ocorrer no caso do canto como referenciar membros estáticos ou para lambdas aninhados.Isso corrigir bugs que são disparados por lambdas complexos.Além disso, em Visual C++ no Visual Studio 2012os lambdas sem estado são conversíveis ponteiros para funcionar.Isso não estiver no texto N2927, mas é a contagem como parte de lambdas v1.1 de qualquer maneira.FDIS [] 5.1.2 de expr.prim.lambda/6 tem esta descrição: O tipo “de fechamento para uma expressão lambda- sem a lambda- captura tem uma função não explícita não virtual pública de conversão const ao ponteiro para a função que tem o mesmo parâmetro e tipos de retorno que o operador de chamada de função do tipo de bloqueio.O valor retornado pela função de conversão será o endereço de uma função que, quando chamado, tem o mesmo efeito que invocando o operador de chamada de função do tipo de bloqueio.” ( Visual C++ no Visual Studio 2012 mesmo é melhor do que isso, porque nós fizemos lambdas sem estado conversíveis para funcionar ponteiros que têm convenções arbitrárias de chamada.Isso é importante quando você estiver usando APIs que esperam itens como ponteiros de função de __stdcall .)
Depois que o decltype foi votado no documento de trabalho (versão 1,0), recebeu uma correção de erro pequeno mas importante na última hora (versão 1,1).Isso é grande de interesse para os desenvolvedores que trabalham no STL e o aumento.
Enum fortemente tipados foram suportados parcialmente em Visual C++ 2010 (especificamente, a parte sobre tipos subjacente explicitamente especificados).Visual C++ no Visual Studio 2012 implementá-los inteiramente, e também implementa totalmente a semântica C++11 para encaminhar enum declarados.
Nem nem Visual C++ 2010 implementam de Visual C++ no Visual Studio 2012 as palavras-chave da linguagem alignasprincipal/alignofproposta de alinhamento do que foi votado no documento de trabalho.Visual C++ 2010 tinha aligned_storage de TR1.Visual C++ no Visual Studio 2012 adiciona aligned_union e std::align() à biblioteca padrão.
As alterações são expostos de “Vagem N2342 revisitada; Para resolver o problema de revisão principais 568 (5)” adições e de is_trivial de is_standard_layout a <type_traits>.(N2342 reworked muito texto da central, mas nenhuma alteração do compilador é necessária.) Esses traços do tipo estavam disponíveis em Visual C++ 2010, mas duplicaram apenas is_pod.Como consequência, a tabela anterior contida neste documento disse “no” suporte.Em Visual C++ no Visual Studio 2012, são postos pelos ganchos de compilador que são criados para dar respostas exatas.
Isso atravessou uma evolução curto mas complexa.Originalmente, em versão 0,8, houveoverride[] [],hiding[] [], ebase_check[] [] atributos.Em, versão 0,9os atributos são cortadas e substituídos com palavras-chave contextuais.Finalmente, em versão 1,0, foram reduzidos para “final” em classes, e para “override” e “a”finalem funções.Isso torna uma extensão ascensão porque Visual C++ 2010 já suportados essa sintaxe de “override” em funções, e tinha a semântica bastante o das em. C++11. “final” foi suporte também, mas na ortografia diferente “selou”.Em Visual Studio 2012, a ortografia e semântica padrão de “override” e “final” são suportadas pelo.Para obter mais informações, consulte substituir especificador e especificador final.
Física nuclearcompare e troque fortecercas bidirecionais, e ordenação de dados dependência especificar a maquinaria padrão de biblioteca, que são implementadas em Visual C++ no Visual Studio 2012.
Esse aborda o idioma principal.Quanto para a biblioteca C++11 padrão, não é necessário uma tabela bonita de recursos, mas Visual C++ no Visual Studio 2012 implementá-lo, com duas exceções.Primeiro, quando um recurso de biblioteca depende da funcionalidade que está faltando o compilador, nós simulamos o que qualquer um exigir- por exemplo, nós simula modelos variadic para make_shared<T>()— ou - o implementamos nós não estiverem lá apenas alguns casos, especialmente, <initializer_list>.Segundo, a biblioteca C99 padrão, que é inserida por referência na biblioteca C++11 padrão, é basicamente unimplemented, embora <stdint.h> é implementado em Visual C++ 2010.Aqui está uma lista parcial as alterações em Visual C++ no Visual Studio 2012:
Novos cabeçalhos:<atomic>, <chrono>, <condition_variable>, <future>, <mutex>, <ratio>, <scoped_allocator>, e <thread>.
Posicionamento: conforme exigido por C++11 de, emplace()/emplace_front()/emplace_back()/emplace_hint()/emplace_after() é implementado em todos os recipientes para números “” arbitrário de argumentos (consulte a seção “de variadics false”).Por exemplo, vector<T> tem “template <typename... Args> void emplace_back(Args&&... args)” que constrói um elemento diretamente do tipo T em volta do vetor de um número arbitrário de argumentos arbitrários, encaminhado perfeitamente.Isso pode ser mais eficiente do que push_back(T&&), que envolveriam uma compilação e destruindo uma adicionais de animação.
**Variadics de falso:**Visual C++ no Visual Studio 2012 tem um novo esquema para simular modelos variadic.Em Visual C++ 2008 SP1 e em Visual C++ 2010, os subheaders foram incluídos repetidamente com macros definidos de maneira diferente todas as vezes, para carimbar para fora sobrecargas para 0, 1, 2, 3, ou mais argumentos.Por exemplo, <memory> incluiu o subheader interno <xxshared> repetidamente, para carimbar para fora make_shared<T>(args, args, args).Em Visual C++ no Visual Studio 2012, os subheaders são idos.Os modelos variadic próprios agora são definidos como macros (com muitos de barra invertida- continuações), expandidos e então usando macros mestras.Essa alteração de implementação interna tem esses efeitos:
O código é mais sustentável, mais fácil de usar (adicionar um subheaders estava suficiente de trabalho), e mais legível.
É mais difícil depurar no depurador- pesaroso!
O construtor de pair(piecewise_construct_t, tuple<Args1...>, tuple<Args2...>) de std::pair tinha efeitos interessantes “”.Isso requer as sobrecargas N^2 (se suportamos nós até 10 tuples, que significa 121 sobrecargas, porque os tuples vazios contam aqui, muito).
Spamming para fora tão várias sobrecargas de par- tuple, mais todas as sobrecargas de posicionamento, consumiu uma maciça quantidade de memória durante a compilação.Como consequência, nós reduzimos a infinito.Em Visual C++ 2008 SP1 e em Visual C++ 2010, a infinito era 10 (ou seja, os modelos suportavam “variadic” 0 a 10 argumentos, inclusivos).Por padrão, a infinito é 5 em Visual C++ no Visual Studio 2012.Isso transfere o consumo de memória do compilador de volta para o que foi em Visual C++ 2010.Se você precisar de mais argumentos (por exemplo, se você tiver o código existente que usa tuples 6), há um portal de escape.Você pode definir _VARIADIC_MAX Project- amplo entre 5 e 10 inclusivos.Isso consome mais memória, e pode exigir que use a opção de compilador /Zm permitir mais espaço para cabeçalhos pré-compilados.
**Aleatoriedade:**uniform_int_distribution agora é perfeitamente imparcial, e shuffle() é implementado em <algorithm>, que aceita diretamente geradores de número aleatório uniforme como mersenne_twister.
Resistência ao sobrecarregado endereço- dos operadores: C++98/03 proibiu um elemento de um contêiner de STL de sobrecarga seu endereço- do operador.Este é o que classifica como CComPtr faz, de modo que as classes auxiliares como CAdapt sejam necessárias para proteger o STL de tais sobrecargas.Durante o desenvolvimento de Visual C++ 2010, STL alterações feitas o para descartar sobrecarregado endereço- dos operadores em ainda mais situações.C++11 alterou os requisitos fazer sobrecarregado endereço- dos operadores aceitável.C++11, e Visual C++ 2010, fornecem a função std::addressof()auxiliar, que pode obter o endereço verdadeiro de um objeto independentemente de sobrecarga de operador.Antes que Visual C++ 2010 esteve solto, tenta-se substituir ocorrências de “&elem” com “std::addressof(elem)”, que está apropriadamente o.Em Visual C++ no Visual Studio 2012, nós fomos mais.Agora temos auditado todos os recipientes e todos iteradores, de modo que as classes à sobrecarga do seu endereço- de operador devessem ser úteis durante qualquer STL.
Visual C++ no Visual Studio 2012 vai além de C++11 em várias maneiras:
Iteradores ASSUSTADORES: como permitido mas não seja necessário por padrão C++11, iteradores ASSUSTADORES foi implementado, como descrito por N2911 “que minimiza dependências em classes genéricas para programas mais rápido e menores” e “Atribuição ASSUSTADOR de iterador N2980 e inicialização, revisão 1 ".
O sistema de arquivos: o cabeçalho de <filesystem> de a proposta TR2 foi adicionado.Oferece recursive_directory_iterator e outros recursos interessantes.Antes que o trabalho em TR2 esteve congelado porque C++0x estava executando muito tarde e estiver alterando a C++11, a proposta 2006 foi derivada de Boost.Filesystem V2.Deixou posteriormente em Boost.Filesystem V3, mas isto não é implementada em Visual C++ no Visual Studio 2012.
E uma otimização principal!Todos nossos recipiente são agora ideal pequenos dados suas representações atual.Isso refere-se a objetos contêiner eles mesmos, não apontar- ao seu conteúdo.Por exemplo, std::vector contém três ponteiros não processada.Em Visual C++ 2010, o modo de lançamento x, std::vector era 16 bytes.Em Visual C++ no Visual Studio 2012, é 12 bytes, que é ideal pequeno.Este é um grande negócio- se você tem 100.000 vetores em seu programa, salve o Visual C++ no Visual Studio 2012 400.000 bytes.O uso de memória diminuído economiza espaço e hora.
Isso foi obtido evitando o armazenamento de distribuidores vazios e de comparadores, porque std::allocator e std::less é sem estado.(Esses são otimizações habilitadas para distribuidores personalizados/comparadores além disso, desde que é sem estado.Obviamente, o armazenamento de distribuidores com estado/comparadores não pode ser evitado, mas esses são muito raros).
As tabelas a seguir mostram os tamanhos de contêiner, em bytes, para as plataformas x e x64.(o BRAÇO de 32 bits é equivalente a x86 para essas fins).Modo de lançamento de capa dessas tabelas, porque o modo de depuração contém verifique a maquinaria que consome o espaço e hora.As colunas são separadas para Visual C++ 2008 SP1, onde _SECURE_SCL usou padrão é 1, e para Visual C++ 2008 com SP1 _SECURE_SCL defina manualmente a 0 para a velocidade máxima.Visual C++ 2010 e Visual C++ no Visual Studio 2012 padrão _SECURE_SCL a 0 (agora conhecido como _ITERATOR_DEBUG_LEVEL).
tamanhos do recipiente (x)) |
VC9 SP1 |
VC9 SP1 SCL=0 |
VC10 |
VC11 |
---|---|---|---|---|
vetor<int> |
24 |
16 |
16 |
12 |
matriz<int, 5> |
20 |
20 |
20 |
20 |
deque<int> |
32 |
32 |
24 |
20 |
forward_list<int> |
N/A |
N/A |
8 |
4 |
lista<int> |
28 |
12 |
12 |
8 |
priority_queue<int> |
28 |
20 |
20 |
16 |
fila<int> |
32 |
32 |
24 |
20 |
pilha<int> |
32 |
32 |
24 |
20 |
pares<int, int> |
8 |
8 |
8 |
8 |
tuple<int, int, int> |
16 |
16 |
16 |
12 |
mapa<int, int> |
32 |
12 |
16 |
8 |
multimap<int, int> |
32 |
12 |
16 |
8 |
definir<int> |
32 |
12 |
16 |
8 |
multiset<int> |
32 |
12 |
16 |
8 |
hash_map<int, int> |
72 |
44 |
44 |
32 |
hash_multimap<int, int> |
72 |
44 |
44 |
32 |
hash_set<int> |
72 |
44 |
44 |
32 |
hash_multiset<int> |
72 |
44 |
44 |
32 |
unordered_map<int, int> |
72 |
44 |
44 |
32 |
unordered_multimap<int, int> |
72 |
44 |
44 |
32 |
unordered_set<int> |
72 |
44 |
44 |
32 |
unordered_multiset<int> |
72 |
44 |
44 |
32 |
cadeia de caracteres |
28 |
28 |
28 |
24 |
wstring |
28 |
28 |
28 |
24 |
tamanhos do contêiner x64 (bytes) |
VC9 SP1 |
VC9 SP1 SCL=0 |
VC10 |
VC11 |
---|---|---|---|---|
vetor<int> |
48 |
32 |
32 |
24 |
matriz<int, 5> |
20 |
20 |
20 |
20 |
deque<int> |
64 |
64 |
48 |
40 |
forward_list<int> |
N/A |
N/A |
16 |
8 |
lista<int> |
56 |
24 |
24 |
16 |
priority_queue<int> |
56 |
40 |
40 |
32 |
fila<int> |
64 |
64 |
48 |
40 |
pilha<int> |
64 |
64 |
48 |
40 |
pares<int, int> |
8 |
8 |
8 |
8 |
tuple<int, int, int> |
16 |
16 |
16 |
12 |
mapa<int, int> |
64 |
24 |
32 |
16 |
multimap<int, int> |
64 |
24 |
32 |
16 |
definir<int> |
64 |
24 |
32 |
16 |
multiset<int> |
64 |
24 |
32 |
16 |
hash_map<int, int> |
144 |
88 |
88 |
64 |
hash_multimap<int, int> |
144 |
88 |
88 |
64 |
hash_set<int> |
144 |
88 |
88 |
64 |
hash_multiset<int> |
144 |
88 |
88 |
64 |
unordered_map<int, int> |
144 |
88 |
88 |
64 |
unordered_multimap<int, int> |
144 |
88 |
88 |
64 |
unordered_set<int> |
144 |
88 |
88 |
64 |
unordered_multiset<int> |
144 |
88 |
88 |
64 |
cadeia de caracteres |
40 |
40 |
40 |
32 |
wstring |
40 |
40 |
40 |
32 |
Visual C++ tem “números de versão” diferentes dependendo de onde você observar.Há a versão marcadas (impressa na caixa), a versão interna (exibida na caixa de diálogo de Sobre ), e a versão do compilador (exibida por cl.exe e o macro de _MSC_VER ).
Número de versão marcado |
Número de versão interno |
número de versão de#define _MSC_VER |
---|---|---|
O Visual C++ 2005 |
VC8 |
1400 |
Visual C++ 2008 |
VC9 |
1500 |
Visual C++ 2010 |
VC10 |
1600 |
Visual C++ no Visual Studio 2012 |
VC11 |
1700 |
A macro de _MSC_VER é interessante para pessoas que desejam selecionar versões diferentes de chave Visual C++ e se para emitir código diferente para eles.
Instrução for com base em intervalo (C++)
Guia de programação C++ moderno