C + + 11 recursos (C++ moderno)

Artigo
03/25/2013

Este documento descreve os recursos do novo padrão - C++ também conhecido como C++11-that é implementado em Visual C++.

Recursos de linguagem principal C++11

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.

Recursos de linguagem principal C++11	VC10	VC11
Referências v0.1de Rvalue v1.0 v2.0 v2.1, v3.0	v2.0	v2.1*
de qualificadores	Não	Não
inicializadores do membro de dados não-estático	Não	Não
Modelos v0.9de Variadic, v1.0	Não	Não
Lista de inicializador	Não	Não
static_assert	Sim	Sim
automaticamente v0.9, v1.0	v1.0	v1.0
Tipos de retorno para a direita	Sim	Sim
Lambdas v0.9 v1.0, v1.1	v1.0	v1.1
decltype v1.0, v1.1	v1.0	v1.1 **
Colchetes angulares direito	Sim	Sim
Argumentos padrão de modelo para modelos de função	Não	Não
Expressão SFINAE	Não	Não
Modelos do alias	Não	Não
Modelos Extern	Sim	Sim
nullptr	Sim	Sim
Enum fortemente tipados	Parcial	Sim
Forward declarou enum	Não	Sim
Atributos	Não	Não
constexpr	Não	Não
Alinhamento	TR1	Parcial
Construtores de delegação	Não	Não
Herdando construtores	Não	Não
Operadores de conversão explícita	Não	Não
char16_t	Não	Não
Literais de cadeias de caracteres Unicode	Não	Não
Literais de cadeia de caracteres crua	Não	Não
Nomes de caracteres (em literais	Não	Não
Literais definidos pelo usuário	Não	Não
padrões layout e tipos triviais	Não	Sim
Funções usadas como padrão e excluídos	Não	Não
Declarações estendidos friend	Sim	Sim
Estendido	Não	Não
Namespaces in-line	Não	Não
Uniões irrestritas	Não	Não
Tipos locais e sem nome como argumentos de modelo	Sim	Sim
para- loop com base Intervalo-	Não	Sim
substituição e finais v0.8 v0.9, v1.0	Parcial	Sim
Suporte mínimo de GC	Sim	Sim
noexcept	Não	Não

Recursos de linguagem principal C++11: Concorrência	VC10	VC11
Pontos de reformulados sequência	N/A	N/A
Física nuclear	Não	Sim
Compare e troque forte	Não	Sim
Cercas bidirecionais	Não	Sim
Modelo de memória	N/A	N/A
ordenação de dados dependência	Não	Sim
ordenação de dados dependência: anotação de função	Não	Não
exception_ptr	Sim	Sim
quick_exit	Não	Não
Física nuclear em manipuladores de sinal	Não	Não
com local de armazenamento	Parcial	Parcial
Static mágica	Não	Não

Recursos de linguagem principal C++11: C99	VC10	VC11
__func	Parcial	Parcial
Pré-processador C99	Parcial	Parcial
long long	Sim	Sim
Tipos estendidos inteiro	N/A	N/A

Aqui está um guia rápido para informações nas tabelas.

Referências de Rvalue

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.

Lambdas

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 .)

decltype

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.

Altamente digitado/encaminhar enum declarados

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.

Alinhamento

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.

Padrões layout e tipos triviais

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.

substituição e final

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 nuclear, e mais

Física nuclear compare e troque forte cercas 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.

Recursos padrão de biblioteca

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).

Tamanhos de contêiner

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

Guia de referência rápida para números de versão do Visual C++

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.