Novità di Visual C++ in Visual Studio 2017Visual Studio 2017What's New for Visual C++ in Visual Studio 2017Visual Studio 2017

In Visual Studio 2017Visual Studio 2017 sono stati inclusi numerosi aggiornamenti e correzioni per l'ambiente Visual C++.Visual Studio 2017Visual Studio 2017 brings many updates and fixes to the Visual C++ environment. Sono stati corretti più di 250 bug e problemi nel compilatore e negli strumenti, molti dei quali sono stati segnalati dai clienti attraverso Microsoft Connect.We've fixed over 250 bugs and reported issues in the compiler and tools, many submitted by customers through Microsoft Connect. Microsoft ringrazia i clienti per le segnalazioni inviate.Thank you for reporting bugs! Per altre informazioni sulle novità in tutto Visual Studio, visitare la pagina Novità in Visual Studio 2017Visual Studio 2017.For more information on what's new in all of Visual Studio, please visit What's new in Visual Studio 2017Visual Studio 2017.

compilatore C++C++ compiler

Miglioramenti della conformità di C++C++ conformance improvements

Questa versione include aggiornamenti al compilatore C++ e alla libreria standard, con supporto avanzato per funzionalità di C++11 e C++14, oltre al supporto preliminare per determinate funzionalità che si prevede verranno incluse nello standard C++17.In this release, we've updated the C++ compiler and standard library with enhanced support for C++11 and C++14 features, as well as preliminary support for certain features expected to be in the C++17 standard. Per informazioni dettagliate, vedere Miglioramenti della conformità di C++ in Visual Studio 2017.For detailed information, see C++ Conformance Improvements in Visual Studio 2017.

Nuove opzioni del compilatoreNew compiler switches

-/std:c++14 e /std:c++latest: queste opzioni del compilatore controllano il consenso esplicito per versioni specifiche del linguaggio di programmazione ISO C++ in un progetto.-/std:c++14 and /std:c++latest: These compiler switches enable you to opt-in to specific versions of the ISO C++ programming language in a project. Per altre informazioni, vedere -std (specifica la versione standard del linguaggio).For more information, see -std (Specify Language Standard Version). La maggior parte delle nuove funzionalità standard in fase di progettazione è protetta dall'opzione /std:c++latest.Most of the new draft standard features are guarded by the /std:c++latest switch.

Visual Studio 2017 versione 15.3: l'opzione /std:c++17 abilita il set di funzionalità C++17 implementate dal compilatore Visual C++.Visual Studio 2017 version 15.3: The /std:c++17 option enables the set of C++17 features implemented by the Visual C++ compiler. Questa opzione disabilita il supporto del compilatore e della libreria standard per le funzionalità modificate o nuove nelle versioni più recenti del documento di lavoro e degli aggiornamenti sui difetti dello standard C++.This option disables compiler and standard library support for features that are changed or new in more recent versions of the Working Draft and defect updates of the C++ Standard.

-/permissive-: consente di abilitare tutte le opzioni del compilatore relative alla conformità allo standard e disabilitare la maggior parte delle estensioni del compilatore specifiche di Microsoft (ma non __declspec(dllimport), ad esempio).-/permissive-: Enable all strict standards conformance compiler options and disable most Microsoft-specific compiler extensions (but not __declspec(dllimport), for example). L'opzione è disattivata per impostazione predefinita ma sarà attivata per impostazione predefinita in un determinato momento nel futuro.(Off by default but will be on by default at some point in the future.)

-/diagnostics: consente di abilitare la visualizzazione di numero di riga, numero di riga e colonna o numero di riga e colonna e cursore sotto la riga di codice in cui è stato rilevato l'errore o l'avviso relativo alla diagnostica.-/diagnostics: Enable display of the line number, the line number and column, or the line number and column and a caret under the line of code where the diagnostic error or warning was found.

-/debug:fastlink:-/debug:fastlink:
consente di abilitare fasi di collegamento incrementali fino al 30% più veloci (rispetto a Visual Studio 2015) evitando di copiare tutte le informazioni di debug nel file PDB.Enable up to 30% faster incremental link times (vs. Visual Studio 2015) by not copying all debug information into the PDB file. Il file PDB punta invece alle informazioni di debug per i file di libreria e oggetto usati per creare il file eseguibile.The PDB file instead points to the debug information for the object and library files used to create the executable. Vedere i post relativi al ciclo di build di C++ più rapido in Visual Studio "15" con /Debug:fastlink e i consigli per velocizzare le compilazioni di C++ in Visual Studio.See Faster C++ build cycle in VS “15” with /Debug:fastlink and Recommendations to speed C++ builds in Visual Studio.

Visual Studio 2017Visual Studio 2017 consente l'uso di /sdl con /await. allows using /sdl with /await. È stata rimossa la limitazione /RTC con le coroutine.We removed the /RTC limitation with Coroutines.

Visual Studio 2017 versione 15.5: il compilatore di Visual C++ supporta il 75% circa delle funzionalità di C++17, comprese le associazioni strutturate, espressioni lambda constexpr, if constexpr, variabili in linea, la riduzione di espressioni e l'aggiunta di noexcept al sistema tipo.Visual Studio 2017 version 15.5: The Visual C++ compiler supports about 75% of C++17 features, including structured bindings, constexpr lambdas, if constexpr, inline variables, fold expressions, and adding noexcept to the type system. Queste sono disponibili tramite l'istruzione switch /std:c++17.These are available under the /std:c++17 switch. La modalità di conformità /permissive- comprende il supporto parziale della ricerca del nome in due fasi.The /permissive- conformance mode includes partial support for two-phase name lookup. Per altre informazioni, vedere Miglioramenti della conformità di C++ in Visual Studio 2017.For more information, see C++ Conformance Improvements in Visual Studio 2017.

Codegen, sicurezza, diagnostica e controllo delle versioniCodegen, security, diagnostics and versioning

