C++11 funzionalità (C++ moderno)
In questo documento vengono descritte le funzionalità di nuovo standard di C++ anche noto come C++11-that viene implementato in Visual C++.
Funzionalità principali del linguaggio C++11
Visual C++ 2010 ha implementato molte funzionalità della specifica di linguaggio di base C++0x, che è il precursore C++11e Visual C++ in Visual Studio 2012 viene illustrato quello per incorporare molte funzionalità C++11.Nella tabella seguente sono elencate le funzionalità principali del linguaggio C++11 e il relativo stato di implementazione sia in Visual C++ 2010 che in Visual C++ in Visual Studio 2012.
VC10 |
VC11 |
|
---|---|---|
v2.0 |
v2.1* |
|
No |
No |
|
No |
No |
|
No |
No |
|
No |
No |
|
Sì |
Sì |
|
v1.0 |
v1.0 |
|
Sì |
Sì |
|
v1.0 |
v1.1 |
|
v1.0 |
v1.1 ** |
|
Sì |
Sì |
|
No |
No |
|
No |
No |
|
No |
No |
|
Sì |
Sì |
|
Sì |
Sì |
|
Partial |
Sì |
|
No |
Sì |
|
No |
No |
|
No |
No |
|
TR1 |
Partial |
|
No |
No |
|
No |
No |
|
No |
No |
|
No |
No |
|
No |
No |
|
No |
No |
|
No |
No |
|
No |
No |
|
No |
Sì |
|
No |
No |
|
Sì |
Sì |
|
No |
No |
|
No |
No |
|
No |
No |
|
Sì |
Sì |
|
No |
Sì |
|
Partial |
Sì |
|
Sì |
Sì |
|
No |
No |
Funzionalità principali del linguaggio C++11: Concorrenza |
VC10 |
VC11 |
---|---|---|
N/D |
N/D |
|
No |
Sì |
|
No |
Sì |
|
No |
Sì |
|
N/D |
N/D |
|
No |
Sì |
|
ordine di visualizzazione dipendenza: annotazione di funzione |
No |
No |
Sì |
Sì |
|
No |
No |
|
No |
No |
|
Partial |
Partial |
|
No |
No |
Funzionalità principali del linguaggio C++11: C99 |
VC10 |
VC11 |
---|---|---|
Partial |
Partial |
|
Partial |
Partial |
|
Sì |
Sì |
|
N/D |
N/D |
Di seguito viene illustrata la guida rapida alle informazioni nelle tabelle.
Riferimenti Rvalue
N1610 "chiarimento di inizializzazione degli oggetti di classe di valori rvalue da" è un tentativo iniziale di abilitare la semantica di spostamento senza riferimenti rvalue.Per questa discussione, che verrà denominata "rvalue fa riferimento v0.1". È stato sostituito da v1.0"riferimenti rvalue." "Rvalue fa v2.0riferimento a", utilizzato dal lavoro in Visual C++ 2010 è stato basato su, impedisce i riferimenti rvalue dall'associazione a lvalue e quindi il risolvere un problema di sicurezza importante. I riferimenti v2.1Rvalue "perfezionare questa regola.Si consideri vector<string>::push_back(), con gli overload push_back(const string&) e push_back(string&&)e la chiamata v.push_back("strval").L'espressione "strval" è un valore letterale stringa e rappresenta un lvalue.In altri valori letterali, ad esempio il numero 1729, sono di valori rvalue, ma i valori letterali stringa vengono speciali perché sono matrici.) Il valore rvalue fa riferimento alle regole v2.0 è detto, string&& non può essere associato a "strval" perché "strval" è un lvalue, pertanto push_back(const string&) è l'unico overload possibile.Si creerebbe std::stringtemporaneo, la copia nel vettore e quindi eliminato std::stringtemporaneo.Ciò non è molto efficiente.Le regole di v2.1 riferimenti rvalue supportano che string&& l'associazione a "strval" creerebbe std::stringtemporaneo e temporaneo che è un rvalue.Pertanto, è push_back(const string&) che push_back(string&&) possibili e push_back(string&&) viene preferito.std::string temporaneo costruito viene quindi viene spostato nel vettore.È più efficiente.
"Riferimenti v3.0Rvalue" aggiunte nuove regole generare automaticamente i costruttori di spostamento e spostare gli operatori di assegnazione a determinate condizioni.Tuttavia, questo non è implementato in Visual C++ in Visual Studio 2012, a causa dei vincoli di risorse e di tempo.
Attenzione |
---|
I v0.1, v1.0, v2.0, v2.1, le designazioni v3.0 sono inventati per chiarezza e visualizzare all'evoluzione di C++11. |
Lambdas
Dopo funzioni lambda è stato polling del documento di lavoro (versione 0,9) e le espressioni lambda modificabili sono stati aggiunti (versione 1,0), il comitato di normalizzazione stato revisionato l'espressione.Ciò ha prodotto le espressioni versione 1,1lambda.Ciò si è verificata motivi per essere incorporata in Visual C++ 2010, ma è in Visual C++ in Visual Studio 2012.L'espressione lambdas v1.1 illustra in che modo si desidera trascinandolo in casi come fare riferimento ai membri statici o alle espressioni lambda annidati.Si risolve bug che sono attivati lambda complessi.Inoltre in Visual C++ in Visual Studio 2012, le espressioni lambda indipendenti dallo stato sono convertibili ai puntatori a funzione.Si tratta dell'espressione N2927, ma è comunque calcolata come parte delle espressioni lambda v1.1.FDIS 5.1.2] o [6 di expr.prim.lambda dispone di questa descrizione: "Tipo di chiusura di un'espressione lambda senza la lambda- acquisizione ha una funzione non esplicita non virtuale pubblica di conversione const al puntatore alla funzione che ha lo stesso parametro e tipi restituiti dell'operatore della chiamata di funzione di tipo di chiusura.Il valore restituito dalla funzione di conversione verrà l'indirizzo di una funzione che, una volta chiamato, ha lo stesso effetto ottenuto chiamando l'operatore di una chiamata di funzione di tipo di terminazione." ( Visual C++ in Visual Studio 2012 è ancora maggiore di quello, perché è stato effettuato le espressioni lambda indipendenti dallo stato a conversione ai puntatori a funzione che utilizzano convenzioni di chiamata arbitrarie.Ciò è importante quando si utilizza API che prevedono operazioni come puntatori a funzione di __stdcall ).
decltype
Dopo che il decltype è stato polling del documento di lavoro (versione 1,0), ha ricevuto una piccola ma correzione dei bug importante all'ultimo minuto (versione 1,1).Si tratta di notevole interesse ai programmatori che lavorano a STL e a incremento.
Fortemente tipizzato/avanti dichiarato enumerazioni
Le enumerazioni fortemente tipizzati parzialmente erano supportati in Visual C++ 2010 (in particolare, la parte sui tipi sottostanti specificati in modo esplicito).Visual C++ in Visual Studio 2012 completamente li implementa inoltre completamente implementa la semantica C++11 per inviare le enumerazioni dichiarati.
Allineamento
Visual C++ 2010 né né l'utilizzo di Visual C++ in Visual Studio 2012 le parole chiave principali alignas/alignof del proposta di allineamento linguaggio che è stato polling del documento di lavoro.Visual C++ 2010 ha aligned_storage da TR1.Visual C++ in Visual Studio 2012 aggiunge aligned_union e std::align() alla raccolta standard.
Standard- layout e tipi semplici
Le modifiche vengono esposte dalle "POD N2342 riconfigurare; Risolvere il problema principale 568 (revisione 5)" aggiunte di is_trivial e di is_standard_layout a <type_traits>.(N2342 ha ripreso la più espressione principale del linguaggio, ma non sono presenti modifiche del compilatore.) Questi tratti del tipo sono disponibili in Visual C++ 2010, ma nomi duplicati solo is_pod.Pertanto, la tabella precedente di questo documento è detto "no" supporto.In Visual C++ in Visual Studio 2012, vengono alimentati da hook del compilatore progettati per fornire le risposte precise.
override e ultimate
Ciò ha passato a una breve ma evoluzione complessa.In origine, in versione 0,8, èoverride[] [], [hiding] [] e [] []base_checkattributi.Quindi in versione 0,9, gli attributi eliminati e sostituiti con le parole chiave contestuali.Infine, in versione 1,0breve, sono stati "a"finalsulle classi eoverride"a" e "a"finalsulle funzioni.In tal modo si crea un'estensione dimensioni perché Visual C++ 2010 già supportato questa sintassi "dioverride" sulle funzioni e presenta una semantica abbastanza da quelli in C++11. final" è stato supportato, ma all'ortografia di "è sealed".In Visual Studio 2012, l'ortografia e la semantica standard "dioverride" e "difinal" completamente supportate.Per ulteriori informazioni, vedere Identificatore override e Identificatore final.
Fisica nucleare e più
Fisica nucleareforte confronti e scambia, recinti bidirezionalie ordine di visualizzazione dipendenza specificare il macchinario standard di libreria, distribuiti in Visual C++ in Visual Studio 2012.
Funzionalità standard di libreria
Tale relative al linguaggio di base.Per quanto riguarda la libreria standard C++11, non è una tabella riformattazione di funzionalità, ma Visual C++ in Visual Studio 2012 la implementa, con due eccezioni.Innanzitutto, quando una funzionalità della libreria dipende da funzionalità mancanti nel compilatore, o simulato cosa richiedere- ad esempio, si simula i modelli variadic per make_shared<T>()— oppure non è implementiamo - vi sono solo alcuni casi, in particolare, <initializer_list>.In secondo luogo, la libreria standard C99, che è incorporata per riferimento nella libreria standard C++11, è principalmente non implementata, sebbene <stdint.h> sia stato implementato in Visual C++ 2010.Segue un elenco parziale modifiche in Visual C++ in Visual Studio 2012:
Nuove intestazioni:<atomic>, <chrono>, <condition_variable>, <future>, <mutex>, <ratio>, <scoped_allocator>e <thread>.
Percorso: secondo le esigenze di C++11, emplace()/emplace_front()emplace_back()///emplace_hint()emplace_after() viene implementato in tutti i contenitori per i numeri "arbitrari" degli argomenti (vedere la sezione "variadics di Faux").Ad esempio, vector<T> ha "template <typename... Args> void emplace_back(Args&&... args)" che direttamente da un elemento con tipo T posteriore del vettore da un numero arbitrario di argomenti arbitrari, inoltrato perfettamente.Ciò può risultare più efficace di push_back(T&&), che dovrebbero includere una costruzione e la distruzione aggiuntive di spostamento.
**Variadics di Faux:**Visual C++ in Visual Studio 2012 ha una nuova combinazione per la simulazione dei modelli variadic.In Visual C++ 2008 SP1 e in Visual C++ 2010, i subheaders inclusi ripetutamente con le macro definite in modo diverso ogni volta, per contrassegnare agli overload per 0, 1, 2, 3, o più argomenti.Ad esempio, <memory> includeva ripetutamente il subheader interno <xxshared>, per contrassegnare a make_shared<T>(args, args, args).In Visual C++ in Visual Studio 2012, i subheaders vengono conservati.Ora i modelli variadic stessi sono definiti come macro (con molta di sbarra- continuazioni) e quindi vengono espansi utilizzando le macro master.Questa modifica interna di implementazione di questi effetti:
Il codice è più gestibile, più facile da utilizzare (i subheaders aggiunta di costituiscono un'ottima quantità di lavoro) e più leggibile.
È più complessa l'esecuzione dello debugger- spiacente!
Il costruttore di pair(piecewise_construct_t, tuple<Args1...>, tuple<Args2...>) di std::pair ha effetti interessanti "".Questo richiede gli overload N^2 (se supportiamo fino a 10 tuple, che indica 121 overload, poiché le tuple vuote conto di seguito, installati).
Spamming da consentire a diversi overload di coppia- tupla, oltre a qualsiasi overload di percorso, utilizza una quantità notevole di memoria durante la compilazione.Pertanto, è stato ridotto infinito.In Visual C++ 2008 SP1 e in Visual C++ 2010, infinito è 10 (ovvero i modelli "variadic" supportate da 0 a 10 argomenti, inclusi).Per impostazione predefinita, infinito è 5 in Visual C++ in Visual Studio 2012.Ciò fornisce il consumo di memoria del compilatore di nuovo su cui è in Visual C++ 2010.Se sono necessari più argomenti (ad esempio, se il codice esistente che utilizza 6 tuple), esiste un punto debole.È possibile definire _VARIADIC_MAX progetto ampio tra 5 e 10.Si utilizza più memoria e può richiedere che non si utilizzi l'opzione del compilatore di /Zm riservare più spazio alle intestazioni precompilate.
**Anomalia:**uniform_int_distribution è perfettamente imparziale e shuffle() viene implementato in <algorithm>, che accetta direttamente i generatori di numeri casuali uniforme come mersenne_twister.
La resistenza ha eseguito l'overload dell'operators: C++98/03 proibiti un elemento di un contenitore STL dall'overload del relativo l'operatore address-of.Questa operazione classi come CComPtr affermativo, in modo che le classi di supporto come CAdapt sono state richieste per proteggere STL da tali overload.Durante lo sviluppo di Visual C++ 2010, STL viene eseguito per rifiutare l'operators di overload in ulteriormente situazioni.C++11 ha modificato i requisiti rendere l'operators di overload accettabile.C++11 e Visual C++ 2010, fornisce la funzione di supporto std::addressof(), che può ottenere l'indirizzo true di un oggetto indipendentemente dall'overload degli operatori.Prima di Visual C++ 2010 venga rilasciato, è tentato di sostituire le occorrenze di "&elem" con "std::addressof(elem)", ovvero in modo appropriato apportate.In Visual C++ in Visual Studio 2012, è necessario più avanti.A questo punto sono state controllate tutti i contenitori e tutti gli iteratori, in modo che le classi in overload del relativo l'operatore address-of devono essere utilizzabili in STL.
Visual C++ in Visual Studio 2012 va oltre C++11 in diversi modi:
Iteratori SPAVENTOSI: come consentito ma non richiesto dallo standard C++11, gli iteratori SPAVENTOSI è stato implementato, come descritto in N2911 "che riduce le dipendenze all'interno di classi generiche per i programmi più veloce e più piccoli" e "Assegnazione di iteratore N2980 e inizializzazione SPAVENTOSE, revisione 1 ".
Filesystem: l'intestazione di <filesystem> da la proposta TR2 è stato aggiunto.Offre recursive_directory_iterator e altre funzionalità interessanti.Prima che il lavoro su TR2 sia bloccato perché C++0x eseguiva molto tardiva e stava modificando a C++11, la proposta 2006 è stata derivata da Boost.Filesystem V2.Successivamente si è evoluta in Boost.Filesystem V3, ma che non è implementata in Visual C++ in Visual Studio 2012.
E un'ottimizzazione importante!Tutti avrà contenitori sono ora in modo ottimale piccolo fornite le rappresentazioni correnti.Ciò fa riferimento agli oggetti contenitore stesso, non al puntare- al contenuto.Ad esempio, std::vector contiene tre puntatori non elaborati.In Visual C++ 2010, x86 la modalità di rilascio, std::vector è di 16 byte.In Visual C++ in Visual Studio 2012, è di 12 byte, in quanto il piccolo.Si tratta di un affare- se sono presenti 100.000 vettori nel programma, Visual C++ in Visual Studio 2012 consente di risparmiare 400.000 byte.L'utilizzo della memoria prima salvato sia lo spazio che il tempo.
È stata raggiunta evitare l'archiviazione di allocatori e i comparatori vuoti, poiché std::allocator e std::less sono indipendenti dallo stato.(Tali ottimizzazioni abilitate per gli allocatori personalizzati/comparatori inoltre, purché siano indipendenti dallo stato.Ovviamente, l'archiviazione di allocatori con stato o comparatori non può essere risolto, ma questi sono molto rare).
Dimensione del contenitore
Nelle tabelle seguenti vengono illustrate le dimensioni del contenitore, in byte, per le piattaforme x86 e x64.(il monitoraggio ARM a 32 bit è equivalente a x86 per tali scopi).Modalità di rilascio di analizzare di queste tabelle, perché la modalità di debug contiene controllare il macchinario che utilizza lo spazio e il tempo.Le colonne separate per Visual C++ 2008 SP1, dove _SECURE_SCL ha impostato come valore predefinito a 1 e per Visual C++ 2008 con SP1 _SECURE_SCL manualmente impostato su 0 per la velocità massima.Visual C++ 2010 e Visual C++ in Visual Studio 2012 impostato come valore predefinito _SECURE_SCL a 0 (ora noto come _ITERATOR_DEBUG_LEVEL).
dimensione del contenitore x86 (byte) |
VC9 SP1 |
VC9 SP1 SCL=0 |
VC10 |
VC11 |
---|---|---|---|---|
vettore<int> |
24 |
16 |
16 |
12 |
matrice<int, 5> |
20 |
20 |
20 |
20 |
deque<int> |
32 |
32 |
24 |
20 |
forward_list<int> |
N/D |
N/D |
8 |
4 |
elenco<int> |
28 |
12 |
12 |
8 |
priority_queue<int> |
28 |
20 |
20 |
16 |
coda<int> |
32 |
32 |
24 |
20 |
stack<int> |
32 |
32 |
24 |
20 |
coppia<int, int> |
8 |
8 |
8 |
8 |
tupla<int, int, int> |
16 |
16 |
16 |
12 |
mapping<int, int> |
32 |
12 |
16 |
8 |
multimap<int, int> |
32 |
12 |
16 |
8 |
impostare<int> |
32 |
12 |
16 |
8 |
multi-insieme<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 |
string |
28 |
28 |
28 |
24 |
wstring |
28 |
28 |
28 |
24 |
dimensione del contenitore x64 (byte) |
VC9 SP1 |
VC9 SP1 SCL=0 |
VC10 |
VC11 |
---|---|---|---|---|
vettore<int> |
48 |
32 |
32 |
24 |
matrice<int, 5> |
20 |
20 |
20 |
20 |
deque<int> |
64 |
64 |
48 |
40 |
forward_list<int> |
N/D |
N/D |
16 |
8 |
elenco<int> |
56 |
24 |
24 |
16 |
priority_queue<int> |
56 |
40 |
40 |
32 |
coda<int> |
64 |
64 |
48 |
40 |
stack<int> |
64 |
64 |
48 |
40 |
coppia<int, int> |
8 |
8 |
8 |
8 |
tupla<int, int, int> |
16 |
16 |
16 |
12 |
mapping<int, int> |
64 |
24 |
32 |
16 |
multimap<int, int> |
64 |
24 |
32 |
16 |
impostare<int> |
64 |
24 |
32 |
16 |
multi-insieme<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 |
string |
40 |
40 |
40 |
32 |
wstring |
40 |
40 |
40 |
32 |
Guida di riferimento rapida ai numeri di versione di Visual C++
Visual C++ include "numeri di versione" diversi a seconda apparite.È la versione bollata (stampata nella casella), la versione interna (visualizzato nella finestra di dialogo Su ) e la versione del compilatore (visualizzato da cl.exe e dalla macro di _MSC_VER ).
Numero di versione personalizzato |
Numero di versione interno |
numero di versione di#define _MSC_VER |
---|---|---|
Visual C++ 2005 |
VC8 |
1400 |
Visual C++ 2008 |
VC9 |
1500 |
Visual C++ 2010 |
VC10 |
1600 |
Visual C++ in Visual Studio 2012 |
VC11 |
1700 |
La macro di _MSC_VER è interessante agli utenti che desiderano utilizzare versioni diverse principali di Visual C++ e generare il codice diverso per essi.
Vedere anche
Riferimenti
Istruzione for basata su intervallo (C++)
Altre risorse
Digitare di nuovo a C++ (C++ moderno)