Cronologia delle modifiche di Visual C++ dal 2003 al 2015Visual C++ change history 2003 - 2015

Questo articolo descrive tutte le modifiche di rilievo apportate in Visual Studio dalla versione 2003 alla 2015, in ordine cronologico inverso. I termini "nuovo comportamento" o "ora" fanno riferimento a Visual Studio 2015 e versioni successive.This article describes all the breaking changes from Visual Studio 2015 going back to Visual Studio 2003, and in this article the terms "new behavior" or "now" refer to Visual Studio 2015 and later. I termini "vecchio comportamento" e "prima" fanno riferimento a Visual Studio 2013 e alle versioni precedenti.The terms "old behavior" and "before" refer to Visual Studio 2013 and earlier releases.

Per informazioni su Visual Studio 2017, vedere Novità di Visual C++ in Visual Studio 2017 e Miglioramenti della conformità di Visual C++ in Visual Studio 2017.For information about Visual Studio 2017, see What's new for Visual C++ in Visual Studio 2017 and Conformance Improvements in Visual C++ in Visual Studio 2017.

Nota

Non sono state apportate modifiche binarie di rilevo tra Visual Studio 2015 e Visual Studio 2017.There are no binary breaking changes between Visual Studio 2015 and Visual Studio 2017.

Quando si esegue l'aggiornamento a una nuova versione di Visual Studio, potrebbero verificarsi errori di compilazione e/o runtime nel codice precedentemente compilato ed eseguito correttamente.When you upgrade to a new version of Visual Studio, you might encounter compilation and/or runtime errors in code that previously compiled and ran correctly. Le modifiche apportate alla nuova versione che provocano questi problemi sono note come modifiche importantie in genere sono richieste dalle modifiche nel linguaggio C++ standard, nelle firme di funzione o nel layout degli oggetti in memoria.Changes in the new version that cause such problems are known as breaking changes, and typically they're required by modifications in the C++ language standard, function signatures, or the layout of objects in memory.

Per evitare errori di runtime difficili da rilevare e diagnosticare, è consigliabile non collegarsi mai in modo statico a file binari compilati usando versioni diverse del compilatore.To avoid run-time errors that are difficult to detect and diagnose, we recommend that you never statically link to binaries that were compiled by using different versions of the compiler. Inoltre, quando si esegue l'aggiornamento a un progetto EXE o DLL, assicurarsi di aggiornare anche le librerie collegate.Also, when you upgrade an EXE or DLL project, make sure to upgrade the libraries that it links to. Se si usano tipi CRT (runtime C) o C++ Standard Library (libreria di C++ standard), non passarli tra file binari (inclusi DLL) compilati usando versioni diverse del compilatore.If you're using CRT (C Runtime) or C++ Standard Library (C++ Standard Library) types, don't pass them between binaries (including DLLs) that were compiled by using different versions of the compiler. Per altre informazioni, vedere Potenziali errori di passaggio di oggetti CRT attraverso i limiti DLL.For more information, see Potential Errors Passing CRT Objects Across DLL Boundaries.

È inoltre consigliabile non scrivere mai codice che dipende da un layout specifico per un oggetto diverso da un'interfaccia COM o un oggetto POD.We further recommend that you never write code that depends on a particular layout for an object that is not a COM interface or a POD object. Se si scrive codice di questo tipo, è necessario assicurarsi che funzioni dopo l'aggiornamento.If you do write such code, then you must ensure that it works after you upgrade. Per altre informazioni, vedere Portabilità in base ai limiti ABI.For more information, see Portability At ABI Boundaries.

I miglioramenti apportati in modo costante alla conformità del compilatore possono talvolta modificare il modo in cui il compilatore riconosce il codice sorgente esistente.Additionally, ongoing improvements to compiler conformance can sometimes change how the compiler understands your existing source code. In questo caso, si possono riscontrare errori nuovi o diversi durante la compilazione o addirittura differenze di comportamento nel codice che apparentemente in precedenza veniva compilato ed eseguito correttamente.When this happens, you might encounter new or different errors during your build, or even behavioral differences in code that previously built and seemed to run correctly. Anche se queste modifiche non sono importanti come quelle descritte in questo documento, è possibile che sia necessario modificare il codice sorgente per risolvere questi problemi.Although these are not breaking changes like the ones discussed in this document, source code changes might be needed to resolve these issues.

  1. Modifiche importanti apportate alla libreria di runtime C (CRT)C Runtime (CRT) Library Breaking Changes

  2. Modifiche importanti apportate a C++ standard e alla libreria di C++ standardStandard C++ and C++ Standard Library Breaking Changes

  3. Modifiche importanti apportate a MFC e ATLMFC and ATL Breaking Changes

  4. Modifiche importanti apportate al runtime di concorrenzaConcurrency Runtime Breaking Changes

Modifiche della conformità di Visual C++ 2015Visual C++ 2015 Conformance Changes

Libreria di runtime C (CRT)C Runtime Library (CRT)

Modifiche generaliGeneral Changes

  • File binari di refactoring La libreria CRT è stata sottoposta a refactoring in un due diversi file binari, CRT universale (ucrtbase), che contiene la maggior parte delle funzionalità standard, e una libreria di Runtime VC (vcruntime), che contiene le funzionalità relative al compilatore, ad esempio la gestione delle eccezioni e le funzioni intrinseche.Refactored binaries The CRT Library has been refactored into a two different binaries, a Universal CRT (ucrtbase), which contains most of the standard functionality, and a VC Runtime Library (vcruntime), which contains the compiler-related functionality, such as exception handling, and intrinsics. Se si usano le impostazioni di progetto predefinite, questa modifica non influisce in alcun modo poiché il linker userà le nuove librerie predefinite.If you are using the default project settings, then this change does not impact you since the linker will use the new default libraries automatically. Se è stata impostata la proprietà Linker del progetto Ignora tutte le librerie predefinite su o si usa l'opzione del linker /NODEFAULTLIB nella riga di comando, è necessario aggiornare l'elenco delle librerie (nella proprietà Dipendenze aggiuntive ) per includere le nuove librerie di refactoring.If you have set the project's Linker property Ignore All Default Libraries to Yes or you are using the /NODEFAULTLIB linker option on the command line, then you must update your list of libraries (in the Additional Dependencies property) to include the new, refactored libraries. Sostituire la libreria CRT precedente (libcmt.lib, libcmtd.lib, msvcrt.lib, msvcrtd.lib) con le librerie di refactoring equivalenti.Replace the old CRT library (libcmt.lib, libcmtd.lib, msvcrt.lib, msvcrtd.lib) with the equivalent refactored libraries. Per ognuna delle due librerie di refactoring, esistono versioni statiche (con estensione lib) e dinamiche (con estensione dll) e versioni di rilascio (senza alcun suffisso) e di debug (con il suffisso "d").For each of the two refactored libraries, there are static (.lib) and dynamic (.dll) versions, and release (with no suffix) and debug versions (with the "d" suffix). Le versioni dinamiche hanno una libreria di importazione con cui collegarsi.The dynamic versions have an import library that you link with. Due librerie di refactoring sono CRT universali, in particolare ucrtbase.dll o .lib, ucrtbased.dll o .lib e la libreria di runtime VC ibvcruntime.lib, vcruntimeversione.dll, libvcruntimed.lib e vcruntimedversione.dll.The two refactored libraries are Universal CRT, specifically ucrtbase.dll or .lib, ucrtbased.dll or .lib, and the VC runtime library, libvcruntime.lib, vcruntimeversion.dll, libvcruntimed.lib, and vcruntimedversion.dll. versione sia in Visual Studio 2015 che in Visual Studio 2017 è 140.The version in both Visual Studio 2015 and Visual Studio 2017 is 140. Vedere Funzionalità libreria CRT.See CRT Library Features.

<locale.h><locale.h>

  • localeconv La funzione localeconv dichiarata in locale.h ora funziona correttamente quando sono abilitate le impostazioni locali dei singoli thread.localeconv The localeconv function declared in locale.h now works correctly when per-thread locale is enabled. Nelle versioni precedenti della libreria, questa funzione restituisce i dati lconv per le impostazioni locali globali, non per le impostazioni locali del thread.In previous versions of the library, this function would return the lconv data for the global locale, not the thread's locale.

    Se si usano le impostazioni locali per thread, è necessario controllare l'uso di localeconv per vedere se il codice suppone che i dati lconv restituiti siano per le impostazioni locali globali e modificarli in modo appropriato.If you use per thread locale, you should check your use of localeconv to see if your code assumes that the lconv data returned is for the global locale and modify it appropriately.

<math.h><math.h>

  • Overload di C++ di funzioni della libreria matematica Nelle versioni precedenti <math.h> definiva alcuni, ma non tutti, overload di C++ per le funzioni della libreria matematica.C++ overloads of math library functions In previous versions, <math.h> defined some, but not all, of the C++ overloads for the math library functions. <cmath> definiva gli overload rimanenti, in modo da ottenere tutti gli overload, di cui uno necessario per includere l'intestazione <cmath>.<cmath> defined the remaining overloads, so to get all of the overloads, one needed to include the <cmath> header. Ciò causava problemi con la risoluzione di overload della funzione nel codice che includeva solo <math.h>.This led to problems with function overload resolution in code that only included <math.h>. Ora, tutti gli overload di C++ sono stati rimossi da <math.h> e ora sono presenti solo in <cmath>.Now, all C++ overloads have been removed from <math.h> and are now present only in <cmath>.

    Per risolvere gli errori, includere per ottenere le dichiarazioni delle funzioni che sono state rimosse da <math.h>.To resolve errors, include to get the declarations of the functions that were removed from <math.h>. La tabella seguente elenca le funzioni che sono state spostate.The following table lists the functions that were moved.

    Funzioni che sono state spostate:Functions that were moved:

    1. double abs(double) e float abs(float)double abs(double) and float abs(float)

    2. double pow (double, int), float pow (float, float) float pow (float, int) long double pow (long double, long double), long double pow (long double, int)double pow(double, int), float pow(float, float), float pow(float, int), long double pow(long double, long double), long double pow(long double, int)

    3. versioni float e long double di funzioni a virgola mobile acos, acosh, asin, asinh, atan, atanh, atan2, cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp2, expm1, fabs, fdim, floor, fma, fmax, fmin, fmod, frexp, hypot, ilogb, ldexp, lgamma, llrint, llround, log, log10, log1p, log2, lrint, lround, modf, nearbyint, nextafter, nexttoward, remainder, remquo, rint, round, scalbln, scalbn, sin, sinh, sqrt, tan, tanh, tgamma, truncfloat and long double versions of floating point functions acos, acosh, asin, asinh, atan, atanh, atan2, cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp2, expm1, fabs, fdim, floor, fma, fmax, fmin, fmod, frexp, hypot, ilogb, ldexp, lgamma, llrint, llround, log, log10, log1p, log2, lrint, lround, modf, nearbyint, nextafter, nexttoward, remainder, remquo, rint, round, scalbln, scalbn, sin, sinh, sqrt, tan, tanh, tgamma, trunc

      Se si dispone di codice che usa abs con un tipo a virgola mobile che include solo l'intestazione math.h, le versioni a virgola mobile non saranno più disponibili, pertanto la chiamata, anche con un argomento a virgola mobile, a questo punto si risolve in abs(int).If you have code that uses abs with a floating point type that only includes the math.h header, the floating point versions will no longer be available, so the call, even with a floating point argument, now resolves to abs(int). In questo modo si produce l'errore:This produces the error:

    warning C4244: 'argument' : conversion from 'float' to 'int', possible loss of data  
    

    La correzione per questo avviso consiste nel sostituire la chiamata a abs con una versione a virgola mobile di abs, ad esempio fabs per un argomento double o fabsf per un argomento float o includere l'intestazione cmath e continuare a usare abs.The fix for this warning is to replace the call to abs with a floating point version of abs, such as fabs for a double argument or fabsf for a float argument, or include the cmath header and continue to use abs.

  • Conformità del punto a virgola mobile Sono state apportate numerose modifiche alla libreria matematica per migliorare la conformità alle specifiche IEEE 754 e C11 allegato F rispetto all'input per casi speciali, ad esempio NaN e infiniti.Floating point conformance Many changes to the math library have been made to improve conformance to the IEEE-754 and C11 Annex F specifications with respect to special case inputs such as NaNs and infinities. Ad esempio, gli input NaN non interattivi, che spesso venivano considerati errori nelle versioni precedenti della libreria, non vengono più considerati errori.For example, quiet NaN inputs, which were often treated as errors in previous versions of the library, are no longer treated as errors. Vedere Standard IEEE 754 e l'allegato F dello Standard C11.See IEEE 754 Standard and Annex F of the C11 Standard.

    Queste modifiche non provocheranno errori in fase di compilazione, ma potrebbero causare un comportamento diverso da parte dei programmi, sebbene più corretto in base allo standard.These changes won't cause compile-time errors, but might cause programs to behave differently and more correctly according to the standard.

  • FLT_ROUNDS In Visual Studio 2013 la macro FLT_ROUNDS veniva espansa in un'espressione costante, che non era corretta perché la modalità di arrotondamento è configurabile al runtime, ad esempio chiamando fesetround.FLT_ROUNDS In Visual Studio 2013, the FLT_ROUNDS macro expanded to a constant expression, which was incorrect because the rounding mode is configurable at runtime, for example, by calling fesetround. La macro FLT_ROUNDS è ora dinamica e riflette in modo corretto la modalità di arrotondamento corrente.The FLT_ROUNDS macro is now dynamic and correctly reflects the current rounding mode.

<new> e <new.h><new> and <new.h>

  • new e delete Nelle versioni precedenti della libreria le funzioni dell'operatore new e delete definito dall'implementazione venivano esportate dalla libreria di runtime DLL (ad esempio, msvcr120.dll).new and delete In previous versions of the library, the implementation-defined operator new and delete functions were exported from the runtime library DLL (for example, msvcr120.dll). Queste funzioni operatore ora sono sempre collegate staticamente nei file binari, anche quando si usano le DLL della libreria di runtime.These operator functions are now always statically linked into your binaries, even when using the runtime library DLLs.

    Non si tratta di una modifica rilevante per il codice misto o nativo (/clr), tuttavia per il codice compilato come /clr:pure potrebbe causare un errore di compilazione da parte del codice.This is not a breaking change for native or mixed code (/clr), however for code compiled as /clr:pure, this might cause your code to fail to compile. Se si compila codice come /clr:pure, può essere necessario aggiungere #include <new> o #include <new.h> per risolvere errori di compilazione dovuti a questa modifica.If you compile code as /clr:pure, you may need to add #include <new> or #include <new.h> to work around build errors due to this change. Si noti che /clr:pure è deprecato in Visual Studio 2015 e non è supportato in Visual Studio 2017.Note that /clr:pure is deprecated in Visual Studio 2015 and unsupported in Visual Studio 2017. Il codice che deve essere "puro" deve essere trasferito in C#.Code that needs to be "pure" should be ported to C#.

<process.h><process.h>

  • _beginthread e _beginthreadex Le funzioni _beginthread e _beginthreadex ora contengono un riferimento al modulo in cui è definita la procedura del thread per la durata del thread._beginthread and _beginthreadex The _beginthread and _beginthreadex functions now hold a reference to the module in which the thread procedure is defined for the duration of the thread. Ciò contribuisce ad assicurare che i moduli non vengono scaricati fino a quando un thread non viene eseguito fino al completamento.This helps to ensure that modules are not unloaded until a thread has run to completion.

<stdarg.h><stdarg.h>

  • va_start e tipi riferimento Quando compila il codice C++, va_start verifica ora in fase di compilazione che l'argomento passato non sia di tipo riferimento.va_start and reference types When compiling C++ code, va_start now validates at compile-time that the argument passed to it is not of reference type. Gli argomenti di tipo riferimento non sono consentiti dallo Standard C++.Reference-type arguments are prohibited by the C++ Standard.