In questa versione sono stati introdotti numerosi miglioramenti per l'ottimizzazione, la generazione del codice, il controllo delle versioni del set di strumenti e la diagnostica.This release brings several improvements in optimization, code generation, toolset versioning, and diagnostics. Ecco alcuni dei miglioramenti più rilevanti:Some notable improvements include:

  • Miglioramento della generazione del codice per i cicli: supporto della vettorializzazione automatica della divisione di interi costanti, migliore identificazione dei modelli memset.Improved code generation of loops: Support for automatic vectorization of division of constant integers, better identification of memset patterns.
  • Maggiore sicurezza del codice: è stata migliorata l'emissione della diagnostica del compilatore per i sovraccarichi del buffer e /guard:cf ora protegge le istruzioni switch che generano tabelle di collegamento.Improved code security: Improved emission of buffer overrun compiler diagnostics, and /guard:cf now guards switch statements that generate jump tables.
  • Controllo delle versioni: il valore del preprocessore predefinito macro_MSC_VER ora viene monotonicamente aggiornato ad ogni aggiornamento del set di strumenti di Visual C++.Versioning: The value of the built-in preprocessor macro _MSC_VER is now being monotonically updated at every Visual C++ toolset update. Per altre informazioni, vedere il post relativo alla versione del compilatore Visual C++.For more information, see Visual C++ Compiler Version.
  • Nuovo layout del set di strumenti: il compilatore e gli strumenti di compilazione correlati hanno un nuovo percorso e una nuova struttura di directory nel computer di sviluppo.New toolset layout: The compiler and related build tools have a new location and directory structure on your development machine. Il nuovo layout consente installazioni side-by-side di più versioni del compilatore.The new layout enables side-by-side installations of multiple versions of the compiler. Per altre informazioni, vedere il post Compiler Tools Layout in Visual Studio "15" (Layout degli strumenti del compilatore in Visual Studio "15").For more information, see Compiler Tools Layout in Visual Studio "15".
  • Miglioramenti alla diagnostica: nella finestra di output ora appare la colonna in cui si verifica un errore.Improved diagnostics: The output window now shows the column where an error occurs. Per altre informazioni, vedere il post C++ compiler diagnostics improvements in VS "15" Preview 5 (Miglioramenti della diagnostica del compilatore C++ in VS "15" anteprima 5).For more information, see C++ compiler diagnostics improvements in VS "15" Preview 5.
  • Quando si usano coroutine, la parola chiave sperimentale "yield" (disponibile con l'opzione /await) è stata rimossa.When using co-routines, the experimental keyword "yield" (available under the /await switch) has been removed. È necessario aggiornare il codice per l'uso di co_yield.Your code should be updated to use co_yield instead. Per altre informazioni, vedere il blog del team di Visual C++.For more information, see the Visual C++ Team blog.

Visual Studio 2017 versione 15.3: ulteriori miglioramenti alla diagnostica nel compilatore.Visual Studio 2017 version 15.3: Additional improvements to diagnostics in the compiler. Per altre informazioni, vedere Diagnostic Improvements in Visual Studio 2017 15.3.0 (Miglioramenti della diagnostica in Visual Studio 2017 15.3.0).For more information, see Diagnostic Improvements in Visual Studio 2017 15.3.0.

Visual Studio 2017 versione 15.5: le prestazioni di runtime di Visual C++ continuano a migliorare grazie a una migliore qualità del codice generato.Visual Studio 2017 version 15.5: Visual C++ runtime performance continues to improve due to better generated code quality. Ciò significa che è sufficiente ricompilare il codice e l'app viene eseguita più velocemente.This means that you can simply recompile your code, and your app just runs faster. Alcune ottimizzazioni del compilatore sono totalmente nuove, come la vettorizzazione di archivi scalari condizionali, la combinazione di chiamate SEN(x) e COS(x) in un nuovo SENCOS(x) e l'eliminazione di istruzioni ridondanti dall'ottimizzatore SSA.Some of the compiler optimizations are brand new, such as the vectorization of conditional scalar stores, the combining of calls sin(x) and cos(x) into a new sincos(x), and the elimination of redundant instructions from the SSA Optimizer. Altre ottimizzazioni del compilatore sono miglioramenti delle funzionalità esistenti, quali euristica della vettorizzazione per le espressioni condizionali, migliori ottimizzazioni di ciclo e codegen min/max float.Other compiler optimizations are improvements to existing functionality such as vectorizer heuristics for conditional expressions, better loop optimizations, and float min/max codegen. Il linker ha un'implementazione di /OPT:ICF nuova e più veloce che può comportare fino al 9% di speedup del tempo di collegamento, inoltre sono presenti altre correzioni di prestazioni nel "collegamento incrementale".The linker has a new and faster /OPT:ICF implementation which can result in up to 9% link time speedups, and there are other perf fixes in "incremental linking". Per altre informazioni, vedere /OPT (Ottimizzazioni) e /INCREMENTAL (collegamento incrementale).For more information, see /OPT (Optimizations) and /INCREMENTAL (Link Incrementally).

Visual C++ supporta Intel AVX-512, comprese le istruzioni per la lunghezza del vettore che offrono nuove funzioni in AVX-512 nei registri a 128 e 256 bit.Visual C++ supports Intel's AVX-512, including the Vector Length instructions that bring new functions in AVX-512 to 128- and 256-bit wide registers.

Lo switch /Zc:noexceptTypes- può essere usato per ripristinare la versione C++14 di noexcept durante l'utilizzo della modalità C++ 17 in generale.The /Zc:noexceptTypes- switch can be used to revert to the C++14 version of noexcept while using C++17 mode in general. In questo modo è possibile aggiornare il codice sorgente per garantire la conformità a C++17 senza dover riscrivere contemporaneamente tutto il codice throw().This enables you to update your source code to conform to C++17 without having to rewrite all your throw() code at the same time. Per altre informazioni, vedere Dynamic exception specification removal and noexcept (Rimozione della specifica di eccezione dinamica e noexcept).For more information, see Dynamic exception specification removal and noexcept.

Miglioramenti della Libreria standard C++C++ Standard Library improvements

  • Piccoli miglioramenti della diagnostica basic_string _ITERATOR_DEBUG_LEVEL != 0.Minor basic_string _ITERATOR_DEBUG_LEVEL != 0 diagnostics improvements. L'attivazione di un controllo IDL in una struttura basata su stringhe ora segnalerà il comportamento specifico che ha causato l'attivazione.Tripping an IDL check in string machinery will now report the specific behavior that caused the trip. Ad esempio, anziché un messaggio del tipo "iteratore stringa non dereferenziabile" se ne otterrà uno del tipo "impossibile dereferenziare l'iteratore stringa perché non compreso nell'intervallo (potrebbe trattarsi ad esempio di un iteratore di fine)".For example, instead of "string iterator not dereferencable" you'll get "cannot dereference string iterator because it is out of range (e.g. an end iterator)".
  • Miglioramento delle prestazioni: gli overload di basic_string::find(char) ora possono chiamare traits::find solo una volta.Performance improvement: made basic_string::find(char) overloads only call traits::find once. In precedenza questa funzione era implementata come una ricerca di stringa generale avente come obiettivo una stringa di lunghezza 1.Previously this was implemented as a general string search for a string of length 1.
  • Miglioramento delle prestazioni: basic_string::operator== ora controlla la dimensione della stringa prima di confrontare il contenuto delle stringhe.Performance improvement: basic_string::operator== now checks the string's size before comparing the strings' contents.
  • Miglioramento delle prestazioni: è stato rimosso l'accoppiamento dei controlli in basic_string che era difficile da analizzare per l'utilità di ottimizzazione del compilatore.Performance improvement: removed control coupling in basic_string which was difficult for the compiler optimizer to analyze. Risolve l'errore VSO n. 262848 "<string>: reserve() esegue troppe operazioni".Resolves VSO# 262848 "<string>: reserve() does too much work". Si noti che, per tutte le stringhe brevi, la chiamata di reserve ha comunque un costo senza eseguire alcuna operazione.Note that for all short strings, calling reserve still has nonzero cost to do nothing.
  • Sono stati aggiunti <any>, <string_view>, apply() e make_from_tuple().We added <any>, <string_view>, apply(), make_from_tuple().
  • std::vector è stata migliorata nella correttezza e nelle prestazioni: l'uso di alias durante l'inserimento/ubicazione è ora gestito correttamente come richiesto dallo Standard, la solida garanzia di eccezione viene ora fornita quando richiesto dallo Standard tramite move_if_noexcept() e altra logica e l'inserimento/ubicazione eseguono meno operazioni sugli elementi.std::vector has been overhauled for correctness and performance: aliasing during insertion/emplacement is now correctly handled as required by the Standard, the strong exception guarantee is now provided when required by the Standard via move_if_noexcept() and other logic, and insertion/emplacement perform fewer element operations.
  • La libreria dello standard C++ ora evita la dereferenziazione dei puntatori null ricercati.The C++ Standard Library now avoids dereferencing null fancy pointers.
  • Aggiunta di <optional>, <variant>, shared_ptr::weak_type e <cstdalign>.Added <optional>, <variant>, shared_ptr::weak_type, and <cstdalign>.
  • Abilitazione di constexpr C++14 in min/max/minmax(initializer_list) e min_element/max_element/minmax_element().Enabled C++14 constexpr in min/max/minmax(initializer_list) and min_element/max_element/minmax_element().
  • Miglioramento delle prestazioni weak_ptr::lock().Improved weak_ptr::lock() performance.
  • Correzione dell'operatore di assegnazione per lo spostamento di std::promise, che in precedenza causava il blocco definitivo del codice.Fixed std::promise's move assignment operator, which previously could cause code to block forever.
  • Correzione di errori del compilatore con la conversione implicita di atomic<T *> in T *.Fixed compiler errors with atomic<T *>'s implicit conversion to T *.
  • pointer_traits<Ptr> ora rileva correttamente Ptr::rebind<U>.pointer_traits<Ptr> now correctly detects Ptr::rebind<U>.
  • Correzione di un qualificatore di costante mancante nell'operatore di sottrazione di move_iterator.Fixed a missing const qualifier in move_iterator's subtraction operator.
  • Correzione del codegen silenzioso errato per gli allocatori con stato definiti dall'utente che richiedono propagate_on_container_copy_assignment e propagate_on_container_move_assignment.Fixed silent bad codegen for stateful user-defined allocators requesting propagate_on_container_copy_assignment and propagate_on_container_move_assignment.
  • atomic<T> ora tollera operator&() in overload.atomic<T> now tolerates overloaded operator&().
  • Per aumentare la velocità effettiva del compilatore, le intestazioni della libreria standard C++ evitano di includere dichiarazioni per le funzioni intrinseche del compilatore non indispensabili.To increase compiler throughput, C++ Standard Library headers now avoid including declarations for unnecessary compiler intrinsics.
  • Diagnostica del compilatore leggermente migliorata per le chiamate bind() non corrette.Slightly improved compiler diagnostics for incorrect bind() calls.
  • Miglioramento delle prestazioni (più che triplicate) per i costruttori di spostamento di std::string/std::wstringImproved the performance of std::string/std::wstring's move constructors by more than 3x
  • Per l'elenco completo dei miglioramenti apportati alla libreria standard, vedere Standard Library Fixes In VS 2017 RTM (Correzioni alla libreria standard in Visual Studio 2017 RTM).For a complete list of Standard Library improvments see the Standard Library Fixes In VS 2017 RTM.

Visual Studio 2017 versione 15.3Visual Studio 2017 version 15.3

Funzionalità C++17C++17 features

Sono state implementate varie funzionalità aggiuntive C++17.Several additional C++17 features have been implemented. Per altre informazioni, vedere Conformità al linguaggio di Visual C++.For more information, see Visual C++ Language Conformance.

Altre nuove funzionalitàOther new features

  • Implementazione di P0602R0 "variant e optional devono propagare trivially_move e trivially_copy".Implemented P0602R0 "variant and optional should propagate copy/move triviality".
  • La libreria standard ora tollera ufficialmente la disabilitazione dell'opzione RTTI dinamica tramite /GR-.The Standard Library now officially tolerates dynamic RTTI being disabled via /GR-. Le funzioni dynamic_pointer_cast() e rethrow_if_nested() richiedono intrinsecamente dynamic_cast, quindi la libreria standard le contrassegna ora come =delete in /GR-.dynamic_pointer_cast() and rethrow_if_nested() inherently require dynamic_cast, so the Standard Library now marks them as =delete under /GR-.
  • Anche quando l'opzione RTTI dinamica viene disabilitata tramite /GR-, l'opzione "RTTI statica" (sotto forma di typeid(Tipo)) è ancora disponibile e interagisce con vari componenti della libreria standard.Even when dynamic RTTI has been disabled via /GR-, "static RTTI" (in the form of typeid(SomeType)) is still available and powers several Standard Library components. La libreria standard ora supporta anche la disabilitazione di questa opzione, tramite /D_HAS_STATIC_RTTI=0.The Standard Library now supports disabling this too, via /D_HAS_STATIC_RTTI=0. Si noti che verranno così disabilitati std::any, target() e target_type() di std::function e get_deleter() di shared_ptr.Note that this will disable std::any, std::function's target() and target_type(), and shared_ptr's get_deleter().

Correzioni di correttezzaCorrectness fixes

  • I contenitori della libreria standard fissano ora max_size() a numeric_limits<tipo_differenza>::max() invece che al valore max di size_type. Ciò garantisce che il risultato di distance() sugli iteratori da tale contenitore sia rappresentabile nel tipo restituito di distance().Standard Library containers now clamp their max_size() to numeric_limits<difference_type>::max() rather than size_type's max. This ensures that the result of distance() on iterators from that container is representable in the return type of distance().
  • Correzione della specializzazione mancante auto_ptr<void>.Fixed missing specialization auto_ptr<void>.
  • Gli algoritmi meow_n() generavano in precedenza errori di compilazione se l'argomento della lunghezza non era un tipo integrale. Ora viene tentata la conversione delle lunghezze non integrali nel difference_type degli iteratori.The meow_n() algorithms previously failed to compile if the length argument was not an integral type; they now attempt to convert non-integral lengths to the iterators' difference_type.
  • normal_distribution<float> non genera più avvisi nella libreria standard in merito alla conversione da double a float.normal_distribution<float> no longer emits warnings inside the Standard Library about narrowing from double to float.
  • Correzione di alcune operazioni basic_string che eseguivano il confronto con npos anziché max_size() durante il controllo dell'overflow delle dimensioni massime.Fixed some basic_string operations which were comparing with npos instead of max_size() when checking for maximum size overflow.
  • condition_variable::wait_for(lock, relative_time, predicate) rispettava tutto il tempo relativo di attesa in caso di riattivazione spuria.condition_variable::wait_for(lock, relative_time, predicate) would wait for the entire relative time in the event of a spurious wake. Ora l'attesa corrisponde a un singolo intervallo del tempo relativo.Now, it will wait for only a single interval of the relative time.
  • future::get() ora invalida future, come richiesto dallo standard.future::get() now invalidates the future, as the standard requires.
  • iterator_traits<void *> era un errore complesso perché veniva eseguito un tentativo di formare void&;. Ora diventa in modo fluido uno struct vuoto per consentire l'uso di iterator_traits nelle condizioni "is iterator" SFINAE.iterator_traits<void *> used to be a hard error because it attempted to form void&; it now cleanly becomes an empty struct to allow use of iterator_traits in "is iterator" SFINAE conditions.
  • Sono stati corretti alcuni avvisi segnalati da Clang -Wsystem-headers.Some warnings reported by Clang -Wsystem-headers were fixed.
  • È stato corretto anche il problema "la specifica dell'eccezione nella dichiarazione non corrisponde alla dichiarazione precedente" segnalato da Clang -Wmicrosoft-exception-spec.Also fixed "exception specification in declaration does not match previous declaration" reported by Clang -Wmicrosoft-exception-spec.
  • Sono stati corretti anche gli avvisi relativi all'ordinamento dell'elenco degli inizializzatori dei membri segnalati da Clang e C1XX.Also fixed mem-initializer-list ordering warnings reported by Clang and C1XX.
  • I contenitori non ordinati non scambiavano i rispettivi hasher o predicati quando venivano scambiati i contenitori stessi.The unordered containers did not swap their hashers or predicates when the containers themselves were swapped. Ora lo fanno.Now they do.
  • Molte operazioni di scambio del contenitore sono ora contrassegnate noexcept (dato che la libreria standard non intende mai generare un'eccezione quando rileva la condizione di comportamento indefinito non-propagate_on_container_swap non-equal-allocator).Many container swap operations are now marked noexcept (as our Standard Library never intends to throw an exception when detecting the non-propagate_on_container_swap non-equal-allocator undefined behavior condition).
  • Molte operazioni vector<bool> sono ora contrassegnate noexcept.Many vector<bool> operations are now marked noexcept.
  • La libreria standard impone ora la corrispondenza di value_types dell'allocatore (in modalità C++17) con un'opzione per il rifiuto esplicito.The Standard Library will now enforce matching allocator value_types (in C++17 mode) with an opt-out escape hatch.
  • Correzione di alcune condizioni nelle quali un'operazione self-range-insert in basic_string compromette il contenuto delle stringhe.Fixed some conditions where self-range-insert into basic_strings would scramble the strings' contents. (Nota: lo standard proibisce ancora le operazioni self-range-insert in vettori.)(Note: self-range-insert into vectors is still prohibited by the Standard.)
  • propagate_on_container_swap dell'allocatore non influisce più su basic_string::shrink_to_fit().basic_string::shrink_to_fit() is no longer affected by the allocator's propagate_on_container_swap.
  • std::decay gestisce ora i tipi di funzione abominable, ovvero i tipi di funzione qualificati con cv e/o ref.std::decay now handles abominable function types (i.e. function types that are cv-qualified and/or ref-qualified).
  • Modifica delle direttive include per l'uso corretto della distinzione tra maiuscole e minuscole e delle barre, con miglioramento della portabilità.Changed include directives to use proper case sensitivity and forward slashes, improving portability.
  • Correzione dell'avviso C4061: "l'enumeratore 'miao' nell'istruzione switch dell'enum 'gatti' non viene gestito da un'etichetta case in modo esplicito".Fixed warning C4061 "enumerator 'Meow' in switch of enum 'Kitten' is not explicitly handled by a case label". Questo avviso è disattivato per impostazione predefinita ed è stato risolto come eccezione alle norme generali della libreria standard per gli avvisi.This warning is off-by-default and was fixed as an exception to the Standard Library's general policy for warnings. (La libreria standard garantisce il livello /W4, ma non tenta di offrire il livello /Wall.(The Standard Library is /W4 clean, but does not attempt to be /Wall clean. Molti avvisi disattivati per impostazione predefinita sono estremamente fastidiosi e non sono progettati per essere usati regolarmente.)Many off-by-default warnings are extremely noisy and aren't intended to be used on a regular basis.)
  • Controlli di debug migliorati per std::list.Improved std::list's debug checks. Gli iteratori di elenco controllano ora operator->() e list::unique() contrassegna ora gli iteratori come invalidati.List iterators now check operator->(), and list::unique() now marks iterators as invalidated.
  • Correzione della metaprogrammazione uses-allocator nella tupla.Fixed uses-allocator metaprogramming in tuple.

Correzioni per prestazioni e velocitàPerformance/throughput fixes

  • Correzione delle interazioni con noexcept che impedivano l'implementazione inline di std::atomic nelle funzioni che usano la gestione delle eccezioni strutturata.Worked around interactions with noexcept which prevented inlining std::atomic's implementation into functions that use Structured Exception Handling (SEH).
  • Modifica della funzione _Deallocate() interna della libreria standard per l'ottimizzazione in codice più ridotto, consentendone l'implementazione inline in più posizioni.Changed the Standard Library's internal _Deallocate() function to optimize into smaller code, allowing it to be inlined into more places.
  • Modifica di std::try_lock() per l'uso dell'espansione di pacchetto invece della ricorsione.Changed std::try_lock() to use pack expansion instead of recursion.
  • Miglioramento dell'algoritmo per la prevenzione di deadlock di std::lock() con l'uso di operazioni lock() al posto della rotazione di tutti i try_lock() dei blocchi.Improved std::lock()'s deadlock avoidance algorithm to use lock() operations instead of spinning on all the locks' try_lock()s.
  • Abilitazione dell'ottimizzazione del valore restituito denominato in system_category::message().Enabled the Named Return Value Optimization in system_category::message().
  • La congiunzione e la disgiunzione ora creano istanze di tipi N + 1, invece di tipi 2N + 2.conjunction and disjunction now instantiate N + 1 types, instead of 2N + 2 types.
  • std::function non crea più istanze del meccanismo di supporto degli allocatori per ogni chiamata di cancellazione dei tipi, con conseguente miglioramento della velocità e riduzione delle dimensioni dei file obj nei programmi che passano molte espressioni lambda distinte a std::function.std::function no longer instantiates allocator support machinery for each type-erased callable, improving throughput and reducing .obj size in programs that pass many distinct lambdas to std::function.
  • allocator_traits<std:: allocator> contiene operazioni std::allocator implementate manualmente inline, con conseguente riduzione delle dimensioni nel codice che interagisce con std::allocator solo tramite allocator_traits, ovvero la maggior parte del codice.allocator_traits<std::allocator> contains manually inlined std::allocator operations, reducing code size in code that interacts with std::allocator through allocator_traits only (i.e. most code).
  • L'interfaccia minima dell'allocatore C++11 viene ora gestita dalla libreria standard che chiama direttamente allocator_traits, invece di eseguire il wrapping dell'allocatore in un _Wrap_alloc della classe interna.The C++11 minimal allocator interface is now handled by the Standard Library calling allocator_traits directly, instead of wrapping the allocator in an internal class _Wrap_alloc. Ciò consente di ridurre le dimensioni del codice generato per il supporto dell'allocatore, migliorare la capacità dell'ottimizzatore di interpretare i contenitori della libreria standard in alcuni casi e offre una migliore esperienza di debug, perché è ora possibile vedere il tipo di allocatore anziché dover ricorrere a _Wrap_alloc<tipo allocatore> nel debugger.This reduces the code size generated for allocator support, improves the optimizer's ability to reason about Standard Library containers in some cases, and provides a better debugging experience (as now you see your allocator type, rather than _Wrap_alloc<your allocator type> in the debugger).
  • Rimozione della metaprogrammazione per versioni personalizzate di allocator::reference, che gli allocatori non sono in effetti autorizzati a personalizzare.Removed metaprogramming for customized allocator::reference, which allocators aren't actually allowed to customize. (Gli allocatori possono fare in modo che i contenitori usino puntatori fantasiosi, ma non riferimenti fantasiosi.)(Allocators can make containers use fancy pointers but not fancy references.)
  • Il front-end del compilatore è stato addestrato ad annullare il wrapping degli iteratori di debug nei cicli for basati su intervalli, con conseguente miglioramento delle build di debug.The compiler front-end was taught to unwrap debug iterators in range-based for-loops, improving the performance of debug builds.
  • Il percorso di riduzione interno di basic_string per shrink_to_fit() e reserve() non è più nel percorso delle operazioni di riallocazione, con conseguente riduzione delle dimensioni del codice per tutti i membri mutanti.basic_string's internal shrink path for shrink_to_fit() and reserve() is no longer in the path of reallocating operations, reducing code size for all mutating members.
  • Il percorso di crescita interno di basic_string non è più nel percorso di shrink_to_fit().basic_string's internal grow path is no longer in the path of shrink_to_fit().
  • Le operazioni di mutazione di basic_string vengono ora sottoposte a factoring nelle funzioni del percorso veloce senza allocazione e del percorso lento con allocazione, quindi l'implementazione inline nei chiamanti del caso comune senza riallocazione diventa più probabile.basic_string's mutating operations are now factored into non-allocating fast path and allocating slow path functions, making it more likely for the common no-reallocate case to be inlined into callers.
  • Le operazioni di mutazione di basic_string costruiscono ora i buffer riallocati nello stato desiderato anziché eseguire il ridimensionamento in loco.basic_string's mutating operations now construct reallocated buffers in the desired state rather than resizing in place. Ad esempio, un'operazione di inserimento all'inizio di una stringa ora sposta il contenuto dopo l'inserimento una sola volta (verso il basso o nel nuovo buffer allocato) invece di due come nel caso della riallocazione (nel nuovo buffer allocato e poi verso il basso).For example, inserting at the beginning of a string now moves the content after the insertion exactly once (either down or to the newly allocated buffer), instead of twice in the reallocating case (to the newly allocated buffer and then down).
  • Le operazioni che chiamano la libreria standard C in <string> ora memorizzano nella cache l'indirizzo di errno per evitare interazioni ripetute con TLS.Operations calling the C standard library in <string> now cache errno's address to remove repeated interaction with TLS.
  • Implementazione semplificata di is_pointer.Simplified is_pointer's implementation.
  • Completamento della modifica dell'espressione SFINAE da basata su funzioni a basata su struct/void_t.Finished changing function-based Expression SFINAE to struct/void_t-based.
  • Gli algoritmi della libreria standard ora evitano il post-incremento degli iteratori.Standard Library algorithms now avoid postincrementing iterators.
  • Correzione degli avvisi di troncamento durante l'uso di allocatori a 32 bit in sistemi a 64 bit.Fixed truncation warnings when using 32-bit allocators on 64-bit systems.
  • L'assegnazione di spostamento di std::vector è ora più efficiente nel caso di allocatori non uguali e non POCMA, grazie al riutilizzo del buffer quando possibile.std::vector move assignment is now more efficient in the non-POCMA non-equal-allocator case, by reusing the buffer when possible.

Miglioramenti della leggibilità e altri miglioramentiReadability and other improvements

  • La libreria standard ora usa constexpr C++14 incondizionatamente, anziché le macro definite in modo condizionale.The Standard Library now uses C++14 constexpr unconditionally, instead of conditionally-defined macros.
  • La libreria standard ora usa modelli di alias internamente.The Standard Library now uses alias templates internally.
  • La libreria standard ora usa nullptr internamente, invece di nullptr_t{}.The Standard Library now uses nullptr internally, instead of nullptr_t{}. (L'utilizzo interno di NULL è stato eliminato.(Internal usage of NULL has been eradicated. L'utilizzo interno di 0 come null verrà rimosso gradualmente.)Internal usage of 0-as-null is being cleaned up gradually.)
  • La libreria standard ora usa std::move() internamente invece di usare std::forward() in modo stilisticamente non corretto.The Standard Library now uses std::move() internally, instead of stylistically misusing std::forward().
  • Modifica di static_assert(false, "messaggio") in messaggio #error.Changed static_assert(false, "message") to #error message. Ciò migliora la diagnostica del compilatore perché #error interrompe immediatamente la compilazione.This improves compiler diagnostics because #error immediately stops compilation.
  • La libreria standard non contrassegna più le funzioni come __declspec(dllimport).The Standard Library no longer marks functions as __declspec(dllimport). Ciò non è più richiesto dalla tecnologia dei linker moderni.Modern linker technology no longer requires this.
  • Estrazione di SFINAE negli argomenti del modello predefiniti, con conseguente riduzione della confusione rispetto ai tipi restituiti e ai tipi di argomenti delle funzioni.Extracted SFINAE to default template arguments, which reduces clutter compared to return types and function argument types.
  • I controlli di debug in <random> usano ora i normali meccanismi della libreria standard, invece della funzione interna _Rng_abort() che chiamava fputs() per stderr.Debug checks in <random> now use the Standard Library's usual machinery, instead of the internal function _Rng_abort() which called fputs() to stderr. L'implementazione di questa funzione viene mantenuta per la compatibilità binaria, ma verrà rimossa nella prossima versione della libreria standard non compatibile dal punto di vista binario.This function's implementation is being retained for binary compatibility, but has been removed in the next binary-incompatible version of the Standard Library.

Visual Studio 2017 versione 15.5Visual Studio 2017 version 15.5

Sono state aggiunte, deprecate o rimosse diverse funzionalità della libreria standard, in conformità allo standard C++17.Several Standard Library features have been added, deprecated or removed in accordance with the C++17 standard. Per altre informazioni, vedere Miglioramenti della conformità di C++ in Visual Studio 2017.For more information see C++ conformance improvements in Visual Studio.

Nuove funzionalità sperimentaliNew experimental features

  • Supporto sperimentale per gli algoritmi paralleli seguenti:Experimental support for the following parallel algorithms:
    • all_ofall_of
    • any_ofany_of
    • for_eachfor_each
    • for_each_nfor_each_n
    • none_ofnone_of
    • reducereduce
    • replacereplace
    • replace_ifreplace_if
    • sortsort
  • Le firme per gli algoritmi paralleli seguenti vengono aggiunte ma non parallelizzate in questa fase; la profilatura non ha rivelato alcun vantaggio nella parallelizzazione di algoritmi che spostano o permutano soltanto gli elementi:The signatures for the following parallel algorithms are added but not parallelized at this time; profiling showed no benefit in parallelizing algorithms that only move or permute elements:
    • copycopy
    • copy_ncopy_n
    • fillfill
    • fill_nfill_n
    • movemove
    • reversereverse
    • reverse_copyreverse_copy
    • rotaterotate
    • rotate_copyrotate_copy
    • swap_rangesswap_ranges

Correzioni e miglioramenti delle prestazioniPerformance fixes and improvements

  • basic_string<char16_t> coinvolge ora le ottimizzazioni memcmp/memcpy/ecc. attivate da basic_string<wchar_t>.basic_string<char16_t> now engages memcmp/memcpy/etc. optimizations that basic_string<wchar_t> engages.
  • È stata corretta una limitazione dell'ottimizzatore che impediva ai puntatori a funzione di essere esposti inline tramite le "funzioni per evitare la copia" nell'aggiornamento 3 di Visual Studio 2015, ripristinando le prestazioni di lower_bound (iter, iter, puntatore a funzione).An optimizer limitation which prevented function pointers from being inlined exposed by our "avoid copying functions" work in Visual Studio 2015 Update 3 has been worked around, restoring performance of lower_bound(iter, iter, function pointer).
  • È stato ridotto l'overhead della verifica degli ordini di input da includere del debug dell'iteratore, set_difference, set_symmetric_difference e set_union, rimuovendo il wrapping degli iteratori prima di controllare l'ordine.The overhead of iterator debugging's order verification of inputs to includes, set_difference, set_symmetric_difference, and set_union was reduced by unwrapping iterators before checking order.
  • std::inplace_merge ora ignora gli elementi che sono già in posizione.std::inplace_merge now skips over elements that are already in position.
  • La costruzione std::random_device non costruisce più, quindi distrugge la std::string.Constructing std::random_device no longer constructs and then destroys a std::string.
  • std::equal e std::partition hanno superato un test di ottimizzazione dei thread dei collegamenti che salva il confronto di un iteratore.std::equal and std::partition had a jump-threading optimization pass which saves an iterator comparison.
  • Quando in std::reverse vengono passati dei puntatori a T facilmente copiabili, ora viene inviata un'implementazione vettorizzata scritta a mano.When std::reverse is passed pointers to trivially copyable T, it will now dispatch to a handwritten vectorized implementation.
  • std::fill, std::equal e std::lexicographical_compare hanno appreso come inviare a memset/memcmp per std::byte e gsl::byte (e altre enumerazioni e classi di enumerazione con caratteri).std::fill, std::equal, and std::lexicographical_compare were taught how to dispatch to memset / memcmp for std::byte and gsl::byte (and other char-ish enums and enum classes). Si noti che std::copy esegue l'invio utilizzando is_trivially_copyable, pertanto richiede alcuna modifica.Note that std::copy dispatches using is_trivially_copyable and thus didn't need any changes.
  • La libreria STL non contiene più distruttori con parentesi graffe vuote il cui unico comportamento consisteva nel creare tipi non facilmente destructible.The STL no longer contains empty-braces destructors whose only behavior was to make types non-trivially-destructible.

Correzioni di correttezzaCorrectness fixes

  • std::partition chiama il predicato N volte anziché N + 1 volte, come richiesto dallo standard.std::partition now calls the predicate N times instead of N + 1 times, as the standard requires.
  • I tentativi di evitare le asserzioni statiche chiave nella versione 15.3 sono state riparate nella versione 15.5.Attempts to avoid magic statics in 15.3 have been repaired in 15.5.
  • std::atomic<T> non richiede più che T sia costruibile per impostazione predefinita.std::atomic<T> no longer requires T to be default constructible.
  • Gli algoritmi di heap che assumono un tempo logaritmico non effettuano più un'asserzione di tempo lineare secondo cui l'input è in realtà un heap quando è abilitato il debug dell'iteratore.Heap algorithms that take logarithmic time no longer do a linear time assertion that the input is in fact a heap when iterator debugging is enabled.
  • __declspec(allocator) viene mantenuto solo per C1XX, per impedire gli avvisi da Clang, che non comprende questo declspec.__declspec(allocator) is now guarded for C1XX only, to prevent warnings from Clang which doesn't understand this declspec.
  • basic_string::npos è disponibile come costante della fase di compilazione.basic_string::npos is now available as a compile time constant.
  • std:: allocator ora gestisce correttamente l'allocazione dei tipi eccessivamente allineati (tipi il cui allineamento è maggiore di max_align_t) in modalità C++17 (tranne se disabilitati da /Zc:alignedNew-).std::allocator now properly handles allocation of over-aligned types - types whose alignment is greater than max_align_t – in C++17 mode (unless disabled by /Zc:alignedNew-). Ad esempio, i vettori di oggetti con allineamento a 16 o 32 byte verranno ora correttamente allineati per le istruzioni SSE/AVX.For example, vectors of objects with 16 or 32-byte alignment will now be properly aligned for SSE / AVX instructions.

Altre librerieOther Libraries

Supporto librerie open sourceOpen source library support

Vcpkg è un strumento open source da riga di comando che semplifica notevolmente il processo di acquisizione e di creazione di librerie statiche e DLL C++ open source in Visual Studio.Vcpkg is an open-source command line tool that greatly simplifies the process of acquiring and building open source C++ static libs and DLLS in Visual Studio. Per altre informazioni, vedere vcpkg: gestione pacchetti per C++.For more information, see vcpkg: A package manager for C++.

Visual Studio 2017 versione 15.5Visual Studio 2017 version 15.5

CPPRestSDK 2.9.0CPPRest SDK 2.9.0

CPPRestSDK, un'API Web multipiattaforma per C++, è stato aggiornato alla versione 2.9.0.The CPPRestSDK, a cross-platform web API for C++, has been updated to version 2.9.0. Per altre informazioni, vedere il post sulla disponibilità di CppRestSDK 2.9.0 su GitHub.For more information, see CppRestSDK 2.9.0 is available on GitHub.

ATLATL

  • Un altro set di correzioni per la conformità della ricerca dei nomiYet another set of name-lookup conformance fixes
  • I costruttori di spostamento e gli operatori di assegnazione dello spostamento esistenti sono ora contrassegnati correttamente per non generare eccezioniExisting move constructors and move assignment operators are now properly marked as non-throwing
  • Annullamento dell'eliminazione dell'avviso valido C4640 relativo all'inizializzazione thread-safe di elementi statici locali in atlstr.hUn-suppress valid warning C4640 about thread safe init of local statics in atlstr.h
  • L'inizializzazione thread-safe di elementi statici locali veniva disattivata automaticamente nel set di strumenti XP quando [si usava ATL e si compilava una DLL].Thread Safe Initialization of local statics was automatically turned off in the XP toolset when [using ATL AND building a DLL]. Questa procedura non è più necessaria.This is no longer the case. È possibile aggiungere /Zc:threadSafeInit- nelle impostazioni del progetto se si desidera disattivare l'inizializzazione thread-safe.You can add /Zc:threadSafeInit- in your Project settings if having thread safe initialization off is desired.

Runtime di Visual C++Visual C++ runtime

  • Nuova intestazione "cfguard.h" per i simboli di protezione del flusso di controllo.New header "cfguard.h" for Control Flow Guard symbols.

IDE C++C++ IDE

  • Le prestazioni di modifica della configurazione sono ora migliori per i progetti nativi C++ e molto migliori per i progetti C++/CLI.Configuration change performance is now better for C++ native projects and much better for C++/CLI projects. La prima attivazione di una configurazione della soluzione è ora più veloce e tutte le attivazioni successive saranno quasi immediate.When a solution configuration is activated for the first time it will now be faster and all subsequent activations of this solution configuration will be almost instantaneous.

Visual Studio 2017 versione 15.3:Visual Studio 2017 version 15.3:

  • Sono state riscritte diverse procedure guidate per il progetto e il codice nello stile basato su finestre di dialogo.Several project and code wizards have been rewritten in the signature dialog style.
  • Aggiungi classe ora avvia direttamente la procedura guidata Aggiungi classe.Add Class now launches the Add Class wizard directly. Tutti gli altri elementi che in precedenza erano disponibili in questa posizione ora sono disponibili in Aggiungi > Nuovo elemento.All of the other items that were previously here are now available under Add > New Item.
  • I progetti Win32 ora sono inclusi nella categoria Desktop di Windows nella finestra di dialogo Nuovo progetto.Win32 projects are now under the Windows Desktop category in the New Project dialog.
  • I modelli Applicazione console di Windows e Applicazione desktop di Windows ora creano i progetti senza visualizzare una procedura guidata.The Windows Console and Desktop Application templates now create the projects without displaying a wizard. Nella stessa categoria ora è presente una nuova Creazione guidata applicazione desktop di Windows, che visualizza le stesse opzioni disponibili in precedenza.There's a new Windows Desktop Wizard now under the same category that displays the same options as before.

Visual Studio 2017 versione 15.5: diverse operazioni C++ che usano il motore IntelliSense per il refactoring e lo spostamento di codice vengono eseguite molto più velocemente.Visual Studio 2017 version 15.5: Several C++ operations that use the IntelliSense engine for refactoring and code navigation run much faster. I numeri seguenti sono basati sulla soluzione di Visual Studio Chromium con i progetti 3500:The following numbers are based on the Visual Studio Chromium solution with 3500 projects:

FunzionalitàFeature Miglioramento delle prestazioniPerformance Improvement
RinominaRename 5.3x5.3x
Modifica firmaChange Signature 4.5x4.5x
Trova tutti i riferimentiFind All References 4.7x4.7x

C++ supporta ora Ctrl+ clic Vai a definizione, semplificando lo spostamento del mouse sulle definizioni.C++ now supports Ctrl+Click GoTo Definition, making mouse navigation to definitions easy. Anche il visualizzatore della struttura appartenente al pacchetto di strumenti di potenziamento della produttività è ora incluso nel prodotto per impostazione predefinita.The Structure Visualizer from the Productivity Power Tools pack is now also included in the product by default.

IntelliSenseIntelliSense

Il nuovo motore di database basato su SQLite viene ora usato per impostazione predefinita.The new SQLite-based database engine is now being used by default. Questo consente di velocizzare le operazioni di database come Vai a definizione e Trova tutti i riferimenti e migliorerà significativamente il tempo di analisi iniziale.This will speed up database operations like Go To Definition and Find All References, and will significantly improve initial solution parse time. L'impostazione è stata spostata in Strumenti > Opzioni > Editor di testo -> C/C++ -> Avanzate. Nelle versioni precedenti si trova in ...C/C++ > Sperimentale.The setting has been moved to Tools | Options | Text Editor | C/C++ | Advanced (it was formerly under ...C/C++ | Experimental).

  • Le prestazioni di IntelliSense sono state migliorate su progetti e file senza intestazioni precompilate. Per le intestazioni nel file corrente verrà creata un'intestazione automatica precompilata.We've improved IntelliSense performance on projects and files not using precompiled headers - an Automatic Precompiled Header will be created for headers in the current file.

  • Sono state aggiunte funzioni di filtro e guida per gli errori di IntelliSense presenti nell'elenco errori.We've added error filtering and help for IntelliSense errors in the error list. È ora possibile fare clic sulla colonna degli errori per applicare un filtro.Clicking on the error column now allows for filtering. È inoltre possibile fare clic su errori specifici o premere F1 per avviare la ricerca online del messaggio di errore.Also, clicking on the specific errors or pressing F1 will launch an online search for the error message.

    Elenco erroriError List

    Elenco errori filtratoError List Filtered

  • È stata aggiunta la possibilità di filtrare per tipo gli elementi dell'elenco dei membri.Added the ability to filter Member List items by kind.

    Filtro elenco membriMember List Filtering

  • È stata aggiunta una nuova funzionalità sperimentale IntelliSense predittivo che fornisce un elenco di risultati filtrato e compatibile con il contesto per l'elenco dei membri.Added a new experimental Predictive IntelliSense feature that provides contextually-aware filtering of what appears in the Member List. Vedere C++ IntelliSense Improvements - Predictive IntelliSense & Filtering (Miglioramenti di IntelliSense per C++ - IntelliSense predittiva e filtri)See C++ IntelliSense Improvements - Predictive IntelliSense & Filtering

  • Trova tutti i riferimenti (MAIUSC+F12) ora consente di spostarsi con facilità, anche nelle codebase complesse.Find All References (Shift+F12) now helps you get around easily, even in complex codebases. Offre funzioni avanzate di raggruppamento, filtro, ordinamento, ricerca all'interno dei risultati e, per alcuni linguaggi, colorazione, che agevolano notevolmente la comprensione dei riferimenti.It provides advanced grouping, filtering, sorting, searching within results, and (for some languages) colorization, so you can get a clear understanding of your references. Per C++ la nuova interfaccia utente include informazioni che indicano se è in corso la lettura o la scrittura in una variabile.For C++, the new UI includes information about whether we are reading from or writing to a variable.

  • La funzionalità IntelliSense "da punto a freccia" è passata dalla fase sperimentale alla fase avanzata ed è ora abilitata per impostazione predefinita.The Dot-to-Arrow IntelliSense feature has been moved from experimental to advanced, and is now enabled by default. Anche le funzionalità di espansione ambito e di espansione precedenza dell'editor sono passate dalla fase sperimentale alla fase avanzata.The editor features Expand Scopes and Expand Precedence have also been moved from experimental to advanced.

  • Le funzionalità di refactoring sperimentale Cambia firma ed Estrai funzione ora sono disponibili per impostazione predefinita.The experimental refactoring features Change Signature and Extract Function are now available by default.

  • La funzionalità sperimentale per il caricamento più rapido dei progetti C++.The experimental feature for C++ projects 'Faster project load'. Alla successiva apertura di un progetto C++, questo verrà caricato più velocemente e la volta successiva ciò avverrà in modo rapidissimo.The next time you open a C++ project it will load faster, and the time after that it will load really fast!

Alcune di queste funzionalità sono usate anche in altri linguaggi e alcune sono specifiche di C++.Some of these features are common to other languages, and some are specific to C++. Per altre informazioni su queste nuove funzionalità, vedere il post che annuncia Visual Studio "15".For more information about these new features, see Announcing Visual Studio “15”.

Progetti non MSBuild con Apri cartellaNon-MSBuild projects with Open Folder

Visual Studio 2017 introduce la funzionalità "Apri cartella", che consente di codificare, compilare ed eseguire il debug in un cartella contenente il codice sorgente senza dover creare soluzioni o progetti.Visual Studio 2017 introduces the “Open Folder” feature, which enables you to code, build and debug in a folder containing source code without the need to create any solutions or projects. Questo rende molto più semplice iniziare a usare Visual Studio anche se il progetto non è un progetto basato su MSBuild.This makes it much simpler to get started with Visual Studio even if your project is not an MSBuild-based project. Con "Apri cartella" è possibile accedere alle potenti funzionalità per la comprensione, la modifica, la compilazione e il debug del codice già offerte da Visual Studio per i progetti MSBuild.With “Open Folder” you get access to the powerful code understanding, editing, building and debugging capabilities that Visual Studio already provides for MSBuild projects. Per altre informazioni, vedere Open Folder projects in Visual C++ (Aprire una cartella di progetti in Visual C++).For more information, see Open Folder projects in Visual C++.

  • Sono stati apportati miglioramenti all'esperienza Apri cartella.Improvements to the Open Folder experience. È possibile personalizzare l'esperienza usando i file JSON seguenti:You can customize the experience through these json files:
    • CppProperties.json per personalizzare l'esperienza IntelliSense e di esplorazione.CppProperties.json to customize the IntelliSense and browsing experience.
    • Tasks.json per personalizzare le procedure di compilazione.Tasks.json to customize the build steps.
    • Launch.json per personalizzare l'esperienza di debug.Launch.json to customize the debugging experience.

Visual Studio 2017 versione 15.3:Visual Studio 2017 version 15.3:

  • Supporto migliorato per i compilatori alternativi e gli ambienti di compilazione, come MinGW e Cygwin.Improved support for alternative compilers and build environments such as MinGW and Cygwin. Per altre informazioni, vedere Using MinGW and Cygwin with Visual C++ and Open Folder (Uso di MinGW e Cygwin con Visual C++ e Apri cartella).For more information, see Using MinGW and Cygwin with Visual C++ and Open Folder.
  • È stato aggiunto il supporto per la definizione di variabili di ambiente globali e specifiche della configurazione in "CppProperties.json" e "CMakeSettings.json".Added support to define global and configuration specific environment variables in "CppProperties.json" and "CMakeSettings.json". Queste variabili di ambiente possono essere usate dalle configurazioni di debug definite in "launch.vs.json" e dalle attività in "tasks.vs.json".These environment variables can be consumed by debug configurations defined in "launch.vs.json" and tasks in "tasks.vs.json". Per altre informazioni, vedere Customizing your Environment with Visual C++ and Open Folder (Personalizzazione dell'ambiente in uso con Visual C++ e Apri cartella).For more information, see Customizing your Environment with Visual C++ and Open Folder.
  • È stato migliorato il supporto del generatore Ninja di CMake, inclusa la possibilità di creare facilmente codice destinato alle piattaforme a 64 bit.Improved support for CMake's Ninja generator, including the ability to easily target 64-bit platforms.

Supporto CMake con Apri cartellaCMake support via Open Folder

Visual Studio 2017 introduce il supporto per l'uso dei progetti CMake senza la conversione in file di progetto di MSBuild (con estensione vcxproj).Visual Studio 2017 introduces support for using CMake projects without converting to MSBuild project files (.vcxproj). Per altre informazioni, vedere Progetti CMake in Visual C++.For more information, see CMake projects in Visual C++. Se si aprono i progetti CMake con "Apri cartella", l'ambiente viene automaticamente configurato per la modifica, la compilazione e il debug in C++.Opening CMake projects with “Open Folder” will automatically configure the environment for C++ editing, building and debugging.

  • IntelliSense C++ funzionerà senza necessità di creare un file CppProperties.json nella cartella radice.C++ IntelliSense will work without the need to create a CppProperties.json file in the root folder. È stato anche aggiunto un nuovo elenco a discesa per consentire agli utenti di passare facilmente tra le configurazioni fornite dai file CMake e CppProperties.json.Along with this, we've added a new dropdown to allow users to easily switch between configurations provided by CMake and CppProperties.json files.

  • Supporto per configurazione aggiuntiva tramite un file CMakeSettings.json che si trova nella stessa cartella del file CMakeLists.txt.Further configuration is supported via a CMakeSettings.json file that sits in the same folder as the CMakeLists.txt file.

    Apri cartella CmakeCmake Open Folder

Visual Studio 2017 versione 15.3: è stato aggiunto il supporto per il generatore Ninja CMake.Visual Studio 2017 version 15.3: Support added for the CMake Ninja generator. Per altre informazioni, vedere Progetti CMake in Visual C++.For more information, see CMake projects in Visual C++.

Visual Studio 2017 versione 15.5: aggiunto il supporto per l'importazione di cache CMake esistenti.Visual Studio 2017 version 15.5: Support added for importing existing CMake caches. Per altre informazioni, vedere Progetti CMake in Visual C++.For more information, see CMake projects in Visual C++.

Sviluppo per Windows Desktop con C++Windows desktop development with C++

È ora disponibile un'esperienza più granulare per l'installazione del carico di lavoro per C++ originario.We now provide a more granular installation experience for installing the original C++ workload. Sono stati aggiunti componenti selezionabili che consentono di installare solo gli strumenti necessari.We have added selectable components that enable you to install just the tools that you need. Si noti che le dimensioni di installazione indicate per i componenti elencati nell'interfaccia utente del programma di installazione non sono precise e sottovalutano la dimensione totale.Please note that the indicated installation sizes for the components listed in the installer UI are not accurate and underestimate the total size.

Per creare progetti Win32 nel carico di lavoro per desktop C++, è necessario installare un set di strumenti e un SDK Windows.To successfully create Win32 projects in the C++ desktop workload, you must install both a toolset and a Windows SDK. L'installazione dei componenti consigliati (selezionati) "Set di strumenti VC++ 2017 versione 141 (x86, x64)" e "Windows 10 SDK (10.0.14393)" ne garantirà il funzionamento.Installing the recommended (selected) components “VC++ 2017 v141 toolset (x86, x64)” and “Windows 10 SDK (10.0.14393)” will ensure this will work. Se gli strumenti necessari non vengono installati, i progetti non verranno creati e la procedura guidata verrà interrotta.If the necessary tools are not installed, projects will not be created successfully and the wizard will hang.

Visual Studio 2017 versione 15.5: gli strumenti di compilazione di Visual C++ (in precedenza disponibili come prodotto autonomo) sono ora inclusi come carico di lavoro nel programma di installazione di Visual Studio.Visual Studio 2017 version 15.5: The Visual C++ Build tools (previously available as a standalone product) are now included as a workload in the Visual Studio Installer. Questo carico di lavoro installa solo gli strumenti necessari per compilare progetti C++ senza installare l'IDE di Visual Studio.This workload installs only the tools required to build C++ projects without installing the Visual Studio IDE. Sono inclusi entrambi i set di strumenti v140 e v141.Both the v140 and v141 toolsets are included. Il set di strumenti v141 contiene i miglioramenti più recenti di Visual Studio 2015 versione 15.5.The v141 toolset contains the lastest improvements in Visual Studio 2015 version 15.5. Per altre informazioni, vedere Visual Studio Build Tools now include the VS2017 and VS2015 MSVC Toolset (Gli strumenti di compilazione di Visual Studio ora includono i set di strumenti MSVC di VS2017 e VS2015).For more information, see Visual Studio Build Tools now include the VS2017 and VS2015 MSVC Toolsets.

Sviluppo di applicazioni Linux con C++Linux development with C++

L'estensione comune Visual C++ for Linux Development ora fa parte di Visual Studio.The popular extension Visual C++ for Linux Development is now part of Visual Studio. Questa installazione include tutto il necessario per lo sviluppo e il debug di applicazioni C++ in esecuzione in un ambiente Linux.This installation provides everything you need to develop and debug C++ applications running on a Linux environment.

Visual Studio 2017 versione 15.2: miglioramenti per la condivisione del codice tra piattaforme e per la visualizzazione dei tipi.Visual Studio 2017 version 15.2: Improvements for cross-platform code sharing and type visualization. Per altre informazioni vedere, Linux C++ improvements for cross-platform code sharing and type visualization (Miglioramenti di Linux C++ per la condivisione del codice tra piattaforme e per la visualizzazione dei tipi).For more information, see Linux C++ improvements for cross-platform code sharing and type visualization.

Visual Studio 2017 versione 15.5:Visual Studio 2017 version 15.5:

  1. Il carico di lavoro di Linux ha aggiunto il supporto per rsync come alternativa a sftp per la sincronizzazione dei file nei computer remoti di Linux.The Linux workload has added support for rsync as an alternative to sftp for synchronizing files to remote Linux machines.
  2. È stato aggiunto il supporto per la compilazione trasversale mirata ai microcontroller ARM.Support is added for cross compilation targeting ARM microcontrollers. Per abilitarlo durante l'installazione, scegliere lo sviluppo di Linux con carico di lavoro di C++ e selezionare l'opzione Sviluppo incorporato e IoT.To enable this in the installation choose the Linux development with C++ workload and select the option for Embedded and IoT Development. In questo modo vengono aggiunti gli strumenti di compilazione incrociata ARM GCC e Make all'installazione.This adds the ARM GCC cross compilation tools and Make to your installation. Per altre informazioni, vedere ARM GCC Cross Compilation in Visual Studio (Compilazione incrociata GCC ARM in Visual Studio).For more information, see ARM GCC Cross Compilation in Visual Studio.
  3. Supporto aggiunto per CMake.Support added for CMake. È ora possibile lavorare sulla base di codice CMake esistente senza la necessità di convertirlo in un progetto di Visual Studio.You can now work on your existing CMake code base without having to convert it to a Visual Studio project. Per altre informazioni, vedereConfigurare un progetto CMake Linux.For more information, see Configure a Linux CMake Project.
  4. Supporto aggiunto per l'esecuzione di attività remote.Support added for running remote tasks. Questa funzionalità consente di eseguire qualsiasi comando in un sistema remoto definito nella gestione connessione di Visual Studio.This capability allows you to run any command on a remote system that is defined in Visual Studio’s Connection Manager. Le attività remote consentono anche di copiare i file nel sistema remoto.Remote tasks also provide the capability to copy files to the remote system.

Sviluppo di giochi con C++Game development with C++

Usare tutta la potenza di C++ per compilare giochi professionali con tecnologia DirectX o Cocos2d.Use the full power of C++ to build professional games powered by DirectX or Cocos2d.

Sviluppo di applicazioni per dispositivi mobili con C++ (Android e iOS)Mobile development with C++ (Android and iOS)

Usando Visual Studio è ora possibile creare app per dispositivi mobili destinate ad Android e iOS ed eseguirne il debug.You can now create and debug mobile apps using Visual Studio that can target Android and iOS.

App di Windows universaleUniversal Windows Apps

C++ viene fornito come componente facoltativo del carico di lavoro per lo sviluppo di app di Windows universale.C++ comes as an optional component for the Universal Windows App workload. Attualmente l'aggiornamento di progetti C++ deve essere eseguito manualmente.Upgrading C++ projects currently must be done manually. Quando si apre un progetto UWP destinato a v140 in Visual Studio 2017, se Visual Studio 2015 non è installato è necessario selezionare il set di strumenti della piattaforma v141 nelle pagine delle proprietà del progetto.If you open a v140-targeted UWP project in Visual Studio 2017, you need to select the v141 platform toolset in the project property pages if you do not have Visual Studio 2015 installed.

Nuove opzioni per C++ nella piattaforma UWP (Universal Windows Platform)New options for C++ on Universal Windows Platform (UWP)

Sono ora disponibili nuove opzioni per la scrittura e la creazione di pacchetti di applicazioni C++ per la piattaforma UWP e Windows Store: è possibile usare Desktop App Converter per creare un pacchetto dell'applicazione desktop esistente per la distribuzione nel Windows Store.You now have new options for writing and packaging C++ applications for the Universal Windows Platform and the Windows Store: You can use the Desktop App Converter to package your existing desktop application for deployment through the Windows Store. Per altre informazioni, vedere i post relativi all'uso del runtime di Visual C++ nel progetto Centennial e al trasferimento dell'app desktop sulla piattaforma UWP con Desktop Bridge.For more information, see Using Visual C++ Runtime in Centennial project and Bring your desktop app to the Universal Windows Platform (UWP) with the Desktop Bridge.

Visual Studio 2017 versione 15.5Visual Studio 2017 version 15.5
Viene aggiunto un modello di Progetto di creazione di pacchetti di applicazioni Windows che supporta le applicazioni desktop di creazione pacchetti tramite Desktop Bridge.A Windows Application Packaging Project project template is added which supports packaging desktop applications by using Desktop Bridge. È disponibile in File > Nuovo > Progetto > Installato > Visual C++ > Piattaforma UWP.It is available under File | New | Project | Installed | Visual C++ | Universal Windows Platform.

Quando si scrive nuovo codice, ora è possibile usare C++/WinRT, una proiezione standard del linguaggio C++ per Windows Runtime implementata esclusivamente nei file di intestazione.When writing new code, you can now use C++/WinRT, a standard C++ language projection for the Windows Runtime implemented solely in header files. Consente sia di creare che di consumare le API di Windows Runtime usando qualsiasi compilatore C++ conforme agli standard.It allows you to both author and consume Windows Runtime APIs using any standards-compliant C++ compiler. C++/WinRT è progettato per offrire agli sviluppatori C++ un accesso di prima classe all'API Windows moderna.C++/WinRT is designed to provide C++ developers with first-class access to the modern Windows API. Per altre informazioni, vedere il post sulla disponibilità di C++/WinRT su GitHub.For more information, see C++/WinRT Available on GitHub.

A partire dal build 17025 di Windows SDK Insider Preview, C++/WinRT è incluso in Windows SDK.As of build 17025 of the Windows SDK Insider Preview, C++/WinRT is included in the Windows SDK. Per altre informazioni, vedere C++/WinRT is now included the Windows SDK (C++/WinRT ora incluso in Windows SDK).For more information, see C++/WinRT is now included the Windows SDK.

Set di strumenti della piattaforma Clang/C2Clang/C2 platform toolset

Il set di strumenti Clang/C2 incluso in Visual Studio 2017Visual Studio 2017 supporta ora l'opzione /bigobj, essenziale per lo sviluppo di progetti di grandi dimensioni.The Clang/C2 toolset that ships with Visual Studio 2017Visual Studio 2017 now supports the /bigobj switch, which is crucial for building large projects. Include inoltre alcune importanti correzioni di bug sia sul front-end che sul back-end del compilatore.It also includes several important bug fixes, both in the front-end and the back-end of the compiler.

Analisi del codice C++C++ code analysis

I controlli di base per C++ per l'applicazione delle C++ Core Guidelines (Linee guida di base per C++) ora sono distribuiti con Visual Studio.The C++ Core Checkers for enforcing the C++ Core Guidelines are now distributed with Visual Studio. È sufficiente abilitare i controlli nella finestra di dialogo delle estensioni di analisi del codice nelle pagine di proprietà del progetto per includere le estensioni durante l'esecuzione dell'analisi del codice.Simply enable the checkers in the Code Analysis Extensions dialog in the project's property pages and the extensions will be included when you run code analysis. Per altre informazioni, vedere Using the C++ Core Guidelines checkers (Uso dei controlli delle linee guida di base per C++).For more information, see Using the C++ Core Guidelines checkers.

CppCoreCheckCppCoreCheck

Visual Studio 2017 versione 15.3: è stato aggiunto il supporto di regole correlate alla gestione delle risorse.Visual Studio 2017 version 15.3: Support added for rules related to resource management.

Visual Studio 2017 versione 15.5: i nuovi controlli delle linee guida di base di C++ riguardano la correttezza del puntatore intelligente, l'uso corretto degli inizializzatori globali e gli usi flag dei costrutti come goto e bad cast.Visual Studio 2017 version 15.5: New C++ Core Guidelines checks cover smart pointer correctness, correct use of global initializers, and flagging uses of constructs like goto and bad casts.
Alcuni numeri di avviso che potrebbero essere presenti in 15.3 non sono più disponibili in 15.5.Some warning numbers you may find in 15.3 are no longer available in 15.5. Questi avvisi sono stati sostituiti con controlli più specifici.These warnings were replaced with more specific checks.

Testing unitàUnit testing

Visual Studio 2017 versione 15.5: sono ora disponibili Test Adapter for Google Test e Adattatore di test per Boost.Test come componenti dello sviluppo Desktop con C++ e sono integrati con Esplora test.Visual Studio 2017 version 15.5: Google Test Adapter and Boost.Test Adapter are now available as components of the Desktop Development with C++ and are integrated with Test Explorer. Viene aggiunto il supporto CTest per i progetti Cmake (tramite Apri cartella) sebbene non sia ancora disponibile l'integrazione completa con Esplora test.CTest support is added for Cmake projects (using Open Folder) although full integration with Test Explorer is not yet available. Per altre informazioni, vedere Scrittura di unit test per C/C++.For more information, see Writing unit tests for C/C++.

Diagnostica della grafica di Visual StudioVisual Studio graphics diagnostics

Diagnostica della grafica di Visual Studio è un set di strumenti per la registrazione e l'analisi dei problemi di prestazioni e di rendering nelle app Direct3D.Visual Studio Graphics Diagnostics is a set of tools for recording and analyzing rendering and performance problems in Direct3D apps. Le funzionalità di Diagnostica della grafica possono essere usate con app eseguite localmente in un computer Windows, in un emulatore di dispositivo Windows oppure in un computer o un dispositivo remoto.Graphics Diagnostics features can be used with apps that are running locally on your Windows PC, in a Windows device emulator, or on a remote PC or device.

  • Input e output per vertex e geometry shader: la possibilità di visualizzare input e output di vertex shader e geometry shader era una delle funzionalità più richieste ed è ora supportata negli strumenti.Input & Output for Vertex and Geometry shaders: The ability to view input and output of vertex shaders and geometry shaders has been one of the most requested features, and it is now supported in the tools. È sufficiente selezionare la fase VS o GS nella visualizzazione Fasi pipeline per avviare la verifica dell'input e dell'output nella tabella che segue.Simply select the VS or GS stage in the Pipeline Stages view to start inspecting its input and output in the table below.

    Input/output per shader

  • Ricerca e filtro nella tabella degli oggetti: un modo rapido e semplice per individuare le risorse che si stanno cercando.Search and filter in the object table: Provides a quick and easy way to find the resources you're looking for.

    Cerca

  • Cronologia risorse: consente di visualizzare con facilità l'intera cronologia delle modifiche di una risorsa usata durante il rendering di un frame acquisito.Resource History: This new view provides a streamlined way of seeing the entire modification history of a resource as it was used during the rendering of a captured frame. Per richiamare la cronologia per una risorsa, basta fare clic sull'icona orologio accanto al collegamento ipertestuale della risorsa.To invoke the history for any resource, simply click the clock icon next to any resource hyperlink.

    Cronologia risorse

    Viene visualizzata la nuova finestra dello strumento Cronologia risorse, che contiene la cronologia delle modifiche della risorsa.This will display the new Resource History tool window, populated with the change history of the resource.

    Modifica della cronologia delle risorse

    Notare che se il frame è stato acquisito con l'acquisizione dello stack di chiamate completo abilitata (Visual Studio > Strumenti > Opzioni > Diagnostica della grafica), il contesto di ogni evento di modifica può essere rapidamente dedotto e verificato all'interno del progetto di Visual Studio.Note that if your frame was captured with full call stack capturing enabled (Visual Studio | Tools | Options | Graphics Diagnostics), then the context of each change event can be quickly deduced and inspected within your Visual Studio project.

  • Statistiche API: consente di visualizzare un riepilogo dettagliato dell'utilizzo dell'API nel frame.API Statistics: View a high-level summary of API usage in your frame. Può essere utile per individuare chiamate che si stanno effettuando senza saperlo o chiamate che si effettuano in quantità eccessiva.This can be handy in discovering calls you may not realize you’re making at all or calls you are making too much. Questa finestra è disponibile da Visualizza > Statistiche API in Analizzatore grafica di Visual Studio.This window is available via View | API Statistics in Visual Studio Graphics Analyzer.

    Statistiche API

  • Statistiche memoria: consente di visualizzare la quantità di memoria allocata dal driver per le risorse create nel frame.Memory Statistics: View how much memory the driver is allocating for the resources you create in the frame. Questa finestra è disponibile da Visualizza > Statistiche memoria in Analizzatore grafica di Visual Studio.This window is available via View | Memory Statistics in Visual Studio Graphics Analyzer. I dati possono essere copiati in un file CSV per la visualizzazione in un foglio di calcolo facendo clic con il pulsante destro e scegliendo Copia tutto.Data can be copied to a CSV file for viewing in a spreadsheet by right clicking and choosing Copy All.

    Statistiche memoria

  • Convalida frame: il nuovo elenco di errori e avvisi consente di spostarsi con facilità nell'elenco di eventi in base a potenziali problemi rilevati dal livello di debug Direct3D.Frame Validation: The new errors and warnings list provides an easy way to navigate your event list based on potential issues detected by the Direct3D debug layer. Fare clic su Visualizza-> Convalida frame in Analizzatore grafica di Visual Studio per aprire la finestra.Click View | Frame Validation in Visual Studio Graphics Analyzer to open the window. Quindi fare clic su Esegui convalida per avviare l'analisi.Then click Run Validation to start the analysis. L'operazione può richiedere alcuni minuti, a seconda della complessità del frame.It can take several minutes to complete, depending on the frame's complexity.

    Convalida frame

  • Analisi dei frame per D3D12: usare Analisi dei Frame per analizzare le prestazioni delle chiamate di disegno con esperimenti di simulazione diretti.Frame Analysis for D3D12: Use Frame Analysis to analyze draw call performance with directed “what-if” experiments. Passare alla scheda Analisi dei frame ed eseguire l'analisi per visualizzare il report.Switch to the Frame Analysis tab and run analysis to view the report. Per informazioni dettagliate, guardare il video GoingNative 25 sull'analisi dei frame di grafica di Visual Studio.For more details, watch the GoingNative 25: Visual Studio Graphics Frame Analysis video.

    Analisi dei frame

  • Miglioramenti dell'utilizzo della GPU: aprire le tracce eseguite con il profiler Utilizzo GPU di Visual Studio dalla visualizzazione GPU o con lo strumento Windows Performance Analyzer (WPA) per eseguire analisi più dettagliate.GPU Usage Improvements: Open traces taken via the Visual Studio GPU Usage profiler with either GPU View or the Windows Performance Analyzer (WPA) tool for more detailed analysis. Se Windows Performance Toolkit è installato, sono disponibili due collegamenti ipertestuali, uno per WPA e altro per la visualizzazione GPU, in basso a destra nella panoramica della sessione.If you have the Windows Performance Toolkit installed there will be two hyperlinks, one for WPA and other for GPU View, at the bottom right of the session overview.

    Utilizzo GPU

    Le tracce aperte nella visualizzazione GPU usando questo collegamento supportano lo zoom e la panoramica sincronizzati nella sequenza temporale tra Visual Studio e la visualizzazione GPU.Traces opened in GPU View via this link support synchronized zooming and panning in the timeline between VS and GPU View. Viene usata una casella di controllo in Visual Studio per verificare se la sincronizzazione è abilitata o meno.A checkbox in VS is used to control whether synchronization is enabled or not.

    Visualizzazione GPU