<stdio.h> e <conio.h><stdio.h> and <conio.h>

  • La famiglia di funzioni di printf e scanf ora viene definita inline.The printf and scanf family of functions are now defined inline. Le definizioni di tutte le funzioni printf e scanf sono state spostate inline in <stdio.h>, <conio.h> e altre intestazioni CRT.The definitions of all of the printf and scanf functions have been moved inline into <stdio.h>, <conio.h>, and other CRT headers. Si tratta di una modifica che comporta un errore del linker (LNK2019, simbolo esterno non risolto) per tutti i programmi che hanno dichiarato localmente queste funzioni senza includere le intestazioni CRT appropriate.This is a breaking change that leads to a linker error (LNK2019, unresolved external symbol) for any programs that declared these functions locally without including the appropriate CRT headers. Se possibile, aggiornare il codice per includere le intestazioni CRT, ovvero aggiungere #include <stdio.h>, e le funzioni inline, ma se non si intende modificare il codice per includere questi file di intestazione, una soluzione alternativa consiste nell'aggiungere una libreria aggiuntiva all'input del linker legacy_stdio_definitions.lib.If possible, you should update the code to include the CRT headers (that is, add #include <stdio.h>) and the inline functions, but if you do not want to modify your code to include these header files, an alternative solution is to add an additional library to your linker input, legacy_stdio_definitions.lib.

    Per aggiungere questa libreria all'input del linker nell'IDE, aprire il menu di scelta rapida per il nodo del progetto, scegliere Proprietà, quindi nella finestra di dialogo Proprietà del progetto scegliere Linkere modificare Input del Linker per aggiungere legacy_stdio_definitions.lib all'elenco di valori delimitati da punto e virgola.To add this library to your linker input in the IDE, open the context menu for the project node, choose Properties, then in the Project Properties dialog box, choose Linker, and edit the Linker Input to add legacy_stdio_definitions.lib to the semi-colon-separated list. Se il progetto è collegato con librerie statiche compilate con una versione di Visual Studio precedente al 2015, il linker potrebbe segnalare un simbolo esterno non risolto.If your project links with static libraries that were compiled with a release of Visual Studio earlier than 2015, the linker might report an unresolved external symbol. Questi errori potrebbero fare riferimento a definizioni stdio interne per_iob, iob_func o importazioni correlate per determinate funzioni stdio nel formato _imp\*.These errors might reference internal stdio definitions for iob, _iob_func, or related imports for certain stdio functions in the form of _imp\*. Microsoft consiglia di ricompilare tutte le librerie statiche con la versione più recente delle librerie e del compilatore C++ quando si aggiorna un progetto.Microsoft recommends that you recompile all static libraries with the latest version of the C++ compiler and libraries when you upgrade a project. Se la raccolta è una libreria di terze parti per cui l'origine non è disponibile, è consigliabile richiedere un aggiornamento binario da terze parti o incapsulare l'utilizzo di quella libreria in una DLL separata che deve essere compilata con la versione precedente del compilatore e delle librerie.If the library is a third-party library for which source is not available, you should either request an updated binary from the third party or encapsulate your usage of that library into a separate DLL that you compile with the older version of the compiler and libraries.

    Avviso

    Se ci si collega con Windows SDK 8.1 o versione precedente, potrebbero verificarsi errori di simbolo esterno non risolto.If you are linking with Windows SDK 8.1 or earlier, you might encounter these unresolved external symbol errors. In tal caso, è necessario risolvere l'errore aggiungendo legacy_stdio_definitions.lib all'input del linker come descritto in precedenza.In that case, you should resolve the error by adding legacy_stdio_definitions.lib to the linker input as described previously.

    Per risolvere gli errori di simbolo non risolto, provare a usare dumpbin.exe per esaminare i simboli definiti in un file binario.To troubleshoot unresolved symbol errors, you can try using dumpbin.exe to examine the symbols defined in a binary. Provare la riga di comando seguente per visualizzare i simboli definiti in una libreria.Try the following command line to view symbols defined in a library.

    dumpbin.exe /LINKERMEMBER somelibrary.lib  
    
  • gets e _getws Le funzioni gets e _getws sono state rimosse.gets and _getws The gets and _getws functions have been removed. La funzione gets è stata rimossa dalla libreria C Standard in C11 perché non può essere usata in modo sicuro.The gets function was removed from the C Standard Library in C11 because it cannot be used securely. La funzione _getws era un'estensione di Microsoft che era equivalente a gets ma per stringhe wide.The _getws function was a Microsoft extension that was equivalent to gets but for wide strings. In alternativa a queste funzioni, provare a usare fgets, fgetws, gets_se _getws_s.As alternatives to these functions, consider use of fgets, fgetws, gets_s, and _getws_s.

  • _cgets e _cgetws Le funzioni _cgets e _cgetws sono state rimosse._cgets and _cgetws The _cgets and _cgetws functions have been removed. In alternativa a queste funzioni, provare a usare _cgets_s e _cgetws_s.As alternatives to these functions, consider use of _cgets_s and _cgetws_s.

  • Formattazione di valori infiniti e NaN Nelle versioni precedenti, valori infiniti e NaN potrebbero essere formattati usando un set di stringhe sentinella specifiche di MSVC.Infinity and NaN Formatting In previous versions, infinities and NaNs would be formatted using a set of MSVC-specific sentinel strings.

    • Valori infiniti: 1.#INFInfinity: 1.#INF

    • NaN non interattivo: 1.#QNANQuiet NaN: 1.#QNAN

    • Segnalazione NaN: 1.#SNANSignaling NaN: 1.#SNAN

    • NaN indefinito: 1.#INDIndefinite NaN: 1.#IND

      Ognuno di questi elementi potrebbe essere preceduto da un segno e potrebbe essere stato formattato in modo leggermente diverso a seconda della larghezza e della precisione del campo (talvolta con effetti insoliti, ad esempio, printf ("%.2f\n", INFINITY) visualizzerà 1. #J perché #INF potrebbe essere "arrotondato" a una precisione di 2 cifre).Any of these may have been prefixed by a sign and may have been formatted slightly differently depending on field width and precision (sometimes with unusual effects, e.g. printf("%.2f\n", INFINITY) would print 1.#J because the #INF would be "rounded" to a precision of 2 digits). C99 ha introdotto nuovi requisiti relativi a come devono essere formattati valori infiniti e NaN.C99 introduced new requirements on how infinities and NaNs are to be formatted. A questo punto l'implementazione di MSVC è conforme a tali requisiti.The MSVC implementation now conforms to these requirements. Sono disponibili le nuove stringhe seguenti:The new strings are as follows:

    • Valori infiniti: infInfinity: inf

    • NaN non interattivo: nanQuiet NaN: nan

    • Segnalazione NaN: nan(snan)Signaling NaN: nan(snan)

    • NaN indefinito:nan(ind)Indefinite NaN:nan(ind)

      Uno di questi può essere preceduto da un segno.Any of these may be prefixed by a sign. Se si usa un identificatore di formato lettere maiuscole (%F anziché %f), le stringhe vengono visualizzate in lettere maiuscole (INF anziché inf), così come richiesto.If a capital format specifier is used (%F instead of %f) then the strings are printed in capital letters (INF instead of inf), as is required.

      Le funzioni scanf sono state modificate per l'analisi di queste nuove stringhe in modo che venga eseguito il roundtrip con printf e scanf.The scanf functions have been modified to parse these new strings, so these strings will round-trip through printf and scanf.

  • Formattazione e analisi a virgola mobile Sono stati introdotti nuovi algoritmi di analisi e formattazione a virgola mobile per migliorare la correttezza.Floating point formatting and parsing New floating point formatting and parsing algorithms have been introduced to improve correctness. Questa modifica interessa le famiglie di funzioni printf e scanf, nonché funzioni come strtod.This change affects the printf and scanf families of functions, as well as functions like strtod.

    Gli algoritmi di formattazione precedenti genererebbero solo un numero limitato di cifre, riempiendo le posizioni decimali rimanenti con zero.The old formatting algorithms would generate only a limited number of digits, then would fill the remaining decimal places with zero. Ciò è sufficiente per generare stringhe che eseguiranno il round trip al valore a virgola mobile originale, ma non è ideale se si vuole il valore esatto (o la rappresentazione decimale più vicina).This is usually good enough to generate strings that will round-trip back to the original floating point value, but it's not great if you want the exact value (or the closest decimal representation thereof). I nuovi algoritmi di formattazione generano tante cifre quante sono necessarie per rappresentare il valore (o per riempire la precisione specificata).The new formatting algorithms generate as many digits as are required to represent the value (or to fill the specified precision). Un esempio del miglioramento è rappresentato dai risultati che si ottengono quando si calcola una potenza molto elevata di due:As an example of the improvement; consider the results when printing a large power of two:

    printf("%.0f\n", pow(2.0, 80))  
    
        Old:  1208925819614629200000000    New:  1208925819614629174706176  
    

    Gli algoritmi di analisi precedenti considererebbero solo fino a 17 cifre significative dalla stringa di input ed eliminerebbero le restanti cifre.The old parsing algorithms would consider only up to 17 significant digits from the input string and would discard the rest of the digits. Ciò è sufficiente per generare un'approssimazione molto vicina del valore rappresentato dalla stringa e il risultato è in genere molto vicino al risultato arrotondato correttamente.This is sufficient to generate a very close approximation of the value represented by the string, and the result is usually very close to the correctly rounded result. La nuova implementazione considera tutte le cifre presenti e produce il risultato arrotondato correttamente per tutti gli input (fino a 768 cifre).The new implementation considers all present digits and produces the correctly rounded result for all inputs (up to 768 digits in length). Queste funzioni inoltre rispettano a questo punto la modalità di arrotondamento (controllabile tramite fesetround).In addition, these functions now respect the rounding mode (controllable via fesetround). Si tratta di una modifica potenziale del comportamento poiché queste funzioni potrebbero restituire risultati diversi.This is a potentially breaking behavior change because these functions might output different results. I nuovi risultati sono sempre più corretti di quelli precedenti.The new results are always more correct than the old results.

  • Analisi a virgola mobile esadecimale e valori infiniti o NaN Gli algoritmi di analisi a virgola mobile a questo punto analizzeranno le stringhe a virgola mobile (ad esempio quelle generate dagli identificatori di formato printf %A e %a) e tutti i valori infiniti e NaN generati dalle funzioni printf, come descritto in precedenza.Hexadecimal and infinity/NaN floating point parsing The floating point parsing algorithms will now parse hexadecimal floating point strings (such as those generated by the %a and %A printf format specifiers) and all infinity and NaN strings that are generated by the printf functions, as described above.

  • Aggiunta di zero prima del numero %A e %a Gli identificatori di formato %A e %a formattano un numero a virgola mobile come una mantissa esadecimale e un esponente binario.%A and %a zero padding The %a and %A format specifiers format a floating point number as a hexadecimal mantissa and binary exponent. Nelle versioni precedenti le funzioni printf aggiungerebbero uno zero prima del numero in modo non corretto nelle stringhe.In previous versions, the printf functions would incorrectly zero-pad strings. Ad esempio, printf("%07.0a\n", 1.0) visualizzerebbe 00x1p+0, mentre dovrebbe visualizzare 0x01p+0.For example, printf("%07.0a\n", 1.0) would print 00x1p+0, where it should print 0x01p+0. Questo problema è stato risolto.This has been fixed.

  • Precisione %A e %a La precisione predefinita degli identificatori di formato %A e %a era 6 nelle versioni precedenti della libreria.%A and %a precision The default precision of the %A and %a format specifiers was 6 in previous versions of the library. La precisione predefinita è ora 13 per conformità agli standard C.The default precision is now 13 for conformance with the C Standard.

    Si tratta di una modifica del comportamento di runtime nell'output di qualsiasi funzione che usa una stringa di formato con %A o %a.This is a runtime behavior change in the output of any function that uses a format string with %A or %a. Nel comportamento precedente l'output che usava l'identificatore %A potrebbe essere "1.1A2B3Cp+111".In the old behavior, the output using the %A specifier might be "1.1A2B3Cp+111". A questo punto l'output per lo stesso valore è "1.1A2B3C4D5E6F7p + 111".Now the output for the same value is "1.1A2B3C4D5E6F7p+111". Per ottenere il comportamento precedente, è possibile specificare la precisione, ad esempio, %.6A.To get the old behavior, you can specify the precision, for example, %.6A. Vedere Specifica precisione.See Precision Specification.

  • Identificatore %F L'identificatore di conversione o di formato %F è ora supportato.%F specifier The %F format/conversion specifier is now supported. È funzionalmente equivalente all'identificatore di formato %f, ad eccezione del fatto che valori infiniti e NaN vengono formattati con lettere maiuscole.It is functionally equivalent to the %f format specifier, except that infinities and NaNs are formatted using capital letters.

    Nelle versioni precedenti l'implementazione era usata per analizzare F e N come modificatori di lunghezza.In previous versions, the implementation used to parse F and N as length modifiers. Questo comportamento risaliva all'età degli spazi degli indirizzi segmentati: questi modificatori di lunghezza erano usati per indicare puntatori far e near, rispettivamente, come in Ns % o % Fp.This behavior dated back to the age of segmented address spaces: these length modifiers were used to indicate far and near pointers, respectively, as in %Fp or %Ns. Questo comportamento è stato rimosso.This behavior has been removed. Se viene rilevato %F, a questo punto viene considerato come l'identificatore di formato %F. Se viene rilevato %N, a questo punto viene considerato come un parametro non valido.If %F is encountered, it is now treated as the %F format specifier; if %N is encountered, it is now treated as an invalid parameter.

  • Formattazione esponente Gli identificatori di formato %e e %E formattano un numero a virgola mobile come una mantissa esadecimale e un esponente binario.Exponent formatting The %e and %E format specifiers format a floating point number as a decimal mantissa and exponent. Anche gli identificatori di formato %g e %G formattano i numeri in questo modo in alcuni casi.The %g and %G format specifiers also format numbers in this form in some cases. Nelle versioni precedenti CRT genererebbe sempre stringhe con esponenti a tre cifre.In previous versions, the CRT would always generate strings with three-digit exponents. Ad esempio, printf("%e\n", 1.0) visualizzerebbe 1.000000e+000.For example, printf("%e\n", 1.0) would print 1.000000e+000. Ciò non è corretto: C richiede che se l'esponente può essere rappresentato usando solo una o due cifre, devono essere visualizzate solo due cifre.This was incorrect: C requires that if the exponent is representable using only one or two digits, then only two digits are to be printed.

    In Visual Studio 2005 è stata aggiunta un'opzione di conformità globale: _set_output_format.In Visual Studio 2005 a global conformance switch was added: _set_output_format. Un programma può chiamare questa funzione con l'argomento _TWO_DIGIT_EXPONENT, per consentire la visualizzazione di esponenti conformi.A program could call this function with the argument _TWO_DIGIT_EXPONENT, to enable conforming exponent printing. È stato modificato il comportamento predefinito per la modalità di visualizzazione degli esponenti conformi agli standard.The default behavior has been changed to the standards-conforming exponent printing mode.

  • Convalida del formato di stringa Nelle versioni precedenti le funzioni printf e scanf accetterebbero automaticamente molte stringhe di formato non valido, talvolta con effetti insoliti.Format string validation In previous versions, the printf and scanf functions would silently accept many invalid format strings, sometimes with unusual effects. Ad esempio, %hlhlhld verrebbe considerato come %d.For example, %hlhlhld would be treated as %d. Tutte le stringhe di formato non valido a questo punto vengono considerate parametri non validi.All invalid format strings are now treated as invalid parameters.

  • Convalida delle stringhe in modalità fopenfopen mode string validation

    Nelle versioni precedenti la famiglia fopen di funzioni accettava automaticamente alcune stringhe di modalità non valida (ad esempio r+b+).In previous versions, the fopen family of functions silently accepted some invalid mode strings (e.g. r+b+). Le stringhe di modalità non valida vengono ora rilevate e considerate come parametri non validi.Invalid mode strings are now detected and treated as invalid parameters.

  • Modalità _O_U8TEXT_O_U8TEXT mode

    La funzione _setmode ora segnala correttamente la modalità per i flussi aperti nella modalità _O_U8TEXT.The _setmode function now correctly reports the mode for streams opened in_O_U8TEXT mode. Nelle versioni precedenti della libreria segnalerebbe tali flussi come aperti in _O_WTEXT.In previous versions of the library, it would report such streams as being opened in _O_WTEXT.

    Si tratta di una modifica importante se il codice interpreta la modalità _O_WTEXT per i flussi in cui la codifica è UTF-8.This is a breaking change if your code interprets the _O_WTEXT mode for streams where the encoding is UTF-8. Se l'applicazione non supporta UTF_8, prendere in considerazione l'aggiunta del supporto per questa codifica sempre più comune.If your application doesn't support UTF_8, consider adding support for this increasingly common encoding.

  • snprintf e vsnprintf Le funzioni snprintf e vsnprintf ora sono implementate.snprintf and vsnprintf The snprintf and vsnprintf functions are now implemented. Il codice precedente spesso forniva le definizioni delle versioni macro di queste funzioni perché non erano implementate dalla libreria CRT, ma queste non sono più necessarie nelle versioni più recenti.Older code often provided definitions macro versions of these functions because they were not implemented by the CRT library, but these are no longer needed in newer versions. Se snprintf o vsnprintf viene definita come macro prima di includere <stdio.h>, ora la compilazione ha esito negativo con un errore che indica dove la macro è stata definita.If snprintf or vsnprintf is defined as a macro before including <stdio.h>, compilation now fails with an error that indicates where the macro was defined.

    In genere, la correzione per questo problema consiste nell'eliminare tutte le dichiarazioni di snprintf o vsnprintf nel codice utente.Normally, the fix to this problem is to delete any declarations of snprintf or vsnprintf in user code.

  • tmpnam genera nomi dei file utilizzabili Nelle versioni precedenti le funzioni tmpnam e tmpnam_s generavano nomi di file nella directory radice dell'unità (ad esempio \sd3c.).tmpnam Generates Usable File Names In previous versions, the tmpnam and tmpnam_s functions generated file names in the root of the drive (such as \sd3c.). Queste funzioni ora generano percorsi di nome file utilizzabili in una directory temporanea.These functions now generate usable file name paths in a temporary directory.

  • Incapsulamento FILE Nelle versioni precedenti il tipo di FILE era completamente definito in <stdio.h>, pertanto era possibile per il codice utente accedere a un FILE e modificarne gli elementi interni.FILE Encapsulation In previous versions, the FILE type was completely defined in <stdio.h>, so it was possible for user code to reach into a FILE and modify its internals. La libreria stdio è stata modificata per nascondere i dettagli di implementazione.The stdio library has been changed to hide implementation details. Nell'ambito di questa operazione, FILE come definito in <stdio.h> ora è un tipo opaco e i relativi membri non sono accessibili di fuori di CRT stesso.As part of this, FILE as defined in <stdio.h> is now an opaque type and its members are inaccessible from outside of the CRT itself.

  • _outp e _inp Le funzioni _outp, _outpw, _outpd, _inp, _inpwe _inpd sono state rimosse._outp and _inp The functions _outp, _outpw, _outpd, _inp, _inpw, and _inpd have been removed.

<stdlib.h>, <malloc.h> e <sys/stat.h><stdlib.h>, <malloc.h>, and <sys/stat.h>

  • strtof e wcstof The strtof e wcstof functions failed to set errno to ERANGE when the value was not representable as a float.strtof and wcstof The strtof and wcstof functions failed to set errno to ERANGE when the value was not representable as a float. Questo problema è stato risolto.This has been fixed. Si noti che questo errore era specifico per queste due funzioni; le funzioni strtod, wcstod, strtold e wcstold non erano interessate. Si tratta di una importante modifica di runtime.(Note that this error was specific to these two functions; the strtod, wcstod, strtold, and wcstold functions were unaffected.) This is a runtime breaking change.

  • Funzioni di allocazione allineata Nelle versioni precedenti le funzioni di allocazione allineata (_aligned_malloc, _aligned_offset_malloc e così via) accetterebbero automaticamente le richieste di un blocco con un allineamento pari a 0.Aligned allocation functions In previous versions, the aligned allocation functions (_aligned_malloc, _aligned_offset_malloc, etc.) would silently accept requests for a block with an alignment of 0. L'allineamento richiesto deve essere una potenza di due, per cui non è pari a zero.The requested alignment must be a power of two, which zero is not. Questo problema è stato risolto e un allineamento richiesto pari a 0 a questo punto viene considerato come un parametro non valido.This has been fixed, and a requested alignment of 0 is now treated as an invalid parameter. Si tratta di una importante modifica di runtime.This is a runtime breaking change.

  • Funzioni heap Le funzioni _heapadd, _heapset e _heapused sono state rimosse.Heap functions The _heapadd, _heapset, and _heapused functions have been removed. Queste funzioni hanno smesso di funzionare da quando CRT è stato aggiornato in modo da usare l'heap di Windows.These functions have been nonfunctional since the CRT was updated to use the Windows heap.

  • smallheap L'opzione di collegamento smalheap è stata rimossa.smallheap The smalheap link option has been removed. Vedere Opzioni collegamento.See Link Options.

<string.h><string.h>

  • wcstok La firma della funzione wcstok è stata modificata in modo da corrispondere alle richieste dello standard C.wcstok The signature of the wcstok function has been changed to match what is required by the C Standard. Nelle versioni precedenti della libreria la firma di questa funzione era:In previous versions of the library, the signature of this function was:

    wchar_t* wcstok(wchar_t*, wchar_t const*)  
    

    Viene usato un contesto interno per ogni thread per tenere traccia dello stato tra chiamate, come avviene per strtok.It used an internal, per-thread context to track state across calls, as is done for strtok. Ora la funzione ha la firma wchar_t * wcstok(wchar_t*, wchar_t const*, wchar_t**) e il chiamante deve passare il contesto come terzo argomento della funzione.The function now has the signature wchar_t* wcstok(wchar_t*, wchar_t const*, wchar_t**), and requires the caller to pass the context as a third argument to the function.

    È stata aggiunta una nuova funzione _wcstok con la firma precedente per facilitare la portabilità.A new _wcstok function has been added with the old signature to ease porting. Quando si compila codice C++, esiste anche un overload inline di wcstok con la firma precedente.When compiling C++ code, there is also an inline overload of wcstok that has the old signature. Questo overload è dichiarato come deprecato.This overload is declared as deprecated. Nel codice C è possibile definire _CRT_NON_CONFORMING_WCSTOK affinché venga usato _wcstok al posto di wcstok.In C code, you may define_CRT_NON_CONFORMING_WCSTOK to cause _wcstok to be used in place of wcstok.

<time.h><time.h>

  • clock Nelle versioni precedenti, la funzione clock veniva implementata usando l'API Windows GetSystemTimeAsFileTime.clock In previous versions, the clock function was implemented using the Windows API GetSystemTimeAsFileTime. Con questa implementazione la funzione clock era sensibile all'ora di sistema e pertanto non era necessariamente monotonica.With this implementation, the clock function was sensitive to the system time, and was thus not necessarily monotonic. La funzione clock è stata reimplementata in termini di QueryPerformanceCounter ed è ora monotonica.The clock function has been reimplemented in terms of QueryPerformanceCounter and is now monotonic.

  • fstat e _utime Nelle versioni precedenti, le funzioni _stat, fstat e _utime gestiscono in modo non corretto l'ora legale.fstat and _utime In previous versions, the _stat, fstat, and _utime functions handle daylight savings time incorrectly. Prima di Visual Studio 2013 tutte queste funzioni regolavano gli orari dell'ora solare in modo non corretto come se fossero nell'ora legale.Prior to Visual Studio 2013, all of these functions incorrectly adjusted standard time times as if they were in daylight time.

    In Visual Studio 2013 il problema è stato corretto nella famiglia di funzioni _stat, ma non sono stati risolti problemi simili nelle famiglie delle funzioni fstat e _utime.In Visual Studio 2013, the problem was fixed in the _stat family of functions, but the similar problems in the fstat and _utime families of functions were not fixed. Ciò ha comportato problemi a causa di un'incoerenza tra le funzioni.This led to problems due to the inconsistency between the functions. Le famiglie delle funzioni fstat e _utime ora sono state corrette in modo che tutte le funzioni ora gestiscono l'ora legale in modo corretto e coerente.The fstat and _utime families of functions have now been fixed, so all of these functions now handle daylight savings time correctly and consistently.

  • asctime Nelle versioni precedenti la funzione asctime avrebbe riempito i giorni a una cifra con uno zero iniziale, ad esempio: venerdì 06 giugno 08.00.00 2014.asctime In previous versions, the asctime function would pad single-digit days with a leading zero, for example: Fri Jun 06 08:00:00 2014. La specifica richiede che tali giorni vengano riempiti con uno spazio iniziale, ad esempio Ven 6 giugno venerdì 08.00.00 2014.The specification requires that such days be padded with a leading space, e.g. Fri Jun 6 08:00:00 2014. Questo problema è stato risolto.This has been fixed.

  • strftime e wcsftime The strftime e wcsftime functions now support the %C, %D, %e, %F, %g, %G, %h, %n, %r, %R, %t, %T, %u, and %V format specifiers.strftime and wcsftime The strftime and wcsftime functions now support the %C, %D, %e, %F, %g, %G, %h, %n, %r, %R, %t, %T, %u, and %V format specifiers. I modificatori E e O inoltre vengono analizzati, ma ignorati.Additionally, the E and O modifiers are parsed but ignored.

    L'identificatore di formato %c viene specificato poiché produce una "rappresentazione appropriata di data e ora" per le impostazioni locali correnti.The %c format specifier is specified as producing an "appropriate date and time representation" for the current locale. Nelle impostazioni locali C questa rappresentazione deve corrispondere a %a %b %e %T %Y.In the C locale, this representation is required to be the same as %a %b %e %T %Y. Si tratta dello stesso formato che viene prodotto da asctime.This is the same form as is produced by asctime. Nelle versioni precedenti l'identificatore di formato %c formattava non correttamente le ore usando una rappresentazione MM/GG/AA HH:MM:SS.In previous versions, the %c format specifier incorrectly formatted times using a MM/DD/YY HH:MM:SS representation. Questo problema è stato risolto.This has been fixed.

  • timespec e TIME_UTC L'intestazione <time.h> ora definisce il tipo timespec e la funzione timespec_get in base allo standard C11.timespec and TIME_UTC The <time.h> header now defines the timespec type and the timespec_get function from the C11 Standard. La macro TIME_UTC inoltre è ora definita per essere usata con la funzione timespec_get.In addition, the TIME_UTC macro, for use with the timespec_get function, is now defined. Si tratta di una modifica per il codice che ha una definizione in conflitto per ognuno di questi elementi.This is a breaking change for code that has a conflicting definition for any of these.

  • CLOCKS_PER_SEC La macro CLOCKS_PER_SEC ora si espande in un numero intero di tipo clock_t, come richiesto dal linguaggio C.CLOCKS_PER_SEC The CLOCKS_PER_SEC macro now expands to an integer of type clock_t, as required by the C language.

Libreria standard C++C++ Standard Library

Per attivare nuove ottimizzazioni e controlli di debug, l'implementazione di Visual Studio della libreria standard C++ interrompe intenzionalmente la compatibilità binaria da una versione a quella successiva.To enable new optimizations and debugging checks, the Visual Studio implementation of the C++ Standard Library intentionally breaks binary compatibility from one version to the next. Pertanto, se si usa la libreria standard C++, i file oggetto e le librerie statiche compilati usando versioni diverse non possono essere combinati in un file binario (EXE o DLL) e gli oggetti della libreria standard C++ non possono essere passati tra i file binari compilati usando versioni diverse.Therefore, when the C++ Standard Library is used, object files and static libraries that are compiled by using different versions can't be mixed in one binary (EXE or DLL), and C++ Standard Library objects can't be passed between binaries that are compiled by using different versions. Tale combinazione genera errori del linker relativi a mancate corrispondenze di _MSC_VER.Such mixing emits linker errors about _MSC_VER mismatches. _MSC_VER è la macro che contiene il numero di versione principale del compilatore, ad esempio 1800 per Visual Studio 2013. Questo controllo non consente di rilevare la combinazione DLL e altre combinazioni inerenti a Visual Studio 2008 o versioni precedenti.(_MSC_VER is the macro that contains the compiler's major version—for example, 1800 for Visual Studio 2013.) This check cannot detect DLL mixing, and cannot detect mixing that involves Visual Studio 2008 or earlier.

  • File di inclusione della libreria standard C++ Sono state apportate alcune modifiche alla struttura di inclusione nelle intestazioni della libreria standard C++.C++ Standard Library include files Some changes have been made to the include structure in the C++ Standard Library headers. Le intestazioni della libreria standard C++ possono ora includersi reciprocamente in modi non specificati.C++ Standard Library headers are allowed to include each other in unspecified ways. In generale, è consigliabile scrivere il codice in modo che includa accuratamente tutte le intestazioni necessarie in base allo standard C++ e non si basi su quali intestazioni della libreria standard C++ includono altre intestazioni della libreria standard C++.In general, you should write your code so that it carefully includes all of the headers that it needs according to the C++ standard and doesn't rely on which C++ Standard Library headers include which other C++ Standard Library headers. In questo modo il codice diventa portabile tra versioni e piattaforme.This makes code portable across versions and platforms. Almeno due modifiche di intestazione in Visual Studio 2015 influiscono sul codice utente.At least two header changes in Visual Studio 2015 affect user code. Per prima cosa <string> non include più <iterator>.First, <string> no longer includes <iterator>. Secondo, <tuple> ora dichiara std::array senza includere tutti i valori <array>, cosa che può interrompere il codice attraverso la seguente combinazione di costrutti di codice: il codice include una variabile denominata "array", si ha una direttiva using "using namespace std;" e si include un'intestazione della libreria standard C++ (ad esempio <functional>) che include <tuple>, che ora dichiara std::array.Second, <tuple> now declares std::array without including all of <array>, which can break code through the following combination of code constructs: your code has a variable named "array", and you have a using-directive "using namespace std;", and you include a C++ Standard Library header (such as <functional>) that includes <tuple>, which now declares std::array.

  • steady_clock L'implementazione di <chrono> di steady_clock è stata modificata per soddisfare i requisiti standard C++ per tenuta e monotonicità.steady_clock The <chrono> implementation of steady_clock has changed to meet the C++ Standard requirements for steadiness and monotonicity. steady_clock ora è basato su QueryPerformanceCounter e high_resolution_clock è ora un typedef per steady_clock.steady_clock is now based on QueryPerformanceCounter and high_resolution_clock is now a typedef for steady_clock. Di conseguenza in Visual Studio steady_clock::time_point è ora un typedef per chrono::time_point <steady_clock>; tuttavia, ciò non vale necessariamente per altre implementazioni.As a result, in Visual Studio steady_clock::time_point is now a typedef for chrono::time_point<steady_clock>; however, this is not necessarily the case for other implementations.

  • allocatori e const Sono ora necessari confronti di uguaglianza/disuguaglianza di allocatori per accettare argomenti const su entrambi i lati.allocators and const We now require allocator equality/inequality comparisons to accept const arguments on both sides. Se gli allocatori definiscono questi operatori come segue:If your allocators define these operators as follows:

    bool operator==(const MyAlloc& other)  
    

    È necessario aggiornare questi strumenti per dichiararli membri const.You should update these to declare them as const members.

    bool operator==(const MyAlloc& other) const  
    
  • Elementi const Lo standard C++ ha sempre rifiutato i contenitori di elementi const (ad esempio vector<const T> o set<const T>).const elements The C++ standard has always forbidden containers of const elements (such as vector<const T> or set<const T>). In Visual Studio 2013 e versioni precedenti tali contenitori erano accettati.Visual Studio 2013 and earlier accepted such containers. Nella versione corrente tali contenitori causano errori di compilazione.In the current version, such containers fail to compile.

  • std::allocator::deallocate In Visual Studio 2013 e versioni precedenti, std::allocator::deallocate(p, n) ignorava l'argomento passato per n.std::allocator::deallocate In Visual Studio 2013 and earlier, std::allocator::deallocate(p, n) ignored the argument passed in for n. Lo standard C++ ha sempre richiesto che n sia uguale al valore passato come primo argomento alla chiamata di allocare che ha restituito p.The C++ standard has always required that n be equal to the value passed as the first argument to the invocation of allocate which returned p. Tuttavia, nella versione corrente il valore di n viene controllato.However, in the current version, the value of n is inspected. Il codice che passa gli argomenti per n che differiscono da ciò che richiede lo standard potrebbe arrestarsi in modo anomalo in fase di esecuzione.Code that passes arguments for n that differ from what the standard requires might crash at runtime.

  • hash_map e hash_set I file di intestazione non standard hash_map e hash_set sono deprecati in Visual Studio 2015 e verranno rimossi in una versione futura.hash_map and hash_set The non-standard header files hash_map and hash_set are deprecated in Visual Studio 2015 and will be removed in a future release. Usare invece unordered_map e unordered_set.Use unordered_map and unordered_set instead.

  • comparators e operator() I contenitori associativi (la famiglia <map>) ora richiedono che i loro comparatori abbiano operatori di chiamata di funzioni in grado di chiamare const.comparators and operator() Associative containers (the <map> family) now require their comparators to have const-callable function call operators. Il codice seguente in una dichiarazione di classe comparatore ora causa errori di compilazione:The following code in a comparator class declaration now fails to compile:

    bool operator()(const X& a, const X& b)  
    

    Per risolvere questo errore, modificare la dichiarazione di funzione in:To resolve this error, change the function declaration to:

    bool operator()(const X& a, const X& b) const  
    
  • tratti di tipo The old names for tratti di tipo from an earlier version of the C++ draft standard have been removed.type traits The old names for type traits from an earlier version of the C++ draft standard have been removed. Sono stati modificati in C++11 e sono stati aggiornati ai valori C++11 in Visual Studio 2015.These were changed in C++11 and have been updated to the C++11 values in Visual Studio 2015. La tabella seguente illustra i nomi precedenti e nuovi:The following table shows the old and new names.

    Nome precedenteOld name Nuovo nomeNew name
    add_referenceadd_reference add_lvalue_referenceadd_lvalue_reference
    has_default_constructorhas_default_constructor is_default_constructibleis_default_constructible
    has_copy_constructorhas_copy_constructor is_copy_constructibleis_copy_constructible
    has_move_constructorhas_move_constructor is_move_constructibleis_move_constructible
    has_nothrow_constructorhas_nothrow_constructor is_nothrow_default_constructibleis_nothrow_default_constructible
    has_nothrow_default_constructorhas_nothrow_default_constructor is_nothrow_default_constructibleis_nothrow_default_constructible
    has_nothrow_copyhas_nothrow_copy is_nothrow_copy_constructibleis_nothrow_copy_constructible
    has_nothrow_copy_constructorhas_nothrow_copy_constructor is_nothrow_copy_constructibleis_nothrow_copy_constructible
    has_nothrow_move_constructorhas_nothrow_move_constructor is_nothrow_move_constructibleis_nothrow_move_constructible
    has_nothrow_assignhas_nothrow_assign is_nothrow_copy_assignableis_nothrow_copy_assignable
    has_nothrow_copy_assignhas_nothrow_copy_assign is_nothrow_copy_assignableis_nothrow_copy_assignable
    has_nothrow_move_assignhas_nothrow_move_assign is_nothrow_move_assignableis_nothrow_move_assignable
    has_trivial_constructorhas_trivial_constructor is_trivially_default_constructibleis_trivially_default_constructible
    has_trivial_default_constructorhas_trivial_default_constructor is_trivially_default_constructibleis_trivially_default_constructible
    has_trivial_copyhas_trivial_copy is_trivially_copy_constructibleis_trivially_copy_constructible
    has_trivial_move_constructorhas_trivial_move_constructor is_trivially_move_constructibleis_trivially_move_constructible
    has_trivial_assignhas_trivial_assign is_trivially_copy_assignableis_trivially_copy_assignable
    has_trivial_move_assignhas_trivial_move_assign is_trivially_move_assignableis_trivially_move_assignable
    has_trivial_destructorhas_trivial_destructor is_trivially_destructibleis_trivially_destructible
  • launch::any e launch::sync policies The nonstandard launch::any e launch::sync policies were removed.launch::any and launch::sync policies The nonstandard launch::any and launch::sync policies were removed. Per launch::any, usare invece launch:async | launch:deferred.Instead, for launch::any, use launch:async | launch:deferred. Per launch::sync, usare launch::deferred.For launch::sync, use launch::deferred. Vedere Enumerazione launch.See launch Enumeration.

MFC e ATLMFC and ATL

  • Microsoft Foundation Classes (MFC) non è più incluso in un'installazione "Tipica" di Visual Studio per le grandi dimensioni.Microsoft Foundation Classes (MFC) is no longer included in a "Typical" install of Visual Studio because of its large size. Per installare MFC, scegliere l'opzione di installazione personalizzata nel programma di installazione di Visual Studio 2015.To install MFC, choose the Custom install option in Visual Studio 2015 setup. Se Visual Studio 2015 è già installato, è possibile installare MFC, eseguendo nuovamente l'installazione di Visual Studio, scegliendo l'opzione di installazione personalizzata e scegliendo Microsoft Foundation Classes.If you already have Visual Studio 2015 installed, you can install MFC by re-running Visual Studio setup, choosing the Custom install option, and choosing Microsoft Foundation Classes. È possibile eseguire nuovamente il programma di installazione di Visual Studio dal Pannello di controllo, Programmi e funzionalità o dai supporti di installazione.You can re-run Visual Studio setup from the Control Panel, Programs and Features, or from the installation media.

    Il pacchetto ridistribuibile di Visual C++ include ancora questa libreria.The Visual C++ Redistributable Package still includes this library.

Runtime di concorrenzaConcurrency Runtime

  • Macro Yield di Windows.h in conflitto con concurrency::Context::Yield Il runtime di concorrenza in precedenza usava #undef per rimuovere la definizione della macro Yield in modo da evitare conflitti tra la macro Yield definita in Windows.h e la funzione concurrency::Context::Yield.Yield macro from Windows.h conflicting with concurrency::Context::Yield The Concurrency Runtime previously used #undef to undefine the Yield macro to avoid conflicts between the Yield macro defined in Windows.h h and the concurrency::Context::Yield function. Il runtime #undef è stato rimosso ed è stata aggiunta una nuova chiamata API equivalente non in conflitto concurrency::Context::YieldExecution .This #undef has been removed and a new non-conflicting equivalent API call concurrency::Context::YieldExecution has been added. Per risolvere i conflitti con Yield, è possibile aggiornare il codice per chiamare la funzione YieldExecution o per racchiudere il nome della funzione Yield tra parentesi nei siti di chiamata, come nell'esempio seguente:To work around conflicts with Yield, you can either update your code to call the YieldExecution function instead, or surround the Yield function name with parentheses at call sites, as in the following example:

    (concurrency::Context::Yield)();  
    

Miglioramenti della conformità del compilatore in Visual Studio 2015Compiler Conformance Improvements in Visual Studio 2015

Quando si aggiorna il codice rispetto alle versioni precedenti, potrebbero verificarsi anche errori del compilatore dovuti ai miglioramenti apportati alla conformità in Visual Studio 2015.When upgrading code from previous versions, you might also encounter compiler errors that are due to conformance improvements made in Visual Studio 2015. Tali miglioramenti non interrompono la compatibilità binaria dalle versioni precedenti di Visual Studio, ma possono generare errori di compilazione mai riscontrati in precedenza.These improvements do not break binary compatibility from earlier versions of Visual Studio, but they can produce compiler errors where none were emitted before. Per altre informazioni, vedere Visual C++: novità dalla versione 2003 alla 2015.For more information, see Visual C++ What's New 2003 through 2015.

In Visual Studio 2015 i miglioramenti apportati in modo costante alla conformità del compilatore possono talvolta modificare il modo in cui il compilatore riconosce il codice sorgente esistente.In Visual Studio 2015, ongoing improvements to compiler conformance can sometimes change how the compiler understands your existing source code. In questo caso, si possono riscontrare errori nuovi o diversi durante la compilazione o addirittura differenze di comportamento nel codice che apparentemente in precedenza veniva compilato ed eseguito correttamente.When this happens, you might encounter new or different errors during your build, or even behavioral differences in code that previously built and seemed to run correctly.

Fortunatamente, queste differenze hanno poco o nessun impatto sulla maggior parte del codice sorgente e quando è necessario usare codice sorgente o altre modifiche per risolvere queste differenze, le correzioni sono in genere minime e semplici.Fortunately, these differences have little or no impact on most of your source code and when source code or other changes are needed to address these differences, fixes are usually small and straight-forward. Sono stati inclusi numerosi esempi di codice sorgente in precedenza accettabile per cui potevano essere necessarie modifiche (prima) e di correzioni da apportare per risolvere i problemi (dopo).We've included many examples of previously-acceptable source code that might need to be changed (before) and the fixes to correct them (after).

Benché queste differenze possano influire sul codice sorgente o altri elementi di compilazione, non influiscono sulla compatibilità binaria tra gli aggiornamenti alle versioni di Visual Studio.Although these differences can affect your source code or other build artifacts, they don't affect binary compatibility between updates to Visual Studio versions. Una modifica sostanziale, molto più drastica, può influire sulla compatibilità binaria, ma le interruzioni della compatibilità binaria si verificano solo tra le versioni principali di Visual Studio.A more-severe kind of change, the breaking change can affect binary compatibility, but these kinds of binary compatibility breaks only occur between major versions of Visual Studio. Ad esempio tra Visual Studio 2013 e Visual Studio 2015.For example, between Visual Studio 2013 and Visual Studio 2015. Per informazioni sulle modifiche sostanziali apportate tra Visual Studio 2013 e Visual Studio 2015, vedere Modifiche della conformità di Visual Studio 2015.For information on the breaking changes that occurred between Visual Studio 2013 and Visual Studio 2015, see Visual Studio 2015 Conformance Changes.

Miglioramenti della conformità in Visual Studio 2015Conformance Improvements in Visual Studio 2015

  • /Zc:forScope- option/Zc:forScope- option

    L'opzione del compilatore /Zc:forScope- è deprecata e verrà rimossa in una versione futura.The compiler option /Zc:forScope- is deprecated and will be removed in a future release.

    Command line warning  D9035: option 'Zc:forScope-' has been deprecated and will be removed in a future release  
    

    L'opzione in genere è stata usata per consentire codice non standard che usa variabili di ciclo dopo il punto in cui, in base allo standard, dovrebbero essere uscite dall'ambito.The option was usually used in order to allow nonstandard code that uses loop variables after the point where, according to the standard, they should have gone out of scope. È necessaria solo quando si esegue la compilazione con l'opzione /Za, poiché è sempre consentito l'utilizzo di una variabile di ciclo dopo la fine del ciclo senza /Za.It was only necessary when you are compiling with the /Za option, since without /Za, using a for loop variable after the end of the loop is always allowed. Se non è rilevante la conformità agli standard (ad esempio, se il codice non è destinato a essere portabile in altri compilatori), è possibile disattivare l'opzione /Za (o impostare la proprietà Disabilita estensioni linguaggio su No).If you don't care about standards conformance (for example, if your code isn't meant to portable to other compilers), you could turn off the /Za option (or set the Disable Language Extensions property to No). Se si vuole scrivere codice portabile, conforme agli standard, è necessario riscrivere il codice affinché sia conforme allo standard spostando la dichiarazione di tali variabili in un punto esterno al ciclo.If you do care about writing portable, standards-compliant code, you should rewrite your code so that it conforms to the standard by moving the declaration of such variables to a point outside the loop.

    // C2065 expected  
    int main() {  
        // Uncomment the following line to resolve.  
        // int i;  
        for (int i = 0; i < 1; i++);  
        i = 20;   // i has already gone out of scope under /Za  
    }  
    
  • /Zg (opzione del compilatore)/Zg compiler option

    L'opzione del compilatore /Zg (Genera i prototipi delle funzioni) non è più disponibile.The /Zg compiler option (Generate Function Prototypes) is no longer available. Questa opzione del compilatore è stata precedentemente deprecata.This compiler option was previously deprecated.

  • Non è più possibile eseguire unit test con C++/CLI dalla riga di comando con mstest.exe.You can no longer run unit tests with C++/CLI from the command-line with mstest.exe. Usare invece vstest.console.exe.Instead, use vstest.console.exe. Vedere Opzioni della riga di comando di VSTest.Console.exe.See VSTest.Console.exe command-line options.

  • mutable (parola chiave)mutable keyword

    L'identificatore di classi di archiviazione mutable non è più consentito in posizioni dove in precedenza eseguiva compilazioni senza errori.The mutable storage class specifier is no longer allowed in places where previously it compiled without error. Ora il compilatore genera l'errore C2071 (classe di archiviazione non valida).Now, the compiler gives error C2071 (illegal storage class). In base allo standard, l'identificatore modificabile può essere applicato solo ai nomi dei membri di dati della classe, non può essere applicato ai nomi dichiarati const o statici e non può essere applicato ai membri di riferimento.According to the standard, the mutable specifier can be applied only to names of class data members, and cannot be applied to names declared const or static, and cannot be applied to reference members.

    Si consideri il codice di esempio seguente:For example, consider the following code:

    struct S   
    {  
        mutable int &r;  
    };  
    

    Nelle versioni precedenti del compilatore questa situazione è accettabile, ma ora il compilatore genera l'errore seguente:Previous versions of the compiler accepted this, but now the compiler gives the following error:

    error C2071: 'S::r': illegal storage class  
    

    Per correggere l'errore, rimuovere semplicemente la parola chiave mutable ridondante.To fix the error, simply remove the redundant mutable keyword.

  • char_16_t e char32_tchar_16_t and char32_t

    Non è possibile usare char16_t o char32_t come alias di un typedef, poiché questi tipi ora vengono considerati come incorporati.You can no longer use char16_t or char32_t as aliases in a typedef, because these types are now treated as built-in. Per gli utenti e gli autori di libreria era comune definire char16_t e char32_t come alias rispettivamente di uint16_t e uint32_t.It was common for users and library authors to define char16_t and char32_t as aliases of uint16_t and uint32_t, respectively.

    #include <cstdint>  
    
    typedef uint16_t char16_t; //C2628  
    typedef uint32_t char32_t; //C2628  
    
    int main(int argc, char* argv[])  
    {  
        uint16_t x = 1; uint32_t y = 2;  
        char16_t a = x;  
        char32_t b = y;  
        return 0;  
    }  
    

    Per aggiornare il codice, rimuovere le dichiarazioni typedef e rinominare tutti gli identificatori che sono in conflitto con questi nomi.To update your code, remove the typedef declarations and rename any other identifiers that collide with these names.

  • Parametri di modello non di tipoNon-type template parameters

    Determinato codice che prevede parametri di modello non di tipo viene ora verificato correttamente per la compatibilità del tipo quando vengono forniti gli argomenti di modello espliciti.Certain code that involves non-type template parameters is now correctly checked for type compatibility when you provide explicit template arguments. Ad esempio, il seguente codice veniva compilato senza errori nelle versioni precedenti di Visual Studio.For example, the following code compiled without error in previous versions of Visual Studio.

    struct S1  
    {  
        void f(int);  
        void f(int, int);  
    };  
    
    struct S2  
    {  
        template <class C, void (C::*Function)(int) const> void f() {}  
    };  
    
    void f()  
    {  
        S2 s2;  
        s2.f<S1, &S1::f>();  
    }  
    

    Il compilatore corrente restituisce correttamente un errore, perché il tipo di parametro di modello non corrisponde all'argomento di modello (il parametro è un puntatore a un membro const, ma la funzione f è non const):The current compiler correctly gives an error, because the template parameter type doesn't match the template argument (the parameter is a pointer to a const member, but the function f is non-const):

    error C2893: Failed to specialize function template 'void S2::f(void)'note: With the following template arguments:note: 'C=S1'note: 'Function=S1::f'  
    

    Per risolvere questo errore nel codice, verificare che il tipo di argomento del modello usato corrisponda al tipo dichiarato del parametro di modello.To address this error in your code, make sure that the type of the template argument you use matches the declared type of the template parameter.

  • __declspec(align)__declspec(align)

    Il compilatore non accetta più __declspec(align) sulle funzioni.The compiler no longer accepts __declspec(align) on functions. È sempre stato ignorato, ma ora genera un errore del compilatore.This was always ignored, but now it produces a compiler error.

    error C3323: 'alignas' and '__declspec(align)' are not allowed on function declarations  
    

    Per risolvere questo problema, rimuovere __declspec(align) dalla dichiarazione di funzione.To fix this problem, remove __declspec(align) from the function declaration. Dal momento che non ha avuto effetto, la rimozione non comporta alcuna modifica.Since it had no effect, removing it does not change anything.

  • Gestione delle eccezioniException handling

    Sono state apportate alcune modifiche alla gestione delle eccezioni.There are a couple of changes to exception handling. In primo luogo, gli oggetti eccezione devono poter essere copiati o spostati.First, exception objects have to be either copyable or movable. Il codice seguente veniva compilato in Visual C++ in Visual Studio 2013Visual C++ in Visual Studio 2013, ma non viene compilato in Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015:The following code compiled in Visual C++ in Visual Studio 2013Visual C++ in Visual Studio 2013, but does not compile in Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015:

    struct S  
    {  
    public:  
        S();  
    private:  
        S(const S &);  
    };  
    
    int main()  
    {  
        throw S(); // error  
    }  
    

    Il problema è che il costruttore di copia è privato e quindi l'oggetto non può essere copiato, come accade durante il normale funzionamento di gestione di un'eccezione.The problem is that the copy constructor is private, so the object cannot be copied as happens in the normal course of handling an exception. Lo stesso vale quando il costruttore di copia viene dichiarato explicit.The same applies when the copy constructor is declared explicit.

    struct S  
    {  
        S();  
        explicit S(const S &);  
    };  
    
    int main()  
    {  
        throw S(); // error  
    }  
    

    Per aggiornare il codice, verificare che il costruttore di copia per l'oggetto eccezione sia pubblico e non sia contrassegnato come explicit.To update your code, make sure that the copy constructor for your exception object is public and not marked explicit.

    L'individuazione di un'eccezione in base al valore richiede anche che sia possibile copiare l'oggetto eccezione.Catching an exception by value also requires the exception object to be copyable. Il codice seguente veniva compilato in Visual C++ in Visual Studio 2013Visual C++ in Visual Studio 2013, ma non viene compilato in Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015:The following code compiled in Visual C++ in Visual Studio 2013Visual C++ in Visual Studio 2013, but does not compile in Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015:

    struct B  
    {  
    public:  
        B();  
    private:  
        B(const B &);  
    };  
    
    struct D : public B {};  
    
    int main()  
    {  
        try  
        {  
        }  
        catch (D d) // error  
        {  
        }  
    }  
    

    Per risolvere questo problema, è possibile modificare il tipo di parametro per catch in un riferimento.You can fix this issue by changing the parameter type for the catch to a reference.

    catch (D& d)  
    {  
    }  
    
  • Valori letterali stringa seguiti da macroString literals followed by macros

    Il compilatore supporta ora i valori letterali definiti dall'utente.The compiler now supports user defined literals. Di conseguenza, i valori letterali stringa seguiti da macro senza eventuali spazi intermedi vengono interpretati come valori letterali definiti dall'utente, che potrebbero produrre errori o risultati imprevisti.As a consequence, string literals followed by macros without any intervening whitespace are interpreted as user-defined literals, which might produce errors or unexpected results. Nei compilatori precedenti, ad esempio, il codice seguente veniva compilato correttamente:For example, in previous compilers the following code compiled successfully:

    #define _x "there"  
    char* func() {  
        return "hello"_x;  
    }  
    int main()  
    {  
        char * p = func();  
        return 0;  
    }  
    

    Il compilatore lo interpretava come un valore letterale stringa "hello" seguito da una macro, espansa in "there", e quindi i due valori letterali stringa venivano concatenati in uno.The compiler interpreted this as a string literal "hello" followed by a macro, which is expanded "there", and then the two string literals were concatenated into one. In Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015 il compilatore lo interpreta come un valore letterale definito dall'utente, ma poiché non esiste alcun valore letterale _x corrispondente definito dall'utente, viene restituito un errore.In Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015, the compiler interprets this as a user-defined literal, but since there is no matching user-defined literal _x defined, it gives an error.

    error C3688: invalid literal suffix '_x'; literal operator or literal operator template 'operator ""_x' not found  
    note: Did you forget a space between the string literal and the prefix of the following string literal?  
    

    Per risolvere questo problema, aggiungere uno spazio tra il valore letterale stringa e la macro.To fix this problem, add a space between the string literal and the macro.

  • Valori letterali stringa adiacentiAdjacent string literals

    Analogamente al precedente esempio, a causa di modifiche correlate nell'analisi delle stringhe, i valori letterali stringa adiacenti (uno dei valori letterali stringa di carattere wide o narrow) senza gli spazi vuoti sono stati interpretati come una singola stringa concatenata nelle versioni precedenti di Visual C++.Similarly to the previous, due to related changes in string parsing, adjacent string literals (either wide or narrow character string literals) without any whitespace were interpreted as a single concatenated string in previous releases of Visaul C++. In Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015 è necessario aggiungere spazi vuoti tra le due stringhe.In Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015, you must now add whitespace between the two strings. Ad esempio, il codice seguente deve essere modificato:For example, the following code must be changed:

    char * str = "abc""def";  
    

    Aggiungere semplicemente uno spazio tra le due stringhe.Simply add a space in between the two strings.

    char * str = "abc" "def";  
    
  • Operatore new e delete di posizionamentoPlacement new and delete

    È stata apportata una modifica all'operatore delete per fare in modo che sia conforme con lo standard C++14.A change has been made to the delete operator in order to bring it into conformance with C++14 standard. Per informazioni dettagliate sulla modifica agli standard, vedere Deallocazione con dimensione C++.Details of the standards change can be found at C++ Sized Deallocation. Le modifiche aggiungono un modulo dell'operatore delete globale che accetta un parametro di dimensione.The changes add a form of the global delete operator that takes a size parameter. La differenza sostanziale è che se in precedenza si usava un operatore delete con la stessa firma (per la corrispondenza con un operatore new di posizionamento), ora si riceve un errore del compilatore (C2956, che si verifica nel punto in cui viene usato l'operatore new di posizionamento, poiché è la posizione nel codice in cui il compilatore tenta di identificare un operatore delete corrispondente appropriato).The breaking change is that if you were previously using an operator delete with the same signature (to correspond with a placement new operator), you will receive a compiler error (C2956, which occurs at the point where the placement new is used, since that's the position in code where the compiler tries to identify an appropriate matching delete operator).

    La funzione void operator delete(void *, size_t) è un operatore delete di posizionamento corrispondente alla nuova funzione di posizionamento "void * operator new (size_t, size_t)" in C++11.The function void operator delete(void *, size_t) was a placement delete operator corresponding to the placement new function "void * operator new(size_t, size_t)" in C++11. Con la deallocazione con dimensione C++14, questa funzione delete è ora una funzione di deallocazione consueta (operatore delete globale).With C++14 sized deallocation, this delete function is now a usual deallocation function (global delete operator). Lo standard richiede che, se l'uso di un operatore new cerca una funzione delete corrispondente e trova una funzione di deallocazione consueta, il programma non ha un formato corretto.The standard requires that if the use of a placement new looks up a corresponding delete function and finds a usual deallocation function, the program is ill-formed.

    Si supponga, ad esempio, che il codice definisca un operatore new e delete di posizionamento:For example, suppose your code defines both a placement new and a placement delete:

    void * operator new(std::size_t, std::size_t);  
    void operator delete(void*, std::size_t) noexcept;  
    

    Il problema si verifica a causa della corrispondenza delle firme funzione tra un operatore delete di posizionamento che è stato definito e il nuovo operatore delete con dimensione globale.The problem occurs because of the match in function signatures between a placement delete operator you've defined, and the new global sized delete operator. Stabilire se è possibile usare un tipo diverso da size_t per qualsiasi operatore new e delete di posizionamento.Consider whether you can use a different type other than size_t for any placement new and delete operators. Si noti che il tipo di size_t typedef è dipendente dal compilatore; è un typedef per int senza segno in MSVC.Note that the type of the size_t typedef is compiler-dependent; it is a typedef for unsigned int in MSVC. Una buona soluzione consiste nell'usare un tipo enumerato simile al seguente:A good solution is to use an enumerated type such as this:

    enum class my_type : size_t {};  
    

    Modificare quindi la definizione dell'operatore new e delete di posizionamento per usare questo tipo come secondo argomento anziché size_t.Then, change your definition of placement new and delete to use this type as the second argument instead of size_t. È necessario anche aggiornare le chiamate all'operatore new di posizionamento per passare al nuovo tipo (ad esempio, usando static_cast<my_type> per convertire il valore integer) e aggiornare la definizione di new e delete per eseguire il cast di tipo integer.You’ll also need to update the calls to placement new to pass the new type (for example, by using static_cast<my_type> to convert from the integer value) and update the definition of new and delete to cast back to the integer type. Non è necessario usare un enum per questo oggetto; funzionerebbe anche un tipo classe con un membro size_t.You don’t need to use an enum for this; a class type with a size_t member would also work.

    Una soluzione alternativa è che si potrebbe eliminare completamente la nuova posizione.An alternative solution is that you might be able to eliminate the placement new altogether. Se il codice usa l'operatore new di posizionamento per implementare un pool di memoria dove l'argomento di posizione è la dimensione dell'oggetto allocato o eliminato, la funzionalità di deallocazione con dimensione potrebbe essere adatta a sostituire il codice del pool di memoria personalizzato ed è possibile eliminare le funzioni di posizionamento e usare semplicemente il proprio operatore delete a due argomenti anziché le funzioni di posizionamento.If your code uses placement new to implement a memory pool where the placement argument is the size of the object being allocated or deleted, then sized deallocation feature might be suitable to replace your own custom memory pool code, and you can get rid of the placement functions and just use your own two-argument delete operator instead of the placement functions.

    Se non si intende aggiornare immediatamente il codice, è possibile ripristinare il comportamento precedente usando l'opzione del compilatore /Zc:sizedDealloc-.If you don't want to update your code immediately, you can revert to the old behavior by using the compiler option /Zc:sizedDealloc-. Se si usa questa opzione, le funzioni di eliminazione a due argomenti non esistono e non provocheranno un conflitto con l'operatore delete di posizionamento.If you use this option, the two-argument delete functions don’t exist and won't cause a conflict with your placement delete operator.

  • Membri dati di unioniUnion data members

    I membri dati di unioni non possono avere tipi di riferimento.Data members of unions can no longer have reference types. Il codice seguente veniva compilato correttamente in Visual C++ in Visual Studio 2013Visual C++ in Visual Studio 2013, ma produce un errore in Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015.The following code compiled successfully in Visual C++ in Visual Studio 2013Visual C++ in Visual Studio 2013, but produces an error in Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015.

    union U1   
    {  
        const int i;  
    };  
    union U2  
    {  
        int & i;  
    };  
    union U3  
    {  
        struct { int & i; };  
    };  
    

    Il codice precedente produce gli errori seguenti:The preceding code produces the following errors:

    
    test.cpp(67): error C2625: 'U2::i': illegal union member; type 'int &' is reference type  
    test.cpp(70): error C2625: 'U3::i': illegal union member; type 'int &' is reference type  
    

    Per risolvere questo problema, modificare i tipi di riferimento in un puntatore o un valore.To address this issue, change reference types either to a pointer or a value. La modifica del tipo in un puntatore richiede modifiche al codice che usa il campo di unione.Changing the type to a pointer requires changes in the code that uses the union field. La modifica del codice in un valore modificherebbe i dati archiviati nell'unione, che influiscono su altri campi, poiché i campi in tipi di unione condividono la stessa memoria.Changing the code to a value would change the data stored in the union, which affects other fields since fields in union types share the same memory. A seconda delle dimensioni del valore, è possibile anche modificare le dimensioni dell'unione.Depending on the size of the value, it might also change the size of the union.

  • Unioni anonime sono ora più conformi allo standard.Anonymous unions are now more conformant to the standard. Le versioni precedenti del compilatore hanno generato un costruttore e distruttore esplicito per unioni anonime.Previous versions of the compiler generated an explicit constructor and destructor for anonymous unions. Questi vengono eliminati in Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015.These are deleted in Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015.

    struct S   
    {  
        S();  
    };  
    
    union   
    {  
        struct   
        {  
            S s;  
        };  
    } u; // C2280  
    

    Il codice precedente produce gli errori seguenti in Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015:The preceding code generates the following error in Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015:

    error C2280: '<unnamed-type-u>::<unnamed-type-u>(void)': attempting to reference a deleted function  
    note: compiler has generated '<unnamed-type-u>::<unnamed-type-u>' here  
    

    Per risolvere questo problema, specificare definizioni personalizzate del costruttore e/o del distruttore.To resolve this issue, provide your own definitions of the constructor and/or destructor.

    struct S   
    {  
        // Provide a default constructor by adding an empty function body.  
        S() {}  
    };  
    
    union   
    {  
        struct   
        {  
            S s;  
        };  
    } u;  
    
  • Unioni con strutture anonimeUnions with anonymous structs

    Per la conformità allo standard, il comportamento di runtime è stato modificato per i membri di strutture anonime nelle unioni.In order to conform with the standard, the runtime behavior has changed for members of anonymous structures in unions. Il costruttore per i membri di strutture anonime in un'unione non viene più chiamato in modo implicito quando viene creato questo tipo di unione.The constructor for anonymous structure members in a union is no longer implicitly called when such a union is created. Il distruttore per i membri di strutture anonime in un'unione non viene più chiamato in modo implicito quando l'unione è esterna all'ambito.Also, the destructor for anonymous structure members in a union is no longer implicitly called when the union goes out of scope. Si consideri il codice seguente, in cui un'unione U contiene una struttura anonima con un membro che è una struttura S denominata con un distruttore.Consider the following code, in which a union U contains an anonymous structure that contains a member which is a named structure S that has a destructor.

    #include <stdio.h>  
    struct S   
    {  
        S() { printf("Creating S\n"); }  
        ~S() { printf("Destroying S\n"); }  
    };  
    union U   
    {  
        struct {  
            S s;  
        };  
        U() {}  
        ~U() {}  
    };  
    
    void f()  
    {  
        U u;  
        // Destructor implicitly called here.  
    }  
    
    int main()  
    {  
        f();  
    
        char s[1024];  
        printf("Press any key.\n");  
        gets_s(s);  
        return 0;  
    }  
    

    In Visual C++ in Visual Studio 2013Visual C++ in Visual Studio 2013 il costruttore per S viene chiamato quando viene creata l'unione e il distruttore per S viene chiamato durante la pulitura dello stack per la funzione f.In Visual C++ in Visual Studio 2013Visual C++ in Visual Studio 2013, the constructor for S is called when the union is created, and the destructor for S is called when the stack for function f is cleaned up. Tuttavia in Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015 il costruttore e distruttore non vengono chiamati.But in Visual C++ in Visual Studio 2015Visual C++ in Visual Studio 2015, the constructor and destructor are not called. Il compilatore visualizza un avviso relativo a questa modifica del comportamento.The compiler gives a warning about this behavior change.

    warning C4587: 'U::s': behavior change: constructor is no longer implicitly calledwarning C4588: 'U::s': behavior change: destructor is no longer implicitly called  
    

    Per ripristinare il comportamento originale, assegnare alla struttura anonima un nome.To restore the original behavior, give the anonymous structure a name. Il comportamento di runtime di strutture non anonime è lo stesso, indipendentemente dalla versione del compilatore.The runtime behavior of non-anonymous structures is the same, regardless of the compiler version.

    #include <stdio.h>  
    
    struct S   
    {  
        S() { printf("Creating S.\n"); }  
        ~S() { printf("Destroying S\n"); }  
    };  
    union U   
    {  
        struct   
        {  
            S s;  
        } namedStruct;  
        U() {}  
        ~U() {}  
    };  
    
    void f()  
    {  
        U u;  
    }  
    
    int main()  
    {  
        f();  
    
        char s[1024];  
        printf("Press any key.\n");  
        gets_s(s);  
        return 0;  
    }  
    

    In alternativa, provare a spostare il codice del costruttore e del distruttore in nuove funzioni e aggiungere chiamate a queste funzioni provenienti dal costruttore e distruttore per l'unione.Alternatively, try moving the constructor and destructor code into new functions, and add calls to these functions from the constructor and destructor for the union.

    #include <stdio.h>  
    
    struct S   
    {  
        void Create() { printf("Creating S.\n"); }  
        void Destroy() { printf("Destroying S\n"); }  
    };  
    union U   
    {  
        struct   
        {  
            S s;  
        };  
        U() { s.Create(); }  
        ~U() { s.Destroy(); }  
    };  
    
    void f()  
    {  
        U u;  
    }  
    
    int main()  
    {  
        f();  
    
        char s[1024];  
        printf("Press any key.\n");  
        gets_s(s);  
        return 0;  
    }  
    
  • Risoluzione per il modelloTemplate resolution

    Sono state apportate modifiche alla risoluzione dei nomi per i modelli.Changes have been made to name resolution for templates. In C++, quando si considerano i candidati per la risoluzione di un nome, può accadere che uno o più nomi presi in considerazione come corrispondenze potenziali producano un'istanza del modello non valida.In C++, when considering candidates for the resolution of a name, it can be the case that one or more names under consideration as potential matches produces an invalid template instantiation. Queste istanze non valide in genere non provocano errori del compilatore, un principio che è noto come SFINAE (Substitution Failure Is Not An Error).These invalid instantiations do not normally cause compiler errors, a principle which is known as SFINAE (Substitution Failure Is Not An Error).

    A questo punto, se SFINAE richiede al compilatore di creare un'istanza di specializzazione del modello di classe, eventuali errori verificatisi durante questo processo sono errori del compilatore.Now, if SFINAE requires the compiler to instantiate the specialization of a class template, then any errors that occur during this process are compiler errors. Nelle versioni precedenti il compilatore potrebbe ignorare tali errori.In previous versions, the compiler would ignore such errors. Si consideri il codice di esempio seguente:For example, consider the following code:

    #include <type_traits>  
    
    template< typename T>  
    struct S  
    {  
        S() = default;  
        S(const S&);  
        S(S& &);  
    
        template< typename U, typename = typename std::enable_if< std::is_base_of< T, U> ::value> ::type>  
        S(S< U> & &);  
    };  
    
    struct D;  
    
    void f1()  
    {  
        S< D> s1;  
        S< D> s2(s1);  
    }  
    
    struct B  
    {  
    };  
    
    struct D : public B  
    {  
    };  
    
    void f2()  
    {  
        S< D> s1;  
        S< D> s2(s1);  
    }  
    

    Se si compila con il compilatore corrente, viene visualizzato l'errore seguente:If you compile with the current compiler, you get the following error:

    
    type_traits(1110): error C2139: 'D': an undefined class is not allowed as an argument to compiler intrinsic type trait '__is_base_of'  
    ..\t331.cpp(14): note: see declaration of 'D'  
    ..\t331.cpp(10): note: see reference to class template instantiation 'std::is_base_of<T,U>' being compiled  
    with  
    [  
        T=D,  
        U=D  
    ]  
    

    Ciò accade perché al momento della prima chiamata di is_base_of la classe 'D' non è stata definita.This is because at the point of the first invocation of the is_base_of the class 'D' has not yet been defined.

    In questo caso, la correzione non deve usare tale tratti di tipo fino a quando non è stata definita la classe.In this case, the fix is not to use such type traits until the class has been defined. Se si spostano le definizioni di B e D all'inizio del file di codice, l'errore viene risolto.If you move the definitions of B and D to the beginning of the code file, the error is resolved. Se le definizioni sono nei file di intestazione, controllare l'ordine delle istruzioni include per i file di intestazione per verificare che tutte le definizioni di classe vengano compilate prima di usare modelli problematici.If the definitions are in header files, check the order of the include statements for the header files to make sure that any class definitions are compiled before the problematic templates are used.

  • Costruttori di copiaCopy constructors

    Sia in Visual Studio 2013Visual Studio 2013 che in Visual Studio 2015 il compilatore genera un costruttore di copia per una classe se tale classe ha un costruttore di spostamento definito dall'utente, ma nessun costruttore di copia definito dall'utente.In both Visual Studio 2013Visual Studio 2013 and Visual Studio 2015, the compiler generates a copy constructor for a class if that class has a user-defined move constructor but no user-defined copy constructor. In Dev14, questo costruttore di copia generato in modo implicito è contrassegnato come "= delete".In Dev14, this implicitly generated copy constructor is also marked "= delete".

  • main dichiarato come "C" esterno richiede ora un tipo restituito.main declared as extern "C" now requires a return type.

Il codice seguente genera ora l'errore C4430.The following code now produces C4430.

extern "C" __cdecl main(){} // C4430

Per correggere l'errore, aggiungere il tipo restituito:To fix the error, add the return type:

extern "C" int __cdecl main(){} // OK
  • typename non consentito in un inizializzatore di membrotypename is not allowed in a member initializer

Il codice seguente genera ora l'errore C2059:The following code now produces C2059:

template<typename T>
struct S1 : public T::type
{
   S1() : typename T::type() // C2059
   {
   }
};

struct S2 {
   typedef S2 type;
};

S1<S2> s;

Per correggere l'errore, rimuovere typename dall'inizializzatore:To fix the error, remove typename from the initializer:

S1() : T::type() // OK
...
  • La classe di archiviazione in specializzazioni esplicite viene ignorata.The storage class on explicit specializations is ignored.

Nel codice seguente viene ignorato l'identificatore di classe di archiviazione staticaIn the following code, the static storage class specifier is ignored

template <typename T>
void myfunc(T h)
{
}

template<>
static void myfunc(double h) // static is ignored
{
}
  • Una costante usata in static_assert all'interno di un modello di classe avrà sempre esito negativo.A constant used in a static_assert inside a class template will always fail.

Nel codice seguente l'asserzione static_assert ha sempre esito negativo:The following code causes the static_assert to always fail:

template <size_t some_value>
struct S1
{
    static_assert(false, "default not valid"); // always invoked

};

//other partial specializations here

Per risolvere il problema, racchiudere il valore in uno struct:To work around this, wrap the value in a struct:

template <size_t some_value>
struct constant_false {
    static const bool value = false;
};

template <size_t some_value>
struct S1
{
    static_assert(constant_false<some_value>::value, "default not valid");
};

//other partial specializations here
  • Regole applicate per le dichiarazioni con prototipo (valido per solo C)Rules enforced for forward declarations. (Applies only to C.)

Il codice seguente genera ora l'errore C2065:The following code now produces C2065:

struct token_s;
typedef int BOOL;
typedef int INT;



typedef int(*PFNTERM)(PTOKEN, BOOL, INT); // C2065: 'PTOKEN' : undeclared identifier

Per risolvere il problema, aggiungere le dichiarazioni con prototipo appropriate:To fix the problem add the proper forward declarations:

struct token_s;
typedef int BOOL;
typedef int INT;

// forward declarations:
typedef struct token_s TOKEN; 
typedef TOKEN *PTOKEN;

typedef int(*PFNTERM)(PTOKEN, BOOL, INT);
  • Applicazione più coerente dei tipi di puntatore a funzioneMore consistent enforcement of function pointer types

Il codice seguente genera ora l'errore C2197:The following code now produces C2197:

typedef int(*F1)(int);
typedef int(*F2)(int, int);

void func(F1 f, int v1, int v2)
{
    f(v1, v2); // C2197
}
  • Chiamate ambigue a funzioni in overloadAmbiguous calls to overloaded functions

Il codice seguente produce ora l'errore C266: 'N::bind': chiamata ambigua a funzione in overloadThe following code now produces C266: 'N::bind': ambiguous call to overloaded function

template<typename R, typename T, typename T1, typename A1>
void bind(R(T::*)(T1), A1&&);

namespace N
{
    template <typename T, typename R, typename ... Tx>
    void bind(R(T::*)(Tx...), T* ptr);
}

using namespace N;

class Manager
{
public:
    void func(bool initializing);

    void mf()
    {
        bind(&Manager::func, this); //C2668
    }
};

Per correggere l'errore, è possibile qualificare interamente la chiamata per l'associazione: N::bind(...). Se questa modifica è resa manifesta tramite un identificatore non dichiarato (C2065), può essere opportuno correggere l'errore con una dichiarazione 'using'.To fix the error, you can fully qualify the call to bind: N::bind(...). However, if this change is manifest through an undeclared identifier (C2065), then it may be appropriate to fix this with a 'using' declaration instead.

Questo modello si verifica spesso con ComPtr e altri tipi nello spazio dei nomi Microsoft::WRL.This pattern happens frequently with ComPtr and other types in the Microsoft::WRL namespace.

  • Risolvere un indirizzo erratoFix incorrect address of

Il codice seguente produce ora C2440: '=': impossibile convertire da 'type *' a 'type'.The following code now produces C2440: '=': cannot convert from 'type *' to 'type'. Per correggere l'errore, modificare &(type) in (type) e (&f()) in (f()).To fix the error, change &(type) to (type) and (&f()) to (f()).

\\ C
typedef void (*type)(void);

void f(int i, type p);
void g(int);
void h(void)
{
    f(0, &(type)g);
}

\\ C++
typedef void(*type)(void);

type f();

void g(type);

void h()
{
    g(&f());
}
  • Il valore letterale della stringa è una matrice costanteString literal is a constant array

Il codice seguente genera ora l'errore C2664: 'void f(void )': impossibile convertire l'argomento 1 da 'const char ()[2]' a 'void *'The following code now produces C2664: 'void f(void )': cannot convert argument 1 from 'const char ()[2]' to 'void *'

void f(void *);

void h(void)
{
    f(&__FUNCTION__); 
    void *p = &"";
}

Per correggere l'errore, modificare il tipo di parametro di funzione in 'const void*'; in caso contrario, modificare il corpo di h in modo che risulti simile al seguente:To fix the error, change the function parameter type to 'const void*', or else change the body of h to look like this:

void h(void)
{
    char name[] = __FUNCTION__;
    f( name); 
    void *p = &"";
}
  • Stringhe UDL per C++ 11C++11 UDL strings

Il codice seguente genera ora l'errore C3688: suffisso letterale 'L' non valido; l'operatore di valori letterali o il modello di operatore di valori letterali 'operatore ""L' non è stato trovatoThe following code now produces error C3688: invalid literal suffix 'L'; literal operator or literal operator template 'operator ""L' not found

#define MACRO

#define STRCAT(x, y) x\#\#y

int main(){

    auto *val1 = L"string"MACRO;
    auto *val2 = L"hello "L"world";

    std::cout << STRCAT(L"hi ", L"there");
}

Per correggere l'errore, modificare il codice come segue:To fix the error, change the code to this:

#define MACRO

// Remove ##. Strings are automatically
// concatenated so they are not needed
#define STRCAT(x, y) x y

int main(){
    //Add space after closing quote
    auto *val1 = L"string" MACRO;
    auto *val2 = L"hello " L"world";

    std::cout << STRCAT(L"hi ", L"there");
}

Nell'esempio precedente, MACRO non viene più analizzato come doppio token (una stringa seguita da una macro),In the example above, MACRO is no longer parsed as two tokens (a string followed by a macro). ma come un unico token UDL.Now it is parsed as a single token UDL. Lo stesso vale per L""L"", che in precedenza veniva analizzato come L"" e L"" e ora viene analizzato come L""L e "".The same applies to L""L"", which was parsed previously as L"" and L"", and is now parsed as L""L and "".

Anche le regole di concatenazione delle stringhe sono state rese conformi agli standard, ovvero L"a" "b" equivale a L"ab".String concatenation rules were also brought into compliance with the standard, which means L"a" "b" is equivalent to L"ab". Le edizioni precedenti di Visual Studio non accettavano la concatenazione delle stringhe con una larghezza dei caratteri diversa.Previous editions of Visual Studio did not accept concatenation of strings with different character width.

  • Carattere vuoto C++ 11 rimossoC++11 empty character removed

Il codice seguente genera ora l'errore C2137: costante carattere vuotaThe following code now produces error C2137: empty character constant

bool check(wchar_t c){
    return c == L''; //implicit null character
}

Per correggere l'errore, modificare il codice come segue:To fix the error, change the code to this:

bool check(wchar_t c){
    return c == L'\0';
}
  • Le eccezioni MFC non possono essere intercettate per valore perché non sono copiabiliMFC exceptions can't be caught by value because they are not copyable

Il codice seguente in un'applicazione MFC genera ora l'errore C2316: 'D': non può essere intercettato come distruttore e/o i costruttori di copia sono inaccessibili oppure sono stati eliminatiThe following code in an MFC application now causes error C2316: 'D': cannot be caught as the destructor and/or copy constructor are inaccessible or deleted

struct B {
public:
    B();
private:
    B(const B &);
};

struct D : public B {
};

int main()
{
    try
    {
    }
    catch (D) // C2316
    {
    }
}

Per correggere il codice, è possibile modificare il blocco catch `catch (const D &)' ma, in genere, la soluzione migliore è quella di usare le macro MFC TRY/CATCH.To fix the code, you can change the catch block to `catch (const D &)' but the better solution is usually to use the MFC TRY/CATCH macros.

  • alignof è ora una parola chiavealignof is now a keyword

Il codice seguente genera ora l'errore C2332: 'class': nome tag mancante.The following code now produces error C2332: 'class': missing tag name. Per correggere il codice è necessario rinominare la classe o, se la classe esegue le stesse operazioni di alignof, è sufficiente sostituire la classe con la nuova parola chiave.To fix the code you must rename the class or, if the class is performing the same work as alignof, just replace the class with the new keyword.

class alignof{}
  • constexpr è ora una parola chiaveconstexpr is now a keyword

Il codice seguente genera ora l'errore C2059: errore di sintassi: ')'.The following code now produces error C2059: syntax error: ')'. Per correggere il codice, è necessario rinominare qualsiasi funzione o variabile denominata "constexpr".To fix the code, you must rename any function or variable names that are called "constexpr".

int constexpr() {return 1;}
  • I tipi movable non possono essere constMovable types cannot be const

Se una funzione restituisce un tipo che deve essere spostato, il tipo restituito non deve essere const.When a function returns a type that is intended to be moved, its return type should not be const.

  • Costruttori di copia eliminatiDeleted copy constructors

Il codice seguente genera ora l'errore C2280 'S::S(S &&)': tentativo di fare riferimento a una funzione eliminata:The following code now produces C2280 'S::S(S &&)': attempting to reference a deleted function:

struct S{
    S(int, int);
    S(const S&) = delete;
    S(S&&) = delete;
};

S s2 = S(2, 3); //C2280

Per correggere l'errore, usare l'inizializzazione diretta per S2:To fix the error, use direct initialization for S2:

struct S{
    S(int, int);
    S(const S&) = delete;
    S(S&&) = delete;
};

S s2 = {2,3}; //OK
  • Conversione in puntatore a funzione generata solo senza acquisizione delle espressioni lambdaConversion to function pointer only generated when no lambda capture

Il codice seguente genera l'errore C2664 in Visual Studio 2015.The following code produces C2664 in Visual Studio 2015.

void func(int(*)(int)) {}

int main() {

    func([=](int val) { return val; });
}

Per correggere l'errore, rimuovere = dall'elenco di acquisizioni.To fix the error, remove the = from the capture list.

  • Chiamate ambigue che coinvolgono operatori di conversioneAmbiguous calls involving conversion operators

Il codice seguente genera ora l'errore C2440: 'type cast': impossibile convertire da 'S2' a 'S1':The following code now produces error C2440: 'type cast': cannot convert from 'S2' to 'S1':

struct S1 {
    S1(int);
};

struct S2 {
    operator S1();
    operator int();
};

void f(S2 s2)
{

    (S1)s2;

}

Per correggere l'errore, chiamare l'operatore di conversione in modo esplicito:To fix the error, explicitly call the conversion operator:

void f(S2 s2)
{
    //Explicitly call the conversion operator
    s2.operator S1();
    // Or
    S1((int)s2);
}

Il codice seguente genera ora l'errore C2593: 'operator =' è ambiguo:The following code now produces error C2593: 'operator =' is ambiguous:

struct S1 {};

struct S2 {
    operator S1&();
    operator S1() const;
};

void f(S1 *p, S2 s)
{
    *p = s;
}

Per correggere l'errore, chiamare l'operatore di conversione in modo esplicito:To fix the error, explicitly call the conversion operator:

void f(S1 *p, S2 s)
{
       *p = s.operator S1&();
}
  • Correggere un'inizializzazione di copia non valida in un'inizializzazione di membri dati non statici (NSDMI)Fix invalid copy initialization in non-static data member initialization (NSDMI)

Il codice seguente genera ora l'errore C2664: 'S1::S1(S1 &&)': impossibile convertire l'argomento 1 da 'bool' a 'const S1 &':The following code now produces error C2664: 'S1::S1(S1 &&)': cannot convert argument 1 from 'bool' to 'const S1 &':

struct S1 {
    explicit S1(bool);
};

struct S2 {
    S1 s2 = true; // error
};

Per correggere l'errore, usare l'inizializzazione diretta:To fix the error, use direct initialization:

struct S2 {
S1 s1{true}; // OK
};
  • Accesso ai costruttori all'interno di istruzioni decltypeAccessing constructors inside decltype statements

Il codice seguente genera ora l'errore C2248: 'S::S': cannot access private member declared in class 'S' (S::S': impossibile accedere al membro privato dichiarato nella classe 'S'):The following code now produces C2248: 'S::S': cannot access private member declared in class 'S':

class S {
    S();
public:
    int i;
};

class S2 {
    auto f() -> decltype(S().i);
};

Per correggere l'errore, aggiungere una dichiarazione Friend per S2 in S:To fix the error, add a friend declaration for S2 in S:

class S {
    S();
    friend class S2; // Make S2 a friend
public:
    int i;
};
  • Il costruttore predefinito dell'espressione lambda viene eliminato in modo implicitoDefault ctor of lambda is implicitly deleted

Il codice seguente genera ora l'errore C3497: impossibile costruire un'istanza di un'espressione lambda:The following code now produces error C3497: you cannot construct an instance of a lambda:

void func(){
    auto lambda = [](){};    

    decltype(lambda) other;
}

Per correggere l'errore, rimuovere la necessità che venga chiamato il costruttore predefinito.To fix the error, remove the need for the default constructor to be called. Se l'espressione lambda non acquisisce niente, è possibile eseguirne il cast a un puntatore a funzione.If the lambda does not capture anything then it can be cast to a function pointer.

  • Espressioni lambda con un operatore di assegnazione eliminatoLambdas with a deleted assignment operator

Il codice seguente genera ora l'errore C2280:The following code now produces error C2280:

#include <memory>
#include <type_traits>

template <typename T, typename D>
std::unique_ptr<T, typename std::remove_reference<D &&>::type> wrap_unique(T *p, D &&d);

void f(int i)
{
    auto encodedMsg = wrap_unique<unsigned char>(nullptr, [i](unsigned char *p) {
    });
    encodedMsg = std::move(encodedMsg);
}

Per correggere l'errore, sostituire l'espressione lambda con una classe funtore o rimuovere la necessità di usare l'operatore di assegnazione.To fix the error, replace the lambda with a functor class or remove the need to use the assignment operator.

  • Tentativo di passare un oggetto con costruttore di copia eliminatoAttempting to move an object with deleted copy constructor

Il codice seguente genera ora l'errore C2280: 'moveable::moveable(const moveable &)': tentativo di fare riferimento a una funzione eliminataThe following code now produces error C2280: 'moveable::moveable(const moveable &)': attempting to reference a deleted function

struct moveable {

    moveable() = default;
    moveable(moveable&&) = default;
    moveable(const moveable&) = delete;
};

struct S {
    S(moveable && m) :
        m_m(m)//copy constructor deleted
    {}
    moveable m_m;
};

Per correggere l'errore, usare invece std::move:To fix the error, use std::move instead:

S(moveable && m) :
    m_m(std::move(m))
  • La classe locale non può fare riferimento a un'altra classe locale definita successivamente nella stessa funzioneLocal class can't reference other local class defined later in the same function

Il codice seguente genera ora l'errore C2079: 's' uses undefined struct 'main::S2' ('s' usa lo struct indefinito 'main::S2')The following code now produces error C2079: 's' uses undefined struct 'main::S2'

int main()
{
    struct S2;
    struct S1 {
        void f() {
            S2 s;
        }
    };
    struct S2 {};
}

Per correggere l'errore, spostare verso l'alto la definizione di S2:To fix the error, move up the definition of S2:

int main()
{
    struct S2 { //moved up
    };

struct S1 {
    void f() {
        S2 s;
        }
    };
}
  • Impossibile chiamare un costruttore base protetto nel corpo di un costruttore derivato.Cannot call a protected base ctor in the body of derived ctor.

Il codice seguente genera ora l'errore C2248: 'S1::S1': cannot access protected member declared in class 'S1' ('S1::S1': impossibile accedere al membro protetto dichiarato nella classe 'S1')The following code now produces error C2248: 'S1::S1': cannot access protected member declared in class 'S1'

struct S1 {
protected:
    S1();
};

struct S2 : public S1 {
    S2() {
        S1();
    }
};

Per correggere l'errore, in S2 rimuovere la chiamata a S1() dal costruttore e, se necessario, inserirla in un'altra funzione.To fix the error, in S2 remove the call to S1() from the constructor and if necessary put it in another function.

  • {} impedisce la conversione a puntatore{} prevents conversion to pointer

Il codice seguente genera ora l'errore C2439 'S::p': impossibile inizializzare il membroThe following code now produces C2439 'S::p': member could not be initialized

struct S {
    S() : p({ 0 }) {}
    void *p;
};

Per correggere l'errore, rimuovere le parentesi graffe intorno allo 0 oppure usare nullptr, come illustrato in questo esempio:To fix the error, remove the braces from around the 0 or else use nullptr instead, as shown in this example:

struct S {
    S() : p(nullptr) {}
    void *p;
};
  • Definizione di macro non corretta e uso con parentesiIncorrect macro definition and usage with parentheses

L'esempio seguente genera ora l'errore C2008: ';': imprevisto nella definizione macroThe following example now produces error C2008: ';': unexpected in macro definition

#define A; //cause of error

struct S {
    A(); // error
};

Per correggere il problema, modificare la riga superiore in #define A();To fix the problem change the top line to #define A();

Il codice seguente genera ora l'errore C2059: errore di sintassi ')'The following code produces error C2059: syntax error: ')'


//notice the space after 'A'
#define A () ;

struct S {
    A();
};

Per correggere il codice, rimuovere lo spazio tra A e ().To fix the code remove the space between A and ().

Il codice seguente genera l'errore C2091: la funzione restituisce una funzione:The following code produces error C2091: function returns function:


#define DECLARE void f()

struct S {
    DECLARE();
};

Per correggere l'errore, rimuovere le parentesi dopo DECLARE in S: DECLARE;.To fix the error, remove the parentheses after DECLARE in S: DECLARE;.

Il codice seguente genera l'errore C2062: tipo 'int' imprevistoThe following code produces error C2062: type 'int' unexpected

#define A (int)

struct S {
    A a;
};

Per correggere il problema, definire A come illustrato di seguito:To fix the problem, define A like this:

#define A int
  • Parentesi superflue nelle dichiarazioniExtra parens in declarations

Il codice seguente genera l'errore C2062: tipo 'int' imprevistoThe following code produces error C2062: type 'int' unexpected


struct S {
    int i;
    (int)j;
};

Per correggere l'errore, rimuovere le parentesi da j.To fix the error, remove the parens from j. Se le parentesi sono necessarie per maggiore chiarezza, usare un typedef.If the parens are needed for clarity, then use a typedef.

  • Costruttori generati dal compilatore e __declspec(novtable)Compiler-generated constructors and __declspec(novtable)

In Visual Studio 2015 esiste la possibilità che i costruttori generati da compilatori inline di classi astratte con classi di base virtuali possano presentare un uso non corretto di __declspec(novtable) se non vengono usati in combinazione con __declspec(dllimport).In Visual Studio 2015, there is an increased likelihood that inline compiler-generated constructors of abstract classes with virtual base classes may expose improper usage of __declspec(novtable) when used in combination with __declspec(dllimport).

  • auto richiede una sola espressione in direct-list-initialization Il codice seguente genera ora l'errore C3518: 'testPositions': in un contesto direct-list-initialization il tipo per 'auto' può essere dedotto solo da una singola espressione dell'inizializzatoreauto requires single expression in direct-list-initialization The following code now produces error C3518: 'testPositions': in a direct-list-initialization context the type for 'auto' can only be deduced from a single initializer expression
auto testPositions{
    std::tuple<int, int>{13, 33},
    std::tuple<int, int>{-23, -48},
    std::tuple<int, int>{38, -12},
    std::tuple<int, int>{-21, 17}
};

Per correggere l'errore, è possibile inizializzare testPositions come indicato di seguito:To fix the error, one possibility is to initialize testPositions as follows:

std::tuple<int, int> testPositions[]{
    std::tuple<int, int>{13, 33},
    std::tuple<int, int>{-23, -48},
    std::tuple<int, int>{38, -12},
    std::tuple<int, int>{-21, 17}
};
  • Confronto tra tipi e puntatori a tipi per is_convertibleChecking types vs. pointers to types for is_convertible

Il codice seguente genera ora l'esito negativo dell'asserzione statica.The following code now causes the static assertion to fail.

struct B1 {
private:
    B1(const B1 &);
};
struct B2 : public B1 {};
struct D : public B2 {};

static_assert(std::is_convertible<D, B2>::value, "fail");

Per correggere l'errore, modificare static_assert in modo che metta a confronto i puntatori a D e B2:To fix the error, change the static_assert so that it compares pointers to D and B2:

static_assert(std::is_convertible<D*, B2*>::value, "fail");
  • le dichiarazioni declspec(novtable) devono essere coerentideclspec(novtable) declarations must be consistent

Le dichiarazioni declspec devono essere coerenti in tutte le librerie.declspec declarations must be consistent across all libraries. Il seguente codice ora genera una violazione One Definition Rule:The following code will now produce a one-definition rule (ODR) violation:


//a.cpp
class __declspec(dllexport)
    A {
public:
    A();
    A(const A&);
    virtual ~A();
private:
    int i;
};

A::A() {}
A::~A() {}
A::A(const A&) {}

//b.cpp
// compile with cl.exe /nologo /LD /EHsc /Osx b.cpp
#pragma comment(lib, "A")
class __declspec(dllimport) A
{
public: A();
         A(const A&);
         virtual ~A();
private:
    int i;
};

struct __declspec(novtable) __declspec(dllexport) B
    : virtual public A {
    virtual void f() = 0;
};

//c.cpp
#pragma comment(lib, "A")
#pragma comment(lib, "B")
class __declspec(dllimport) A
{
public:
    A();
    A(const A&);
    virtual ~A();
private:
    int i;
};
struct  /* __declspec(novtable) */ __declspec(dllimport) B // Error. B needs to be novtable here also.
    : virtual public A
{
    virtual void f() = 0;
};

struct C : virtual B
{
    virtual void f();
};

void C::f() {}
C c;

Miglioramenti della conformità in Update 1Conformance Improvements in Update 1

  • Classi base virtuali private ed ereditarietà indirettaPrivate virtual base classes and indirect inheritance

    Le versioni precedenti del compilatore consentivano a una classe derivata di chiamare le funzioni di membro relative alle classi base indirettamente derivateprivate virtual.Previous versions of the compiler allowed a derived class to call member functions of its indirectly-derivedprivate virtual base classes. Questo comportamento precedente non era corretto e non è conforme allo standard C++.This old behavior was incorrect and does not conform to the C++ standard. Il compilatore non accetta più il codice scritto in questo modo e genera l'errore del compilatore C2280 di conseguenza.The compiler no longer accepts code written in this way and issues compiler error C2280 as a result.

    
    error C2280: 'void *S3::__delDtor(unsigned int)': attempting to reference a deleted function  
    

    Esempio (prima)Example (before)

    class base  
    {  
    protected:  
        base();  
        ~base();  
    };  
    
    class middle : private virtual base {}; class top : public virtual middle {};   
    
    void destroy(top *p)  
    {  
        delete p;  //  
    }  
    

    Esempio (dopo)Example (after)

    class base;  // as above  
    
    class middle : protected virtual base {};  
    class top : public virtual middle {};  
    
    void destroy(top *p)  
    {  
        delete p;  
    }  
    

    -oppure--or -

    class base;  // as above  
    
    class middle : private virtual base {};  
    class top : public virtual middle, private virtual bottom {};  
    
    void destroy(top *p)  
    {  
        delete p;  
    }  
    
  • Funzioni operator new e operator delete in overloadOverloaded operator new and operator delete

    Le versioni precedenti del compilatore consentivano di dichiarare static le funzioni non membro operator new e non membro operator delete negli spazi dei nomi diversi dallo spazio dei nomi globale.Previous versions of the compiler allowed non-member operator new and non-member operator delete to be declared static, and to be declared in namespaces other than the global namespace. Questo comportamento precedente creava il rischio che il programma non chiamasse l'implementazione dell'operator new o delete prevista dal programmatore, determinando un comportamento errato in fase di esecuzione senza avvisare.This old behavior created a risk that the program would not call the new or delete operator implementation that the programmer intended, resulting in silent bad runtime behavior. Il compilatore non accetta più il codice scritto in questo modo e genera invece l'errore del compilatore C2323.The compiler no longer accepts code written in this way and issues compiler error C2323 instead.

    
    error C2323: 'operator new': non-member operator new or delete functions may not be declared static or in a namespace other than the global namespace.  
    

    Esempio (prima)Example (before)

    static inline void * __cdecl operator new(size_t cb, const std::nothrow_t&)  // error C2323  
    

    Esempio (dopo)Example (after)

    void * __cdecl operator new(size_t cb, const std::nothrow_t&)  // removed 'static inline'  
    

    Inoltre, nonostante il compilatore non fornisca una diagnostica specifica, il formato dell'operatore new inline viene considerato non valido.Additionally, although the compiler doesn't give a specific diagnostic, inline operator new is considered ill-formed.

  • Chiamata di 'operator type()' (conversione definita dall'utente) in tipi non classeCalling 'operator type()' (user-defined conversion) on non-class types

    Le versioni precedenti del compilatore consentivano di chiamare 'operator type()' su tipi non classe ignorandolo senza avvisare.Previous versions of the compiler allowed 'operator type()' to be called on non-class types while silently ignoring it. Questo comportamento precedente creava un rischio di generazione di codice errato senza avvisare, determinando un comportamento imprevedibile in fase di esecuzione.This old behavior created a risk of silent bad code generation, resulting in unpredictable runtime behavior. Il compilatore non accetta più il codice scritto in questo modo e genera invece l'errore del compilatore C2228.The compiler no longer accepts code written in this way and issues compiler error C2228 instead.

    
    error C2228: left of '.operator type' must have class/struct/union  
    

    Esempio (prima)Example (before)

    typedef int index_t;  
    void bounds_check(index_t index);  
    void login(int column)  
    {  
        bounds_check(column.operator index_t());  // error C2228  
    }  
    

    Esempio (dopo)Example (after)

    typedef int index_t;  
    void bounds_check(index_t index);  
    void login(int column)  
    {  
        bounds_check(column);  // removed cast to 'index_t', 'index_t' is an alias of 'int'  
    }  
    
  • Typename ridondante negli identificatori di tipi elaboratiRedundant typename in elaborated type specifiers

    Le versioni precedenti del compilatore consentivano typename negli identificatori di tipi elaborati; il codice scritto in questo modo non è semanticamente corretto.Previous versions of the compiler allowed typename in an elaborated type specifiers; code written in this way is semantically incorrect. Il compilatore non accetta più il codice scritto in questo modo e genera invece l'errore del compilatore C3406.The compiler no longer accepts code written in this way and issues compiler error C3406 instead.

    error C3406: 'typename' cannot be used in an elaborated type specifier  
    

    Esempio (prima)Example (before)

    template <typename class T>  
    class container;  
    

    Esempio (dopo)Example (after)

    template <class T>  // alternatively, could be 'template <typename T>'; 'typename' is not elaborating a type specifier in this case  
    class container;  
    
  • Deduzione del tipo di matrici da un elenco di inizializzatoriType deduction of arrays from an initializer list

    Le versioni precedenti del compilatore non supportavano la deduzione del tipo di matrici da un elenco di inizializzatori.Previous versions of the compiler did not support type deduction of arrays from an initializer list. Il compilatore supporta ora questa forma di deduzione del tipo e, di conseguenza, le chiamate a modelli di funzione con gli elenchi di inizializzatori potrebbero essere ambigue o potrebbe essere scelto un altro overload rispetto alle versioni precedenti del compilatore.The compiler now supports this form of type deduction and, as a result, calls to function templates using initializer lists might now be ambiguous or a different overload might be chosen than in previous versions of the compiler. Per risolvere questi problemi, il programma deve ora specificare in modo esplicito l'overload previsto dal programmatore.To resolve these issues, the program must now explicitly specify the overload that the programmer intended.

    Quando questo nuovo comportamento fa sì che la risoluzione dell'overload consideri un candidato aggiuntivo che sia altrettanto efficace del candidato storico, la chiamata diventa ambigua e il compilatore genera l'errore del compilatore C2668 di conseguenza.When this new behavior causes overload resolution to consider an additional candidate that is equally as good as the historic candidate, the call becomes ambiguous and the compiler issues compiler error C2668 as a result.

    
    error C2668: 'function' : ambiguous call to overloaded function.  
    

    Esempio 1: chiamata ambigua a funzione in overload (prima)Example 1: Ambiguous call to overloaded function (before)

    // In previous versions of the compiler, code written in this way would unambiguously call f(int, Args...)  
    template < typename... Args>  
    void f(int, Args...);  //  
    
    template < int N, typename... Args>  
    void f(const int(&)[N], Args...);  
    
    int main()  
    {  
        // The compiler now considers this call ambiguous, and issues a compiler error  
         f({ 3 });   error C2668 : 'f' ambiguous call to overloaded function  
    }  
    

    Esempio 1: chiamata ambigua a funzione in overload (dopo)Example 1: ambiguous call to overloaded function (after)

    template < typename... Args>  
    void f(int, Args...);  //  
    
    template < int N, typename... Args>  
    void f(const int(&)[N], Args...);  
    
    int main()  
    {  
        // To call f(int, Args...) when there is just one expression in the initializer list, remove the braces from it.  
        f(3);   
    }  
    

    Quando questo nuovo comportamento fa sì che la risoluzione dell'overload consideri un candidato aggiuntivo che sia una corrispondenza migliore rispetto al candidato storico, la chiamata viene risolta senza ambiguità nel nuovo candidato, causando una modifica nel comportamento del programma che è probabilmente diverso da quello previsto dal programmatore.When this new behavior causes overload resolution to consider an additional candidate that is a better match than the historic candidate, the call resolves unambiguously to the new candidate, causing a change in program behavior that is probably different than the programmer intended.

    Esempio 2: modifica nella risoluzione dell'overload (prima)Example 2: change in overload resolution (before)

    // In previous versions of the compiler, code written in this way would unambiguously call f(S, Args...)  
    struct S  
    {  
        int i;  
        int j;  
    };  
    
    template < typename... Args>  
    void f(S, Args...);  
    
    template < int N, typename... Args>  
    void f(const int *&)[N], Args...);  
    
    int main()  
    {  
        // The compiler now resolves this call to f(const int (&)[N], Args...) instead  
         f({ 1, 2 });   
    }  
    

    Esempio 2: modifica nella risoluzione dell'overload (dopo)Example 2: change in overload resolution (after)

    struct S;  // as before  
    
    template < typename... Args>  
    void f(S, Args...);  
    
    template < int N, typename... Args>  
    void f(const int *&)[N], Args...);  
    
    int main()  
    {  
        // To call f(S, Args...), perform an explicit cast to S on the initializer list.  
        f(S{ 1, 2 });   
    }  
    
  • Ripristino di avvisi di istruzione switchRestoration of switch statement warnings

    Una versione precedente del compilatore rimuoveva gli avvisi preesistenti correlati alle istruzioni switch ; questi avvisi sono ora stati ripristinati.A Previous version of the compiler removed previously-existing warnings related to switch statements; these warnings have now been restored. Il compilatore genera ora gli avvisi ripristinati e gli avvisi correlati a casi specifici (incluso il caso predefinito) sono ora rilasciati sulla riga contenente il caso che causa l'errore, anziché l'ultima riga dell'istruzione switch.The compiler now issues the restored warnings, and warnings related to specific cases (including the default case) are now issued on the line containing the offending case, rather than on the last line of the switch statement. Dal momento che gli avvisi vengono ora emessi su diverse righe rispetto al passato, di conseguenza gli avvisi precedentemente eliminato con #pragma warning(disable:####) non potranno più essere eliminati come previsto.As a result of now issuing those warnings on different lines than in the past, warnings previously suppressed by using #pragma warning(disable:####) may no longer be suppressed as intended. Per eliminare questi avvisi come previsto, potrebbe essere necessario spostare la direttiva #pragma warning(disable:####) a una riga sopra il primo caso potenzialmente danneggiato.To suppress these warnings as intended, it might be necessary to move the #pragma warning(disable:####) directive to a line above the first potentially-offending case. Di seguito sono elencati gli avvisi ripristinati.The following are the restored warnings.

    warning C4060: switch statement contains no 'case' or 'default' labels  
    
    
    warning C4061: enumerator 'bit1' in switch of enum 'flags' is not explicitly handled by a case label  
    
    
    warning C4062: enumerator 'bit1' in switch of enum 'flags' is not handled  
    
    
    warning C4063: case 'bit32' is not a valid value for switch of enum 'flags'  
    
    
    warning C4064: switch of incomplete enum 'flags'  
    
    warning C4065: switch statement contains 'default' but no 'case' labels  
    
    
    warning C4808: case 'value' is not a valid value for switch condition of type 'bool'  
    
    Warning C4809: switch statement has redundant 'default' label; all possible 'case' labels are given  
    

    Esempio di C4063 (prima)Example of C4063 (before)

    class settings  
    {  
    public:  
        enum flags  
        {  
            bit0 = 0x1,  
            bit1 = 0x2,  
            ...  
        };  
        ...  
    };  
    
    int main()  
    {  
        auto val = settings::bit1;  
    
        switch (val)  
        {  
        case settings::bit0:  
            break;  
    
        case settings::bit1:  
            break;  
    
             case settings::bit0 | settings::bit1:  // warning C4063  
                break;  
        }  
    };  
    

    Esempio di C4063 (dopo)Example of C4063 (after)

    class settings { ... };  // as above  
    int main()  
    {  
        // since C++11, use std::underlying_type to determine the underlying type of an enum  
        typedef std::underlying_type< settings::flags> ::type flags_t;   
    
            auto val = settings::bit1;  
    
        switch (static_cast< flags_t> (val))  
        {  
        case settings::bit0:  
            break;  
    
        case settings::bit1:  
            break;  
    
        case settings::bit0 | settings::bit1:  // ok  
            break;  
        }  
    };  
    

    Gli esempi di altri avvisi ripristinati vengono forniti nella relativa documentazione.Examples of the other restored warnings are provided in their documentation.

  • #include: usare l'identificatore di directory padre '..' nel percorso (influisce solo su /Wall /WX)#include: use of parent-directory specifier '..' in pathname (only affects /Wall /WX)

    Le versioni precedenti del compilatore non è stato rilevato l’utilizzo dell’identificatore di directory padre ‘... ‘Previous versions of the compiler did not detect the use of the parent-directory specifier '..' nel percorso del #include direttive.in the pathname of #include directives. Il codice scritto in questo modo è in genere usato in modo da includere le intestazioni che esistono di fuori del progetto usando in modo non corretto percorsi relativi al progetto.Code written in this way is usually intended to include headers that exist outside of the project by incorrectly using project-relative paths. Questo comportamento precedente creava il rischio che il programma potesse essere compilato con l'inclusione di un file di origine diversa rispetto a quello previsto dal programmatore, o che i percorsi relativi non sarebbero stati portabili in altri ambienti di compilazione.This old behavior created a risk that the program could be compiled by including a different source file than the programmer intended, or that these relative paths would not be portable to other build environments. Il compilatore ora rileva e invia una notifica al programmatore riguardo il codice scritto in questo modo e genera un avviso del compilatore C4464 facoltativo, se abilitato.The compiler now detects and notifies the programmer of code written in this way and issues an optional compiler warning C4464, if enabled.

    warning C4464: relative include path contains '..'  
    

    Esempio (prima)Example (before)

    #include "..\headers\C4426.h"  // emits warning C4464  
    

    Esempio (dopo)Example (after)

    #include "C4426.h"  // add absolute path to 'headers\' to your project's include directories  
    

    Inoltre, nonostante il compilatore non offra una diagnostica specifica, è anche consigliabile che l'identificatore di directory padre ".." non venga usato per specificare le directory include del progetto.Additionally, although the compiler does not give a specific diagnostic, we also recommend that the parent-directory specifier ".." should note be used to specify your project's include directories.

  • #pragma optimize() estende oltre la fine del file di intestazione (influisce solo su /Wall /WX)#pragma optimize() extends past end of header file (only affects /Wall /WX)

    Le versioni precedenti del compilatore non rilevavano le modifiche alle impostazioni del flag di ottimizzazione non incluse in un file di intestazione all'interno di un'unità di conversione.Previous versions of the compiler did not detect changes to optimization flag settings that escape a header file included within a translation unit. Il compilatore ora rileva e invia una notifica al programmatore riguardo il codice scritto in questo modo e genera un avviso del compilatore C4426 facoltativo nella posizione della direttiva #includedanneggiata, se abilitata.The compiler now detects and notifies the programmer of code written in this way and issues an optional compiler warning C4426 at the location of the offending #include, if enabled. Questo avviso viene generato solo se le modifiche sono in conflitto con i flag di ottimizzazione impostati dagli argomenti della riga di comando nel compilatore.This warning is only issued if the changes conflict with the optimization flags set by command-line arguments to the compiler.

    warning C4426: optimization flags changed after including header, may be due to #pragma optimize()  
    

    Esempio (prima)Example (before)

    // C4426.h  
    #pragma optimize("g", off)  
    ...  
    // C4426.h ends  
    
    // C4426.cpp  
    #include "C4426.h"  // warning C4426  
    

    Esempio (dopo)Example (after)

    // C4426.h  
    #pragma optimize("g", off)  
                ...  
    #pragma optimize("", on)  // restores optimization flags set via command-line arguments  
    // C4426.h ends  
    
    // C4426.cpp  
    #include "C4426.h"  
    
  • Stati #pragma warning(push) e #pragma warning(pop) (influisce solo su /Wall /WX)Mismatched #pragma warning(push) and #pragma warning(pop) (only affects /Wall /WX)

    Le versioni precedenti del compilatore non rilevavano l'abbinamento delle modifiche di stato #pragma warning(push) con le modifiche di stato #pragma warning(pop) in un file di origine differente e questo raramente rappresenta lo scopo previsto.Previous versions of the compiler did not detect #pragma warning(push) state changes being paired with #pragma warning(pop) state changes in a different source file, which is rarely intended. Questo comportamento precedente creava il rischio che il programma fosse compilato con un set di avvisi abilitato diverso da quello previsto dal programmatore, determinando un probabile comportamento errato in fase di esecuzione senza avvisare.This old behavior created a risk that the program would be compiled with a different set of warnings enabled than the programmer intended, possibly resulting in silent bad runtime behavior. Il compilatore ora rileva e invia una notifica al programmatore riguardo al codice scritto in questo modo e genera un avviso del compilatore C5031 facoltativo nella posizione della direttiva #pragma warning(pop) corrispondente, se abilitata.The compiler now detects and notifies the programmer of code written in this way and issues an optional compiler warning C5031 at the location of the matching #pragma warning(pop), if enabled. Questo avviso include una nota che fa riferimento alla posizione della direttiva #pragma warning(push) corrispondente.This warning includes a note referencing the location of the corresponding #pragma warning(push).

    warning C5031: #pragma warning(pop): likely mismatch, popping warning state pushed in different file  
    

    Esempio (prima)Example (before)

    // C5031_part1.h  
    #pragma warning(push)  
    #pragma warning(disable:####)  
    ...  
    // C5031_part1.h ends without #pragma warning(pop)  
    
    // C5031_part2.h  
    ...  
    #pragma warning(pop)  // pops a warning state not pushed in this source file  
    ...  
    // C5031_part1.h ends  
    
    // C5031.cpp  
    #include "C5031_part1.h" // leaves #pragma warning(push) 'dangling'  
    ...  
    #include "C5031_part2.h" // matches 'dangling' #pragma warning(push), resulting in warning C5031  
    ...  
    

    Esempio (dopo)Example (after)

    // C5031_part1.h  
    #pragma warning(push)  
    #pragma warning(disable:####)  
    ...  
    #pragma warning(pop)  // pops the warning state pushed in this source file  
    // C5031_part1.h ends without #pragma warning(pop)  
    
    // C5031_part2.h  
    #pragma warning(push)  // pushes the warning state pushed in this source file  
    #pragma warning(disable:####)  
    ...  
    #pragma warning(pop)  
    // C5031_part1.h ends  
    
    // C5031.cpp  
    #include "C5031_part1.h" // #pragma warning state changes are self-contained and independent of other source files or their #include order.  
    ...  
    #include "C5031_part2.h"  
    ...  
    

    Benché sia un fatto insolito, a volte il codice scritto in questo modo è intenzionale.Though uncommon, code written in this way is sometimes intentional. Il codice scritto in questo modo è sensibile alle modifiche nell'ordine #include. Se possibile, è consigliabile che i file del codice sorgente gestiscano lo stato di avviso in modo autonomo.Code written in this way is sensitive to changes in #include order; when possible, we recommend that source code files manage warning state in a self-contained way.

  • Stato #pragma warning(push) senza corrispondenza (influisce solo su /Wall /WX)Unmatched #pragma warning(push) (only affects /Wall /WX)

    Le versioni precedenti del compilatore non rilevavano modifiche di stato #pragma warning(push) senza corrispondenza alla fine di un'unità di conversione.Previous versions of the compiler did not detect unmatched #pragma warning(push) state changes at the end of a translation unit. Il compilatore ora rileva e invia una notifica al programmatore riguardo il codice scritto in questo modo e genera un avviso del compilatore C5032 nella posizione della direttiva #pragma warning(push) senza corrispondenza, se abilitata.The compiler now detects and notifies the programmer of code written in this way and issues an optional compiler warning C5032 at the location of the unmatched #pragma warning(push), if enabled. Questo avviso viene generato solo se non sono presenti errori di compilazione nell'unità di conversione.This warning is only issued if there are no compilation errors in the translation unit.

    warning C5032: detected #pragma warning(push) with no corresponding #pragma warning(pop)  
    

    Esempio (prima)Example (before)

    // C5032.h  
    #pragma warning(push)  
    #pragma warning(disable:####)  
    ...  
    // C5032.h ends without #pragma warning(pop)  
    
    // C5032.cpp  
    #include "C5032.h"  
    ...  
    // C5032.cpp ends -- the translation unit is completed without #pragma warning(pop), resulting in warning C5032 on line 1 of C5032.h  
    

    Esempio (dopo)Example (after)

    // C5032.h  
    #pragma warning(push)  
    #pragma warning(disable:####)  
    ...  
    #pragma warning(pop) // matches #pragma warning (push) on line 1  
    // C5032.h ends  
    
    // C5032.cpp  
    #include "C5032.h"  
    ...  
    // C5032.cpp ends -- the translation unit is completed without unmatched #pragma warning(push)  
    
  • Potrebbero essere generati avvisi aggiuntivi in seguito al migliorato rilevamento dello stato della direttiva #pragma warningAdditional warnings might be issued as a result of improved #pragma warning state tracking

    Le versioni precedenti del compilatore rilevavano le modifiche di stato della direttiva #pragma warning in maniera non sufficiente a generare tutti gli avvisi previsti.Previous versions of the compiler tracked #pragma warning state changes insufficiently well to issue all intended warnings. Questo comportamento comportava il rischio che alcuni avvisi sarebbero stati eliminati in modo efficace in circostanze diverse rispetto a quelle previste dal programmatore.This behavior created a risk that certain warnings would be effectively suppressed in circumstances different than the programmer intended. Il compilatore ora tiene traccia dello stato della direttiva #pragma warning in modo più affidabile, specialmente per quanto riguarda le modifiche dello stato della direttiva #pragma warning all'interno dei modelli, e facoltativamente rilascia nuovi avvisi C5031 e C5032 che aiutano il programmatore a trovare gli usi imprevisti di #pragma warning(push) e #pragma warning(pop).The compiler now tracks #pragma warning state more robustly -- especially related to #pragma warning state changes inside of templates -- and optionally issues new warnings C5031 and C5032 which are intended to help the programmer locate unintended uses of #pragma warning(push) and #pragma warning(pop).

    In seguito al migliorato rilevamento delle modifiche di stato della direttiva #pragma warning, è ora possibile generare gli avvisi in precedenza eliminati in modo errato oppure gli avvisi relativi ai problemi in precedenza diagnosticati in modo errato.As a result of improved #pragma warning state change tracking, warnings formerly incorrectly suppressed or warnings related to issues formerly misdiagnosed might now be issued.

  • Identificazione del codice non eseguibile migliorataImproved identification of unreachable code

    Le modifiche della Libreria standard C++ e la migliorata capacità di incorporare le chiamate di funzione inline rispetto alle versioni precedenti del compilatore potrebbero consentire al compilatore di dimostrare che determinato codice è ora non eseguibile.C++ Standard Library changes and improved ability to inline function calls over previous versions of the compiler might allow the compiler to prove that certain code is now unreachable. Questo nuovo comportamento può comportare nuove e più frequenti visualizzazioni dell'avviso C4720.This new behavior can result in new and more-frequently issued instances of warning C4720.

    warning C4720: unreachable code  
    

    In molti casi, l'avviso potrebbe essere generato solo durante la compilazione con ottimizzazioni abilitate, dal momento che le ottimizzazioni potrebbero incorporare più chiamate di funzione, eliminare il codice ridondante o altrimenti consentire di determinare che determinato codice non è eseguibile.In many cases, this warning might only be issued when compiling with optimizations enabled, since optimizations may inline more function calls, eliminate redundant code, or otherwise make it possible to determine that certain code is unreachable. Si è osservato che le nuove istanze dell'avviso C4720 si sono verificate di frequente nei blocchi try/catch, in special modo in relazione all'uso di std::find.We have observed that new instances of warning C4720 have frequently occurred in try/catch blocks, especially in relation to use of std::find.

    Esempio (prima)Example (before)

    try  
    {  
        auto iter = std::find(v.begin(), v.end(), 5);  
    }  
    catch (...)  
    {  
        do_something();   // ok  
    }  
    

    Esempio (dopo)Example (after)

    try  
    {  
        auto iter = std::find(v.begin(), v.end(), 5);  
    }  
    catch (...)  
    {  
        do_something();   // warning C4702: unreachable code  
    }  
    

Miglioramenti della conformità in Update 2Conformance Improvements in Update 2

  • Errori e avvisi aggiuntivi potrebbero essere generati in seguito a un supporto parziale per l'espressione SFINAEAdditional warnings and errors might be issued as a result of partial support for expression SFINAE

    Le versioni precedenti del compilatore non analizzavano alcuni tipi di espressioni negli identificatori decltype a causa della mancanza di supporto per l'espressione SFINAE.Previous versions of the compiler did not parse certain kinds of expressions inside decltype specifiers due to lack of support for expression SFINAE. Questo comportamento precedente non era corretto e non è conforme allo standard C++.This old behavior was incorrect and does not conform to the C++ standard. Grazie ai costanti miglioramenti alla conformità, ora il compilatore analizza le espressioni e ha un supporto parziale per l'espressione SFINAE.The compiler now parses these expressions and has partial support for expression SFINAE due to ongoing conformance improvements. Di conseguenza, ora vengono visualizzati avvisi ed errori rilevati nelle espressioni non analizzati dalle versioni precedenti del compilatore.As a result, the compiler now issues warnings and errors found in expressions that previous versions of the compiler did not parse.

    Quando questo nuovo comportamento analizza un'espressione decltype che include un tipo non ancora dichiarato, il compilatore genera l'errore C2039.When this new behavior parses a decltype expression that includes a type that has not yet been declared, the compiler issues compiler error C2039 as a result.

    
    error C2039: 'type': is not a member of '`global namespace''  
    

    Esempio 1: uso di un tipo non dichiarato (prima)Example 1: use of an undeclared type (before)

    struct s1  
    {  
        template < typename T>  
        auto f() - > decltype(s2< T> ::type::f());  // error C2039  
    
        template< typename>  
        struct s2 {};  
    }  
    

    Esempio 1 (dopo)Example 1 (after)

    struct s1  
    {  
        template < typename>  // forward declare s2struct s2;   
    
            template < typename T>  
        auto f() - > decltype(s2< T> ::type::f());  
    
        template< typename>  
        struct s2 {};  
    }  
    

    Quando questo nuovo comportamento analizza un'espressione decltype in cui non è presente un utilizzo necessario della parola chiave typename per specificare che il nome dipendente è un tipo, il compilatore genera l'avviso C4346 e l'errore C2923.When this new behavior parses a decltype expression that is missing a necessary use of the typename keyword to specify that a dependent name is a type, the compiler issues compiler warning C4346 together with compiler error C2923.

    
    warning C4346: 'S2<T>::Type': dependent name is not a type  
    
    
    error C2923: 's1': 'S2<T>::Type' is not a valid template type argument for parameter 'T'  
    

    Esempio 2: il nome dipendente non è un tipo (prima)Example 2: dependent name is not a type (before)

    template < typename T>  
    struct s1  
    {  
        typedef T type;  
    };  
    
    template < typename T>  
    struct s2  
    {  
        typedef T type;  
    };  
    
    template < typename T>  
    T declval();  
    
    struct s  
    {  
        template < typename T>  
        auto f(T t) - > decltype(t(declval< S1< S2< T> ::type> ::type> ()));  // warning C4346, error C2923  
    };  
    

    Esempio 2 (dopo)Example 2 (after)

    template < typename T> struct s1 { ... };  // as above  
    template < typename T> struct s2 { ... };  // as above  
    
    template < typename T>  
    T declval();  
    
    struct s  
    {  
        template < typename T>  
        auto f(T t) - > decltype(t(declval< S1< typename S2< T> ::type> ::type> ()));  
    };  
    
  • volatile Le variabili membro impediscono i costruttori e gli operatori di assegnazione definiti in modo implicitovolatile member variables prevent implicitly defined constructors and assignment operators

    Le versioni precedenti del compilatore consentivano a una classe con variabili membro volatile di generare automaticamente costruttori di copia/spostamento predefiniti e operatori di assegnazione di copia/spostamento predefiniti.Previous versions of the compiler allowed a class that has volatile member variables to have default copy/move constructors and default copy/move assignment operators automatically generated. Questo comportamento precedente non era corretto e non è conforme allo standard C++.This old behavior was incorrect and does not conform to the C++ standard. Ora il compilatore presuppone che una classe con variabili membro volatili includa operatori di costruzione e di assegnazione non semplici e, di conseguenza, impedisce la generazione automatica delle implementazioni predefinite di questi operatori.The compiler now considers a class that has volatile member variables to have non-trivial construction and assignment operators which prevents default implementations of these operators from being automatically generated. Quando questa classe è un membro di un'unione (o un'unione anonima all'interno di una classe), i costruttori di copia/spostamento e gli operatori di assegnazione di copia/spostamento dell'unione (o della classe che contiene l'unione anonima) vengono definiti in modo implicito come eliminati.When such a class is a member of a union (or an anonymous union inside of a class), the copy/move constructors and copy/move assignment operators of the union (or the class containing the unonymous union) will be implicitly defined as deleted. Il tentativo di costruire o copiare l'unione (o la classe che contiene l'unione anonima) senza definirli in modo esplicito è un errore e, di conseguenza, il compilatore genera l'errore C2280.Attempting to construct or copy the union (or class containing the anonymous union) without explicitly defining them is an error and the compiler issues compiler error C2280 as a result.

    
    error C2280: 'B::B(const B &)': attempting to reference a deleted function  
    

    Esempio (prima)Example (before)

    struct A  
    {  
        volatile int i;  
        volatile int j;  
    };  
    
    extern A* pa;  
    
    struct B  
    {  
        union  
        {  
            A a;  
            int i;  
        };  
    };  
    
    B b1{ *pa };  
    B b2(b1);  // error C2280  
    

    Esempio (dopo)Example (after)

    struct A  
    {  
        int i; int j;   
    };  
    
    extern volatile A* pa;  
    
    A getA()  // returns an A instance copied from contents of pa  
    {  
        A a;  
        a.i = pa - > i;  
        a.j = pa - > j;  
        return a;  
    }  
    
    struct B;  // as above  
    
    B b1{ GetA() };  
    B b2(b1);  // error C2280  
    
  • Le funzioni membro statiche non supportano i qualificatori CV.Static member functions do not support cv-qualifiers.

    Le versioni precedenti di Visual Studio 2015 consentivano alle funzioni membro statiche di avere qualificatori CV.Previous versions of Visual Studio 2015 allowed static member functions to have cv-qualifiers. Questo comportamento è dovuto a una regressione in Visual Studio 2015 e Visual Studio 2015 Update 1. Visual Studio 2013 e le versioni precedenti del compilatore non accettano il codice scritto in questo modo.This behavior is due to a regression in Visual Studio 2015 and Visual Studio 2015 Update 1; Visual Studio 2013 and previous versions of the compiler reject code written in this way. Il comportamento di Visual Studio 2015 e Visual Studio 2015 Update 1 non è corretto e non è conforme allo standard C++.The behavior of Visual Studio 2015 and Visual Studio 2015 Update 1 is incorrect and does not conform to the C++ standard. Visual Studio 2015 Update 2 non accetta il codice scritto in questo modo e genera l'errore del compilatore C2511.Visual Studio 2015 Update 2 rejects code written in this way and issues compiler error C2511 instead.

    error C2511: 'void A::func(void) const': overloaded member function not found in 'A'  
    

    Esempio (prima)Example (before)

    struct A  
    {  
        static void func();  
    };  
    
    void A::func() const {}  // C2511  
    

    Esempio (dopo)Example(after)

    struct A  
    {  
        static void func();  
    };  
    
    void A::func() {}  // removed const  
    
  • La dichiarazione con prototipo di tipo enum non è consentita nel codice WinRT (interessa solo /ZW)Forward declaration of enum is not allowed in WinRT code (affects /ZW only)

    Il codice compilato per Windows Runtime (WinRT) non consente la dichiarazione con prototipo dei tipi enum, analogamente a quanto accade quando il codice C++ gestito viene compilato per .NET Framework usando l'opzione /clr del compilatore.Code compiled for the Windows Runtime (WinRT) doesn't allow enum types to be forward declared, similarly to when managed C++ code is compiled for the .Net Framework using the /clr compiler switch. Questo comportamento garantisce che le dimensioni di un'enumerazione siano sempre note e possano essere proiettate correttamente nel sistema di tipi WinRT.This behavior is ensures that the size of an enumeration is always known and can be correctly projected to the WinRT type system. Il compilatore non accetta il codice scritto in questo modo e genera gli errori C2599 e C3197.The compiler rejects code written in this way and issues compiler error C2599 together with compiler error C3197.

    
    error C2599: 'CustomEnum': the forward declaration of a WinRT enum is not allowed  
    
    
    error C3197: 'public': can only be used in definitions  
    

    Esempio (prima)Example (before)

    namespace A {  
        public enum class CustomEnum : int32;  // forward declaration; error C2599, error C3197  
    }  
    
    namespace A {  
        public enum class CustomEnum : int32  
        {  
            Value1  
        };  
    }  
    
    public ref class Component sealed  
    {  
    public:  
        CustomEnum f()  
        {  
            return CustomEnum::Value1;  
        }  
    };  
    

    Esempio (dopo)Example (after)

              // forward declaration of CustomEnum removed  
    
    namespace A {  
        public enum class CustomEnum : int32  
        {  
            Value1  
        };  
    }  
    
    public ref class Component sealed  
    {  
    public:  
        CustomEnum f()  
        {  
            return CustomEnum::Value1;  
        }  
    };  
    
  • È possibile che le funzioni new o delete dell'operatore non membro in overload non siano dichiarate come inline (livello 1 (/W1) attivato per impostazione predefinita)Overloaded non-member operator new and operator delete may not be declared inline (Level 1 (/W1) on-by-default)

    Le versioni precedenti del compilatore non generano un avviso quando le funzioni new e delete di un operatore non membro vengono dichiarate inline.Previous versions of the compiler do not issue a warning when non-member operator new and operator delete functions are declared inline. Il codice scritto in questo modo non è valido (diagnostica non necessaria) e può causare problemi di memoria difficili da diagnosticare derivanti dalla mancata corrispondenza degli operatori new e delete (in particolare quando sono usati insieme con la deallocazione dimensionata).Code written in this way is ill-formed (no diagnostic required) and can cause memory issues resulting from mismatched new and delete operators (especially when used together with sized deallocation) that can be difficult to diagnose. Ora il compilatore genera l'avviso C4595 per identificare il codice scritto in questo modo.The compiler now issues compiler warning C4595 to help identify code written in this way.

    
    warning C4595: 'operator new': non-member operator new or delete functions may not be declared inline  
    

    Esempio (prima)Example (before)

              inline void* operator new(size_t sz)  // warning C4595  
    {  
        ...  
    }  
    

    Esempio (dopo)Example (after)

              void* operator new(size_t sz)  // removed inline  
    {  
        ...  
    }  
    

    La correzione del codice scritto in questo modo potrebbe richiedere lo spostamento delle definizioni dell'operatore da un file di intestazione a un file di origine corrispondente.Fixing code that's written in this way might require that the operator definitions be moved out of a header file and into a corresponding source file.

Miglioramenti della conformità in Update 3Conformance Improvements in Update 3

  • std::is_convertable ora rileva l'assegnazione automatica (libreria standard)std::is_convertable now detects self-assignment (standard library)

    Le versioni precedenti del tratto di tipo std::is_convertable non rilevano correttamente l'assegnazione automatica di un tipo di classe quando il relativo costruttore di copia è eliminato o privato.Previous versions of the std::is_convertable type-trait did not correctly detect self-assignment of a class type when its copy constructor is deleted or private. Ora std::is_convertable<>::value è impostato correttamente su false quando è applicato a un tipo di classe con costruttore di copia privato o eliminato.Now, std::is_convertable<>::value is correctly set to false when applied to a class type with a deleted or private copy constructor.

    A questa modifica non è associata alcuna diagnostica del compilatore.There is no compiler diagnostic associated with this change.

    EsempioExample

    #include <type_traits>  
    
                class X1  
    {  
                public:  
                X1(const X1&) = delete;  
                };  
    
                class X2  
    {  
                private:  
                X2(const X2&);  
                };  
    
    static_assert(std::is_convertible<X1&, X1>::value, "BOOM");static_assert(std::is_convertible<X2&, X2>::value, "BOOM");  
    

    Nelle versioni precedenti del compilatore, le asserzioni statiche nella parte inferiore di questo esempio passano perché std::is_convertable<>::value è stato impostato erroneamente su true.In previous versions of the compiler, the static assertions at the bottom of this example pass because std::is_convertable<>::value was incorrectly set to true. Ora std::is_convertable<>::value è impostato correttamente su false causando l'esito negativo delle asserzioni statiche.Now, std::is_convertable<>::value is correctly set to false, causing the static assertions to fail.

  • I costruttori di copia e di spostamento semplici impostati come predefiniti o eliminati rispettano gli identificatori di accessoDefaulted or deleted trivial copy and move constructors respect access specifiers

    Le versioni precedenti del compilatore non verificavano l'identificatore di accesso dei costruttori di copia o spostamento semplici impostati come predefiniti o eliminati prima di consentirne la chiamata.Previous versions of the compiler did not check the access specifier of defaulted or deleted trivial copy and move constructors before allowing them to be called. Questo comportamento precedente non era corretto e non è conforme allo standard C++.This old behavior was incorrect and does not conform to the C++ standard. In alcuni casi questo comportamento creava un rischio di generazione di codice errato senza avvisare, determinando un comportamento imprevedibile in fase di esecuzione.In some cases, this old behavior created a risk of silent bad code generation, resulting in unpredictable runtime behavior. Il compilatore ora controlla l'identificatore di accesso dei costruttori di copia e spostamento semplici impostati come predefiniti o eliminati per determinare se può essere effettuata la chiamata e, se non è possibile, genera un avviso del compilatore C2248 di conseguenza.The compiler now checks the access specifier of defaulted or deleted trivial copy and move constructors to determine whether it can be called, and if not, issues compiler warning C2248 as a result.

    
    error C2248: 'S::S' cannot access private member declared in class 'S'  
    

    Esempio (prima)Example (before)

    class S {  
    public:  
        S() = default;  
    private:  
        S(const S&) = default;  
    };  
    
    void f(S);  // pass S by value  
    
    int main()  
    {  
        S s;  
        f(s);  // error C2248, can't invoke private copy constructor  
    }  
    

    Esempio (dopo)Example (after)

    class S {  
    public:  
        S() = default;  
    private:  
        S(const S&) = default;  
    };  
    
    void f(const S&);  // pass S by reference  
    
    int main()  
    {  
        S s;  
        f(s);   
    }  
    
  • Deprecazione del supporto per il codice ATL con attributi (livello 1 (/W1) attivo per impostazione predefinita)Deprecation of attributed ATL code support (Level 1 (/W1) on-by-default)

    Le versioni precedenti del compilatore supportavano il codice ATL con attributi.Previous versions of the compiler supported attributed ATL code. Come fase successiva della rimozione del supporto per il codice ATL con attributi avviata in Visual Studio 2008, il codice ATL con attributi è stato deprecato.As the next phase of removing support for attributed ATL code that began in Visual Studio 2008, attributed ATL code has been deprecated. Ora il compilatore genera l'avviso C4467 per consentire l'identificazione di questo tipo di codice deprecato.The compiler now issues compiler warning C4467 to help identify this kind of deprecated code.

    warning C4467: Usage of ATL attributes is deprecated  
    

    Per continuare a usare codice ATL con attributi finché il supporto viene rimosso dal compilatore, è possibile disabilitare questo avviso passando gli argomenti /Wv:18 o /wd:4467 della riga di comando al compilatore o aggiungendo #pragma warning(disable:4467) nel codice sorgente.If you want to continue using attributed ATL code until support is removed from the compiler, you can disable this warning by passing the /Wv:18 or /wd:4467 command line arguments to the compiler, or by adding #pragma warning(disable:4467) in your source code.

    Esempio 1 (prima)Example 1 (before)

              [uuid("594382D9-44B0-461A-8DE3-E06A3E73C5EB")]  
    class A {};  
    

    Esempio 1 (dopo)Example 1 (after)

    __declspec(uuid("594382D9-44B0-461A-8DE3-E06A3E73C5EB")) A {};  
    

    In alcuni casi potrebbe essere necessario o preferibile creare un file IDL file per evitare l'uso degli attributi ATL deprecati, come nell'esempio di codice riportato di seguitoSometimes you might need or want to create an IDL file to avoid the use deprecated ATL attributes, as in the example code below

    Esempio 2 (prima)Example 2 (before)

    [emitidl];  
    [module(name = "Foo")];  
    
    [object, local, uuid("9e66a290-4365-11d2-a997-00c04fa37ddb")]  
    __interface ICustom {  
        HRESULT Custom([in] long l, [out, retval] long *pLong);  
        [local] HRESULT CustomLocal([in] long l, [out, retval] long *pLong);  
    };  
    
    [coclass, appobject, uuid("9e66a294-4365-11d2-a997-00c04fa37ddb")]  
    class CFoo : public ICustom  
    {  
        // ...  
    };  
    

    Per prima cosa creare il file *.idl. Il file vc140.idl generato può essere usato per ottenere un file *.idl contenente le interfacce e le annotazioni.First, create the *.idl file; the vc140.idl generated file can be used to obtain an *.idl file containing the interfaces and annotations.

    Quindi, aggiungere una fase MIDL alla compilazione per assicurarsi che le definizioni dell'interfaccia di C++ vengano generate.Next, add a MIDL step to your build to make sure that the C++ interface definitions are generated.

    Esempio 2 IDL (dopo)Example 2 IDL (after)

    import "docobj.idl";  
    
    [  
        object, local, uuid(9e66a290 - 4365 - 11d2 - a997 - 00c04fa37ddb)  
    ]  
    
    interface ICustom : IUnknown {  
        HRESULT  Custom([in] long l, [out, retval] long *pLong);  
        [local] HRESULT  CustomLocal([in] long l, [out, retval] long *pLong);  
    };  
    
    [version(1.0), uuid(29079a2c - 5f3f - 3325 - 99a1 - 3ec9c40988bb)]  
    library Foo  
    {  
        importlib("stdole2.tlb");  
    importlib("olepro32.dll");  
    [  
        version(1.0),  
        appobject,uuid(9e66a294 - 4365 - 11d2 - a997 - 00c04fa37ddb)  
    ]  
    
    coclass CFoo {  
        interface ICustom;  
    };  
    }  
    

    Usare quindi ATL direttamente nel file di implementazione, come illustrato nell'esempio di codice che segue.Then, use ATL directly in the implementation file, as in the example code below.

    Esempio 2 Implementazione (dopo)Example 2 Implementation (after)

    #include <idl.header.h>  
    #include <atlbase.h>  
    
    class ATL_NO_VTABLE CFooImpl :  
        public ICustom,  
        public ATL::CComObjectRootEx< CComMultiThreadModel>  
    {  
    public:  
        BEGIN_COM_MAP(CFooImpl)  
            COM_INTERFACE_ENTRY(ICustom)  
        END_COM_MAP()  
    };  
    
  • File di intestazione precompilata (PCH) e direttive #include non corrispondenti (interessa solo /Wall /WX)Precompiled header (PCH) files and mismatched #include directives (only affects /Wall /WX)

    Le versioni precedenti del compilatore accettavano le direttive #include non corrispondenti nei file di origine tra le compilazioni -Yc e -Yu quando venivano usati file di intestazione precompilata (PCH).Previous versions of the compiler accepted mismatched #include directives in source files between -Yc and -Yu compilations when using precompiled header (PCH) files. Il codice scritto in questo modo non è più accettato dal compilatore.Code written in this way is no longer accepted by the compiler. Il compilatore ora genera un avviso CC4598 per consentire l'identificazione delle direttive #include non corrispondenti quando si usano i file PCH.The compiler now issues compiler warning CC4598 to help identify mismatched #include directives when using PCH files.

    
    warning C4598: 'b.h': included header file specified for Ycc.h at position 2 does not match Yuc.h at that position  
    

    Esempio (prima):Example (before):

    X.cpp (-Ycc.h)X.cpp (-Ycc.h)

    #include "a.h"  
    #include "b.h"  
    #include "c.h"  
    

    Z.cpp (-Yuc.h)Z.cpp (-Yuc.h)

    #include "b.h"  
    #include "a.h"  // mismatched order relative to X.cpp  
    #include "c.h"  
    

    Esempio (dopo)Example (after)

    X.cpp (-Ycc.h)X.cpp (-Ycc.h)

    #include "a.h"  
    #include "b.h"   
    #include "c.h"  
    

    Z.cpp (-Yuc.h)Z.cpp (-Yuc.h)

    #include "a.h"  
    #include "b.h" // matched order relative to X.cpp  
    #include "c.h"  
    
  • File di intestazione precompilata (PCH) e directory di inclusione non corrispondenti (interessa solo /Wall /WX)Precompiled header (PCH) files and mismatched include directories (only affects /Wall /WX)

    Le versioni precedenti del compilatore accettavano gli argomenti della riga di comando delle directory di inclusione non corrispondenti (-I) per il compilatore tra le compilazioni -Yc e -Yu quando venivano usati file di intestazione precompilata (PCH).Previous versions of the compiler accepted mismatched include directory (-I) command line arguments to the compiler between -Yc and -Yu compilations when using precompiled header (PCH) files. Il codice scritto in questo modo non è più accettato dal compilatore.Code written in this way is no longer accepted by the compiler. Il compilatore ora genera un avviso CC4599 per consentire l'identificazione degli argomenti della riga di comando delle directory di inclusione non corrispondenti (-I) quando si usano i file PCH.The compiler now issues compiler warning CC4599 to help identify mismatched include directory (-I) command line arguments when using PCH files.

    
    warning C4599: '-I..' : specified for Ycc.h at position 1 does not match Yuc.h at that position  
    

    Esempio (prima)Example (before)

    
    cl /c /Wall /Ycc.h -I.. X.cpp  
    cl /c /Wall /Yuc.h Z.cpp  
    

    Esempio (dopo)Example (after)

    
    cl /c /Wall /Ycc.h -I.. X.cpp  
    cl /c /Wall /Yuc.h -I.. Z.cpp  
    

Modifiche della conformità di Visual Studio 2013Visual Studio 2013 Conformance Changes

CompilatoreCompiler

  • La parola chiave final genera ora un errore di simbolo non risolto laddove in precedenza sarebbe stato compilato:The final keyword now generates an unresolved symbol error where it would have compiled previously:

    struct S1 {  
        virtual void f() = 0;  
    };  
    
    struct S2 final : public S1 {  
        virtual void f();  
    };  
    
    int main(S2 *p)  
    {  
        p->f();  
    }  
    

    Nelle versioni precedenti non viene generato alcun errore perché la chiamata è una chiamata virtuale. Tuttavia, il programma viene arrestato in modo anomalo in fase di esecuzione.In earlier versions, an error wasn't issued because the call was a virtual call; nevertheless, the program would crash at runtime. Ora viene generato un errore del linker perché la classe è finale.Now, a linker error is issued because the class is known to be final. In questo esempio, per correggere l'errore, si esegue il collegamento all'oggetto che contiene la definizione di S2::f.In this example, to fix the error, you would link against the obj that contains the definition of S2::f.

  • Quando si usano funzioni friend negli spazi dei nomi è necessario dichiarare di nuovo la funzione friend prima di farvi riferimento. In caso contrario, verrà generato un errore perché il compilatore ora è conforme allo standard ISO C++.When you use friend functions in namespaces, you must re-declare the friend function before you refer to it or you will get an error because the compiler now conforms to the ISO C++ Standard. Nell'esempio seguente la compilazione non viene più eseguita.For example, this no longer compiles:

    namespace NS {  
        class C {  
            void func(int);  
            friend void func(C* const) {}  
        };  
    
        void C::func(int) {  
            NS::func(this);  // error  
        }  
    }  
    

    Per correggere questo codice, dichiarare la funzione friend:To correct this code, declare the friend function:

    namespace NS {  
        class C {  
            void func(int);  
            friend void func(C* const) {}  
        };  
    
        void func(C* const);  // conforming fix  
    
        void C::func(int) {  
            NS::func(this);  
        }  
    
  • Il linguaggio C++ standard non consente la specializzazione esplicita in una classe.The C++ Standard does not allow explicit specialization in a class. Sebbene sia consentita dal compilatore di Microsoft Visual C++ in alcune situazioni, nei casi come quello citato nell'esempio seguente viene generato un errore, poiché il compilatore non considera la seconda funzione come una specializzazione della prima.Although the Microsoft Visual C++ compiler allows it in some cases, in cases such as the following example, an error is now generated because the compiler doesn't consider the second function to be a specialization of the first one.

    template < int N>  
    class S {  
    public:  
        template  void f(T& val);  
        template < > void f(char val);  
    };  
    
    template class S< 1>;  
    

    Per correggere questo codice, modificare la seconda funzione:To correct this code, modify the second function:

    template <> void f(char& val);  
    
  • Il compilatore non tenta più di risolvere l'ambiguità delle due funzioni riportate nell'esempio seguente e ora restituisce un errore:The compiler no longer tries to disambiguate the two functions in the following example, and now emits an error:

    template< typename T> void Func(T* t = nullptr);  
    template< typename T> void Func(...);  
    
    int main() {  
        Func< int>(); // error  
    }  
    

    Per correggere questo codice, definire la chiamata:To correct this code, clarify the call:

    template< typename T> void Func(T* t = nullptr);  
    template< typename T> void Func(...);  
    
    int main() {  
        Func< int>(nullptr); // ok  
    }  
    
  • Prima che il compilatore fosse reso conforme a C++11 ISO, il codice seguente sarebbe stato compilato e avrebbe risolto x nel tipo int:Before the compiler was made compliant with ISO C++11, the following code would have compiled and caused x to resolve to type int:

    auto x = {0};  
    int y = x;  
    

    Ora il codice risolve x in un tipo di std::initializer_list<int> e genera un errore nella riga successiva che tenta di assegnare x al tipo int. Non viene eseguita alcuna conversione per impostazione predefinita. Per correggere questo codice, usare int per sostituire auto:This code now resolves x to a type of std::initializer_list<int> and causes an error on the next line that tries to assign x to type int. (There is no conversion by default.) To correct this code, use int to replace auto:

    int x = {0};  
    int y = x;  
    
  • Non è più consentita un'inizializzazione aggregata quando il tipo del valore a destra non corrisponde al tipo del valore a sinistra inizializzato e viene generato un errore poiché lo standard ISO C++11 richiede l'inizializzazione uniforme per funzionare senza conversioni verso un tipo di dati più piccolo.Aggregate initialization is no longer allowed when the type of the right-hand value does not match the type of the left-hand value that's being initialized, and an error is issued because the ISO C++11 Standard requires uniform initialization to work without narrowing conversions. In precedenza, se fosse stata disponibile una conversione verso un tipo di dati più piccolo, sarebbe stato generato un avviso del compilatore C4242 (livello 4) anziché un errore.Previously, if a narrowing conversion was available, a Compiler Warning (level 4) C4242 warning would have been issued instead of an error.

    int i = 0;  
    char c = {i}; // error  
    

    Per correggere questo codice, aggiungere una conversione esplicita verso un tipo di dati più piccolo:To correct this code, add an explicit narrowing conversion:

    int i = 0;  
    char c = {static_cast<char>(i)};  
    
  • La seguente inizializzazione non è più consentita:The following initialization is no longer allowed:

    void *p = {{0}};  
    

    Per correggere questo codice, utilizzare uno di questi formati:To correct this code, use either of these forms:

    void *p = 0;  
    // or  
    void *p = {0};  
    
  • È stata modificata la ricerca del nome.Name lookup has changed. Il codice seguente viene risolto in modo diverso nel compilatore C++ in Visual Studio 2012 e Visual Studio 2013:The following code is resolved differently in the C++ compiler in Visual Studio 2012 and Visual Studio 2013:

    enum class E1 { a };  
    enum class E2 { b };  
    
    int main()  
    {  
        typedef E2 E1;  
        E1::b;  
    }  
    

    In Visual Studio 2012 E1 nell'espressione E1::b veniva risolto in :: E1 nell'ambito globale.In Visual Studio 2012, the E1 in expression E1::b resolved to ::E1 in the global scope. In Visual Studio 2013 E1 nell'espressione E1::b viene risolto nella definizione typedef E2 in main() con tipo:: E2.In Visual Studio 2013, E1 in expression E1::b resolves to the typedef E2 definition in main() and has type ::E2.

  • Il layout degli oggetti è stato modificato.Object layout has changed. In x64, il layout degli oggetti di una classe può cambiare rispetto alle versioni precedenti.On x64, the object layout of a class may change from previous releases. Se dispone di una funzione virtuale, ma non di una classe base con una funzione virtuale, il modello a oggetti del compilatore inserisce un puntatore a una tabella di funzioni virtuali dopo il layout dei membri dati.If it has a virtual function but it doesn’t have a base class that has a virtual function, the object model of the compiler inserts a pointer to a virtual function table after the data member layout. Ciò significa che il layout potrebbe non essere ottimale in tutti i casi.This means the layout may not be optimal in all cases. Nelle versioni precedenti, un'ottimizzazione per x64 tentava di migliorare automaticamente il layout, ma poiché non funzionava correttamente in situazioni di codice complesse, è stata rimossa in Visual Studio 2013.In previous releases, an optimization for x64 would try to improve the layout for you, but because it failed to work correctly in complex code situations, it was removed in Visual Studio 2013. Si consideri, ad esempio, il seguente codice:For example, consider this code:

    __declspec(align(16)) struct S1 {  
    };  
    
    struct S2 {  
        virtual ~S2();  
        void *p;  
        S1 s;  
    };  
    
  • In Visual Studio 2013 il risultato di sizeof(S2) su x64 è 48, ma nelle versioni precedenti restituisce 32.In Visual Studio 2013, the result of sizeof(S2) on x64 is 48, but in previous releases, it evaluates to 32. Per fare in modo che restituisca 32 nel compilatore C++ in Visual Studio 2013 per x64, aggiungere una classe di base fittizia con una funzione virtuale:To make this evaluate to 32 in The C++ compiler in Visual Studio 2013 for x64, add a dummy base class that has a virtual function:

    __declspec(align(16)) struct S1 {  
    };  
    
    struct dummy {  
        virtual ~dummy() {}  
    };  
    struct S2 : public dummy {  
        virtual ~S2();  
        void *p;  
        S1 s;  
    };  
    

    Per individuare i punti del codice che una versione precedente avrebbe cercato di ottimizzare, usare un compilatore di tale versione insieme all'opzione /W3 del compilatore e attivare l'avviso 4370.To find places in your code that an earlier release would have tried to optimize, use a compiler from that release together with the /W3 compiler option and turn on Warning 4370. Ad esempio:For example:

    #pragma warning(default:4370)  
    
    __declspec(align(16)) struct S1 {  
    };  
    
    struct S2 {  
        virtual ~S2();  
        void *p;  
        S1 s;  
    };  
    

    Prima di Visual Studio 2013, questo codice genera questo messaggio con avviso C4370: 'S2': il layout della classe è stato modificato rispetto alla precedente versione del compilatore per migliorare la compressione.Before Visual Studio 2013, this code outputs this message: "warning C4370: 'S2' : layout of class has changed from a previous version of the compiler due to better packing".

    Il compilatore x86 ha lo stesso problema di layout inferiore al livello ottimale in tutte le versioni del compilatore.The x86 compiler has the same sub-optimal layout issue in all versions of the compiler. Ad esempio, se questo codice viene compilato per x86:For example, if this code is compiled for x86:

    struct S {  
        virtual ~S();  
        int i;  
        double d;  
    };  
    

    Il risultato di sizeof(S) è 24.The result of sizeof(S) is 24. Può tuttavia essere ridotto a 16 se si utilizza la soluzione alternativa indicata per x64:However, this can be reduced to 16 if you use the workaround just mentioned for x64:

    struct dummy {  
        virtual ~dummy() {}  
    };  
    
    struct S : public dummy {  
        virtual ~S();  
        int i;  
        double d;  
    };  
    

Libreria standardStandard Library

Il compilatore C++ in Visual Studio 2013 rileva le mancate corrispondenze in _ITERATOR_DEBUG_LEVEL, implementato in Visual Studio 2010, e RuntimeLibrary.The C++ compiler in Visual Studio 2013 detects mismatches in _ITERATOR_DEBUG_LEVEL, which was implemented in Visual Studio 2010, and RuntimeLibrary mismatches. Queste si verificano combinando le opzioni del compilatore /MT (versione statica), /MTd (debug statico), /MD (versione dinamica) e /MDd (debug dinamico).These occur when compiler options /MT (static release), /MTd (static debug), /MD (dynamic release), and /MDd (dynamic debug) are mixed.

  • Se il codice riconosce i modelli simulati dell'alias della versione precedente, è necessario modificarlo.If your code acknowledges the previous release's simulated alias templates, you have to change it. Ad esempio, anziché allocator_traits<A>::rebind_alloc<U>::other ora si deve impostare allocator_traits<A>::rebind_alloc<U>.For example, instead of allocator_traits<A>::rebind_alloc<U>::other, now you have to say allocator_traits<A>::rebind_alloc<U>. Anche se ratio_add<R1, R2>::type non è più necessario ed è ora consigliabile impostare ratio_add<R1, R2>, il primo verrà comunque compilato, poiché ratio<N, D> richiede un "tipo" typedef per un rapporto ridotto, che sarà dello stesso tipo se è già ridotto.Although ratio_add<R1, R2>::type is no longer necessary and we now recommend that you say ratio_add<R1, R2>, the former will still compile because ratio<N, D> is required to have a "type" typedef for a reduced ratio, which will be the same type if it's already reduced.

  • È necessario usare #include <algorithm> quando si chiama std::min() o std::max().You must use #include <algorithm> when you call std::min() or std::max().

  • Se il codice esistente usa le enumerazioni con ambito simulate della versione precedente (enumerazioni tradizionali senza ambito contenute negli spazi dei nomi), è necessario modificarle.If your existing code uses the previous release’s simulated scoped enums—traditional unscoped enums wrapped in namespaces—you have to change it. Ad esempio, se prima si faceva riferimento al tipo std::future_status::future_status, ora si deve indicare std::future_status.For example, if you referred to the type std::future_status::future_status, now you have to say std::future_status. Tuttavia, la maggior parte del codice non è interessato, ad esempio std::future_status::ready viene compilato.However, most code is unaffected—for example, std::future_status::ready still compiles.

  • explicit operator bool() è più restrittivo rispetto a operator unspecified-bool-type().explicit operator bool() is stricter than operator unspecified-bool-type(). explicit operator bool() consente conversioni esplicite a bool, ad esempio con shared_ptr<X> sp, sono validi sia both static_cast<bool>(sp) che bool b(sp), e "conversioni contestuali" verificabili in modo booleano a bool, ad esempio uno qualsiasi tra if (sp), !sp, sp &&.explicit operator bool() permits explicit conversions to bool—for example, given shared_ptr<X> sp, both static_cast<bool>(sp) and bool b(sp) are valid—and Boolean-testable "contextual conversions" to bool—for example, if (sp), !sp, sp && whatever. explicit operator bool() tuttavia impedisce la conversione implicita a bool, quindi non è possibile specificare bool b = sp; e dato un tipo restituito bool,non è possibile specificare return sp.However, explicit operator bool() forbids implicit conversions to bool, so you can't say bool b = sp; and given a bool return type, you can't say return sp.

  • Ora che i modelli variadic reali sono implementati, _VARIADIC_MAX e le macro correlate non hanno alcun effetto.Now that real variadic templates are implemented, _VARIADIC_MAX and related macros have no effect. Se si definisce ancora _VARIADIC_MAX, esso viene ignorato.If you're still defining _VARIADIC_MAX, it is just ignored. Se si è riconosciuto il sistema di macro con lo scopo di supportare i modelli variadic simulati in qualsiasi altro modo, è necessario modificare il codice.If you acknowledged our macro machinery intended to support simulated variadic templates in any other way, you have to change your code.

  • Oltre alle parole chiave comuni, le intestazioni della libreria standard C++ ora impediscono l'impostazione delle macro delle parole chiave sensibili al contesto "override" e "final".In addition to ordinary keywords, C++ Standard Library headers now forbid the macro-izing of the context-sensitive keywords "override" and "final".

  • reference_wrapper/ref()/cref() ora impedisce l'associazione agli oggetti temporanei.reference_wrapper/ref()/cref() now forbid binding to temporary objects.

  • <random> ora applica rigorosamente le precondizioni in fase di compilazione.<random> now strictly enforces its compile-time preconditions.

  • Vari tratti di tipo della libreria standard C++ hanno la precondizione "T deve essere un tipo completo".Various C++ Standard Library type traits have the precondition "T shall be a complete type". Sebbene il compilatore applichi ora tale regola in modo più rigido, questa non può essere applicata in tutte le situazioni.Although the compiler now enforces this more strictly, it may not enforce it in all situations. Poiché le violazioni di precondizione della libreria standard C++ attivano un comportamento non definito, lo standard non garantisce l'applicazione.(Because C++ Standard Library precondition violations trigger undefined behavior, the Standard doesn't guarantee enforcement.)

  • La libreria standard C++ non supporta /clr:oldSyntax.The C++ Standard Library does not support /clr:oldSyntax.

  • La specifica C++11 per common_type presenta delle conseguenze impreviste e indesiderate, in particolare induce common_type<int, int>::type a restituire int&&.The C++11 specification for common_type<> had unexpected and undesired consequences; in particular, it makes common_type<int, int>::type return int&&. Il compilatore implementa quindi la Proposta per risolvere il problema 2141 del gruppo di lavoro di libreria, che fa sì che common_type<int, int="">::type restituisca int.Therefore, the compiler implements the Proposed Resolution for Library Working Group issue 2141, which makes common_type<int, int="">::type return int.

    Come effetto collaterale di questa modifica, il case di identità non funziona più (common_type<T> non restituisce sempre il tipo T).As a side-effect of this change, the identity case no longer works (common_type<T> does not always result in type T). Ciò è conforme alla Proposta, ma interrompe il codice basato sul comportamento precedente.This complies with the Proposed Resolution, but it breaks any code that relied on the previous behavior.

    Se è necessario un tratto di tipo identità, non usare l'elemento std::identity non standard definito in <type_traits> perché non funzionerà con <void>.If you require an identity type trait, don't use the non-standard std::identity that's defined in <type_traits> because it won't work for <void> . Diversamente, implementare un tratto di tipo di identità per le proprie esigenze.Instead, implement your own identity type trait to suit your needs. Di seguito è riportato un esempio:Here's an example:

    template < typename T> struct Identity {  
        typedef T type;  
    };  
    

MFC e ATLMFC and ATL

  • Solo Visual Studio 2013: la libreria MFC per MBCS non è inclusa in Visual Studio perché il formato Unicode è estremamente diffuso e l'utilizzo di MBCS si è ridotto significativamente.Visual Studio 2013 only: MFC MBCS Library is not included in Visual Studio because Unicode is so popular and use of MBCS is significantly reduced. Questa modifica mantiene inoltre MFC più allineato a Windows SDK stesso, poiché molti dei nuovi controlli e messaggi sono solo Unicode.This change also keeps MFC more closely aligned with the Windows SDK itself, because many of the new controls and messages are Unicode-only. Se tuttavia è necessario continuare a usare la libreria MFC per MBCS, è possibile scaricarla dall'Area download di MSDN in Libreria MFC multibyte per Visual Studio 2013.However, if you must continue to use the MFC MBCS library, you can download it from the MSDN Download Center at Multibyte MFC Library for Visual Studio 2013. Il pacchetto ridistribuibile di Visual C++ include ancora questa libreria.The Visual C++ Redistributable Package still includes this library. Nota: la DLL MBCS è inclusa nei componenti di configurazione di C++ in Visual Studio 2015 e versioni successive.(Note: The MBCS DLL is included in the C++ setup components in Visual Studio 2015 and later).

  • L'accessibilità per la barra multifunzione MFC è stata modificata.Accessibility for the MFC ribbon is changed. Anziché un'architettura a un livello ora viene usata un'architettura gerarchica.Instead of a one-level architecture, there is now a hierarchical architecture. È possibile continuare a usare il vecchio comportamento chiamando CRibbonBar::EnableSingleLevelAccessibilityMode().You can still use the old behavior by calling CRibbonBar::EnableSingleLevelAccessibilityMode().

  • Il metodo CDatabase::GetConnect è stato rimosso.CDatabase::GetConnect method is removed. Per migliorare la sicurezza, la stringa di connessione viene ora archiviata crittografata e viene decrittografata solo se necessario; non può essere restituita come testo normale.To improve security, the connection string is now stored encrypted and is decrypted only as needed; it cannot be returned as plain text. È possibile ottenere la stringa usando il metodo CDatabase::Dump.The string can be obtained by using the CDatabase::Dump method.

  • La firma di CWnd::OnPowerBroadcast è stata modificata.Signature of CWnd::OnPowerBroadcast is changed. La firma di questo gestore messaggi è stata modificata per accettare un LPARAM come secondo parametro.The signature of this message handler is changed to take an LPARAM as the second parameter.

  • Le firme sono state modificate per includere i gestori di messaggi.Signatures are changed to accommodate message handlers. Gli elenchi di parametri delle seguenti funzioni sono stati modificati per utilizzare i gestori di messaggi ON_WM_* aggiunti recentemente:The parameter lists of the following functions have been changed to use newly added ON_WM_* message handlers:

    • CWnd::OnDisplayChange è stato modificato in (UINT, int, int) anziché (WPARAM, LPARAM) in modo tale che la nuova macro ON_WM_DISPLAYCHANGE possa essere usata nella mappa messaggi.CWnd::OnDisplayChange changed to (UINT, int, int) instead of (WPARAM, LPARAM) so that the new ON_WM_DISPLAYCHANGE macro can be used in the message map.

    • CFrameWnd::OnDDEInitiate è stato modificato in (CWnd*, UINT, UNIT) anziché (WPARAM, LPARAM) in modo tale che la nuova macro ON_WM_DDE_INITIATE possa essere usata nella mappa messaggi.CFrameWnd::OnDDEInitiate changed to (CWnd*, UINT, UNIT) instead of (WPARAM, LPARAM) so that the new ON_WM_DDE_INITIATE macro can be used in the message map.

    • CFrameWnd::OnDDEExecute è stato modificato in (CWnd*, HANDLE) anziché (WPARAM, LPARAM) in mod tale che la nuova macro ON_WM_DDE_EXECUTE possa essere usata nella mappa messaggi.CFrameWnd::OnDDEExecute changed to (CWnd*, HANDLE) instead of (WPARAM, LPARAM) so that the new ON_WM_DDE_EXECUTE macro can be used in the message map.

    • CFrameWnd::OnDDETerminate è stato modificato in (CWnd*) come parametro anziché (WPARAM, LPARAM) in modo tale che la nuova macro ON_WM_DDE_TERMINATE possa essere usata nella mappa messaggi.CFrameWnd::OnDDETerminate changed to (CWnd*) as the parameter instead of (WPARAM, LPARAM) so that the new ON_WM_DDE_TERMINATE macro can be used in the message map.

    • CMFCMaskedEdit::OnCut è stato modificato e non ha parametri anziché avere (WPARAM, LPARAM) in modo tale che la nuova macro ON_WM_CUT possa essere usata nella mappa messaggi.CMFCMaskedEdit::OnCut changed to no parameters instead of (WPARAM, LPARAM) so that the new ON_WM_CUT macro can be used in the message map.

    • CMFCMaskedEdit::OnClear è stato modificato e non ha parametri anziché avere (WPARAM, LPARAM) in modo tale che la nuova macr ON_WM_CLEAR possa essere usata nella mappa messaggi.CMFCMaskedEdit::OnClear changed to no parameters instead of (WPARAM, LPARAM) so that the new ON_WM_CLEAR macro can be used in the message map.

    • CMFCMaskedEdit::OnPaste è stato modificato e non ha parametri anziché avere (WPARAM, LPARAM) in modo tale che la nuova macro ON_WM_PASTE possa essere usata nella mappa messaggi.CMFCMaskedEdit::OnPaste changed to no parameters instead of (WPARAM, LPARAM) so that the new ON_WM_PASTE macro can be used in the message map.

  • Gli oggetti #ifdef nei file di intestazione MFC sono stati rimossi.#ifdefs in the MFC header files are removed. Numerosi oggetti #ifdef nei file di intestazione MFC correlati a versioni non supportate di Windows (WINVER < 0x0501) sono stati rimossi.Numerous #ifdefs in the MFC header files related to unsupported versions of Windows (WINVER < 0x0501) are removed.

  • La DLL ATL (atl120.dll) è stata rimossa.ATL DLL (atl120.dll) is removed. La DLL ATL viene ora fornita come intestazioni e come libreria statica (atls.lib).ATL is now provided as headers and a static library (atls.lib).

  • Atlsd.lib, atlsn.lib e atlsnd.lib sono stati rimossi.Atlsd.lib, atlsn.lib, and atlsnd.lib are removed. Atls.lib non include più dipendenze o codice con set di caratteri specifici per il debug/rilascio.Atls.lib no longer has character-set dependencies or code that's specific for debug/release. Poiché funziona esattamente come per Unicode/ANSI e per il debug/rilascio, è richiesta una sola versione della libreria.Because it works the same for Unicode/ANSI and debug/release, only one version of the library is required.

  • Lo strumento di analisi ATL/MFC è stato rimosso contestualmente alla DLL ATL e il meccanismo di analisi è stato semplificato.ATL/MFC Trace tool is removed together with the ATL DLL, and the tracing mechanism is simplified. Il costruttore CTraceCategory ora accetta un parametro (il nome della categoria) e le macro TRACE chiamano le funzioni CRT di report di debug.The CTraceCategory constructor now takes one parameter (the category name), and the TRACE macros call the CRT debug reporting functions.

Modifiche importanti in Visual C++ 2012Visual C++ 2012 Breaking Changes

CompilatoreCompiler

  • L'opzione /Yl del compilatore è stata modificata.The /Yl compiler option has changed. Per impostazione predefinita, il compilatore usa questa opzione, che può provocare errori LNK2011 in determinate condizioni.By default, the compiler uses this option, which can lead to LNK2011 errors under certain conditions. Per altre informazioni, vedere /Yl (Inserisce il riferimento PCH per la libreria di debug).For more information, see /Yl (Inject PCH Reference for Debug Library).

  • Nel codice compilato con /clr, la parola chiave enum class definisce un enum C++ 11, non un enum Common Language Runtime (CLR).In code that's compiled by using /clr, the enum class keyword defines a C++11 enum, not a common language runtime (CLR) enum. Per definire un enum CLR, è necessario essere espliciti riguardo all'accessibilità.To define a CLR enum, you must be explicit about its accessibility.

  • Usare la parola chiave template per evitare in modo esplicito ambiguità di un nome di dipendente (conformità con lo standard del linguaggio C++).Use the template keyword to explicitly disambiguate a dependent name (C++ Language Standard compliance). Nell'esempio seguente la parola chiave template evidenziata è obbligatoria per risolvere l'ambiguità.In the following example, the highlighted template keyword is mandatory to resolve the ambiguity. Per altre informazioni, vedere Risoluzione dei nomi per tipi dipendenti.For more information, see Name Resolution for Dependent Types.

    template < typename X = "", typename = "" AY = "">  
    struct Container { typedef typename AY::template Rebind< X> ::Other AX; };  
    
  • L'espressione costante di tipo float non è più consentita come argomento di modello, come illustrato nell'esempio seguente.Constant expression of type float is no longer allowed as a template argument, as shown in the following example.

    template<float n=3.14>  
    struct B {};  // error C2993: 'float': illegal type for non-type template parameter 'n'  
    
  • Un codice compilato usando l'opzione della riga di comando /GS e che ha una vulnerabilità off-by-one può determinare la chiusura del processo in fase di esecuzione, come illustrato nell'esempio di pseudocodice seguente.Code that's compiled by using the /GS command-line option and that has an off-by-one vulnerability may lead to process termination at runtime, as shown in the following pseudocode example.

    char buf[MAX]; int cch; ManipulateString(buf, &cch); // ... buf[cch] = '\0'; // if cch >= MAX, process will terminate  
    
  • L'architettura predefinita per le compilazioni x86 viene modificata in SSE2, quindi il compilatore può generare istruzioni SSE e userà i registri XMM per eseguire i calcoli a virgola mobile.The default architecture for x86 builds is changed to SSE2; therefore, the compiler may emit SSE instructions, and will use the XMM registers to perform floating-point calculations. Per ripristinare il comportamento precedente, usare il flag del compilatore /arch:IA32 per specificare l'architettura come IA32.If you want to revert to previous behavior, then use the /arch:IA32 compiler flag to specify the architecture as IA32.

  • Il compilatore può generare avvisi del compilatore (livello 4) C4703 e C4701 mentre prima non ne generava.The compiler may issue warnings Compiler Warning (level 4) C4703 and C4701 where previously it did not. Il compilatore applica controlli più avanzati per l'utilizzo di variabili locali non inizializzate di tipo puntatore.The compiler applies stronger checks for use of uninitialized local variables of pointer type.

  • Quando si specifica il nuovo flag del linker /HIGHENTROPYVA Windows 8 in genere induce le allocazioni di memoria a restituire un indirizzo a 64 bit.When the new linker flag /HIGHENTROPYVA is specified, Windows 8 typically causes memory allocations to return a 64-bit address. Prima di Windows 8 tali allocazioni restituivano più spesso indirizzi inferiori a 2 GB. Questo può esporre bug di troncamento del puntatore nel codice esistente.(Prior to Windows 8, such allocations more often returned addresses that were less than 2 GB.) This may expose pointer truncation bugs in existing code. Per impostazione predefinita, questa opzione è attivata.By default, this switch is on. Per disabilitare questo comportamento, specificare /HIGHENTROPYVA:NO.To disable this behavior, specify /HIGHENTROPYVA:NO.

  • Il compilatore gestito (Visual Basic/C#) supporta anche /HIGHENTROPYVA per le build gestite.The managed compiler (Visual Basic/C#) also supports /HIGHENTROPYVA for managed builds. Tuttavia, in questo caso, l'opzione /HIGHENTROPYVA è disattivata per impostazione predefinita.However, in this case, the /HIGHENTROPYVAswitch is off by default.

IDEIDE

  • Sebbene sia consigliabile non creare applicazioni Windows Form in C++/CLI, la manutenzione di applicazioni di interfaccia utente C++/CLI già esistenti è supportata.Although we recommend that you do not create Windows Forms applications in C++/CLI, maintenance of existing C++/CLI UI applications is supported. Se è necessario creare un'applicazione Windows Form o qualsiasi altra applicazione di interfaccia utente .NET, usare C# o Visual Basic.If you have to create a Windows Forms application, or any other .NET UI application, use C# or Visual Basic. Usare C++/CLI solo a fini di interoperabilità.Use C++/CLI for interoperability purposes only.

Parallel Patterns Library e libreria di runtime di concorrenzaParallel Patterns Library and Concurrency Runtime Library

L'enumerazione SchedulerType di UmsThreadDefault è deprecata.The SchedulerType enumeration of UmsThreadDefault is deprecated. Specificare UmsThreadDefault causa la generazione di un avviso deprecato e l'esecuzione interna del mapping a ThreadScheduler.Specification of UmsThreadDefault produces a deprecated warning, and internally maps back to the ThreadScheduler.

Libreria standardStandard Library

  • A seguito di una modifica importante tra gli standard C++98/03 e C++11, usando argomenti di modello espliciti per la chiamata a make_pair(), come inmake_pair<int, int>(x, y), in genere non viene eseguita la compilazione in Visual C++ in Visual Studio 2012.Following a breaking change between the C++98/03 and C++11 standards, using explicit template arguments to call make_pair()—as inmake_pair<int, int>(x, y)—typically does not compile in Visual C++ in Visual Studio 2012. La soluzione consiste nel chiamare sempre make_pair() senza argomenti di modello espliciti, come in make_pair(x, y).The solution is to always call make_pair()without explicit template arguments—as in make_pair(x, y). Se si indicano argomenti di modello espliciti, viene vanificato lo scopo della funzione.Providing explicit template arguments defeats the purpose of the function. Se è necessario controllare con precisione il tipo risultante, usare pair anziché make_pair, come in pair<short, short >(int1, int2).If you require precise control over the resulting type, use pair instead of make_pair—as in pair<short, short>(int1, int2).

  • Un'altra modifica sostanziale tra gli standard C++98/03 e C++11: quando A è implicitamente convertibile in B e B è implicitamente convertibile in C, ma A non è implicitamente convertibile in C, C++98/03 e Visual C++2010 consentono la conversione di pair<A, X > (in modo implicito o esplicito) in pair<C, X >.Another breaking change between the C++98/03 and C++11 standards: When A is implicitly convertible to B and B is implicitly convertible to C, but A is not implicitly convertible to C, C++98/03 and Visual C++ 2010 permitted pair<A, X> to be converted (implicitly or explicitly) to pair<C, X>. L'altro tipo, X, non interessa in questa sede e non è specifico per il primo tipo nella coppia. Poiché C++11 e il compilatore C++ in Visual Studio 2012 rilevano che A non è implicitamente convertibile in C, rimuovono la conversione della coppia dalla risoluzione dell'overload.(The other type, X, is not of interest here, and this is not specific to the first type in the pair.) Because C++11 and The C++ compiler in Visual Studio 2012 detect that A is not implicitly convertible to C, they remove the pair conversion from overload resolution. Questa modifica è positiva per molti scenari.This is a positive change for many scenarios. Ad esempio, l'overload di func(const pair<int, int>&) e func(const pair<string, string>&) e la chiamata di func() con pair<const char *, const char *> eseguono la compilazione con questa modifica.For example, overloading func(const pair<int, int>&) and func(const pair<string, string>&), and calling func() with pair<const char *, const char *> will compile with this change. Tuttavia, la modifica interrompe il codice che si basava su conversioni di coppia aggressive.However, this change breaks code that relied on aggressive pair conversions. In genere, tale codice può essere corretto eseguendo una parte della conversione in modo esplicito, ad esempio passando make_pair(static_cast<B>(a), x) a una funzione che prevede pair<C, X >.Such code can typically be fixed by performing one part of the conversion explicitly—for example, by passing make_pair(static_cast<B>(a), x) to a function that expects pair<C, X>.

  • Visual C++ 2010 simulava i modelli variadic, ad esempio make_shared<T>(arg1, arg2, argN), fino a un limite massimo di 10 argomenti, contrassegnando overload e specializzazioni con macchine di precompilazione.Visual C++ 2010 simulated variadic templates—for example, make_shared<T>(arg1, arg2, argN)—up to a limit of 10 arguments, by stamping out overloads and specializations with preprocessor machinery. In Visual Studio 2012 questo limite viene ridotto a 5 argomenti per migliorare i tempi di compilazione e il consumo di memoria del compilatore per la maggior parte degli utenti.In Visual Studio 2012, this limit is reduced to 5 arguments to improve compile times and compiler memory consumption for the majority of users. Tuttavia, è possibile impostare il limite precedente definendo in modo esplicito _VARIADIX_MAX come 10, a livello di progetto.However, you can set the previous limit by explicitly defining _VARIADIC_MAX as 10, project-wide.

  • C++ 11 17.6.4.3.1 [macro.names]/2 impedisce l'impostazione delle macro delle parole chiave quando sono incluse le intestazioni della libreria standard di C++.C++11 17.6.4.3.1 [macro.names]/2 forbids macro-izing keywords when C++ Standard Library headers are included. Le intestazioni ora generano errori del compilatore se rilevano parole chiave con macro impostate.The headers now emit compiler errors if they detect macro-ized keywords. La definizione di _ALLOW_KEYWORD_MACROS consente la compilazione del codice ma ne è fortemente sconsigliato l'uso. Come eccezione, l'uso di new con macro impostate è consentito per impostazione predefinita, poiché le intestazioni nel complesso si difendono usando #pragma push_macro("new")/#undef new/#pragma pop_macro("new").(Defining _ALLOW_KEYWORD_MACROS allows such code to compile, but we strongly discourage that usage.) As an exception, macro-ized new is permitted by default, because the headers comprehensively defend themselves by using #pragma push_macro("new")/#undef new/#pragma pop_macro("new"). Defining _ENFORCE_BAN_OF_MACRO_NEW esegue esattamente l'operazione indicata nel nome.Defining _ENFORCE_BAN_OF_MACRO_NEW does exactly what its name implies.

  • Per implementare varie ottimizzazioni e controlli di debug, l'implementazione della libreria standard di C++ interrompe intenzionalmente la compatibilità binaria tra le versioni di Visual Studio (2005, 2008, 2010, 2012).To implement various optimizations and debugging checks, the C++ Standard Library implementation intentionally breaks binary compatibility among versions of Visual Studio (2005, 2008, 2010, 2012). Se si usa la libreria standard di C++, viene impedita la combinazione di file oggetto e librerie statiche compilati usando versioni diverse in un unico file binario (EXE o DLL) e non è consentito passare gli oggetti della libreria standard di C++ tra i file binari compilati usando versioni diverse.When the C++ Standard Library is used, this forbids the mixing of object files and static libraries that are compiled by using different versions into one binary (EXE or DLL), and forbids the passing of C++ Standard Library objects between binaries that are compiled by using different versions. La combinazione di librerie statiche e file oggetto (usando la libreria standard di C++) compilati usando Visual C++ 2010 con quelli compilati usando il compilatore C++ in Visual Studio 2012 genera errori del linker per mancata corrispondenza in _MSC_VER, dove _MSC_VER è la macro che contiene la versione principale del compilatore (1700 per Visual C++ in Visual Studio 2012).The mixing of object files and static libraries (using the C++ Standard Library that were compiled by using Visual C++ 2010 with those that were compiled by using The C++ compiler in Visual Studio 2012 emits linker errors about _MSC_VER mismatch, where _MSC_VER is the macro that contains the compiler's major version (1700 for Visual C++ in Visual Studio 2012). Questo controllo non consente di rilevare la combinazione DLL e altre combinazioni inerenti a Visual C++ 2008 o versioni precedenti.This check cannot detect DLL mixing, and cannot detect mixing that involves Visual C++ 2008 or earlier.

  • Oltre a rilevare le mancate corrispondenze in _ITERATOR_DEBUG_LEVEL, implementato in Visual C++ 2010, il compilatore C++ in Visual Studio 2012 rileva le mancate corrispondenze nella libreria di runtime.In addition to detecting _ITERATOR_DEBUG_LEVEL mismatches, which was implemented in Visual C++ 2010, The C++ compiler in Visual Studio 2012 detects Runtime Library mismatches. Queste si verificano se vengono combinate le opzioni del compilatore /MT (versione statica), /MTd (debug statico), /MD (versione dinamica) e /MDd (debug dinamico).These occur when the compiler options /MT (static release), /MTd (static debug), /MD (dynamic release), and /MDd (dynamic debug) are mixed.

  • operator<(), operator>(), operator<=() e operator>=() in precedenza erano disponibili per le famiglie di contenitori std::unordered_map andstdext::hash_map, sebbene implementarli non fosse effettivamente utile.operator<(), operator>(), operator<=(), and operator>=() were previously available for the std::unordered_map andstdext::hash_map families of containers, although their implementations were not actually useful. Questi operatori non standard sono stati rimossi in Visual C++ in Visual Studio 2012.These non-standard operators have been removed in Visual C++ in Visual Studio 2012. Inoltre, l'implementazione di operator==() e operator!=() per la famiglia thestd::unordered_map è stata estesa per coprire la famiglia stdext::hash_map.Additionally, the implementation of operator==() and operator!=() for thestd::unordered_map family has been extended to cover the stdext::hash_map family. Si consiglia di evitare l'uso della famiglia thestdext::hash_map nel nuovo codice.(We recommend that you avoid the use of thestdext::hash_map family in new code.)

  • C++ 11 22.4.1.4 [locale.codecvt] specifica che codecvt::length() e codecvt::do_length() devono usare parametri stateT& modificabili, ma Visual C++ 2010 usava l'elemento const stateT&.C++11 22.4.1.4 [locale.codecvt] specifies that codecvt::length() and codecvt::do_length() should take modifiable stateT&parameters, but Visual C++ 2010 took const stateT&. Il compilatore C++ in Visual Studio 2012 accetta stateT& come definito dallo standard.The C++ compiler in Visual Studio 2012 takes stateT& as mandated by the standard. Questa differenza è significativa se si tenta di eseguire l'override della funzione virtuale do_length().This difference is significant for anyone who is attempting to override the virtual function do_length().

CRTCRT

  • L'heap di CRT (Runtime C) usato per new e malloc() non è più privato.The C Runtime (CRT) heap, which is used for new and malloc(), is no longer private. CRT ora usa l'heap di processo.The CRT now uses the process heap. Questo significa che l'heap non viene eliminato quando viene scaricata una DLL, quindi le DLL collegate in modo statico a CRT devono verificare che la memoria allocata dal codice DLL sia pulita prima di essere scaricata.This means that the heap is not destroyed when a DLL is unloaded, so DLLs that link statically to the CRT must ensure memory that's allocated by the DLL code is cleaned up before it’s unloaded.

  • La funzione iscsymf() esegue asserzioni con valori negativi.The iscsymf() function asserts with negative values.

  • Lo struct threadlocaleinfostruct è stato modificato per contenere le modifiche apportate alle funzioni delle impostazioni locali.The threadlocaleinfostruct struct has changed to accommodate the changes to locale functions.

  • Le funzioni CRT con oggetti intrinseci corrispondenti, ad esempio memxxx(), strxxx() vengono rimosse da intrin.h.CRT functions that have corresponding intrinsics such as memxxx(), strxxx() are removed from intrin.h. Se intrin.h è stato incluso solo per queste funzioni, ora è necessario includere le intestazioni CRT corrispondenti.If you included intrin.h only for these functions, you must now include the corresponding CRT headers.

MFC e ATLMFC and ATL

  • Rimosso il supporto per la fusione (afxcomctl32.h), quindi sono stati rimossi tutti i metodi definiti in afxcomctl32.h.Removed Fusion support (afxcomctl32.h); therefore, all methods that are defined in afxcomctl32.h have been removed. I file di intestazione afxcomctl32.inl e afxcomctl32.h sono stati eliminati.Header files afxcomctl32.h and afxcomctl32.inl have been deleted.

  • Modificato il nome di CDockablePane::RemoveFromDefaultPaneDividier in CDockablePane::RemoveFromDefaultPaneDivider.Changed the name of CDockablePane::RemoveFromDefaultPaneDividier to CDockablePane::RemoveFromDefaultPaneDivider.

  • Modificata la firma di CFileDialog::SetDefExt per l'uso di LPCTSTR. Sono interessate le compilazioni Unicode.Changed the signature of CFileDialog::SetDefExt to use LPCTSTR; therefore, Unicode builds are affected.

  • Rimosse le categorie di analisi ATL obsolete.Removed obsolete ATL tracing categories.

  • Modificata la firma di CBasePane::MoveWindow in modo da accettare un elemento const CRect.Changed the signature of CBasePane::MoveWindow to take a const CRect.

  • Modificata la firma di CMFCEditBrowseCtrl::EnableBrowseButton.Changed the signature of CMFCEditBrowseCtrl::EnableBrowseButton.

  • m_fntTabs e m_fntTabsBold rimossi da CMFCBaseTabCtrl.Removed m_fntTabs and m_fntTabsBold from CMFCBaseTabCtrl.

  • Aggiunto un parametro ai costruttori CMFCRibbonStatusBarPane.Added a parameter to the CMFCRibbonStatusBarPane constructors. È un parametro predefinito che non rappresenta una modifica essenziale per il codice sorgente.(It is a default parameter, and so it is not source-breaking.)

  • Aggiunto un parametro ai costruttori CMFCRibbonCommandsListBox.Added a parameter to the CMFCRibbonCommandsListBox constructor. È un parametro predefinito che non rappresenta una modifica essenziale per il codice sorgente.(It is a default parameter, and so it is not source-breaking.)

  • Rimossa l'API AFXTrackMouse (e proc timer correlato).Removed the AFXTrackMouse API (and related timer proc). Usare l'API TrackMouseEvent di Win32.Use the Win32 TrackMouseEvent API instead.

  • Aggiunto un parametro al costruttore CFolderPickerDialog.Added a parameter to the CFolderPickerDialog constructor. È un parametro predefinito che non rappresenta una modifica essenziale per il codice sorgente.(It is a default parameter, and so it is not source-breaking.)

  • Modificate le dimensioni della struttura CFileStatus: il membro m_attribute è stato modificato da BYTE a DWORD (in base al valore restituito da fromGetFileAttributes).CFileStatus structure size changed: The m_attribute member changed from BYTE to DWORD (to match the value that's returned fromGetFileAttributes).

  • CRichEditCtrl e CRichEditView usano MSFTEDIT_CLASS (controllo RichEdit 4.1) anziché RICHEDIT_CLASS (controllo RichEdit 3.0) nelle compilazioni Unicode.CRichEditCtrl and CRichEditView use MSFTEDIT_CLASS (RichEdit 4.1 control) instead of RICHEDIT_CLASS (RichEdit 3.0 control) in Unicode builds.

  • Rimossa AFX_GLOBAL_DATA::IsWindowsThemingDrawParentBackground perché è sempre TRUE in Windows Vista, Windows 7 e Windows 8.Removed AFX_GLOBAL_DATA::IsWindowsThemingDrawParentBackground because it is always TRUE on Windows Vista, Windows 7, and Windows 8.

  • Rimossa AFX_GLOBAL_DATA::IsWindowsLayerSupportAvailable perché è sempre TRUE in Windows Vista, Windows 7 e Windows 8.Removed AFX_GLOBAL_DATA::IsWindowsLayerSupportAvailable because it is always TRUE on Windows Vista, Windows 7, and Windows 8.

  • Rimossa AFX_GLOBAL_DATA::DwmExtendFrameIntoClientArea.Removed AFX_GLOBAL_DATA::DwmExtendFrameIntoClientArea. Chiamare l'API Windows direttamente in Windows Vista, Windows 7 e Windows 8.Call Windows API directly on Windows Vista, Windows 7, and Windows 8.

  • Rimossa AFX_GLOBAL_DATA::DwmDefWindowProc.Removed AFX_GLOBAL_DATA::DwmDefWindowProc. Chiamare l'API Windows direttamente in Windows Vista, Windows 7 e Windows 8.Call Windows API directly on Windows Vista, Windows 7, and Windows 8.

  • Rinominata AFX_GLOBAL_DATA::DwmIsCompositionEnable in IsDwmCompositionEnabled per eliminare i conflitti di nome.Renamed AFX_GLOBAL_DATA::DwmIsCompositionEnabled to IsDwmCompositionEnabled to eliminate name collision.

  • Modificati gli identificatori per un numero di timer interni di MFC con definizioni spostate in afxres. h (AFX_TIMER_ID_ *).Changed identifiers for a number of MFC internal timers and moved the definitions to afxres.h (AFX_TIMER_ID_*).

  • Modificata la firma del metodo OnExitSizeMove per conformità con la macro ON_WM_EXITSIZEMOVE:Changed the signature of OnExitSizeMove method to agree with the ON_WM_EXITSIZEMOVE macro:

    • CFrameWndExCFrameWndEx

    • CMDIFrameWndExCMDIFrameWndEx

    • CPaneFrameWndCPaneFrameWnd

  • Modificati il nome e la firma di OnDWMCompositionChanged per conformità con la macro ON_WM_DWMCOMPOSITIONCHANGED:Changed the name and signature of OnDWMCompositionChanged to agree with the ON_WM_DWMCOMPOSITIONCHANGED macro:

    • CFrameWndExCFrameWndEx

    • CMDIFrameWndExCMDIFrameWndEx

    • CPaneFrameWndCPaneFrameWnd

  • Modificata la firma del metodo OnMouseLeave per conformità con la macro ON_WM_MOUSELEAVE:Changed the signature of OnMouseLeave method to agree with the ON_WM_MOUSELEAVE macro:

    • CMFCCaptionBarCMFCCaptionBar

    • CMFCColorBarCMFCColorBar

    • CMFCHeaderCtrlCMFCHeaderCtrl

    • CMFCProperySheetListBoxCMFCProperySheetListBox

    • CMFCRibbonBarCMFCRibbonBar

    • CMFCRibbonPanelMenuBarCMFCRibbonPanelMenuBar

    • CMFCRibbonRichEditCtrlCMFCRibbonRichEditCtrl

    • CMFCSpinButtonCtrlCMFCSpinButtonCtrl

    • CMFCToolBar ReplaceThisTextCMFCToolBar ReplaceThisText

    • CMFCToolBarComboBoxEditCMFCToolBarComboBoxEdit

    • CMFCToolBarEditCtrlCMFCToolBarEditCtrl

    • CMFCAutoHideBarCMFCAutoHideBar

  • Modificata la firma di OnPowerBroadcast per conformità con la macro ON_WM_POWERBROADCAST:Changed the signature of OnPowerBroadcast to agree with the ON_WM_POWERBROADCAST macro:

    • CFrameWndExCFrameWndEx

    • CMDIFrameWndExCMDIFrameWndEx

  • Modificata la firma di OnStyleChanged per conformità con la macro ON_WM_STYLECHANGED:Changed the signature of OnStyleChanged to agree with the ON_WM_STYLECHANGED macro:

    • CMFCListCtrlCMFCListCtrl

    • CMFCStatusBarCMFCStatusBar

  • Modificato il nome del metodo interno FontFamalyProcFonts in FontFamilyProcFonts.Renamed the internal method FontFamalyProcFonts to FontFamilyProcFonts.

  • Rimossi numerosi oggetti statici CString globali per eliminare le perdite di memoria in alcune situazioni (sostituiti con #defines) e le seguenti variabili membro di classe:Removed numerous global static CString objects to eliminate memory leaks in some situations (replaced with #defines), and the following class member variables:

    • CKeyBoardManager::m_strDelimiterCKeyBoardManager::m_strDelimiter

    • CMFCPropertyGridProperty::m_strFormatCharCMFCPropertyGridProperty::m_strFormatChar

    • CMFCPropertyGridProperty::m_strFormatShortCMFCPropertyGridProperty::m_strFormatShort

    • CMFCPropertyGridProperty::m_strFormatLongCMFCPropertyGridProperty::m_strFormatLong

    • CMFCPropertyGridProperty::m_strFormatUShortCMFCPropertyGridProperty::m_strFormatUShort

    • CMFCPropertyGridProperty::m_strFormatULongCMFCPropertyGridProperty::m_strFormatULong

    • CMFCPropertyGridProperty::m_strFormatFloatCMFCPropertyGridProperty::m_strFormatFloat

    • CMFCPropertyGridProperty::m_strFormatDoubleCMFCPropertyGridProperty::m_strFormatDouble

    • CMFCToolBarImages::m_strPngResTypeCMFCToolBarImages::m_strPngResType

    • CMFCPropertyGridProperty::m_strFormatCMFCPropertyGridProperty::m_strFormat

  • Modificata la firma di CKeyboardManager::ShowAllAccelerators e rimosso il parametro di delimitazione per i tasti di scelta rapida.Changed the signature of CKeyboardManager::ShowAllAccelerators and removed the accelerator delimiter parameter.

  • Aggiunta CPropertyPage::GetParentSheet; nella classe CPropertyPage chiamarla al posto di GetParent per ottenere la finestra padre delle proprietà corretta, che può essere la finestra padre o padre del padre per CPropertyPage.Added CPropertyPage::GetParentSheet, and in the CPropertyPage class, call it instead of GetParent to get the correct parent sheet window, which may be the parent or a grandparent window to CPropertyPage. Potrebbe essere necessario modificare il codice per chiamare GetParentSheet anziché ofGetParent.You might have to change your code to call GetParentSheet instead ofGetParent.

  • Corretto elemento #pragma warning(push) sbilanciato in ATLBASE.H, che causava la disabilitazione non corretta degli avvisi.Fixed unbalanced #pragma warning(push) in ATLBASE.H, which caused warnings to be disabled incorrectly. Gli avvisi sono ora abilitati correttamente dopo l'analisi di ATLBASE.H.Those warnings are now enabled correctly after ATLBASE.H has been parsed.

  • Spostati i metodi correlati a D2D da AFX_GLOBAL_DATA a _AFX_D2D_STATE:Moved D2D-related methods from AFX_GLOBAL_DATA to _AFX_D2D_STATE:

    • GetDirectD2dFactoryGetDirectD2dFactory

    • GetWriteFactoryGetWriteFactory

    • GetWICFactoryGetWICFactory

    • InitD2DInitD2D

    • ReleaseD2DRefsReleaseD2DRefs

    • IsD2DInitializedIsD2DInitialized

    • D2D1MakeRotateMatrixD2D1MakeRotateMatrix

    • Anziché chiamare, ad esempio, afxGlobalData.IsD2DInitialized, chiamare AfxGetD2DState->IsD2DInitialized.Instead of calling, for example, afxGlobalData.IsD2DInitialized, call AfxGetD2DState->IsD2DInitialized.

  • Rimossi file *.CPP di ATL obsoleti dalla cartella \atlmfc\include.Removed obsolete ATL*.CPP files from the \atlmfc\include\ folder.

  • Inizializzazione afxGlobalData spostata nella fase su richiesta anziché nella fase di inizializzazione CRT, per soddisfare i requisiti di DLLMain.Moved afxGlobalData initialization to on-demand instead of at CRT initialization time, to satisfy DLLMain requirements.

  • Aggiunto il metodo RemoveButtonByIndex alla classe CMFCOutlookBarPane.Added the RemoveButtonByIndex method to the CMFCOutlookBarPane class.

  • CMFCCmdUsageCount::IsFreqeuntlyUsedCmd corretta in IsFrequentlyUsedCmd.Corrected CMFCCmdUsageCount::IsFreqeuntlyUsedCmd to IsFrequentlyUsedCmd.

  • Corrette diverse istanze di RestoreOriginalstate in RestoreOriginalState (CMFCToolBar, CMFCMenuBar, CMFCOutlookBarPane).Corrected several instances of RestoreOriginalstate to RestoreOriginalState (CMFCToolBar, CMFCMenuBar, CMFCOutlookBarPane).

  • Rimossi i metodi non usati da CDockablePane: SetCaptionStyle, IsDrawCaption, IsHideDisabledButtons, GetRecentSiblingPaneInfo e CanAdjustLayout.Removed unused methods from CDockablePane: SetCaptionStyle, IsDrawCaption, IsHideDisabledButtons, GetRecentSiblingPaneInfo, andCanAdjustLayout.

  • Rimosse le variabili m_bCaptionText e m_bHideDisabledButtons del membro statico CDockablePane.Removed CDockablePane static member variables m_bCaptionText and m_bHideDisabledButtons.

  • Aggiunto un metodo di override DeleteString a CMFCFontComboBox.Added an override DeleteString method to CMFCFontComboBox.

  • Rimossi metodi non usati da CPane: GetMinLength e IsLastPaneOnLastRow.Removed unused methods from CPane: GetMinLength and IsLastPaneOnLastRow.

  • CPane::GetDockSiteRow(CDockingPanesRow *) rinominata CPane::SetDockSiteRow.Renamed CPane::GetDockSiteRow(CDockingPanesRow *) to CPane::SetDockSiteRow.

Modifiche importanti in Visual C++ 2010Visual C++ 2010 Breaking Changes

CompilatoreCompiler

  • La parola chiave auto ha un nuovo significato predefinito.The auto keyword has a new default meaning. Poiché l'uso del significato precedente è poco frequente, la maggior parte delle applicazioni non sarà interessata da questa modifica.Because use of the old meaning is rare, most applications will not be affected by this change.

  • Viene introdotta la nuova parola chiave static_assert che causerà un conflitto di nomi se esiste già un identificatore con quel nome nel codice.The new static_assert keyword is introduced, which will cause a name conflict if there is already an identifier by that name in your code.

  • Il supporto per la nuova notazione lambda esclude il supporto per la codifica di un GUID non racchiuso tra virgolette in un attributo uuid IDL.Support for the new lambda notation excludes support for coding an unquoted GUID in an IDL uuid attribute.

  • .NET Framework 4 introduce il concetto di eccezioni di stato danneggiato, ovvero eccezioni che lasciano un processo in uno stato danneggiato irreversibile.The .NET Framework 4 introduces the concept of corrupted state exceptions, which are exceptions that leave a process in an unrecoverable corrupted state. Per impostazione predefinita, non è possibile rilevare un'eccezione di stato danneggiato, nemmeno con l'opzione /EHa del compilatore che rileva tutte le altre eccezioni.By default, you cannot catch a corrupted state exception, even with the /EHa compiler option that catches all other exceptions. Per rilevare in modo esplicito un'eccezione di stato danneggiato, usare le istruzioni _try-__except.To explicitly catch a corrupted state exception, use __try-__except statements. Oppure applicare l'attributo [HandledProcessCorruptedStateExceptions] per abilitare una funzione che rilevi le eccezioni di stato danneggiato.Or, apply the [HandledProcessCorruptedStateExceptions]attribute to enable a function to catch corrupted state exceptions. Questa modifica interessa principalmente i programmatori di sistema che potrebbero dover rilevare un'eccezione di stato danneggiato.This change affects primarily system programmers who might have to catch a corrupted state exception. Le otto eccezioni sono STATUS_ACCESS_VIOLATION, STATUS_STACK_OVERFLOW, EXCEPTION_ILLEGAL_INSTRUCTION, EXCEPTION_IN_PAGE_ERROR, EXCEPTION_INVALID_DISPOSITION, EXCEPTION_NONCONTINUABLE_EXCEPTION, EXCEPTION_PRIV_INSTRUCTION, STATUS_UNWIND_CONSOLIDATE.The eight exceptions are STATUS_ACCESS_VIOLATION, STATUS_STACK_OVERFLOW, EXCEPTION_ILLEGAL_INSTRUCTION, EXCEPTION_IN_PAGE_ERROR, EXCEPTION_INVALID_DISPOSITION, EXCEPTION_NONCONTINUABLE_EXCEPTION, EXCEPTION_PRIV_INSTRUCTION, STATUS_UNWIND_CONSOLIDATE. Per altre informazioni su queste eccezioni, vedere la macro GetExceptionCode.For more information about these exceptions, see the GetExceptionCode macro.

  • La nuova opzione /GS del compilatore protegge dai sovraccarichi del buffer in modo più completo rispetto alle versioni precedenti.The revised /GS compiler option guards against buffer overruns more comprehensively than in earlier versions. Questa versione potrebbe inserire controlli di sicurezza aggiuntivi nello stack riducendo le prestazioni.This version might insert additional security checks in the stack that might decrease performance. Usare la nuova parola chiave __declspec(safebuffers) per indicare al compilatore di non inserire controlli di sicurezza per una determinata funzione.Use the new __declspec(safebuffers) keyword to instruct the compiler to not insert security checks for a particular function.

  • Se si esegue la compilazione con entrambe le opzioni del compilatore, /GL (ottimizzazione intero programma) e /clr (compilazione Common Language Runtime), l'opzione /GL viene ignorata.If you compile with both the /GL (Whole Program Optimization) and /clr (Common Language Runtime Compilation) compiler options, the /GLoption is ignored. Questa modifica è stata apportata poiché la combinazione delle opzioni del compilatore non risultava particolarmente vantaggiosa.This change was made because the combination of compiler options provided little benefit. In seguito a questa modifica le prestazioni della compilazione sono migliorate.As a result of this change, the performance of the build is improved.

  • Per impostazione predefinita, il supporto per i trigrammi è disabilitato in Visual C++ 2010.By default, support for trigraphs is disabled in Visual C++ 2010 . Usare l'opzione /Zc:trigraphs del compilatore per abilitare il supporto dei trigrammi.Use the /Zc:trigraphs compiler option to enable trigraphs support. Un trigramma è costituito da due punti interrogativi consecutivi ("??") seguiti da un terzo carattere univoco.A trigraph consists of two consecutive question marks ("??") followed by a unique third character. Il compilatore sostituisce un trigramma con un carattere di punteggiatura corrispondente.The compiler replaces a trigraph with a corresponding punctuation character. Ad esempio, il compilatore sostituisce il trigramma "??=" con il carattere "#".For example, the compiler replaces the "??=" trigraph with the '#' character. Usare i trigrammi in file di origine C che usano un set di caratteri che non contiene rappresentazioni grafiche adeguate per alcuni caratteri di punteggiatura.Use trigraphs in C source files that use a character set that does not contain convenient graphic representations for some punctuation characters.

  • Il linker non supporta più l'ottimizzazione per Windows 98.The linker no longer supports optimizing for Windows 98. L'opzione /OPT (ottimizzazioni) genera un errore in fase di compilazione se si specifica /OPT:WIN98 o /OPT: NOWIN98.The /OPT (Optimizations) option produces a compile time error if you specify/OPT:WIN98 or /OPT:NOWIN98.

  • Le opzioni predefinite del compilatore specificate dalle proprietà di compilazione RuntimeLibrary e DebugInformationFormat del sistema sono state modificate.The default compiler options that are specified by the RuntimeLibrary and DebugInformationFormat build system properties have been changed. Per impostazione predefinita, queste proprietà di compilazione vengono specificate nei progetti creati nelle versioni da 7.0 a 10.0 di Visual C++.By default, these build properties are specified in projects that are created by Visual C++ releases 7.0 through 10.0. Se si esegue la migrazione di un progetto creato da Visual C++ 6.0, considerare la possibilità di specificare un valore per queste proprietà.If you migrate a project that was created by Visual C++ 6.0, consider whether to specify a value for these properties.

  • In Visual C++ 2010, RuntimeLibrary = MultiThreaded (/MD) e DebugInformationFormat = ProgramDatabase (/Zi).In Visual C++ 2010, RuntimeLibrary = MultiThreaded (/MD) and DebugInformationFormat = ProgramDatabase (/Zi). In Visual C++ 9.0, RuntimeLibrary = MultiThreaded (/MT) e DebugInformationFormat = Disabled.In Visual C++ 9.0,RuntimeLibrary = MultiThreaded (/MT) and DebugInformationFormat = Disabled.

CLRCLR

  • I compilatori Microsoft C# e Visual Basic ora sono in grado di produrre un assembly senza interoperabilità primaria (no-PIA).The Microsoft C# and Visual Basic compilers can now produce a no primary interop assembly (no-PIA). Un assembly no-PIA è in grado di usare i tipi COM senza la distribuzione del relativo assembly di interoperabilità primario (PIA).A no-PIA assembly can use COM types without the deployment of the relevant primary interop assembly (PIA). Quando si consumano assembly no-PIA prodotti da Visual C# o Visual Basic, è necessario fare riferimento all'assembly PIA nel comando di compilazione prima di fare riferimento a qualsiasi assembly no-PIA che usa la libreria.When consuming no-PIA assemblies produced by Visual C# or Visual Basic, you must reference the PIA assembly on the compile command before you reference any no-PIA assembly that uses the library.

Progetti di Visual C++ e MSBuildVisual C++ Projects and MSBuild

  • I progetti di Visual C++ sono ora basati sullo strumento MSBuild.Visual C++ projects are now based on the MSBuild tool. Di conseguenza, i file di progetto usano un nuovo formato di file XML e il suffisso di un file con estensione VCXPROJ.Consequently, project files use a new XML file format and a .vcxproj file suffix. Visual C++ 2010 converte automaticamente i file di progetto da versioni precedenti di Visual Studio nel nuovo formato di file.Visual C++ 2010 automatically converts project files from earlier versions of Visual Studio to the new file format. Un progetto esistente è interessato se dipende dallo strumento di compilazione precedente, VCBUILD.exe, o dal suffisso del file di progetto con estensione VCPROJ.An existing project is affected if it depends on the previous build tool, VCBUILD.exe, or project file suffix, .vcproj.

  • Nelle versioni precedenti Visual C++ supportava la valutazione tardiva delle finestre delle proprietà.In earlier releases, Visual C++ supported the late evaluation of property sheets. Ad esempio, una finestra delle proprietà padre poteva importare una finestra delle proprietà figlio e l'elemento padre poteva usare una variabile definita nell'elemento figlio per definire altre variabili.For example, a parent property sheet could import a child property sheet, and the parent could use a variable defined in the child to define other variables. La valutazione tardiva consentiva all'elemento padre di usare la variabile figlio anche prima dell'importazione della finestra delle proprietà figlio.Late evaluation enabled the parent to use the child variable even before the child property sheet was imported. In Visual C++ 2010 una variabile della finestra del progetto non può essere usata prima che sia definita perché MSBuild supporta solo la valutazione precoce.In Visual C++ 2010, a project sheet variable cannot be used before it is defined because MSBuild supports only early evaluation.

IDEIDE

  • La finestra di dialogo di chiusura dell'applicazione non chiude più un'applicazione.The application termination dialog box no longer ends an application. Nelle versioni precedenti, quando la funzione abort() o terminate() chiudeva la versione per la vendita di un'applicazione, la libreria di runtime C visualizzava un messaggio di chiusura dell'applicazione in una finestra o finestra di dialogo della console.In previous releases, when the abort() or terminate() function closed the retail build of an application, the C Run-Time Library displayed an application termination message in a console window or dialog box. Il messaggio indicava che l'applicazione aveva richiesto al runtime di chiuderla in modo anomaloThe message said in part, "This application has requested the Runtime to terminate it in an unusual way. e di contattare il team di supporto dell'applicazione per maggiori dettagli.Please contact the application's support team for more information." Il messaggio di chiusura dell'applicazione era ridondante perché in Windows veniva successivamente visualizzato il gestore di chiusura corrente, in genere la finestra di dialogo Segnalazione errori Windows (Dr Watson) o il debugger di Visual Studio.The application termination message was redundant because Windows subsequently displayed the current termination handler, which was usually the Windows Error Reporting (Dr. Watson) dialog box or the Visual Studio debugger. A partire da Visual Studio 2010, la libreria di runtime C non visualizza il messaggio.Starting in Visual Studio 2010, the C Run-Time Library does not display the message. Inoltre, il runtime impedisce all'applicazione di chiudersi prima dell'avvio di un debugger.Furthermore, the runtime prevents the application from ending before a debugger starts. Si tratta di una modifica sostanziale solo se si dipende dal comportamento precedente del messaggio di chiusura dell'applicazione.This is a breaking change only if you depend on the previous behavior of the application termination message.

  • In particolare per Visual Studio 2010, IntelliSense non funziona per il codice o gli attributi C++/CLI, Trova tutti i riferimenti non funziona per le variabili locali e Modello codice non recupera i nomi dei tipi dagli assembly importati o non risolve i tipi per i relativi nomi completi.Specifically for Visual Studio 2010, IntelliSense does not work for C++/CLI code or attributes, Find All References does not work for local variables, and Code Model does not retrieve type names from imported assemblies or resolve types to their fully qualified names.

LibrerieLibraries

  • La classe SafeInt è inclusa in Visual C++ e non è più in un download separato.The SafeInt class is included in Visual C++ and is no longer in a separate download. Questa modifica è importante solo se è stata sviluppata una classe denominata anch'essa "SafeInt".This is a breaking change only if you have developed a class that is also named "SafeInt".

  • Il modello di distribuzione delle librerie non usa più manifesti per trovare una particolare versione di una libreria a collegamento dinamico.The libraries deployment model no longer uses manifests to find a particular version of a dynamic link library. Il nome di ogni libreria a collegamento dinamico contiene invece il proprio numero di versione e si usa quel nome per individuare la libreria.Instead, the name of each dynamic link library contains its version number, and you use that name to locate the library.

  • Nelle versioni precedenti di Visual Studio era possibile ricompilare le librerie di runtime.In previous versions of Visual Studio, you could rebuild the run time libraries. Visual C++ 2010 non supporta più la creazione di copie personali dei file della libreria di runtime C.Visual C++ 2010 no longer supports building your own copies of the C run time library files.

Libreria standardStandard Library

  • L'intestazione <iterator> non è più inclusa automaticamente da molti altri file di intestazione.The <iterator> header is no longer included automatically by many other header files. Includere tale intestazione in modo esplicito se si richiede supporto per gli iteratori autonomi definiti nell'intestazione . Un progetto esistente è influenzato se dipende dallo strumento di compilazione precedente, VCBUILD.exe, o dal suffisso del file di progetto con estensione VCPROJ.Instead, include that header explicitly if you require support for the standalone iterators defined in the An existing project is affected if it depends on the previous build tool, VCBUILD.exe, or project file suffix, .vcproj.interator> header.

  • Nell'intestazione <algorithm sono state rimosse le funzioni checked_* e unchecked_*.In the <algorithm> header, the checked_* and unchecked_* functions are removed. E nell'intestazione <iterator>> header la classe checked_iterator è stata rimossa ed è stata aggiunta la classe unchecked_array_iterator.And in the <iterator>> header, the checked_iteratorclass is removed, and the unchecked_array_iterator class has been added.

  • Il costruttore CComPtr::CComPtr(int) è stato rimosso.The CComPtr::CComPtr(int) constructor is removed. Tale costruttore consentiva la creazione di un oggetto CComPtr dalla macro NULL, ma non era necessario e consentiva costruzioni senza senso da valori interi diversi da zero.That constructor allowed a CComPtr object to be constructed from the NULL macro, but was unnecessary and allowed nonsensical constructions from non-zero integers.

    È ancora possibile costruire un oggetto CComPtr da NULL, che viene definita come 0, ma l'esito sarà negativo se l'oggetto viene costruito da un intero diverso dal valore letterale 0.A CComPtr can still be constructed from NULL, which is defined as 0, but will fail if constructed from an integer other than literal 0. Usare nullptr in alternativa.use nullptr instead.

  • Le seguenti funzioni del membro ctype sono state rimosse: ctype::_Do_narrow_s, ctype::_Do_widen_s, ctype::_narrow_s, ctype::_widen_s.The following ctype member functions were removed: ctype::_Do_narrow_s, ctype::_Do_widen_s, ctype::_narrow_s, ctype::_widen_s. Se un'applicazione usa una di queste funzioni membro, è necessario sostituirla con la versione non protetta corrispondente: ctype::do_narrow,ctype::do_widen, ctype::narrow, ctype::widen.If an application uses one of these member functions, you must replace it with the corresponding non-secure version: ctype::do_narrow,ctype::do_widen, ctype::narrow, ctype::widen.

Librerie ATL, MFC e CRTCRT, MFC, and ATL Libraries

  • È stato rimosso il supporto per gli utenti per la creazione delle librerie CRT, MFC e ATL.Support has been removed for users to build the CRT, MFC, and ATL libraries. Ad esempio, non è disponibile un file NMAKE appropriato.For example, an appropriate nmake file is not provided. Tuttavia, gli utenti possono ancora accedere al codice sorgente per queste librerie.However, users still have access to the source code for these libraries. E un documento che descrive le opzioni di MSBuild che Microsoft usa per creare queste librerie verrà probabilmente pubblicato in un blog del team di Visual C++.And a document that describes the MSBuild options that Microsoft uses to build these libraries will probably be posted in a Visual C++ Team Blog.

  • Il supporto MFC per IA64 è stato rimosso.MFC support for IA64 has been removed. Tuttavia, è ancora disponibile il supporto per CRT e ATL per IA64.However, support for the CRT and ATL on IA64 is still provided.

  • Gli ordinali non vengono più riutilizzati nei file di definizione moduli (DEF) di MFC.Ordinals are no longer reused in MFC module-definition (.def) files. Questa modifica implica che gli ordinali non saranno diversi tra le versioni secondarie e che migliorerà la compatibilità binaria per le versioni di progettazione di service pack e quick fix.This change means ordinals will not be different between minor versions, and binary compatibility for service packs and quick fix engineering releases will be improved.

  • È stata aggiunta una nuova funzione virtuale alla classe CDocTemplate.A new virtual function was added to the CDocTemplate class. Questa nuova funzione virtuale è CDocTemplate Class.This new virtual function is CDocTemplate Class. La versione precedente di OpenDocumentFile aveva due parametri.The previous version of OpenDocumentFile had two parameters. La nuova versione ha tre parametri.The new version has three parameters. Per supportare la gestione del riavvio, qualsiasi classe derivata da CDocTemplate deve implementare la versione con tre parametri.To support the restart manager, any class derived from CDocTemplate must implement the version that has three parameters. Il nuovo parametro è bAddToMRU.The new parameter is bAddToMRU.

Macro e variabili di ambienteMacros and Environment Variables

  • La variabile di ambiente __MSVCRT_HEAP_SELECT non è più supportata.The environment variable __MSVCRT_HEAP_SELECT is no longer supported. Questa variabile di ambiente viene rimossa e non vi è alcuna sostituzione.This environment variable is removed and there is no replacement.

Riferimento a Microsoft Macro AssemblerMicrosoft Macro Assembler Reference

  • Sono state rimosse diverse direttive dal compilatore di riferimento a Microsoft Macro Assembler.Several directives were removed from the Microsoft Macro Assembler Reference compiler. Le direttive rimosse sono .186, .286, .286P, .287, .8086, .8087 e .NO87.The removed directives are .186, .286, .286P, .287,.8086, .8087, and .NO87.

Modifiche importanti in Visual C++ 2008Visual C++ 2008 Breaking Changes

CompilatoreCompiler

  • Le piattaforme Windows 95, Windows 98, Windows ME e Windows NT non sono più supportate.The Windows 95, Windows 98, Windows ME, and Windows NT platforms are no longer supported. Questi sistemi operativi sono stati rimossi dall'elenco delle piattaforme assegnate.These operating systems have been removed from the list of targeted platforms.

  • Il compilatore non supporta più diversi attributi direttamente associati al server ATL.The compiler no longer supports multiple attributes that were directly associated with ATL Server. Gli attributi che seguono non sono più supportati:The following attributes are no longer supported:

    • perf_counterperf_counter

    • perf_objectperf_object

    • perfmonperfmon

    • request_handlerrequest_handler

    • soap_handlersoap_handler

    • soap_headersoap_header

    • soap_methodsoap_method

    • tag_nametag_name

Progetti di Visual C++Visual C++ Projects

  • Quando si aggiornano progetti da versioni precedenti di Visual Studio è necessario modificare le macro WINVER e _WIN32_WINNT in modo che siano maggiori o uguali a 0x0500.When upgrading projects from previous versions of Visual Studio, you might have to modify the WINVER and _WIN32_WINNT macros so that they are greater than or equal to 0x0500.

  • A partire da Visual Studio 2008 la procedura guidata per la creazione di un nuovo progetto non ha un'opzione che consente di creare un progetto SQL Server di C++.Beginning with Visual Studio 2008, the new project wizard does not have an option to create a C++ SQL Server project. I progetti SQL Server creati usando una versione precedente di Visual Studio verranno comunque compilati e funzioneranno correttamente.SQL Server projects created by using an earlier version of Visual Studio will still compile and work correctly.

  • Il file di intestazione Winable.h dell'API Windows è stato rimosso.The Windows API header file Winable.h has been removed. Includere invece Winuser.h.Include Winuser.h instead.

  • La libreria Rpcndr.lib dell'API Windows è stata rimossa.The Windows API library Rpcndr.lib has been removed. Eseguire il collegamento a rpcrt4.lib.Link with rpcrt4.lib instead.

CRTCRT

  • Il supporto per Windows 95, Windows 98, Windows Millennium Edition e Windows NT 4.0 è stato rimosso.Support for Windows 95, Windows 98, Windows Millennium Edition, and Windows NT 4.0 has been removed.

  • Sono state rimosse le variabili globali seguenti:The following global variables have been removed:

    • _osplatform_osplatform

    • _osver_osver

    • _winmajor_winmajor

    • _winminor_winminor

    • _winver_winver

  • Le funzioni seguenti sono state rimosse.The following functions have been removed. Usare in alternativa le funzioni API Windows GetVersion o GetVersionEx:Use the Windows API functions GetVersion or GetVersionEx instead:

    • _get_osplatform_get_osplatform

    • _get_osver_get_osver

    • _get_winmajor_get_winmajor

    • _get_winminor_get_winminor

    • _get_winver_get_winver

  • La sintassi per le annotazioni SAL è cambiata.The syntax for SAL Annotations has changed. Per altre informazioni, vedere le annotazioni SAL.For more information, see SAL Annotations.

  • Il filtro IEEE supporta ora il set di istruzioni SSE 4.1.The IEEE filter now supports the SSE 4.1 instruction set. Per altre informazioni, vedere _fpieee_flt_fpieee_flt.For more information, see _fpieee_flt_fpieee_flt.

  • Le librerie di runtime C accluse a Visual Studio non sono più dipendenti dalla DLL di sistema msvcrt.dll.The C Run-Time Libraries that ship with Visual Studio are no longer dependent on the system DLL msvcrt.dll.

Libreria standardStandard Library

  • Il supporto per Windows 95, Windows 98, Windows Millennium Edition e Windows NT 4.0 è stato rimosso.Support for Windows 95, Windows 98, Windows Millennium Edition, and Windows NT 4.0 has been removed.

  • Durante la compilazione in modalità di debug con HAS_ITERATOR_DEBUGGING definita (sostituita da ITERATOR_DEBUG_LEVEL dopo Visual Studio 2010), un'applicazione ora esegue un'asserzione quando un iteratore tenta di incrementare o diminuire oltre i limiti del contenitore sottostante.When compiling in debug mode with _HAS_ITERATOR_DEBUGGING defined (superseded by _ITERATOR_DEBUG_LEVEL after Visual Studio 2010), an application will now assert when an iterator attempts to increment or decrement past the bounds of the underlying container.

  • La variabile membro c della classe stack ora è dichiarata protetta.The member variable c of the stack Class is now declared protected. In precedenza, questa variabile membro era dichiarata pubblica.Previously, this member variable was declared public.

  • Il comportamento di money_get::do_get è stato modificato.The behavior of money_get::do_get has changed. In precedenza, durante l'analisi di un importo monetario con più cifre frazionarie chiamate da frac_digits, do_get le consumava tutte.Previously, when parsing a monetary amount with more fraction digits than are called for by frac_digits, do_get used to consume them all. Ora do_get arresta l'analisi dopo aver consumato al massimo frac_digits caratteri.Now, do_get stops parsing after consuming at most frac_digits characters.

ATLATL

  • Non è possibile compilare ATL senza una dipendenza da CRT.ATL cannot be built without a dependency on CRT. Nelle versioni precedenti di Visual Studio è possibile usare #define ATL_MIN_CRT rendere un progetto ATL in minima parte dipendente da CRT.In earlier versions of Visual Studio, you could use #define ATL_MIN_CRT to make an ATL project minimally dependent on CRT. In Visual C++ 2008 tutti i progetti ATL dipendono in minima parte da CRT indipendentemente dal fatto che sia definita ATL_MIN_CRT.In Visual C++ 2008, all ATL projects are minimally dependent on CRT regardless of whether ATL_MIN_CRT is defined.

  • La codebase di ATL Server è stata rilasciata come progetto di origine condiviso in CodePlex e non viene installata come parte di Visual Studio.The ATL Server codebase has been released as a shared source project on CodePlex and is not installed as part of Visual Studio. Le classi di codifica e decodifica dei dati di atlenc.h e le funzioni e classi di utilità di atlutil.h e atlpath.h sono state mantenute e ora fanno parte della libreria ATL.Data encoding and decoding classes from atlenc.h and utility functions and classes from atlutil.h and atlpath.h have been kept and are now part of the ATL library. Alcuni dei file associati ad ATL Server non fanno più parte di Visual Studio.Several files associated with ATL Server are no longer part of Visual Studio.

  • Alcune funzioni non sono più incluse nella DLL.Some functions are no longer included in the DLL. Si trovano ancora nella libreria di importazione.They are still located in the import library. Ciò non influisce sul codice che usa le funzioni in modo statico.This will not affect code that uses the functions statically. Influirà solo sul codice che usa queste funzioni in modo dinamico.It will affect only the code that uses these functions dynamically.

  • Le macro PROP_ENTRY e PROP_ENTRY_EX sono state deprecate e sostituite con le macro PROP_ENTRY_TYPE e PROP_ENTRY_TYPE_EX per motivi di sicurezza.The macros PROP_ENTRY and PROP_ENTRY_EX have been deprecated and replaced with the macros PROP_ENTRY_TYPE andPROP_ENTRY_TYPE_EX for security reasons.

Classi condivise ATL/MFCATL/MFC Shared Classes

  • Non è possibile compilare ATL senza una dipendenza da CRT.ATL cannot be built without a dependency on CRT. Nelle versioni precedenti di Visual Studio è possibile usare #define ATL_MIN_CRT rendere un progetto ATL in minima parte dipendente da CRT.In earlier versions of Visual Studio, you could use #define ATL_MIN_CRT to make an ATL project minimally dependent on CRT. In Visual C++ 2008 tutti i progetti ATL dipendono in minima parte da CRT indipendentemente dal fatto che sia definita ATL_MIN_CRT.In Visual C++ 2008, all ATL projects are minimally dependent on CRT regardless of whether ATL_MIN_CRT is defined.

  • La codebase di ATL Server è stata rilasciata come progetto di origine condiviso in CodePlex e non viene installata come parte di Visual Studio.The ATL Server codebase has been released as a shared source project on CodePlex and is not installed as part of Visual Studio. Le classi di codifica e decodifica dei dati di atlenc.h e le funzioni e classi di utilità di atlutil.h e atlpath.h sono state mantenute e ora fanno parte della libreria ATL.Data encoding and decoding classes from atlenc.h and utility functions and classes from atlutil.h and atlpath.h have been kept and are now part of the ATL library. Alcuni dei file associati ad ATL Server non fanno più parte di Visual Studio.Several files associated with ATL Server are no longer part of Visual Studio.

  • Alcune funzioni non sono più incluse nella DLL.Some functions are no longer included in the DLL. Si trovano ancora nella libreria di importazione.They are still located in the import library. Ciò non influisce sul codice che usa le funzioni in modo statico.This will not affect code that uses the functions statically. Influirà solo sul codice che usa queste funzioni in modo dinamico.It will affect only the code that uses these functions dynamically.

MFCMFC

  • Classe CTime: la classe CTime ora accetta le date a partire da 1/1/1900 DCCTime Class: The CTime class now accepts dates starting from 1/1/1900 C.E. anziché 1/1/1970 DC.instead of 1/1/1970 C.E.
  • Ordine di tabulazione dei controlli nelle finestre di dialogo MFC: l'ordine di tabulazione corretto di più controlli in una finestra di dialogo MFC è disturbato se un controllo ActiveX di MFC viene inserito nell'ordine di tabulazione.Tab order of controls in MFC dialogs: The correct tab order of multiple controls in an MFC dialog is disturbed if an MFC ActiveX control is inserted in the tab order. Questa modifica corregge il problema.This change corrects that problem.

    Ad esempio, creare un'applicazione di finestre di dialogo MFC che usa un controllo ActiveX e diversi controlli di modifica.For example, create an MFC dialog application that has an ActiveX control and several edit controls. Posizionare il controllo ActiveX nel mezzo dell'ordine di tabulazione dei controlli di modifica.Position the ActiveX control in the middle of the tab order of the edit controls. Avviare l'applicazione, fare clic su un controllo di modifica il cui ordine di tabulazione sia dopo il controllo ActiveX, quindi usare la tabulazione. Prima di questa modifica lo stato attivo passava al controllo di modifica successivo al controllo ActiveX anziché al controllo di modifica successivo nell'ordine di tabulazione.Start the application, click an edit control whose tab order is after the ActiveX control, then tab. Prior to this change, the focus went to the edit control following the ActiveX control instead of the next edit control in the tab order.

  • Classe CFileDialog: i modelli personalizzati per la classe CFileDialog non possono essere portati automaticamente in Windows Vista.CFileDialog Class: Custom templates for the CFileDialog class cannot be automatically ported to Windows Vista. Si possono ancora usare, ma non hanno le funzionalità aggiuntive o l'aspetto delle finestre di dialogo di Windows Vista.They are still usable, but will not have the additional functionality or looks of Windows Vista style dialogs.

  • Classe CWnd e classe CFrameWnd: il metodo CWnd::GetMenuBarInfo è stato rimosso.CWnd Class and CFrameWnd Class: The CWnd::GetMenuBarInfo method was removed.

    Il metodo CFrameWnd::GetMenuBarInfo è ora un metodo non virtuale.The CFrameWnd::GetMenuBarInfo method is now a non-virtual method. Per altre informazioni, vedere la funzione GetMenuBarInfo in Windows SDK.For more information, see GetMenuBarInfo Functionin the Windows SDK.

  • Supporto MFC per ISAPI: MFC non supporta più la compilazione di applicazioni con ISAPI (Internet Server Application Programming Interface).MFC ISAPI support: MFC no longer supports building applications with the Internet Server Application Programming Interface (ISAPI). Per compilare un'applicazione ISAPI, chiamare direttamente le estensioni ISAPI.If you want to build an ISAPI application, call the ISAPI extensions directly.

  • API ANSI deprecate: le versioni ANSI di diversi metodi MFC sono deprecate.Deprecated ANSI APIs: The ANSI versions of several MFC methods are deprecated. Usare le versioni Unicode dei metodi nelle applicazioni future.Use the Unicode versions of those methods in your future applications. Per altre informazioni, vedere i requisiti di compilazione per i controlli comuni di Windows Vista.For more information, see Build Requirements for Windows Vista Common Controls.

Modifiche importanti in Visual C++ 2005Visual C++ 2005 Breaking Changes

CRTCRT

  • Molte funzionalità sono state deprecate.Many functions have been deprecated. Vedere le funzioni CRT deprecate.See Deprecated CRT Functions.

  • Molte funzioni ora convalidano i propri parametri, interrompendo l'esecuzione in presenza di parametri non validi.Many functions now validate their parameters, halting execution if given invalid parameters. Ciò può causare l'interruzione del codice che passa parametri non validi e si basa sulla funzione che li ignora o semplicemente restituisce un codice di errore.This may break code that passes invalid parameters and relies on the function ignoring them or just returning an error code. Vedere Convalida dei parametri.See Parameter Validation.

  • Il valore del descrittore di file -2 viene ora usato per indicare che stdout e stderr non sono disponibili per l'output, ad esempio come in un'applicazione Windows che non ha una finestra di console.The file descriptor value -2 is now used to indicate that stdout and stderr are not available for output, as for example in a Windows application that has no console window. Il valore usato in precedenza era -1.The previous value used was -1. Per altre informazioni, vedere _fileno.For more information, see _fileno.

  • Le librerie CRT a thread singolo, libc.lib e libcd.lib, sono state rimosse.The single-threaded CRT libraries, libc.lib and libcd.lib, have been removed. Usare le librerie CRT multithread.Use the multi-threaded CRT libraries. Il flag del compilatore /ML non è più supportato.The /ML compiler flag is no longer supported. Le versioni non di blocco di alcune funzioni sono state aggiunte nei casi in cui la differenza delle prestazioni tra il codice multithread e il codice a thread singolo è potenzialmente significativa.Non-locking versions of some functions have been added in cases where the performance difference between the multithreaded code and the single-threaded code is potentially significant.

  • L'overload di pow, double pow(int, int) è stato rimosso per migliorare la conformità allo standard.The overload of pow, double pow(int, int), was removed to better conform with the standard.

  • L'identificatore di formato %n non è più supportato per impostazione predefinita in nessuna delle famiglie di funzioni printf perché è intrinsecamente non sicuro.The %n format specifier is no longer supported by default in any of the printf family of functions because it is inherently insecure. Il comportamento predefinito se viene rilevato %n è richiamare il gestore di parametro non valido.The default behavior if %n is encountered is to invoke the invalid parameter handler. Per abilitare il supporto di %n, usare set_printf_count_output (anche see_get_printf_count_output).To enable %n support, use _set_printf_count_output (also see_get_printf_count_output).

  • sprintf ora stampa il segno negativo di uno zero con segno.sprintf now prints the negative sign of a signed zero.

  • L'oggetto swprintf è stato modificato per essere conforme allo standard e ora richiede un parametro di dimensione.swprintf has been changed to conform with the Standard; it now requires a size parameter. Il modulo di swprintf senza un parametro di dimensione è stato deprecato.The form of swprintf without a size parameter has been deprecated.

  • La funzione set_security_error_handler è stata rimossa._set_security_error_handler has been removed. Rimuovere tutte le chiamate a quella funzione. Il gestore predefinito è molto più sicuro per gestire gli errori relativi alla sicurezza.Remove any calls to that function; the default handler is a much safer way of dealing with security errors.

  • time_t è ora un valore a 64 bit (a meno che non si definisca _USE_32BIT_TIME_T).time_t is now a 64-bit value (unless _USE_32BIT_TIME_T is defined).

  • Le funzioni _spawn e _wspawn ora non modificano errno se l'esito è positivo, come specificato dallo standard C.The _spawn, _wspawn Functions now leave errno untouched on success, as specified by the C Standard.

  • RTC ora usa i caratteri wide per impostazione predefinita.RTC now uses wide characters by default.

  • Le funzioni di supporto della parola di controllo a virgola mobile sono state deprecate per le applicazioni compilate con /CLR o /CLR:PURE.Floating-point control word support functions have been deprecated for applications compiled with /CLR or /CLR:PURE. Le funzioni interessate sono _clear87, _clearfp, _control87, _controlfp, _fpreset, _status87, _statusfp.The affected functions are _clear87, _clearfp, _control87, _controlfp, _fpreset, _status87, _statusfp. È possibile disabilitare l'avviso di deprecazione definendo _CRT_MANAGED_FP_NO_DEPRECATE, ma l'uso di queste funzioni nel codice gestito è imprevedibile e non supportato.You can disable the deprecation warning by defining _CRT_MANAGED_FP_NO_DEPRECATE, but the use of these functions in managed code is unpredictable and unsupported.

  • Alcune funzioni ora restituiscono puntatori const.Some functions now return const pointers. Il comportamento precedente, senza const, può essere ripristinato specificando CONST_RETURN.The old, non-const behavior can be reinstated by defining _CONST_RETURN. Le funzioni interessate sonoThe affected functions are

    1. memchr, wmemchrmemchr, wmemchr

    2. strchr, wcschr, _mbschr, _mbschr_lstrchr, wcschr, _mbschr, _mbschr_l

    3. strpbrk, wcspbrk, _mbspbrk, _mbspbrk_lstrpbrk, wcspbrk, _mbspbrk, _mbspbrk_l

    4. strrchr, wcsrchr, _mbsrchr, _mbsrchr_lstrrchr, wcsrchr, _mbsrchr, _mbsrchr_l

    5. strstr, wcsstr, _mbsstr, _mbsstr_lstrstr, wcsstr, _mbsstr, _mbsstr_l

  • Quando si crea un collegamento con Setargv.obj o Wsetargv.obj non è più possibile eliminare l'espansione di un carattere jolly nella riga di comando racchiudendolo tra virgolette doppie.When linking with Setargv.obj or Wsetargv.obj, it is no longer possible to suppress the expansion of a wildcard character on the command line by enclosing it in double quotes. Per altre informazioni, vedere Espansione di argomenti con caratteri jolly.For more information, see Expanding Wildcard Arguments.

Libreria standard (2005)Standard Library (2005)

  • La classe di eccezione (situata nell'intestazione <exception>) è stata spostata nello spazio dei nomi std.The exception class (located in the <exception> header) has been moved to the std namespace. Nelle versioni precedenti questa classe era nello spazio dei nomi globale.In previous versions, this class was in the global namespace. Per risolvere eventuali errori che indicano che è impossibile trovare la classe di eccezione, aggiungere al codice la seguente istruzione: using namespace std;To resolve any errors indicating that the exception class cannot be found, add the following using statement to your code: using namespace std;

  • Quando si chiama valarray::resize(), il contenuto dell'oggetto valarray andrà perso e verrà sostituito da valori predefiniti.When calling valarray::resize(), the contents of the valarray will be lost and will be replaced by default values. È previsto che il metodo resize() reinizializzi valarray anziché aumentarlo dinamicamente come un vettore.The resize() method is intended to reinitialize the valarray rather than grow it dynamically like a vector.

  • Iteratori di debug: le applicazioni compilate con una versione di debug della libreria di runtime di C e che usano gli iteratori in modo non corretto potrebbero iniziare a visualizzare asserzioni in fase di esecuzione.Debug Iterators: Applications built with a debug version of the C-Runtime Library and which use iterators incorrectly might begin to see asserts at runtime. Per disabilitare le asserzioni, è necessario impostare _HAS_ITERATOR_DEBUGGING (sostituito da _ITERATOR_DEBUG_LEVEL dopo Visual Studio 2010) su 0.To disable these asserts, you must define _HAS_ITERATOR_DEBUGGING (superseded by _ITERATOR_DEBUG_LEVEL after Visual Studio 2010) to 0. Per altre informazioni, vedere Supporto degli iteratori di debug.For more information, see Debug Iterator Support

Modifiche importanti in Visual C++ .NET 2003Visual C++ .NET 2003 Breaking Changes

CompilatoreCompiler

  • Le parentesi di chiusura ora sono richieste per la direttiva del preprocessore definita (C2004).Closing parentheses now required for the defined preprocessor directive (C2004).

  • Le specializzazioni esplicite non trovano più i parametri modello del modello principale (errore del compilatore C2146).Explicit specializations no longer find template parameters from primary template (Compiler Error C2146).

  • È possibile accedere a un membro protetto (n) solo usando una funzione membro di una classe (B) che eredita dalla classe (A) di cui (n) è un membro (errore del compilatore C2247).A protected member (n) can only be accessed through a member function of a class (B) that inherits from the class (A) of which it (n) is a member (Compiler Error C2247).

  • I controlli ottimizzati dell'accessibilità nel compilatore ora rilevano classi di base inaccessibili (errore del compilatore C2248).Improved accessibility checks in compiler now detect inaccessible base classes (Compiler Error C2248).

  • Un'eccezione non può essere rilevata se il distruttore e/o il costruttore di copia sono inaccessibili (C2316).An exception cannot be caught if the destructor and/or copy constructor is inaccessible (C2316).

  • Gli argomenti predefiniti sui puntatori a funzioni non sono più consentiti (errore del compilatore C2383).Default arguments on pointers to functions no longer allowed (Compiler Error C2383).

  • Un membro dati statico non può essere inizializzato usando una classe derivata (errore del compilatore C2477).A static data member cannot be initialized via derived class (Compiler Error C2477).

  • L'inizializzazione di un typedef non è consentita dallo standard e attualmente genera un errore del compilatore (errore del compilatore C2513).The initialization of a typedef is not allowed by the standard and now generates a compiler error (Compiler Error C2513).

  • bool è ora un tipo appropriato (errore del compilatore C2632).bool is now a proper type (Compiler Error C2632).

  • Un UDC ora può creare ambiguità con gli operatori di overload (C2666).A UDC can now create ambiguity with overloaded operators (C2666).

  • Altre espressioni ora sono considerate costanti del puntatore Null valide (errore del compilatore C2668).More expressions are now considered valid null pointer constants (Compiler Error C2668).

  • template<> è ora richiesto in posizioni in cui il compilatore in precedenza lo avrebbe implicato (errore del compilatore C2768).template<> is now required in places where the compiler would previously imply it (Compiler Error C2768).

  • La specializzazione esplicita di una funzione membro all'esterno della classe non è valida se la funzione è già stata specializzata in modo esplicito attraverso una specializzazione di classe modello (errore del compilatore C2910).The expilicit specialization of a member function ourside the class is not valid if the function has already been explicitly specialized via a template class specialization (Compiler Error C2910).

  • I parametri di modello non di tipo a virgola mobile non sono più consentiti (errore del compilatore C2993).Floating point non-type template parameters are no longer allowed (Compiler Error C2993).

  • I modelli di classi non sono consentiti come argomenti di tipo modello (C3206).Class templates are not allowed as template type arguments (C3206).

  • I nomi delle funzioni di tipo friend non vengono più introdotti nello spazio dei nomi (errore del compilatore C3767).Friend function names are no longer introduced into containing namespace (Compiler Error C3767).

  • Il compilatore non accetta più virgole aggiuntive in una macro (C4002).The compiler will no longer accept extra commas in a macro (C4002).

  • Un oggetto di tipo POD costruito con un inizializzatore con formato () verrà inizializzato per impostazione predefinita (C4345).An object of POD type constructed with an initializer of the form () will be default-initialized (C4345).

  • typename è ora richiesto se un nome dipendente deve essere trattato come un tipo (avviso del compilatore (livello 1) C4346).typename is now required if a dependent name is to be treated as a type (Compiler Warning (level 1) C4346).

  • Le funzioni che venivano considerate erroneamente specializzazioni del modello non vengono più considerate allo stesso modo (C4347).Functions that were incorrectly considered template specializations are no longer considered so (C4347).

  • I membri dati statici non possono essere inizializzati usando classi derivate (C4356).Static data members cannot be initialized via derived class (C4356).

  • Una specializzazione di modello di classe deve essere definita prima di essere usata in un tipo restituito (avviso del compilatore (livello 3) C4686).A class template specialization needs to be defined before it was used in a return type (Compiler Warning (level 3) C4686).

  • Il compilatore ora segnala il codice irraggiungibile (C4702).The compiler now reports unreachable code (C4702).

Vedere ancheSee Also

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