Visual C++: novità dalla versione 2003 alla 2015Visual C++ What's New 2003 through 2015

Questa pagina raccoglie tutte le pagine "Novità" per tutte le versioni di Visual C++ da Visual Studio 2015 fino alla versione più datata, la 2003.This page gathers all the "What's New" pages for all versions of Visual C++ from Visual Studio 2015 back to 2003. Queste informazioni vengono messe a disposizione nel caso in cui possano risultare utili quando si esegue l'aggiornamento da versioni precedenti di Visual C++.This information is provided as a convenience in case it might be useful when upgrading from earlier versions of Visual C++.

Nota 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.Note 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.

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

In Visual Studio 2015 e versioni successive 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 and later, 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 C++.Although these differences can affect your source code or other build artifacts, they don't affect binary compatibility between updates to Visual C++ 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 C++.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 C++. Ad esempio tra Visual C++ 2013 e Visual C++ 2015.For example, between Visual C++ 2013 and Visual C++ 2015. Per informazioni sulle modifiche sostanziali apportate tra Visual C++ 2013 e Visual C++ 2015, vedere Cronologia delle modifiche di Visual C++ dal 2003 al 2015.For information on the breaking changes that occurred between Visual C++ 2013 and Visual C++ 2015, see Visual C++ change history 2003 - 2015.

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

  • Opzione /Zc:forScope- L'opzione del compilatore /Zc:forScope- è deprecata e verrà rimossa in una versione futura./Zc:forScope- option 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.

     // zc_forScope.cpp
     // compile with: /Zc:forScope- /Za
     // 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
     }
    
  • Opzione del compilatore /Zg.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.exeInstead, use vstest.console.exe

  • Parola chiave mutable.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 Visual C++ questa situazione è accettabile, ma ora il compilatore genera l'errore seguente:Previous versions of the Visual C++ 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_t Non è più possibile usare char16_t o char32_t come alias in un typedef, poiché questi tipi ora vengono considerati predefiniti.char_16_t and char32_t You can no longer use char16_t or char32_t as aliases in a typedef, because these types are now treated as built-in. Era normale per gli utenti e gli autori di librerie definire char16_t e char32_t rispettivamente come alias 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 tipo Il codice in cui sono usati parametri di modello non di tipo viene ora controllato correttamente per verificare la compatibilità del tipo quando si specificano argomenti di modello espliciti.Non-type template parameters 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 C++.For example, the following code compiled without error in previous versions of Visual C++.

     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) Il compilatore non accetta più __declspec(align) per le funzioni.__declspec(align) 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 eccezioni Sono state apportate alcune modifiche alla gestione delle eccezioni.Exception handling 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 macro Il compilatore supporta ora i valori letterali definiti dall'utente.String literals followed by macros 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 adiacenti 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 spazi vuoti venivano interpretati come una singola stringa concatenata nelle versioni precedenti di Visual C++.Adjacent string literals 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 posizionamento È stata apportata una modifica all'operatore delete per fare in modo che sia conforme con lo standard C++14.Placement new and delete 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 Visual C++.Note that the type of the size_t typedef is compiler-dependent; it is a typedef for unsigned int in Visual C++. 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.

  • Le 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 struct anonimi Per la conformità allo standard, il comportamento di runtime è stato modificato per i membri delle strutture anonime nelle unioni.Unions with anonymous structs 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 dei modelli Sono state apportate modifiche alla risoluzione dei nomi per i modelli.Template resolution 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 copie 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.Copy constructors 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".

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

  • Classi di base virtuali private ed ereditarietà indiretta Le versioni precedenti del compilatore consentivano a una classe derivata di chiamare le funzioni membro delle proprie classi di base indirettamente derivateprivate virtual.Private virtual base classes and indirect inheritance 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;
     }
    
  • Operator new e operator delete in rapporto di overload 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.Overloaded operator new and operator delete 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'
    
    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) per i tipi non di classe Le versioni precedenti del compilatore consentivano la chiamata di "operator type()" per i tipi non di classe ignorandolo senza avvisare.Calling 'operator type()' (user-defined conversion) on non-class types 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'
     }
    
  • Nome del tipo ridondante negli identificatori di tipi elaborati Le versioni precedenti del compilatore consentivano typename negli identificatori di tipi elaborati; il codice scritto in questo modo non è semanticamente corretto.Redundant typename in elaborated type specifiers 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 delle matrici da un elenco di inizializzatori Le versioni precedenti del compilatore non supportavano la deduzione del tipo delle matrici da un elenco di inizializzatori.Type deduction of arrays from an initializer list 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 degli avvisi delle istruzioni switch Una versione precedente del compilatore rimuoveva gli avvisi preesistenti correlati alle istruzioni switch; questi avvisi sono ora stati ripristinati.Restoration of switch statement warnings 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.

  • #pragma warning(push) senza corrispondenza (influisce solo su /Wall /WX) Le versioni precedenti del compilatore non rilevavano le modifiche dello stato della direttiva #pragma warning(push) senza corrispondenza alla fine di un'unità di conversione.Unmatched #pragma warning(push) (only affects /Wall /WX) 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)
    
  • Possono essere generati avvisi aggiuntivi in seguito al miglioramento del rilevamento dello stato della direttiva #pragma warning Le versioni precedenti del compilatore rilevavano le modifiche dello stato della direttiva #pragma warning non abbastanza bene da generare gli avvisi previsti.Additional warnings might be issued as a result of improved #pragma warning state tracking 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.

  • Migliorata l'identificazione del codice non eseguibile 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 un codice specifico ora non è eseguibile.Improved identification of unreachable code 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 Visual Studio 2015 Update 2Conformance Improvements in Visual Studio 2015 Update 2

  • Errori e avvisi aggiuntivi potrebbero essere generati in seguito al supporto parziale per l'espressione SFINAE Le versioni precedenti del compilatore non analizzavano determinati tipi di espressioni all'interno degli identificatori decltype a causa della mancanza di supporto per l'espressione SFINAE.Additional warnings and errors might be issued as a result of partial support for expression 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>()));
     };
    
  • volatileLe variabili membro impediscono l'implementazione di costruttori e operatori di assegnazione definiti in modo implicito 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.volatile member variables prevent implicitly defined constructors and assignment operators 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 C++ 2015 consentivano alle funzioni membro statiche di avere qualificatori CV.Previous versions of Visual C++ 2015 allowed static member functions to have cv-qualifiers. Questo comportamento è dovuto a una regressione in Visual C++ 2015 e Visual C++ 2015 Update 1. Visual C++ 2013 e le versioni precedenti di Visual C++ non accettano il codice scritto in questo modo.This behavior is due to a regression in Visual C++ 2015 and Visual C++ 2015 Update 1; Visual C++ 2013 and previous versions of Visual C++ reject code written in this way. Il comportamento di Visual C++ 2015 e Visual C++ 2015 Update 1 non è corretto e non è conforme allo standard C++.The behavior of Visual C++ 2015 and Visual C++ 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 enum non è consentita nel codice WinRT (influisce solo su /ZW) 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.Forward declaration of enum is not allowed in WinRT code (affects /ZW only) 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;
       }
     };
    
  • Le funzioni non membro operator new e operator delete in rapporto di overload non possono essere dichiarate inline (livello 1 (/W1) attivo per impostazione predefinita) Le versioni precedenti del compilatore non generano un avviso quando le funzioni non membro operator new e operator delete vengono dichiarate inline.Overloaded non-member operator new and operator delete may not be declared inline (Level 1 (/W1) on-by-default) 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 Visual Studio 2015 Update 3Conformance Improvements in Visual Studio 2015 Update 3

  • std::is_convertable ora rileva l'assegnazione automatica (libreria standard) 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.std::is_convertable now detects self-assignment (standard library) 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 di Visual C++, le asserzioni statiche nella parte inferiore di questo esempio passano perché std::is_convertable<>::value è stato impostato erroneamente su true.In previous versions of Visual C++, 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 spostamento semplici impostati come predefiniti o eliminati rispettano gli identificatori di accesso 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.Defaulted or deleted trivial copy and move constructors respect access specifiers 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);
     }
    
  • Deprecato il supporto per il codice ATL con attributi (livello 1 (/W1) attivo per impostazione predefinita) Le versioni precedenti del compilatore supportano il codice ATL con attributi.Deprecation of attributed ATL code support (Level 1 (/W1) on-by-default) 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 C++ 2008, il codice ATL con attributi è stato deprecato.As the next phase of removing support for attributed ATL code that began in Visual C++ 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 /wd4467 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 /wd4467 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 (influisce solo su /Wall /WX) Le versioni precedenti del compilatore accettano le direttive #include non corrispondenti nei file di origine tra le compilazioni -Yc e -Yu quando si usano file PCH.Precompiled header (PCH) files and mismatched #include directives (only affects /Wall /WX) 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 (influisce solo su /Wall /WX) Le versioni precedenti del compilatore accettano gli argomenti della riga di comando (-I) delle directory di inclusione non corrispondenti per il compilatore tra le compilazioni -Yc e -Yu quando si usano file PCH.Precompiled header (PCH) files and mismatched include directories (only affects /Wall /WX) 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
    

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

Supporto migliorato degli standard ISO C/C++Improved ISO C/C++ Standards Support

CompilatoreCompiler

Il compilatore Microsoft Visual C++ supporta le seguenti funzionalità del linguaggio ISO C++11:The Microsoft Visual C++ compiler supports these ISO C++11 language features:

  • Argomenti di modello predefiniti per i modelli di funzione.Default template arguments for function templates.
  • Delega dei costruttoriDelegating constructors
  • Operatori di conversione espliciti.Explicit conversion operators.
  • Elenchi di inizializzatori e inizializzazione uniforme.Initializer lists and uniform initialization.
  • Valori letterali stringa di tipo "raw".Raw string literals.
  • Modelli variadic.Variadic templates.
  • Modelli di alias.Alias templates.
  • Funzioni eliminate.Deleted functions.
  • Inizializzatori del membro dati non statici (NSDMI).Non-static data member initializers (NSDMIs).
  • Funzioni impostate come predefinite.Defaulted functions. *
  • Supporta le seguenti funzionalità del linguaggio ISO C99:Supports these ISO C99 language features:
  • _Bool_Bool
  • Valori letterali composti.Compound literals.
  • Inizializzatori designati.Designated initializers.
  • Combinazione di dichiarazioni con codice.Mixing declarations with code.
  • La conversione di valori letterali stringa in valori modificabili può essere impedita usando la nuova opzione del compilatore /Zc:strictStrings.String literal conversion to modifiable values can be disallowed by using the new compiler option /Zc:strictStrings. In C++98 la conversione dai valori letterali stringa in char*, e dai valori letterali stringa a caratteri wide in wchar_t*, è stata deprecata.In C++98, conversion from string literals to char* (and wide string literals to wchar_t*) was deprecated. In C++11 la conversione è stata rimossa completamente.In C++11, the conversion was removed entirely. Anche se il compilatore può essere rigorosamente conforme allo standard, è invece disponibile l'opzione /Zc:strictStrings che consente di controllare la conversione.Although the compiler could strictly conform to the standard, instead it provides the /Zc:strictStrings option so that you can control conversion. Per impostazione predefinita, l'opzione non è attiva.By default, the option is off. Si noti che quando si utilizza questa opzione in modalità debug, STL non verrà compilato.Note that when you are using this option in debug mode, the STL will not compile.
  • Cast di riferimento rvalue/lvalue.rvalue/lvalue Reference Casts. Con i riferimenti rvalue, C++11 è in grado di distinguere chiaramente tra lvalue e rvalue.With rvalue references, C++11 can clearly distinguish between lvalues and rvalues. In precedenza, il compilatore non ha fornito questa opzione negli scenari di cast specifici.Previously, the compiler did not provide this in specific casting scenarios. È stata aggiunta una nuova opzione del compilatore, /Zc:rvalueCast, per rendere il compilatore conforme a quanto indicato nel Documento di lavoro del linguaggio C++ (vedere la sezione 5.4, [expr.cast]/1).A new compiler option, /Zc:rvalueCast, has been added to make the compiler conformant with the C++ Language Working Paper(see section 5.4, [expr.cast]/1). Il comportamento predefinito quando questa opzione non è specificata è uguale a quello in Visual Studio 2012.The default behavior when this option is not specified is the same as in Visual Studio 2012.
    • Nota: per le funzioni impostate come predefinite, l'uso di =default per richiedere i costruttori di spostamento membro e gli operatori di assegnazione di spostamento non è supportato.Note: For defaulted functions, using =default to request memberwise move constructors and move assignment operators is not supported.

Librerie C99C99 Libraries

Le dichiarazioni e le implementazioni vengono aggiunte per le funzioni mancanti in queste intestazioni: math.h, ctype.h, wctype.h, stdio.h, stdlib.h e wchar.h.Declarations and implementations are added for missing functions in these headers: math.h, ctype.h, wctype.h, stdio.h, stdlib.h, and wchar.h. Vengono inoltre aggiunte le nuove intestazioni complex.h, stdbool.h, fenv.h e inttypes.h, nonché implementazioni per tutte le funzioni dichiarate in esse.Also added are the new headers complex.h, stdbool.h, fenv.h, and inttypes.h, and implementations for all the functions declared in them. Sono disponibili nuove intestazioni del wrapper C++ (ccomplex, cfenv, cinttypes, ctgmath) e diverse altre sono state aggiornate (ccomplex, cctype, clocale, cmath, cstdint, cstdio, cstring, cwchar e cwctype).There are new C++ wrapper headers (ccomplex, cfenv, cinttypes, ctgmath) and a number of others are updated (ccomplex, cctype, clocale, cmath, cstdint, cstdio, cstring, cwchar, and cwctype).

Libreria di modelli standardStandard Template Library

Supporto per gli operatori di conversione esplicita C++11, gli elenchi di inizializzatori, le enumerazioni con ambito e i modelli variadic.Support for the C++11 explicit conversion operators, initializer lists, scoped enums, and variadic templates. Tutti i contenitori supportano ora requisiti di elementi C++11 precisi.All containers now support the C++11 fine-grained element requirements. Supporto per queste funzionalità C++14:Support for these C++14 features:

  • "Funtori di operatori trasparenti" less<>, greater<>, plus<>, multiplies<> e così via."Transparent operator functors" less<>, greater<>, plus<>, multiplies<>, and so on.
  • make_unique(args...) e make_unique<T[]>(n)make_unique(args...) and make_unique<T[]>(n)
  • Funzioni non membro cbegin()/cend(), rbegin()/rend() e crbegin()/crend().cbegin()/cend(), rbegin()/rend(), and crbegin()/crend() non-member functions.
  • Numerosi miglioramenti delle prestazioni in <atomic>.<atomic> received numerous performance enhancements.
  • Importanti correzioni del codice e della stabilizzazione in <type_traits>.<type_traits> received major stabilization and code fixes.

Modifiche di interruzioneBreaking Changes

Questo supporto migliorato per gli standard ISO C/C++ può richiedere modifiche del codice esistente in modo che sia conforme a C++11 e venga compilato correttamente in Visual C++ in Visual Studio 2013.This improved support for ISO C/C++ standards may require changes to existing code so that it conforms to C++11 and compiles correctly in Visual C++ in Visual Studio 2013.

Miglioramenti della libreria di Visual C++Visual C++ Library Enhancements

  • Aggiunto C++ REST SDK.C++ REST SDK is added. Include un'implementazione C++ moderna dei servizi REST.It has a modern C++ implementation of REST services.
  • Ottimizzato il supporto trama di C++ AMP.C++ AMP Texture support is enhanced. Ora include il supporto per le mipmap e le nuove modalità di campionamento.It now includes support for mipmaps and new sampling modes.
  • Le attività PPL supportano più tecnologie di pianificazione e il debug asincrono.PPL tasks support multiple scheduling technologies and asynchronous debugging. Le nuovi API consentono la creazione di attività PPL per risultati normali e condizioni di eccezione.New APIs enable the creation of PPL tasks for both normal results and exception conditions.

Prestazioni delle applicazioni C++C++ Application Performance

  • La vettorizzazione automatica ora riconosce e ottimizza più modelli C++ per rendere più rapida l'esecuzione del codice.Auto-Vectorizer now recognizes and optimizes more C++ patterns to make your code run faster.
  • Miglioramenti della qualità del codice della piattaforma ARM e della microarchitettura Atom.ARM platform and Atom micro-architecture code quality improvements.
  • Aggiunta la convenzione di chiamata __vectorcall.__vectorcall calling convention is added. Passare gli argomenti di tipo vettore usando la convenzione di chiamata __vectorcall per usare i registri vettoriali.Pass vector type arguments by using the __vectorcall calling convention to use vector registers.
  • Nuove opzioni del linker.New Linker Options. Le opzioni /Gw (compilatore) e /Gy (assembler) consentono le ottimizzazioni del linker per produrre binari più efficienti.The /Gw (compiler) and /Gy (assembler) switches enable linker optimizations to produce leaner binaries.
  • Supporto della memoria condivisa di C++ AMP per ridurre o eliminare le operazioni di copia dei dati tra la CPU e la GPU.C++ AMP shared memory support to reduce or eliminate data copying between CPU and GPU.

Miglioramenti dell'ottimizzazione PGOProfile Guided Optimization (PGO) enhancements

  • Miglioramenti delle prestazioni da una riduzione nel working set di applicazioni ottimizzate tramite PGO.Performance improvements from a reduction in the working set of apps that are optimized by using PGO.
  • Nuova ottimizzazione PGO per lo sviluppo di app di Windows Runtime.New PGO for Windows Runtime app development.

Supporto per lo sviluppo di app di Windows RuntimeWindows Runtime App Development Support

  • Supporto per tipi boxed in struct di valore.Support For Boxed Types In Value structs. Ora è possibile definire i tipi di valore usando campi che è possibile impostare come Null, ad esempio IBox<int>^, anziché int. Ciò significa che i campi possono avere un valore oppure essere uguali a nullptr.You can now define value types by using fields that can be null—for example, IBox<int>^ as opposed to int. This means that the fields can either have a value, or be equal to nullptr.
  • Informazioni dettagliate sulle eccezioni.Richer Exception Information. C++/CX supporta il nuovo modello di errore Windows che consente di acquisire e propagare informazioni dettagliate sulle eccezioni tramite l'interfaccia applicativa binaria (ABI); sono inclusi gli stack di chiamate e le stringhe di messaggio personalizzate.C++/CX supports the new Windows error model that enables the capture and propagation of rich exception information across the application binary interface (ABI); this includes call stacks and custom message strings.
  • Object::ToString() ora è virtuale.Object::ToString() Is Now Virtual. È ora possibile eseguire l'override di ToString in tipi di riferimento di Windows Runtime definiti dall'utente.You can now override ToString in user-defined Windows Runtime ref types.
  • Supporto per le API deprecate.Support For Deprecated APIs. Le API pubbliche di Windows Runtime possono ora essere contrassegnate come deprecate ed essere dotate di un messaggio personalizzato che viene visualizzato come avviso di compilazione. Possono inoltre fornire linee guida sulla migrazione.Public Windows Runtime APIs can now be marked as deprecated and given a custom message that appears as a build warning and can provide migration guidance.
  • Miglioramenti del debugger.Debugger Improvements. Supporto per il debug di interoperabilità JavaScript/nativo, la diagnostica delle eccezioni di Windows Runtime e il debug del codice asincrono (sia in Windows Runtime che nella libreria PPL).Support for native/JavaScript interop debugging, Windows Runtime exception diagnosis, and async code debugging (both Windows Runtime and PPL).
    • Nota: oltre alle funzionalità e ai miglioramenti specifici di C++ descritti in questa sezione, altri miglioramenti in Visual Studio consentono di scrivere meglio le app di Windows Runtime.Note: In addition to the C++-specific features and enhancements that are described in this section, other enhancements in Visual Studio also can help you write better Windows Runtime apps.

Miglioramenti della diagnosticaDiagnostics Enhancements

  • Miglioramenti del debugger.Debugger Improvements. Supporto per il debug asincrono e il debug Just My Code.Support for async debugging and Just My Code debugging.
  • Categorie di analisi del codice.Code Analysis Categories. È ora possibile visualizzare l'output per categoria dall'analizzatore di codice per rilevare e correggere i difetti del codice.You can now view categorized output from the Code Analyzer to help you find and fix code defects.
  • Diagnostica XAML.XAML Diagnostics. È ora possibile diagnosticare problemi di utilizzo della batteria e di velocità di risposta interfaccia utente nel codice XAML.You can now diagnose UI-responsiveness and battery-usage issues in your XAML.
  • Miglioramenti della grafica e del debug della GPU.Graphics and GPU Debugging Improvements.
  • Acquisizione remota e riproduzione su dispositivi reali.Remote capture and playback on real devices.
  • Debug simultaneo della CPU e di C++ AMP.Simultaneous C++ AMP and CPU debugging.
  • Diagnostica migliorata del runtime di C++ AMP.Improved C++ AMP runtime diagnostics.
  • Debug di traccia del compute shader HLSL.HLSL Compute shader trace debugging.

Miglioramenti della grafica tridimensionale3-D Graphics Enhancements

  • Supporto della pipeline di contenuti immagine per il formato DDS alfa premoltiplicato.Image Content Pipeline support for pre-multiplied alpha DDS format.
  • L'editor di immagini utilizza il valore alfa premoltiplicato internamente per il rendering e quindi evita il rendering di elementi come gli aloni scuri.Image Editor uses internally pre-multiplied alpha for rendering, and thereby avoids rendering artifacts such as dark halos.
  • Editor di modelli e immagini.Image and Model Editors. La creazione di filtri definiti dall'utente è ora supportata nella finestra di progettazione shader nell'editor di immagini e nell'editor di modelli.User-defined filter creation is now supported in Shader Designer in Image Editor and Model Editor.

IDE e produttivitàIDE and Productivity

Ottimizzata la formattazione del codice.Improved Code Formatting. È possibile applicare più impostazioni di formattazione al codice C++.You can apply more formatting settings to your C++ code. Utilizzando queste impostazioni, è possibile controllare il posizionamento di una nuova riga mediante parentesi graffe e parole chiave, rientro, spaziatura e ritorno a capo delle righe.By using these settings, you can control new-line placement of braces and keywords, indentation, spacing, and line wrapping. Il codice verrà formattato automaticamente dopo aver completato le istruzioni e i blocchi e dopo aver incollato il codice in un file.Code is automatically formatted when you complete statements and blocks, and when you paste code into a file.

Completamento parentesi graffa.Brace Completion. Il codice C++ completa ora in modo automatico la chiusura dei caratteri che corrispondono ai seguenti caratteri di apertura:C++ code now auto-completes the closing characters that correspond to these opening characters:

  • { (parentesi graffa){ (curly brace)
  • [ (parentesi quadra)[ (square bracket)
  • ( (parentesi)( (parentheses)
  • ' (virgoletta singola)' (single quote)
  • " (virgolette doppie)" (double quote)

Funzionalità aggiuntive di completamento automatico di C++.Additional C++ Auto-completion Features.

  • Aggiunge il punto e virgola per i tipi di classe.Adds semicolon for class types.
  • Completa le parentesi per i valori letterali stringa di tipo "raw".Completes parentheses for raw string literals.
  • Completa i commenti a più righe (/* */)Completes multi-line comments (/* */)

Trova tutti i riferimenti ora risolve e filtra automaticamente i riferimenti in background dopo aver visualizzato l'elenco delle corrispondenze testuali.Find All References now automatically resolves and filters references in the background after it displays the list of textual matches.

Filtro elenco di membri basato sul contesto.Context-Based Member List Filtering. I membri inaccessibili vengono filtrati dagli elenchi di membri IntelliSense.Inaccessible members are filtered out of the IntelliSense member lists. Ad esempio, i membri privati non vengono visualizzati nell'elenco dei membri a meno che non si stia modificando il codice che implementa il tipo.For example, private members are not displayed in the member list unless you are modifying the code that implements the type. Quando l'elenco dei membri è aperto, è possibile premere CTRL+J per rimuovere un livello di filtro (si applica solo alla finestra dell'elenco dei membri corrente).While the member list is open, you can press Ctrl+J to remove one level of filtering (applies only to the current member list window). È possibile premere nuovamente CTRL+J per rimuovere il filtro testuale e per visualizzare ogni membro.You can press Ctrl+J again to remove the textual filtering and show every member.

Scorrimento della Guida ai parametri.Parameter Help Scrolling. La firma della funzione visualizzata nella descrizione comando della Guida ai parametri cambia in base al numero di parametri effettivamente immessi, anziché visualizzare solo una firma arbitraria e non aggiornarla in base al contesto corrente.The displayed function signature in the parameter-help tooltip now changes based on the number of parameters you've actually typed, rather than just showing an arbitrary signature and not updating it based on the current context. La Guida ai parametri è utile anche quando viene visualizzata sulle funzioni annidate.Parameter help also functions correctly when it's displayed on nested functions.

Passaggio dall'intestazione al file di codice.Toggle Header/Code File. È ora possibile passare da un'intestazione al corrispondente file di codice utilizzando un comando del menu di scelta rapida o un tasto di scelta rapida.You can now toggle between a header and its corresponding code file by using a command on the shortcut menu, or a keyboard shortcut.

Finestra ridimensionabile delle proprietà del progetto C++Resizable C++ Project Properties Window

Generazione automatica del codice del gestore eventi in C++/CX e C++/CLI.Auto-generation of Event Handler Code in C++/CX and C++/CLI. Quando si digita il codice per aggiungere un gestore eventi in un file di codice C++/CX o C++/CLI, l'editor può generare automaticamente la definizione del gestore eventi e l'istanza del delegato.When you are typing code to add an event handler in a C++/CX or C++/CLI code file, the editor can automatically generate the delegate instance and event-handler definition. Quando il codice del gestore eventi può essere generato automaticamente, viene visualizzata una finestra di descrizione comando.A tooltip window appears when event-handler code can be auto-generated.

Miglioramento della compatibilità con DPI.DPI Awareness Enhancement. L'impostazione di compatibilità con DPI per i file manifesto dell'applicazione supporta ora l'impostazione "Per monitor compatibilità DPI avanzata".The DPI Awareness setting for application manifest files now supports the "Per Monitor High DPI Aware" setting.

Cambio di configurazione più rapido.Faster Configuration Switching. Per le applicazioni di grandi dimensioni, il cambio di configurazioni (specialmente le operazioni di cambio successive) viene eseguito molto più rapidamente.For large applications, switching configurations—especially subsequent switching operations—execute much more quickly.

Efficienza in fase di compilazione.Build Time Efficiency. Numerose ottimizzazioni e l'utilizzo multicore rendono le compilazioni più veloci, soprattutto per i progetti di grandi dimensioni.Numerous optimizations and multi-core utilization make builds faster, especially for large projects. Anche le compilazioni incrementali per le applicazioni C++ con riferimenti a C++ WinMD sono molto più veloci.Incremental builds for C++ applications that have references to C++ WinMD are also much faster.

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

Migliorato il supporto per gli standard C++11Improved C++11 Standards Support

Libreria di modelli standardStandard Template Library

  • Supporto per le nuove intestazioni STL: <atomic>, <chrono>, <condition_variable>, <filesystem>, <future>, <mutex>, <ratio> e <thread>.Support for new STL headers: <atomic>, <chrono>, <condition_variable>, <filesystem>, <future>, <mutex>, <ratio>, and <thread>.
  • Per ottimizzare l'uso delle risorse di memoria, i contenitori sono ora più piccoli.To optimize memory resource usage, containers are now smaller. Ad esempio, nella modalità di rilascio x86 con impostazioni predefinite std::vector si è ridotta dai 16 byte di Visual Studio 2010 ai 12 byte di Visual Studio 2012 e std::map si è ridotta dai 16 byte di Visual Studio 2010 agli 8 byte di Visual Studio 2012.For example, in x86 release mode with default settings, std::vector has shrunk from 16 bytes in Visual Studio 2010 to 12 bytes in Visual Studio 2012, and std::map has shrunk from 16 bytes in Visual Studio 2010 to 8 bytes in Visual Studio 2012.
  • Come consentito ma non richiesto dallo standard C++11, gli iteratori SCARY sono stati implementati.As permitted but not required by the C++11 Standard, SCARY iterators have been implemented.

Altri miglioramenti di C++11Other C++11 Enhancements

  • Cicli for basati su intervallo.Range-based for loops. È possibile scrivere cicli più affidabili che funzionano con matrici, contenitori STL e raccolte di Windows Runtime nel formato for ( for-range-declaration : expression ).You can write more robust loops that work with arrays, STL containers, and Windows Runtime collections in the form for ( for-range-declaration : expression ). Tale impostazione fa parte del supporto del linguaggio di base.This is part of the Core Language support.
  • Le espressioni lambda senza stato, ovvero blocchi di codice che iniziano con un elemento introduttivo lambda vuoto [] e non acquisiscono variabili locali, sono ora implicitamente convertibili in puntatori a funzione come richiesto dallo standard C++11.Stateless lambdas, which are blocks of code that begin with an empty lambda introducer [] and capture no local variables, are now implicitly convertible to function pointers as required by the C++11 Standard.
  • Supporto delle enumerazioni con ambito.Scoped enumerations support. La chiave di enumerazione enum class di C++ è ora supportata.The C++ enum class enum-key is now supported. Il codice seguente illustra come il comportamento di questa chiave sia diverso da quello precedente di enum.The following code demonstrates how this enum-key differs from previous enum behavior.

    enum class Element { Hydrogen, Helium, Lithium, Beryllium };
    void func1(Element e);
    func1(Hydrogen); // error C2065: 'Hydrogen' : undeclared identifier
    func1(Element::Helium); // OK
    

Supporto per lo sviluppo di app di Windows RuntimeWindows Runtime App Development Support

  • Modello di interfaccia utente nativo basato su XAML.Native XAML-based UI model. Per le app di Windows Runtime, è possibile usare il nuovo modello di interfaccia utente nativo basato su XAML.For Windows Runtime apps, you can use the new native XAML-based UI model.
  • Estensioni di componenti Visual C++.Visual C++ Component Extensions. Queste estensioni semplificano l'uso degli oggetti Windows Runtime, che sono una parte essenziale delle app di Windows Runtime.These extensions simplify consumption of Windows Runtime objects, which are a necessary part of Windows Runtime apps. Per altre informazioni, vedere Roadmap for Windows Runtime apps using C++ (Roadmap per le app di Windows Runtime che usano C++) e Riferimenti al linguaggio Visual C++ (C++/CX)For more information, see Roadmap for Windows Runtime apps using C++ and Visual C++ language reference (C++/CX)
  • Giochi DirectX.DirectX games. È possibile sviluppare giochi coinvolgenti usando il nuovo supporto di DirectX per le app di Windows Runtime.You can develop engaging games by using the new DirectX support for Windows Runtime apps.
  • Interoperabilità XAML/DirectX.XAML/DirectX interop. Le app di Windows Runtime che usano sia XAML sia DirectX ora interagiscono in modo efficiente.Windows Runtime apps that use both XAML and DirectX now interoperate efficiently.
  • Sviluppo DLL del componente Windows Runtime.Windows Runtime Component DLL development. Lo sviluppo della DLL del componente consente di estendere l'ambiente di Windows Runtime.Component DLL development makes the Windows Runtime environment extensible.

Compilatore e linkerCompiler and Linker

  • Vettorizzazione automatica.Auto-vectorizer. Il compilatore analizza i cicli nel codice e, dove possibile, genera istruzioni che usano i registri e le istruzioni vettoriali che sono presenti in tutti i moderni processori.The compiler analyzes loops in your code and, where possible, emits instructions that use the vector registers and instructions that are present in all modern processors. In questo modo i cicli vengono eseguiti più rapidamente.This makes the loops run faster. Le istruzioni del processore sono note come SSE (Streaming SIMD Extensions).(The processor instructions are known as SSE, for Streaming SIMD Extensions). Non è necessario abilitare o richiedere questa ottimizzazione perché viene applicata automaticamente.You do not have to enable or request this optimization because it is applied automatically.
  • Parallelizzazione automatica.Auto-parallelizer. Il compilatore può analizzare i cicli nel codice e generare istruzioni che distribuiscono i calcoli tra più core o processori.The compiler can analyze loops in your code and emit instructions that spread the calculations across multiple cores or processors. In questo modo i cicli vengono eseguiti più velocemente.This can make the loops run faster. È necessario richiedere questa ottimizzazione perché non è abilitata per impostazione predefinita.You must request this optimization because it is not enabled by default. In molti casi è utile per includere la direttiva #pragma loop(hint_parallel(N)) nel codice immediatamente prima dei cicli da parallelizzare.In many cases, it helps to include a #pragma loop(hint_parallel(N)) in your code immediately before the loops that you want parallelized.
  • La vettorizzazione automatica e la parallelizzazione automatica possono essere usate insieme in modo che i calcoli vengono distribuiti tra più core e il codice in ogni core usi i propri registri vettoriali.The auto-vectorizer and auto-parallelizer can work together so that calculations are spread across multiple cores and the code on each core uses its vector registers.

Novità di Visual Studio 2012 Update 1New in Visual Studio 2012 Update 1

Quando si compila il codice C++ specificare Windows XP come destinazione.Target Windows XP when you build your C++ code. È possibile usare il compilatore e le librerie Visual C++ per impostare Windows XP e Windows Server 2003 come destinazione.You can use the Visual C++ compiler and libraries to target Windows XP and Windows Server 2003.

Supporto per la programmazione parallelaParallel Programming Support

C++ Accelerated Massive Parallelism (AMP)C++ Accelerated Massive Parallelism (AMP)

C++ AMP accelera l'esecuzione del codice C++ sfruttando l'hardware con dati in parallelo in genere presente come GPU in una scheda grafica discreta.C++ AMP accelerates the execution of your C++ code by taking advantage of the data-parallel hardware that's ordinarily present as a GPU on a discrete graphics card. Il modello di programmazione C++ AMP include le matrici multidimensionali, l'indicizzazione, il trasferimento di memoria, l'affiancamento e una libreria di funzioni matematiche.The C++ AMP programming model includes multidimensional arrays, indexing, memory transfer, tiling, and a mathematical function library. Usando le estensioni del linguaggio C++ AMP e le restrizioni del compilatore, è possibile controllare il modo in cui i dati si spostano dalla CPU alla GPU e viceversa.By using C++ AMP language extensions and compiler restrictions, you can control how data is moved from the CPU to the GPU and back.

Debug.Debugging. L'esperienza di debug per le app che usano C++ AMP per impostare la GPU come destinazione è analoga al debug per le altre app C++.The debugging experience for apps that use C++ AMP to target the GPU is just like debugging for other C++ apps. Ciò include gli aggiornamenti del debug parallelo menzionate in precedenza.This includes the new parallel debugging additions that were mentioned earlier.

Profilatura.Profiling. È ora disponibile il supporto della profilatura per l'attività della GPU che si basa su C++ AMP e altri modelli di programmazione basati su Direct3D.There is now profiling support for GPU activity that's based on C++ AMP and other Direct3D-based programming models.

Miglioramenti generali della programmazione parallelaGeneral Parallel Programming Enhancements

Con il passaggio dell'hardware alle architetture multicore o many-core, gli sviluppatori non possono più affidarsi alle velocità di clock in continuo aumento dei core singoli.With hardware moving to multi-core and many-core architectures, developers can no longer rely on ever-increasing clock speeds from single-cores. Il supporto della programmazione parallela nel runtime di concorrenza consente agli sviluppatori di sfruttare queste nuove architetture.The parallel programming support in the Concurrency Runtime enables developers to take advantage of these new architectures. In Visual Studio 2010 sono state introdotte potenti librerie di parallelizzazione C++, ad esempio la Parallel Patterns Library, insieme a funzionalità che consentono di sfruttare i vantaggi della concorrenza esprimendo sofisticate pipeline del flusso di dati.In Visual Studio 2010, powerful C++ parallelization libraries such as the Parallel Patterns Library were introduced, together with features to take advantage of concurrency by expressing sophisticated dataflow pipelines. In Visual Studio 2012 queste librerie sono state estese per offire prestazioni migliori, maggiore controllo e un supporto più completo per i modelli paralleli più utili per gli sviluppatori.In Visual Studio 2012, these libraries have been extended to provide better performance, more control, and richer support for the parallel patterns that developers need most. L'ampiezza dell'offerta ora include:The breadth of the offering now includes:

  • Un modello di programmazione avanzato basato su attività che supporta l'asincronia e le continuazioni.A rich task-based programming model that supports asynchrony and continuations.
  • Algoritmi paralleli che supportano il parallelismo divisione/unione (parallel_for, parallel_for con affinità, parallel_for_each, parallel_sort, parallel_reduce, parallel_transform).Parallel Algorithms , which support fork-join parallelism (parallel_for, parallel_for with affinity, parallel_for_each, parallel_sort, parallel_reduce, parallel_transform).
  • Contenitori indipendenti dalla concorrenza, che offrono versioni thread-safe delle strutture di dati standard, ad esempio priority_queue, queue, vector e map.Concurrency-safe containers, which provide thread-safe versions of std data structures such as priority_queue, queue, vector, and map.
  • La libreria di agenti asincroni, che gli sviluppatori possono usare per esprimere le pipeline del flusso di dati che si scompongono naturalmente in unità simultanee.The Asynchronous Agents Library, which developers can use to express dataflow pipelines that naturally decompose into concurrent units.
  • Un'utilità di pianificazione e gestione delle risorse personalizzabile per agevolare la composizione dei modelli in questo elenco.A customizable scheduler and resource manager to facilitate the smooth composition of the patterns in this list.
Miglioramenti generali del debug paralleloGeneral Parallel Debugging Enhancements

Oltre alla finestra Attività in parallelo e la finestra Stack in parallelo, Visual Studio 2012 offre la nuova finestra Espressione di controllo in parallelo per consentire l'analisi dei valori di un'espressione in tutti i thread e processi e le operazioni di ordinamento e filtro del risultato.In addition to the Parallel Tasks window and Parallel Stacks window, Visual Studio 2012 offers a new Parallel Watch window so that you can examine the values of an expression across all threads and processes, and perform sorting and filtering on the result. È anche possibile usare i propri visualizzatori per estendere la finestra e sfruttare il nuovo supporto a più processi in tutte le finestre degli strumenti.You can also use your own visualizers to extend the window, and you can take advantage of the new multi-process support across all tool windows.

IDEIDE

Supporto per i modelli di Visual Studio.Visual Studio Templates support. È ora possibile usare la tecnologia dei modelli di Visual Studio per creare modelli di progetto e di elemento C++.You can now use the Visual Studio Templates technology to author C++ project and item templates.

Caricamento della soluzione asincrona.Asynchronous Solution Load. I progetti vengono ora caricati in modo asincrono, gli elementi essenziali della soluzione per primi, e si può iniziare a lavorare più velocemente.Projects are now loaded asynchronously—the key parts of the solution first—so that you can start working faster.

Distribuzione automatica per il debug remoto.Automated deployment for remote debugging. La distribuzione dei file per il debug remoto in Visual C++ è stata semplificata.Deployment of files for remote debugging in Visual C++ has been simplified. L'opzione Distribuisci del menu di scelta rapida del progetto copia automaticamente nel computer remoto i file specificati nelle proprietà di configurazione del debug.The Deploy option on the project context menu automatically copies to the remote computer the files that are specified in the debugging configuration properties. Non è più necessario copiare manualmente i file nel computer remoto.Copying files manually to the remote computer is no longer required.

IntelliSense per C++/CLI.C++/CLI IntelliSense. C++/CLI include ora il supporto completo di IntelliSense.C++/CLI now has full IntelliSense support. Le funzionalità di IntelliSense, ad esempio Informazioni rapide, Guida per i parametri, Elenca membri e Completamento automatico ora funzionano per C++/CLI.IntelliSense features such as Quick Info, Parameter Help, List Members, and Auto Completion now work for C++/CLI. Inoltre, anche gli altri miglioramenti di IntelliSense e IDE indicati in questo documento funzionano per C++/CLI.In addition, the other IntelliSense and IDE enhancements listed in this document also work for C++/CLI.

Descrizioni comandi di IntelliSense più complete.Richer IntelliSense Tooltips. Le descrizioni comandi Informazioni rapide di IntelliSense per C++ visualizzano ora informazioni più complete come commenti in formato documentazione XML.C++ IntelliSense Quick Info tooltips now show richer XML documentation comments style information. Se si usa un'API da una libreria, ad esempio C++ AMP, che include commenti in formato documentazione XML, la descrizione comando di IntelliSense visualizza più informazioni rispetto alla semplice dichiarazione.If you are using an API from a library—for example, C++ AMP—that has XML documentation comments, then the IntelliSense tooltip shows more information than just the declaration. Inoltre, se il codice include commenti in formato documentazione XML, le descrizioni comandi di IntelliSense visualizzano le informazioni più complete.Also, if your code has the XML documentation comments, IntelliSense tooltips will show the richer information.

Costrutti di codice C++.C++ Code Constructs. La bozza di codice è disponibile per commutazione, if-else, ciclo for e altri costrutti di codice di base, nell'elenco a discesa Elenca membri.Skeleton code is available for switch, if-else, for loop, and other basic code constructs, in the List Members drop-down list. Selezionare un frammento di codice dall'elenco per inserirlo nel codice, quindi compilare la logica richiesta.Select a piece of code from the list to insert it into your code and then fill in the required logic. È anche possibile creare i propri frammenti di codice personalizzati da usare nell'editor.You can also create your own custom pieces of code for use in the editor.

Miglioramenti di Elenca membri.List Members Enhancements. L'elenco a discesa Elenca membri appare automaticamente quando si digita codice nell'editor di codice.The List Members drop-down list appears automatically as you type code into the code editor. I risultati vengono filtrati in modo che solo i membri pertinenti vengono visualizzati durante la digitazione.Results are filtered, so that only relevant members are displayed as you type. È possibile controllare il tipo di logica di filtro usata per l'elenco dei membri nella finestra di dialogo Opzioni in Editor di testo, C/C++, Avanzate.You can control the kind of filtering logic that's used by the Member List—in the Options dialog box under Text Editor, C/C++, Advanced.

Colorazione semantica.Semantic Colorization. Tipi, enumerazioni, macro e altri token C++ hanno ora una colorazione per impostazione predefinita.Types, enumerations, macros, and other C++ tokens now have colorization by default.

Evidenziazione dei riferimenti.Reference Highlighting. Selezionando un simbolo ora vengono evidenziate tutte le istanze del simbolo nel file corrente.Selecting a symbol now highlights all instances of the symbol in the current file. Premere CTRL+MAIUSC+Freccia SU o CTRL+MAIUSC+Freccia GIÙ per spostarsi tra i riferimenti evidenziati.Press Ctrl+Shift+Up Arrow or Ctrl+Shift+Down Arrow to move among the highlighted references. È possibile disattivare questa funzionalità nella finestra di dialogo Opzioni in Editor di testo, C/C++, Avanzate.You can turn this feature off in the Options dialog box, under Text Editor, C/C++, Advanced.

Strumenti di Application Lifecycle ManagementApplication Lifecycle Management Tools

Analisi codice staticoStatic Code Analysis

L'analisi statica per C++ è stata aggiornata per offrire informazioni più complete sul contesto dell'errore, altre regole di analisi e migliori risultati dell'analisi.Static analysis for C++ has been updated to provide richer error context information, more analysis rules, and better analysis results. Nella nuova finestra Analisi codice è possibile filtrare i messaggi in base a parola chiave, progetto e gravità.In the new Code Analysis window, you can filter messages by keyword, project, and severity. Quando si seleziona un messaggio nella finestra, la riga del codice in cui è stato attivato il messaggio viene evidenziata nell'editor di codice.When you select a message in the window, the line in the code where the message was triggered is highlighted in the code editor. Per alcuni avvisi di C++, il messaggio indica le righe di origine che visualizzano il percorso di esecuzione che genera l'avviso. I punti di decisione e i motivi per la scelta di tale percorso specifico vengono evidenziati.For certain C++ warnings, the message lists source lines that show the execution path that leads to the warning; decision points and the reasons for taking that specific path are highlighted. L'analisi del codice è inclusa nella maggior parte delle edizioni di Visual Studio 2012.Code analysis is included in most editions of Visual Studio 2012. Nelle edizioni Professional, Premium e Ultimate sono incluse tutte le regole.In the Professional, Premium, and Ultimate editions, all rules are included. Nelle edizioni Express per Windows 8 e Windows Phone sono inclusi solo gli avvisi più critici.In the Express editions for Windows 8 and Windows Phone, just the most critical warnings are included. L'analisi del codice non è inclusa nell'edizione Express per il Web.Code analysis is not included in the Express edition for Web. Di seguito sono riportati alcuni altri miglioramenti dell'analisi del codice:Here are some other code analysis enhancements:

  • Nuovi avvisi sulla concorrenza consentono di evitare i bug di concorrenza verificando che siano un uso le corrette discipline di blocco nei programmi multithread di C/C++.New concurrency warnings help you avoid concurrency bugs by making sure that you are using the correct locking disciplines in multithreaded C/C++ programs. L'analizzatore rileva potenziali race condition, inversioni dell'ordine di blocco, violazioni dei contratti di blocco chiamante/chiamato, operazioni di sincronizzazione non corrispondenti e altri bug di concorrenza.The analyzer detects potential race conditions, lock order inversions, caller/callee locking contract violations, mismatched synchronization operations, and other concurrency bugs.
  • È possibile specificare le regole di C++ da applicare alle esecuzioni di analisi del codice usando i set di regole.You can specify the C++ rules that you want to apply to code analysis runs by using rule sets.
  • Nella finestra Analisi codice è possibile inserire nel codice sorgente un pragma che elimina un avviso selezionato.In the Code Analysis window, you can insert into the source code a pragma that suppresses a selected warning.
  • È possibile migliorare la precisione e la completezza dell'analisi del codice statico usando la nuova versione del linguaggio di annotazione del codice sorgente Microsoft (SAL) per descrivere in che modo una funzione usa i propri parametri, i relativi presupposti e le garanzie presentate al termine.You can enhance the accuracy and completeness of static code analysis by using the new version of the Microsoft source-code annotation language (SAL) to describe how a function uses its parameters, the assumptions that it makes about them, and the guarantees that it makes when it finishes.
  • Supporto per i progetti C++ a 64 bit.Support for 64bit C++ projects.

Aggiornato il framework unit testUpdated Unit Test Framework

Usare il nuovo framework unit test di C++ in Visual Studio per scrivere unit test di C++.Use the new C++ unit test framework in Visual Studio to write C++ unit tests. Aggiungere un nuovo progetto unit test alla soluzione C++ esistente individuando il modello Progetto unit test di C++ nella categoria Visual C++ nella finestra di dialogo Nuovo progetto.Add a new unit test project to your existing C++ solution by locating the C++ Unit Test Project template under the Visual C++ category in the New Project dialog box. Iniziare a scrivere gli unit test nello stub di codice TEST_METHOD generato nel file Unittest1.cpp.Start writing your unit tests in the generated TEST_METHOD code stub in the Unittest1.cpp file. Quando viene scritto il codice di test, compilare la soluzione.When the test code is written, build the solution. Per eseguire i test, aprire una finestra Esplora unit test scegliendo Visualizza, Altre finestre, Esplora unit test, quindi scegliere Esecuzione del test selezionato nel menu di scelta rapida del test case da usare.When you want to run the tests, open a Unit Test Explorer window by choosing View, Other Windows, Unit Test Explorer, and then, on the shortcut menu for the test case you want, choose Run selected test. Al termine dell'esecuzione del test, è possibile visualizzare i risultati del test e informazioni aggiuntive sull'analisi dello stack nella stessa finestra.After the test run finishes, you can view test results and additional stack trace information in the same window.

Grafici delle dipendenze dell'architetturaArchitecture Dependency Graphs

Per comprendere meglio il codice, è ora possibile generare grafici delle dipendenze per i file binari, di classe, di spazio dei nomi e di inclusione in una soluzione.To understand your code better, you can now generate dependency graphs for the binary, class, namespace, and include files in a solution. Nella barra dei menu scegliere Architettura, Genera grafico dipendenze e quindi Per soluzione o Per file di inclusione per generare un grafico delle dipendenze.On the menu bar, choose Architecture, Generate Dependency Graph, and then For Solution or For Include File to generate a dependency graph. Completata la generazione del grafico, è possibile esaminarlo espandendo ogni nodo, verificare le relazioni di dipendenza passando da un nodo all'altro e analizzare il codice sorgente scegliendo Visualizza contenuto nel menu di scelta rapida per un nodo.When the graph generation is complete, you can explore it by expanding each node, learn dependency relationships by moving between nodes, and browse source code by choosing View Content on the shortcut menu for a node. Per generare un grafico delle dipendenze per i file di inclusione, nel menu di scelta rapida per un file di codice sorgente *.cpp o un file di intestazione *.h scegliere Genera grafico dei file di inclusione.To generate a dependency graph for include files, on the shortcut menu for a *.cpp source code file or *.h header file, choose Generate Graph of Include Files.

Esplora architetturaArchitecture Explorer

Usando Esplora architettura è possibile esplorare gli asset nella soluzione, nei progetti o nei file C++.By using the Architecture Explorer, you can explore the assets in your C++ solution, projects, or files. Nella barra dei menu scegliere Architettura, Finestre, Esplora architettura.On the menu bar, choose Architecture, Windows, Architecture Explorer. È possibile selezionare un nodo che interessa, ad esempio, Visualizzazione classi.You can select a node you are interested in, for example, Class View. In questo caso, il lato destro della finestra degli strumenti viene espanso con un elenco di spazi dei nomi.In this case, the right side of the tool window is expanded with a list of namespaces. Se si seleziona uno spazio dei nomi, in una nuova colonna viene visualizzato un elenco delle classi, degli struct e delle enumerazioni contenuti nello spazio dei nomi.If you select a namespace, a new column shows a list of the classes, structs, and enums in this namespace. È possibile continuare a esplorare questi asset oppure tornare alla colonna all'estrema sinistra per avviare un'altra query.You can continue to explore these assets, or go back to the column on the far left to start another query. Vedere Trovare codice con Esplora architettura.See Find Code with Architecture Explorer.

Code coverageCode Coverage

Il code coverage è stato aggiornato in modo da instrumentare dinamicamente i file binari in fase di esecuzione.Code coverage has been updated to dynamically instrument binaries at runtime. Questo consente di ridurre il sovraccarico della configurazione e di ottenere prestazioni migliori.This lowers the configuration overhead and provides better performance. È anche possibile raccogliere dati di code coverage dagli unit test per le app C++.You can also collect code-coverage data from unit tests for C++ apps. Se sono stati creati unit test di C++, è possibile usare Esplora unit test per rilevare i test nella soluzione.When you have created C++ unit tests, you can use Unit Test Explorer to discover tests in your solution. Per eseguire gli unit test e raccogliere i dati di code coverage per gli stessi, scegliere Analizza code coverage in Esplora unit test.To run the unit tests and collect code coverage data for them, in Unit Test Explorer, choose Analyze Code Coverage. È possibile esaminare i risultati del code coverage nella finestra Risultati code coverage a cui si accede dalla barra dei menu scegliendo Test, Finestre, Risultati code coverage.You can examine the code coverage results in the Code Coverage Results window—on the menu bar, choose Test, Windows, Code Coverage Results.

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

Compilatore e linker C++C++ Compiler and Linker

Parola chiave auto.auto Keyword. La parola chiave auto ha un'altra funzionalità.The auto keyword has a new purpose. Usare il significato predefinito di auto per dichiarare una variabile il cui tipo viene dedotto dall'espressione di inizializzazione nella dichiarazione della variabile.Use the default meaning of the auto keyword to declare a variable whose type is deduced from the initialization expression in the declaration of the variable. L'opzione del compilatore /Zc:auto richiama il significato nuovo o precedente della parola chiave auto.The /Zc:auto compiler option invokes either the new or the previous meaning of the auto keyword.

Identificatore di tipo decltype.decltype Type Specifier. L'identificatore di tipo decltype restituisce il tipo di un'espressione specificata.The decltype type specifier returns the type of a specified expression. Usare l'identificatore di tipo decltype in combinazione con la parola chiave auto per dichiarare un tipo complesso o noto solo al compilatore.Use the decltype type specifier in combination with the auto keyword to declare a type that is either complex or known only to the compiler. Usare la combinazione, ad esempio, per dichiarare una funzione di modello il cui tipo restituito dipende dai tipi dei relativi argomenti di modello.For example, use the combination to declare a template function whose return type depends on the types of its template arguments. In alternativa, dichiarare una funzione di modello che chiama un'altra funzione e quindi restituisce il tipo restituito della funzione chiamata.Or, declare a template function that calls another function, and then returns the return type of the called function.

Espressioni lambda.Lambda Expressions. Le funzioni lambda hanno un corpo ma non un nome.Lambda functions have a function body but no name. Integrano le caratteristiche migliori dei puntatori a funzioni e degli oggetti funzione.Lambda functions combine the best characteristics of function pointers and function objects. Usare una funzione lambda singolarmente, come parametro di funzione di modello anziché un oggetto funzione, o con la parola chiave auto per dichiarare una variabile il cui tipo è un'espressione lambda.Use a lambda function by itself, as a template function parameter instead of a function object, or together with the auto keyword to declare a variable whose type is a lambda.

Riferimento Rvalue.Rvalue Reference. Il dichiaratore del riferimento Rvalue (&&) consente di dichiarare un riferimento a un elemento Rvalue.The rvalue reference declarator (&&) declares a reference to an rvalue. Un riferimento Rvalue consente di usare la semantica di spostamento e l'inoltro perfetto per scrivere costruttori, funzioni e modelli più efficienti.An rvalue reference lets you use move semantics and perfect forwarding to write more efficient constructors, functions, and templates.

Dichiarazione static_assert.static_assert Declaration. Una dichiarazione static-assert consente di testare un'asserzione software in fase di compilazione, a differenza di altri meccanismi di asserzione che eseguono i test in fase di esecuzione.A static_assert declaration tests a software assertion at compile time, unlike other assertion mechanisms that test at run time. Se l'asserzione ha esito negativo, la compilazione non riesce e viene generato un messaggio di errore specifico.If the assertion fails, the compilation fails and a specified error message is issued.

Parole chiave nullptr e __nullptr.nullptr and __nullptr Keywords. Il compilatore Visual C++ consente di usare la parola chiave nullptr con codice nativo o codice gestito.The Visual C++ compiler lets you use the nullptr keyword with native code or with managed code. La parola chiave nullptr indica che un handle dell'oggetto, un puntatore interno o un tipo di puntatore nativo non punta a un oggetto.The nullptr keyword indicates that an object handle, interior pointer, or native pointer type does not point to an object. Il compilatore interpreta nullptr come codice gestito quando si usa l'opzione del compilatore /clr e come codice nativo quando non si usa l'opzione.The compiler interprets nullptr to be managed code when you use the /clr compiler option, and native code when you do not use the /clr option. La parola chiave __nullptr specifica di Microsoft ha lo stesso significato di nullptr, ma si applica solo al codice nativo.The Microsoft-specific __nullptr keyword has the same meaning as nullptr, but it applies to native code only. Se si compila codice C/C++ nativo con l'opzione del compilatore /clr, il compilatore non è in grado di determinare se la parola chiave nullptr è un termine nativo o gestito.If you compile native C/C++ code by using the /clr compiler option, the compiler cannot determine whether the nullptr keyword is a native or a managed term. Per rendere l'intenzione chiara per il compilatore, usare la parola chiave nullptr per specificare il termine gestito e __nullptr per specificare il termine nativo.To make your intention clear to the compiler, use the nullptr keyword to specify the managed term, and __nullptr to specify the native term.

Opzione /Zc:trigraphs del compilatore./Zc:trigraphs Compiler Option. Per impostazione predefinita, il supporto per i trigrammi è disabilitato.By default, support for trigraphs is disabled. 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 il carattere di punteggiatura corrispondente.The compiler replaces a trigraph with the corresponding punctuation character. Ad esempio, il compilatore sostituisce il trigramma ??= con il carattere # (cancelletto).For example, the compiler replaces the ??= trigraph with the # (number sign) character. Usare i trigrammi nei file di origine C che usano un set di caratteri che non contiene determinati caratteri di punteggiatura.Use trigraphs in C source files that use a character set that does not contain certain punctuation characters.

Nuova opzione PGO (Profile Guided Optimization).New Profile-Guided Optimization Option. PogoSafeMode è una nuova opzione di ottimizzazione PGO che consente di specificare se usare la modalità sicura o la modalità rapida durante l'ottimizzazione dell'applicazione.PogoSafeMode is a new profile-guided optimization option that lets you specify whether to use safe mode or fast mode when you optimize your application. La modalità sicura è thread-safe, ma è più lenta della modalità rapida.Safe mode is thread-safe, but it is slower than fast mode. La modalità rapida è il comportamento predefinito.Fast mode is the default behavior.

Nuova opzione del supporto Common Language Runtime (CLR) /clr:nostdlib.New Common Language Runtime (CLR) Option /clr:nostdlib. È stata aggiunta una nuova opzione per /clr (Compilazione Common Language Runtime).A new option is added for /clr (Common Language Runtime Compilation). Se sono incluse versioni diverse delle stesse librerie, viene generato un errore di compilazione.If different versions of the same libraries are included, a compile error is issued. La nuova opzione consente di escludere le librerie CLR predefinite in modo che il programma sia in grado di usare una determinata versione.The new option lets you exclude the default CLR libraries so that your program can use a specified version.

Nuova direttiva pragma detect_mismatch.New pragma directive detect_mistmatch. La direttiva pragma detect_mismatch consente di inserire un tag nei file per il confronto con altri tag che hanno lo stesso nome.The pragma directive detect_mismatch lets you put a tag in your files that is compared to other tags that have the same name. Se sono presenti più valori per lo stesso nome, il linker genera un errore.If there are multiple values for the same name, the linker issues an error.

Oggetti intrinseci XOP, FMA4 e LWP.XOP Intrinsics, FMA4 Intrinsics, and LWP Intrinsics. Sono state aggiunte nuove funzioni intrinseche per supportare gli oggetti intrinseci XOP aggiunti per Visual Studio 2010 SP1, gli oggetti intrinseci FMA4 aggiunti per Visual Studio 2010 SP1 e gli oggetti intrinseci LWP aggiunti per le tecnologie di processore di Visual Studio 2010 SP1.New intrinsic functions have been added to support the XOP Intrinsics Added for Visual Studio 2010 SP1, FMA4 Intrinsics Added for Visual Studio 2010 SP1, and LWP Intrinsics Added for Visual Studio 2010 SP1 processor technologies. Usare __cpuid, __cpuidex per determinare quali tecnologie di processore sono supportate in un determinato computer.Use __cpuid, __cpuidex to determine which processor technologies are supported on a particular computer.

Progetti Visual C++ e il sistema di compilazioneVisual C++ Projects and the Build System

MSBuild.MSBuild. Le soluzioni e i progetti di Visual C++ vengono ora compilati con MSBuild.exe, che sostituisce VCBuild.exe.Visual C++ solutions and projects are now built by using MSBuild.exe, which replaces VCBuild.exe. MSBuild è lo stesso strumento di compilazione flessibile ed estensibile basato su XML che viene usato in altri linguaggi e tipi di progetto di Visual Studio.MSBuild is the same flexible, extensible, XML-based build tool that is used by the other Visual Studio languages and project types. Grazie a questa modifica, i file di progetto di Visual C++ ora usano un formato di file XML e l'estensione VCXPROJ.Because of this change, Visual C++ project files now use an XML file format and have the .vcxproj file name extension. I file di progetto di Visual C++ da versioni precedenti di Visual Studio vengono automaticamente convertiti nel nuovo formato di file.Visual C++ project files from earlier versions of Visual Studio are automatically converted to the new file format.

Directory di VC++.VC++ Directories. L'impostazione delle directory di VC++ ora si trova in due posizioni.The VC++ directories setting is now located in two places. Usare le pagine delle proprietà del progetto per impostare i valori in base al progetto per le directory di VC++.Use project property pages to set per-project values for VC++ directories. Usare Gestione proprietà e una finestra delle proprietà per impostare valori globali in base alla configurazione per le directory di VC++.Use the Property Manager and a property sheet to set global, per-configuration values for VC++ directories.

Dipendenze da progetto a progetto.Project-to-Project Dependencies. Nelle versioni precedenti, le dipendenze definite tra i progetti vengono archiviate nel file della soluzione.In earlier releases, defined dependencies between projects were stored in the solution file. Quando le soluzioni vengono convertite nel nuovo formato di file di progetto, le dipendenze vengono convertite in riferimenti da progetto a progetto.When these solutions are converted to the new project file format, dependencies are converted to project-to-project references. Questa modifica può influire sulle applicazioni, poiché i concetti di dipendenze delle soluzioni e riferimenti da progetto a progetto sono diversi.This change can affect applications because the concepts of solution dependencies and project-to-project references are different.

Macro e variabili di ambiente.Macros and Environment Variables. La nuova macro ITERATOR_DEBUG_LEVEL richiama il supporto del debug per gli iteratori.The new _ITERATOR_DEBUG_LEVEL macro invokes debugging support for iterators. Usare questa macro anziché le macro SECURE_SCL e HAS_ITERATOR_DEBUGGING precedenti.Use this macro instead of the older _SECURE_SCL and _HAS_ITERATOR_DEBUGGING macros.

Librerie di Visual C++Visual C++ Libraries

Librerie di runtime di concorrenza.Concurrency Runtime Libraries. Il framework Runtime di concorrenza supporta applicazioni e componenti che vengono eseguiti simultaneamente ed è il framework di programmazione delle applicazioni simultanee in Visual C++.The Concurrency Runtime framework supports applications and components that run simultaneously, and is the framework for programming concurrent applications in Visual C++. Per supportare la programmazione delle applicazioni simultanee, la libreria PPL (Parallel Patterns Library) offre contenitori e algoritmi di uso generale per l'esecuzione di un parallelismo accurato.To support concurrent-application programming, the Parallel Patterns Library (PPL) provides general-purpose containers and algorithms for performing fine-grained parallelism. La libreria di agenti asincroni offre un modello di programmazione basato su attori e le interfacce per il passaggio dei messaggi per le attività di pipelining o un flusso di dati meno dettagliato.The Asynchronous Agents Library provides an actor-based programming model and message passing interfaces for coarse-grained dataflow and pipelining tasks.

Libreria standard di C++.Standard C++ Library. Nell'elenco seguente vengono descritte molte delle modifiche apportate alla libreria standard di C++.The following list describes many of the changes that have been made to the Standard C++ Library.

  • La nuova funzionalità del linguaggio C++ di riferimento Rvalue è stata usata per implementare la semantica di spostamento e l'inoltro perfetto per molte funzioni della libreria di modelli standard.The new rvalue reference C++ language feature has been used to implement move semantics and perfect forwarding for many functions in the Standard Template Library. La semantica di spostamento e l'inoltro perfetto migliorano notevolmente le prestazioni delle operazioni che allocano o assegnano variabili o parametri.Move semantics and perfect forwarding greatly improve the performance of operations that allocate or assign variables or parameters.
  • I riferimenti Rvalue sono usati anche per implementare la nuova classe unique_ptr, ovvero un tipo di puntatore intelligente più sicuro rispetto alla classe auto_ptr.Rvalue references are also used to implement the new unique_ptr class, which is a safer smart pointer type than the auto_ptr class. La classe unique_ptr è mobile ma non copiabile, implementa una rigida semantica di proprietà senza influire sulla sicurezza e funziona bene con i contenitori che riconoscono i riferimenti Rvalue.The unique_ptr class is movable but not copyable, implements strict ownership semantics without affecting safety, and works well with containers that are aware of rvalue references. La classe auto_ptr è deprecata.The auto_ptr class is deprecated.
  • Quindici nuove funzioni, ad esempio find_if_not, copy_if e is_sorted, sono state aggiunte all'intestazione <algorithm>.Fifteen new functions, for example, find_if_not, copy_if, and is_sorted, have been added to the <algorithm> header.
  • Nell'intestazione <memory> la nuova funzione make_shared è un modo pratico, affidabile ed efficiente per creare un puntatore condiviso a un oggetto nello stesso momento in cui l'oggetto viene costruito.In the <memory> header, the new make_shared function is a convenient, robust, and efficient way to make a shared pointer to an object at the same time the object is constructed.
  • Gli elenchi collegati singolarmente sono supportati dall'intestazione <forward_list>.Singly linked lists are supported by the <forward_list> header.
  • Le nuove funzioni membro cbegin, cend, crbegin e crend specificano un elemento const_iterator che si sposta avanti o indietro in un contenitore.The new cbegin, cend, crbegin, and crend member functions provide a const_iterator that moves forward or backward through a container.
  • L'intestazione <system_error> intestazione e i modelli correlati supportano l'elaborazione degli errori di sistema di basso livello.The <system_error> header and related templates support the processing of low-level system errors. I membri della classe exception_ptr possono essere usati per il trasporto delle eccezioni tra thread.Members of the exception_ptr class can be used to transport exceptions between threads.
  • L'intestazione <codecvt> supporta la conversione di varie codifiche di caratteri Unicode in altre codifiche.The <codecvt> header supports converting various encodings of Unicode characters to other encodings.
  • L'intestazione <allocators> definisce diversi modelli che consentono di allocare e liberare blocchi di memoria per contenitori basati su nodi.The <allocators> header defines several templates that help allocate and free memory blocks for node-based containers.
  • Sono disponibili numerosi aggiornamenti dell'intestazione <random>.There are numerous updates to the <random> header.

Libreria MFC (Microsoft Foundation Class)Microsoft Foundation Class (MFC) Library

Funzionalità di Windows 7.Windows 7 Features. MFC supporta molte funzionalità di Windows 7, ad esempio l'interfaccia utente della barra multifunzione, la barra delle applicazioni, le jump List, le anteprime e miniature a schede, l'indicatore di stato, l'immagine sovrapposta all'icona e l'indicizzazione della ricerca.MFC supports many Windows 7 features, for example, the Ribbon user interface (UI), the Taskbar, jump lists, tabbed thumbnails, thumbnail previews, the progress bar, icon overlay, and search indexing. Poiché MFC supporta automaticamente molte funzionalità di Windows 7, può non essere necessario modificare l'applicazione esistente.Because MFC automatically supports many Windows 7 features, you may not have to modify your existing application. Per supportare altre funzionalità nelle nuove applicazioni, usare la Creazione guidata applicazione MFC per specificare la funzionalità da usare.To support other features in new applications, use the MFC Application Wizard to specify the functionality you want to use.

Riconoscimento multitocco.Multi-touch Awareness. MFC supporta le applicazioni con interfaccia utente multitocco, ad esempio le applicazioni scritte per il sistema operativo Microsoft Surface.MFC supports applications that have a multi-touch user interface, for example, applications that are written for the Microsoft Surface operating system. Un'applicazione multitocco è in grado di gestire i messaggi con tocco di Windows e i messaggi con movimento, che sono combinazioni di messaggi con tocco.A multi-touch application can handle Windows touch messages and gesture messages, which are combinations of touch messages. È sufficiente registrare l'applicazione per gli eventi di tocco e movimento e il sistema operativo indirizzerà gli eventi multitocco ai gestori degli eventi.Just register your application for touch and gesture events and the operating system will route multi-touch events to your event handlers.

Elevata sensibilità ai valori DPI.High-DPI Awareness. Per impostazione predefinita, le applicazioni MFC rilevano la modalità HDPI.By default, MFC applications are now High-DPI-aware. Se un'applicazione è sensibile ai valori DPI (risoluzione elevata in punti per pollice), il sistema operativo è in grado di ridimensionare finestre, testo e altri elementi dell'interfaccia utente in base alla risoluzione corrente dello schermo.If an application is High-DPI (high dots per inch) aware, the operating system can scale windows, text, and other UI elements to the current screen resolution. Questo significa che più facilmente le immagini ridimensionate vengono visualizzate correttamente e non ritagliate o con effetto pixel.This means that a scaled image is more likely to be correctly laid out, and not clipped or pixelated.

Gestione riavvio.Restart Manager. La funzione Gestione riavvio consente di salvare automaticamente i documenti e riavviare l'applicazione se si chiude o si riavvia in modo imprevisto.The restart manager automatically saves documents and restarts your application if it unexpectedly closes or restarts. Ad esempio, è possibile usare Gestione riavvio per avviare l'applicazione dopo la chiusura a causa di un aggiornamento automatico.For example, you can use the restart manager to start your application after it is closed by an automatic update. Per altre informazioni su come configurare l'applicazione per l'uso di Gestione riavvio, vedere Procedura: Aggiungere il supporto di Gestione riavvio.For more information about how to configure your application to use the restart manager, see How to: Add Restart Manager Support.

CTaskDialog.CTaskDialog. La classe CTaskDialog può essere usata al posto della finestra di messaggio standard AfxMessageBox.The CTaskDialog class can be used instead of the standard AfxMessageBox message box. La classe CTaskDialog visualizza e raccoglie una maggiore quantità di informazioni rispetto alla finestra di messaggio standard.The CTaskDialog class displays and gathers more information than the standard message box does.

Libreria SafeIntSafeInt Library

La nuova libreria SafeInt esegue operazioni aritmetiche sicure per gli overflow di numeri interi.The new SafeInt Library performs safe arithmetic operations that account for integer overflow. Confronta inoltre tipi diversi di numeri interi.This library also compares different kinds of integers.

Nuove macro della libreria ATL (Active Template Library)New Active Template Library (ATL) macros

Sono state aggiunte nuove macro alla libreria ATL per espandere la funzionalità di PROP_ENTRY_TYPE e PROP_ENTRY_TYPE_EX.New macros have been added to ATL to expand the functionality of PROP_ENTRY_TYPE and PROP_ENTRY_TYPE_EX. PROP_ENTRY_INTERFACE e PROP_ENTRY_INTERFACE_EX consentono di aggiungere un elenco di CLSID validi.PROP_ENTRY_INTERFACE and PROP_ENTRY_INTERFACE_EX let you add a list of valid CLSIDs. PROP_ENTRY_INTERFACE_CALLBACK e PROP_ENTRY_INTERFACE_CALLBACK_EX consentono di specificare una funzione di callback per determinare se un CLSID è valido.PROP_ENTRY_INTERFACE_CALLBACK and PROP_ENTRY_INTERFACE_CALLBACK_EX let you specify a callback function to determine whether a CLSID is valid.

Avvisi /analyze/analyze Warnings

È stata rimossa la maggior parte degli avvisi /analyze (analisi codice enterprise) dalle librerie di runtime C (CRT), MFC e ATL.Most /analyze (Enterprise Code Analysis) warnings have been removed from the C Run-Time (CRT), MFC, and ATL libraries.

Animazione e supporto D2DAnimation and D2D support

MFC supporta ora l'animazione e la grafica Direct2D.MFC now supports animation and Direct2D graphics. La libreria MFC offre diverse nuove classi e funzioni MFC per supportare questa funzionalità.The MFC library has several new MFC classes and functions to support this functionality. Sono anche disponibili due nuove procedure dettagliate che illustrano come aggiungere un oggetto D2D e un oggetto di animazione a un progetto.There are also two new walkthroughs to show how to add a D2D object and an animation object to a project. Le procedure sono Procedura dettagliata: Aggiunta di un oggetto D2D a un progetto MFC e Procedura dettagliata: Aggiunta di animazione a un progetto MFC.These walkthroughs are Walkthrough: Adding a D2D Object to an MFC Project and Walkthrough: Adding Animation to an MFC Project.

IDEIDE

Funzionalità IntelliSense migliorata.Improved IntelliSense. La funzionalità IntelliSense per Visual C++ è stata completamente riprogettata per essere più veloce, più precisa e in grado di gestire progetti di maggiori dimensioni.IntelliSense for Visual C++ has been completely redesigned to be faster, more accurate, and able to handle larger projects. Per ottenere questo miglioramento, nell'IDE viene fatta distinzione tra il modo in cui uno sviluppatore visualizza e modifica il codice sorgente e il modo in cui l'IDE usa il codice sorgente e le impostazioni di progetto per creare una soluzione.To achieve this improvement, the IDE makes a distinction between how a developer views and modifies source code, and how the IDE uses source code and project settings to build a solution. A causa di questa separazione dei compiti, le funzionalità di esplorazione, ad esempio Visualizzazione classi e la nuova finestra di dialogo Passa a, vengono gestite da un sistema basato su un nuovo file di database desktop (SDF) di SQL Server che sostituisce il file NCB (No Compile Browse) più datato.Because of this separation of duties, browsing features such as Class View and the new Navigate To dialog box are handled by a system that is based on a new SQL Server desktop database (.sdf) file that replaces the old no compile browse (.ncb) file. Le funzionalità di IntelliSense, ad esempio le informazioni rapide, il completamento automatico e la Guida ai parametri, analizzano le unità di conversione solo quando necessario.IntelliSense features such as Quick Information, Auto Completion, and Parameter Help parse translation units only when required. Le funzionalità ibride, ad esempio la nuova finestra Gerarchia di chiamata, usano una combinazione di funzionalità di esplorazione e di IntelliSense.Hybrid features such as the new Call Hierarchy window use a combination of the browse and IntelliSense features. Poiché IntelliSense elabora solo le informazioni necessarie al momento, l'IDE risponde in modo più rapido.Because IntelliSense processes only the information that you require at the moment, the IDE is more responsive. Inoltre, poiché le informazioni sono più aggiornate, le finestre e le visualizzazioni IDE sono più accurate.Also, because information is more up to date, IDE views and windows are more accurate. Infine, poiché l'infrastruttura IDE è meglio organizzata, più efficace e più scalabile, è in grado di gestire progetti di grandi dimensioni.Finally, because the IDE infrastructure is better organized, more capable, and more scalable, it can handle larger projects.

Errori di IntelliSense migliorati.Improved IntelliSense Errors. L'IDE rileva meglio gli errori che possono causare una perdita di IntelliSense e li evidenzia con una sottolineatura ondulata rossa.The IDE better detects errors that could cause a loss of IntelliSense and displays red wavy underlines under them. Inoltre, l'IDE segnala gli errori di IntelliSense alla finestra Elenco errori.In addition, the IDE reports IntelliSense errors to the Error List Window. Per visualizzare il codice che causa il problema, fare doppio clic su errore nella finestra Elenco errori.To display the code that is causing the problem, double-click the error in the Error List Window.

Funzionalità di completamento automatico per #include#include Auto-Complete Feature. L'IDE supporta il completamento automatico per la parola chiave #include.The IDE supports auto-completion for the #include keyword. Quando si digita #include, l'IDE crea una casella di riepilogo a discesa con i file di intestazione validi.When you type #include, the IDE creates a drop-down list box of valid header files. Se si continua, digitare un nome di file, l'IDE Filtra l'elenco in base al testo immesso.If you continue by typing a file name, the IDE filters the list based on your entry. In qualsiasi momento è possibile selezionare dall'elenco il file da includere.At any point, you can select from the list the file you want to include. Ciò consente di includere rapidamente i file senza conoscere il nome esatto del file.This lets you quickly include files without knowing the exact file name.

Passa a.Navigate To. La finestra di dialogo Passa a consente di cercare tutti i simboli e i file nel progetto che corrispondono a una stringa specificata.The Navigate To dialog box lets you search for all symbols and files in your project that match a specified string. I risultati della ricerca vengono immediatamente aggiornati quando si digitano altri caratteri nella stringa di ricerca.Search results are immediately revised as you type additional characters in your search string. Il campo di feedback Risultati indica il numero di elementi trovati e consente di decidere se forzare la ricerca.The Results feedback field tells you the number of items found and helps you decide whether to constrain your search. I campi di feedback Tipo/Ambito, Percorso e Anteprima consentono di evitare ambiguità tra gli elementi con nomi simili.The Kind/Scope, Location, and Preview feedback fields help you disambiguate items that have similar names. Inoltre, è possibile estendere questa funzionalità per supportare altri linguaggi di programmazione.In addition, you can extend this feature to support other programming languages.

Debug e profilatura paralleli.Parallel Debugging and Profiling. Il debugger di Visual Studio è compatibile con il runtime di concorrenza e consente di risolvere i problemi relativi alle applicazioni con elaborazione parallela.The Visual Studio debugger is aware of the Concurrency Runtime and helps you troubleshoot parallel processing applications. Per visualizzare il comportamento complessivo dell'applicazione, è possibile usare il nuovo profiler di concorrenza.You can use the new concurrency profiler tool to visualize the overall behavior of your application. Inoltre, è possibile usare nuove finestre degli strumenti per visualizzare lo stato delle attività e i rispettivi stack di chiamate.Also, you can use new tool windows to visualize the state of tasks and their call stacks.

Finestra di progettazione della barra multifunzione.Ribbon Designer. La finestra di progettazione della barra multifunzione è un editor grafico che consente di creare e modificare l'interfaccia utente di una barra multifunzione MFC.The Ribbon Designer is a graphical editor that lets you create and modify an MFC ribbon UI. L'interfaccia utente finale della barra multifunzione è rappresentata da un file di risorse basato su XML (estensione mfcribbon-ms).The final ribbon UI is represented by an XML-based resource file (.mfcribbon-ms). Per le applicazioni esistenti, è possibile acquisire l'attuale interfaccia utente della barra multifunzione aggiungendo temporaneamente alcune righe di codice e richiamando la finestra di progettazione della barra multifunzione.For existing applications, you can capture your current ribbon UI by temporarily adding a few lines of code and then invoking the Ribbon Designer. Dopo aver creato il file di risorse della barra multifunzione, è possibile sostituire il codice scritto a mano dell'interfaccia utente della barra multifunzione con alcune istruzioni che caricano la risorsa barra multifunzione.After the ribbon resource file is created, you can replace your handwritten ribbon UI code with a few statements that load the ribbon resource.

Gerarchia di chiamata.Call Hierarchy. La finestra Gerarchia di chiamata consente di passare a tutte le funzioni che vengono chiamate da una determinata funzione o a tutte le funzioni che chiamano una determinata funzione.The Call Hierarchy window lets you navigate to all functions that are called by a particular function, or to all functions that call a particular function.

StrumentiTools

Creazione guidata classe MFC.MFC Class Wizard. Visual C++ 2010 ripropone l'uso dello strumento Creazione guidata classe MFC a suo tempo molto apprezzato.Visual C++ 2010 brings back the well-regarded MFC Class Wizard tool. La procedura Creazione guidata classe MFC è un modo pratico per aggiungere classi, messaggi e variabili a un progetto senza dover modificare manualmente i set di file di origine.The MFC Class Wizard is a convenient way to add classes, messages, and variables to a project without having to manually modify sets of source files.

Creazione guidata controllo ATL.ATL Control Wizard. La procedura Creazione guidata controllo ATL non popola più automaticamente il campo ProgID.The ATL Control Wizard no longer automatically populates the ProgID field. Se un controllo ATL non ha un ProgID, altri strumenti potrebbero non funzionare con esso.If an ATL control does not have a ProgID, other tools may not work with it. Un esempio di strumento che richiede controlli con ProgID è la finestra di dialogo Inserisci controllo ActiveX.One example of a tool that requires controls to have a ProgID is the Insert Active Control dialog box. Per altre informazioni sulla finestra di dialogo, vedere Finestra di dialogo Inserisci controllo ActiveX.For more information about the dialog box, see Insert ActiveX Control Dialog Box.

Riferimento a Microsoft Macro AssemblerMicrosoft Macro Assembler Reference

L'aggiunta del tipo di dati YMMWORD supporta gli operandi multimediali a 256 bit inclusi nelle istruzioni Intel Advanced Vector Extension (AVX).The addition of the YMMWORD data type supports the 256-bit multimedia operands that are included in the Intel Advanced Vector Extensions (AVX) instructions.

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

Ambiente di sviluppo integrato (IDE) di Visual C++Visual C++ Integrated Development Environment (IDE)

  • Le finestre di dialogo create nelle applicazioni Win32, ATL e MFC ora sono conformi alle linee guida di stile di Windows Vista.Dialog boxes that are created in ATL, MFC, and Win32 applications now comply with the Windows Vista style guidelines. Quando si crea un nuovo progetto con Visual Studio 2008, tutte le finestre di dialogo che si inseriscono nell'applicazione saranno conformi alle linee guida di stile di Windows Vista.When you create a new project by using Visual Studio 2008, all dialog boxes that you insert into your application will comply with the Windows Vista style guideline. Se si ricompila un progetto creato con una versione precedente di Visual Studio, le finestre di dialogo esistenti manterranno lo stesso aspetto che avevano in precedenza.If you recompile a project that you created with an earlier version of Visual Studio, any existing dialog boxes will maintain the same look that they previously had. Per altre informazioni sull'inserimento delle finestre di dialogo nell'applicazione, vedere Editor finestre.For more information about how to insert dialog boxes into your application, see Dialog Editor.

  • La Creazione guidata progetto ATL ha ora un'opzione per la registrazione dei componenti per tutti gli utenti.The ATL Project wizard now has an option to register components for all users. A partire da Visual Studio 2008, i componenti COM e le librerie dei tipi creati con la Creazione guidata progetto ATL vengono registrati nel nodo HKEY_CURRENT_USER del Registro di sistema a meno che non si selezioni Registra componente per tutti gli utenti.Beginning with Visual Studio 2008, the COM components and type libraries that are created by the ATL Project wizard are registered in the HKEY_CURRENT_USER node of the registry unless you select Register component for all users.

  • La Creazione guidata progetto ATL non offre più un'opzione per la creazione dei progetti ATL con attributi.The ATL Project wizard no longer provides an option to create attributed ATL projects. A partire da Visual Studio 2008 la Creazione guidata progetto ATL non ha un'opzione che consente di modificare lo stato con attributi di un nuovo progetto.Beginning with Visual Studio 2008, the ATL Project wizard does not have an option to change the attributed status of a new project. Tutti i nuovi progetti ATL creati dalla procedura guidata sono ora privi di attributi.All new ATL projects that the wizard creates are now unattributed.
  • La scrittura nel Registro di sistema può essere reindirizzata.Writing to the registry can be redirected. Con l'introduzione di Windows Vista, la scrittura in determinate aree del Registro di sistema richiede un programma da eseguire con privilegi elevati.With the introduction of Windows Vista, writing to certain areas of the registry requires a program to run in elevated mode. Non è consigliabile eseguire sempre Visual Studio con privilegi elevati.It is not desirable to always run Visual Studio in elevated mode. Il reindirizzamento per utente reindirizza automaticamente le scritture del Registro di sistema da HKEY_CLASSES_ROOT a HKEY_CURRENT_USER, senza apportare modifiche alla programmazione.Per-user redirection automatically redirects registry writes from HKEY_CLASSES_ROOT to HKEY_CURRENT_USER without any programming changes.
  • Progettazione classi ora offre un supporto limitato per il codice C++ nativo.The Class Designer now has limited support for native C++ code. Nelle versioni precedenti di Visual Studio Progettazione classi funzionava solo con Visual C# e Visual Basic.In earlier versions of Visual Studio, the Class Designer worked only with Visual C# and Visual Basic. Gli utenti di C++ ora possono usare Progettazione classi, ma solo in modalità di sola lettura.C++ users can now use the Class Designer, but only in read-only mode. Per altre informazioni su come usare Progettazione classi con C++, vedere Utilizzo del codice Visual C++ in Progettazione classi.For more information about how to use the Class Designer with C++, see Working with Visual C++ Code in Class Designer.
  • La creazione guidata del progetto non ha più un'opzione che consente di creare un progetto C++ di SQL Server.The project wizard no longer has an option to create a C++ SQL Server project. 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.

Librerie di Visual C++Visual C++ Libraries

GeneraleGeneral

  • Le applicazioni possono essere associate a versioni specifiche delle librerie di Visual C++.Applications can be bound to specific versions of the Visual C++ libraries. In alcuni casi un'applicazione dipende dagli aggiornamenti apportati alle librerie di Visual C++ dopo un rilascio.Sometimes an application depends on updates that were made to the Visual C++ libraries after a release. In questo caso l'esecuzione dell'applicazione in un computer con versioni precedenti delle librerie può causare comportamenti imprevisti.In this case, running the application on a computer that has earlier versions of the libraries can cause unexpected behavior. È ora possibile associare un'applicazione a una versione specifica delle librerie in modo che non venga eseguita in un computer con una versione precedente delle librerie.You can now bind an application to a specific version of the libraries so that it will not run on a computer that has an earlier version of the libraries.

Libreria STL/CLRSTL/CLR Library

  • Visual C++ include ora la libreria STL/CLR.Visual C++ now includes the STL/CLR Library. La libreria STL/CLR è un pacchetto della libreria di modelli standard, un subset della libreria C++ standard, per l'uso con C++ e il Common Language Runtime di .NET Framework.The STL/CLR Library is a packaging of the Standard Template Library (STL), a subset of the Standard C++ Library, for use with C++ and the .NET Framework common language runtime (CLR). Con STL/CLR è ora possibile usare tutti i contenitori, iteratori e algoritmi della libreria STL in un ambiente gestito.With STL/CLR, you can now use all the containers, iterators, and algorithms of STL in a managed environment.

Libreria MFCMFC Library

  • Windows Vista supporta i controlli comuni.Windows Vista supports Common Controls. Più di 150 metodi in 18 classi nuove o esistenti sono stati aggiunti per supportare le funzioni in Windows Vista o per migliorare la funzionalità nelle classi MFC correnti.Over 150 methods in 18 new or existing classes have been added to support features in Windows Vista, or to improve functionality in current MFC classes.
  • La nuova classe CNetAddressCtrl consente di inserire e convalidare gli indirizzi IPv4 e IPv6 o i nomi DNS.The new CNetAddressCtrl class enables you to input and validate IPv4 and IPv6 addresses or DNS names.
  • La nuova classe CPagerCtrl semplifica l'uso del controllo pager di Windows.The new CPagerCtrl class simplifies use of the Windows pager control.
  • La nuova classe CSplitButton semplifica l'uso del controllo splitbutton di Windows per selezionare un'azione predefinita o facoltativa.The new CSplitButton class simplifies the use of the Windows splitbutton control to select a default or optional action.

libreria di supporto per C++C++ Support Library

  • C++ introduce la libreria del marshalling.C++ introduces the marshaling library. La libreria del marshalling offre un modo semplice e ottimizzato di eseguire il marshalling dei dati tra gli ambienti nativi e quelli gestiti.The marshaling library provides an easy and optimized way to marshal data between native and managed environments. La libreria è un'alternativa ad approcci più complessi e meno efficienti, ad esempio l'uso di PInvoke.The library is an alternative to more complex and less efficient approaches such as Using PInvoke. Per altre informazioni, vedere Panoramica del marshalling in C++.See Overview of Marshaling in C++ for more information.

ATL ServerATL Server

  • ATL Server viene rilasciato come progetto di origine condiviso.ATL Server is released as a shared source project.
  • La codebase di ATL Server è stata rilasciata per la maggior parte come progetto di origine condiviso in CodePlex e non viene installata come parte di Visual Studio 2008.Most of the ATL Server code base has been released as a shared source project on CodePlex and is not installed as part of Visual Studio 2008. 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. Per l'elenco dei file rimossi, vedere l'articolo relativo ai file di ATL Server rimossi.For the list of removed files, see Removed ATL Server Files.
  • Le classi di codifica e decodifica dei dati di atlenc.h e le funzioni e classi di utilità di atlutil.h e atlpath.h 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 are now part of the ATL library.
  • Microsoft continuerà a supportare le versioni di ATL Server incluse nelle versioni precedenti di Visual Studio, purché tali versioni di Visual Studio siano supportate.Microsoft will continue to support versions of ATL Server that are included in earlier releases of Visual Studio as long as those versions of Visual Studio are supported. CodePlex continuerà lo sviluppo del codice ATL Server come progetto della community.CodePlex will continue development of the ATL Server code as a community project. Microsoft non supporta una versione CodePlex di ATL Server.Microsoft does not support a CodePlex version of ATL Server.

Compilatore e linker Visual C++Visual C++ Compiler and Linker

Modifiche del compilatoreCompiler Changes

  • Il compilatore supporta le compilazioni incrementali gestite.The compiler supports managed incremental builds. Quando si specifica questa opzione, il compilatore non ricompila il codice quando viene modificato un assembly di riferimento.When you specify this option, the compiler will not recompile code when a referenced assembly changes. Esegue invece una compilazione incrementale.Instead it will perform an incremental build. I file vengono ricompilati solo se le modifiche influiscono sul codice dipendente.Files are recompiled only if the changes affect the dependent code.
  • Gli attributi correlati ad ATL Server non sono più supportati.Attributes related to ATL Server are no longer supported. Il compilatore non supporta più diversi attributi direttamente correlati ad ATL Server.The compiler no longer supports several attributes that were directly related to ATL Server. Per un elenco completo degli attributi rimossi, vedere Ultime modifiche.For a complete list of the removed attributes, see Breaking Changes.
  • Il compilatore supporta la microarchitettura Intel Core.The compiler supports Intel Core microarchitecture. Il compilatore contiene la regolazione per la microarchitettura Intel Core durante la generazione di codice.The compiler contains tuning for the Intel Core microarchitecture during code generation. Per impostazione predefinita, la regolazione è attivata e non può essere disabilitata poiché supporta anche Pentium 4 e altri processori.By default, this tuning is on and cannot be disabled as it also helps Pentium 4 and other processors.
  • Gli oggetti intrinseci supportano i processori AMD e Intel più recenti.Intrinsics support newer AMD and Intel processors. Molte nuove istruzioni intrinseche supportano maggiori funzionalità nei processori AMD e Intel più recenti.Several new intrinsic instructions support the greater functionality in more recent AMD and Intel processors. Per altre informazioni sui nuovi oggetti intrinseci, vedere gli articoli su istruzioni Supplemental Streaming SIMD Extensions 3 e Streaming SIMD Extensions 4, SSE4A e gli oggetti intrinseci di modifica dei bit, oggetti intrinseci AES, _mm_clmulepi64_si128 e __rdtscp.For more information about the new intrinsics, see Supplemental Streaming SIMD Extensions 3 Instructions, Streaming SIMD Extensions 4 Instructions, SSE4A and Advanced Bit Manipulation Intrinsics, AES Intrinsics, _mm_clmulepi64_si128, and __rdtscp.
  • La funzione __cpuid è aggiornata.The __cpuid function is updated. Le funzioni __cpuid, __cpuidex ora supportano diverse nuove funzionalità dalle ultime revisioni dei processori AMD e Intel.The __cpuid, __cpuidex functions now support several new features from the latest revisions of AMD and Intel processors. L'oggetto __cpuidex è nuovo e raccoglie più informazioni dai processori recenti.The __cpuidex intrinsic is new and gathers more information from recent processors.
  • L'opzione del compilatore /MP riduce il tempo totale di compilazione.The /MP compiler option reduces total build time. L'opzione /MP può ridurre notevolmente il tempo totale necessario per compilare diversi file di origine creando alcuni processi che compilano simultaneamente i file.The /MP option can significantly reduce the total time to compile several source files by creating several processes that compile the files simultaneously. Questa opzione è particolarmente utile nei computer che supportano l'hyperthreading, più processori o più core.This option is especially useful on computers that support hyperthreading, multiple processors, or multiple cores.
  • L'opzione del compilatore /Wp64 e la parola chiave __w64 sono deprecate.The /Wp64 compiler option and __w64 keyword are deprecated. L'opzione del compilatore /Wp64 e la parola chiave __w64, che rileva i problemi di portabilità a 64 bit, sono deprecate e verranno rimosse in una versione futura del compilatore.The /Wp64 compiler option and __w64 keyword, which detect 64-bit portability issues, are deprecated and will be removed in a future version of the compiler. Anziché questa opzione del compilatore e questa parola chiave, usare un compilatore di Visual C++ che abbia come destinazione una piattaforma a 64 bit.Instead of this compiler option and keyword, use a Visual C++ compiler that targets a 64-bit platform.
  • /Qfast_transcendentals genera codice inline per le funzioni trascendenti./Qfast_transcendentals generates inline code for transcendental functions.
  • /Qimprecise_fwaits rimuove i comandi fwait interni ai blocchi try quando si usa l'opzione del compilatore /fp:except./Qimprecise_fwaits removes the fwait commands internal to try blocks when you use the /fp:except compiler option.

Modifiche del linkerLinker Changes

  • Le informazioni sul controllo dell'account utente vengono ora incorporate in file manifesto per gli eseguibili dal linker di Visual C++ (link.exe).User Account Control information is now embedded into manifest files for executables by the Visual C++ linker (link.exe). Per impostazione predefinita questa funzionalità è attivata.This feature is enabled by default. Per altre informazioni su come disabilitare questa funzionalità o su come modificare il comportamento predefinito, vedere /MANIFESTUAC (incorporazione delle informazioni sul controllo dell'account utente nel manifesto).For more information about how to disable this feature, or how to modify the default behavior, see /MANIFESTUAC (Embeds UAC information in manifest).
  • Il linker ora usa l'opzione /DYNAMICBASE per abilitare la funzionalità ASLR (Address Space Layout Randomization) di Windows Vista.The linker now has the /DYNAMICBASE option to enable the Address Space Layout Randomization feature of Windows Vista. Questa opzione modifica l'intestazione di un file eseguibile per indicare se l'applicazione deve essere riassegnata in modo casuale al momento del caricamento.This option modifies the header of an executable to indicate whether the application should be randomly rebased at load time.

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

Di seguito sono riportate le nuove funzionalità di Visual C++ 2005 Service Pack 1:The following features were new in Visual C++ 2005 Service Pack 1:

Oggetti intrinseci per x86 e x64Intrinsics for x86 and x64

  • __halt__halt
  • __lidt__lidt
  • __nop__nop
  • __readcr8__readcr8
  • __sidt__sidt
  • __svm_clgi__svm_clgi
  • __svm_invlpga__svm_invlpga
  • __svm_skinit__svm_skinit
  • __svm_stgi__svm_stgi
  • __svm_vmload__svm_vmload
  • __svm_vmrun__svm_vmrun
  • __svm_vmsave__svm_vmsave
  • __ud2__ud2
  • __vmx_off__vmx_off
  • __vmx_vmptrst__vmx_vmptrst
  • __writecr8__writecr8

Oggetti intrinseci solo per x64Intrinsics for x64 Only

  • __vmx_on__vmx_on
  • __vmx_vmclear__vmx_vmclear
  • __vmx_vmlaunch__vmx_vmlaunch
  • __vmx_vmptrld__vmx_vmptrld
  • __vmx_vmread__vmx_vmread
  • __vmx_vmresume__vmx_vmresume
  • __vmx_vmwrite__vmx_vmwrite

Nuove parole chiave del linguaggioNew Language Keywords

__sptr, __uptr__sptr, __uptr

Nuove funzionalità del compilatoreNew Compiler Features

Il compilatore include modifiche di rilievo in questa versione.The compiler has breaking changes in this release.

  • Compilatori nativi e incrociati a 64 bit.`64-bit native and cross-compilers.
  • Aggiunta l'opzione del compilatore /analyze (analisi codice enterprise)./analyze (Enterprise Code Analysis) compiler option has been added.
  • Aggiunta l'opzione del compilatore /bigobj./bigobj compiler option has been added.
  • Aggiunte le opzioni /clr:pure, /clr:safe e /clr:oldSyntax./clr:pure, /clr:safe, and /clr:oldSyntax have been added. (Funzionalità in seguito deprecata in Visual Studio 2015 e rimossa in Visual Studio 2017.)(Later deprecated in Visual Studio 2015 and removed in Visual Studio 2017.)
  • Opzioni del compilatore deprecate: molte opzioni del compilatore sono state deprecate in questa versione. Per altre informazioni, vedere Opzioni obsolete del compilatore.Deprecated compiler options: many compiler options have been deprecated in this release; see Deprecated Compiler Options for more information.
  • Ridotto il doppio thunking nel codice /clr. Per altre informazioni, vedere Doppio thunk (C++).Double thunking in /clr code is reduced; see Double Thunking (C++) for more information.
  • Non è più possibile usare /EH (modello di gestione delle eccezioni) o /EHs per rilevare un'eccezione generata con un elemento diverso da un'istruzione throw. Usare /EHa./EH (Exception Handling Model) or /EHs can no longer be used to catch an exception that is raised with something other than a throw; use /EHa.
  • Aggiunta l'opzione del compilatore /errorReport (segnala gli errori interni del compilatore)./errorReport (Report Internal Compiler Errors) compiler option has been added.
  • Aggiunta l'opzione del compilatore /favor (ottimizzazione per 64)./favor (Optimize for 64) compiler option has been added.
  • Aggiunta l'opzione del compilatore /FA, /Fa (file listato)./FA, /Fa (Listing File) compiler option has been added.
  • Aggiunta l'opzione del compilatore /FC (percorso completo del file di codice sorgente nella diagnostica)./FC (Full Path of Source Code File in Diagnostics) compiler option has been added.
  • Aggiunta l'opzione del compilatore /fp (specifica il comportamento della virgola mobile)./fp (Specify Floating-Point Behavior) compiler option has been added.
  • Aggiunta l'opzione del compilatore /G (ottimizzazione per processore)./G (Optimize for Processor) Options compiler option has been added.
  • Aggiunta l'opzione del compilatore /G (ottimizzazione per processore)./G (Optimize for Processor) Options compiler option has been added.
  • Le opzioni del compilatore /G3, /G4, /G5, /G6, /G7 e /GB sono state rimosse./G3, /G4, /G5, /G6, /G7, and /GB compiler options have been removed. Il compilatore ora usa un "modello misto" che tenta di creare il file di output migliore per tutte le architetture.The compiler now uses a "blended model" that attempts to create the best output file for all architectures.
  • L'opzione /Gf è stata rimossa./Gf has been removed. In alternativa, usare /GF (eliminazione delle stringhe duplicate).Use /GF (Eliminate Duplicate Strings) instead.
  • L'opzione /GL (ottimizzazione intero programma) è ora compatibile con /CLRHEADER./GL (Whole Program Optimization) is now compatible with /CLRHEADER.
  • L'opzione /GR ora è attivata per impostazione predefinita./GR is now on by default.
  • /GS (controllo sicurezza buffer) ora offre una protezione per i parametri dei puntatori vulnerabili./GS (Buffer Security Check) now provides security protection for vulnerable pointer parameters. L'opzione /GS ora è attivata per impostazione predefinita./GS is now on by default. /GS ora funziona anche per funzioni compilate in MSIL con /clr (compilazione Common Language Runtime)./GS now also works on functions compiled to MSIL with /clr (Common Language Runtime Compilation).
  • Aggiunta l'opzione del compilatore /homeparams (copia i parametri del registro nello stack)./homeparams (Copy Register Parameters to Stack) compiler option has been added.
  • Aggiunta l'opzione del compilatore /hotpatch (crea immagine con patch a caldo)./hotpatch (Create Hotpatchable Image) compiler option has been added.
  • Aggiornata l'euristica delle funzioni inline. Per altre informazioni, vedere inline, __inline, __forceinline e inline_depthInline function heuristics have been updated; see inline, __inline, __forceinline and inline_depth for more information
  • Sono state aggiunte molte nuove funzioni intrinseche e molti oggetti intrinseci in precedenza non documentati sono ora documentati.Many new intrinsic functions have been added, and many previously undocumented intrinsics are now documented.
  • Per impostazione predefinita, tutte le chiamate a New con esito negativo generano un'eccezione.By default, any call to new that fails will throw an exception.
  • Rimosse le opzioni del compilatore /ML e /MLd./ML and /MLd compiler options have been removed. Visual C++ non supporta più la libreria CRT a thread singolo collegata in modo statico.Visual C++ no longer supports single-threaded, statically linked CRT library support.
  • Il compilatore ha implementato l'ottimizzazione del valore restituito denominato, che viene abilitata quando si esegue la compilazione con /O1, /O2 (riduce dimensione, ottimizza velocità) /Og (ottimizzazioni globali) e /Ox (ottimizzazione completa).The compiler implemented the Named Return Value Optimization, which is enabled when you compile with /O1, /O2 (Minimize Size, Maximize Speed), /Og (Global Optimizations), and /Ox (Full Optimization).
  • L'opzione del compilatore /Oa è stata rimossa ma verrà automaticamente ignorata. Usare i modificatori noalias o restrict__declspec per specificare in che modo il compilatore usa gli alias./Oa compiler option has been removed but will be silently ignored; use the noalias or restrict__declspec modifiers to specify how the compiler does aliasing.
  • Rimossa l'opzione del compilatore /Op./Op compiler option had been removed. In alternativa, usare /fp (specifica il comportamento della virgola mobile).Use /fp (Specify Floating-Point Behavior) instead.
  • Visual C++ ora supporta OpenMP.OpenMP is now supported by Visual C++.
  • Aggiunta l'opzione del compilatore /openmp (abilita il supporto per OpenMP 2.0)./openmp (Enable OpenMP 2.0 Support) compiler option has been added.
  • L'opzione del compilatore /Ow è stata rimossa ma verrà automaticamente ignorata./Ow compiler option has been removed but will be silently ignored. Usare i modificatori noalias o restrict__declspec per specificare in che modo il compilatore usa gli alias.Use the noalias or restrict__declspec modifiers to specify how the compiler does aliasing.

Ottimizzazioni guidate da profilo (PGO)Profile-Guided Optimizations

  • Rimossa l'opzione /QI0f./QI0f has been removed.
  • Rimossa l'opzione /QIfdiv./QIfdiv has been removed.
  • Aggiunta l'opzione del compilatore /QIPF_B (errata per l'istruzione CPU B)./QIPF_B (Errata for B CPU Stepping) compiler option has been added.
  • Aggiunta l'opzione del compilatore /QIPF_C (errata per l'istruzione CPU C)./QIPF_C (Errata for C CPU Stepping) compiler option has been added.
  • Aggiunta l'opzione del compilatore /QIPF_fr32 (non usare i 96 registri a virgola mobile superiori)./QIPF_fr32 (Do Not Use Upper 96 Floating Point Registers) compiler option has been added.
  • Aggiunta l'opzione del compilatore /QIPF_noPIC (genera codice dipendente dalla posizione)./QIPF_noPIC (Generate Position Dependent Code) compiler option has been added.
  • Aggiunta l'opzione del compilatore /QIPF_restrict_plabels (presuppone che non vengano create funzioni in fase di esecuzione)./QIPF_restrict_plabels (Assume No Functions Created at Run Time) compiler option has been added.

Supporto Unicode nel compilatore e nel linkerUnicode Support in the Compiler and Linker

  • /vd (disabilita spostamenti costruttori) consente ora di usare l'operatore dynamic_cast per un oggetto in fase di costruzione (/vd2)/vd (Disable Construction Displacements) now allows you to use dynamic_cast Operator on an object being constructed (/vd2)
  • Rimossa l'opzione del compilatore /YX./YX compiler option has been removed. In alternativa, usare /Yc (crea il file di intestazione precompilata) o /Yu (usa il file di intestazione precompilata).Use /Yc (Create Precompiled Header File) or /Yu (Use Precompiled Header File) instead. Se l'opzione /YX viene rimossa dalle configurazioni della build e non viene sostituita da altri elementi, le compilazioni potranno essere più rapide.If you remove /YX from your build configurations and replace it with nothing, it can result in faster builds.
  • L'opzione /Zc:forScope ora è abilitata per impostazione predefinita./Zc:forScope is now on by default.
  • L'opzione /Zc:wchar_t ora è abilitata per impostazione predefinita./Zc:wchar_t is now on by default.
  • Rimossa l'opzione del compilatore /Zd./Zd compiler option has been removed. Le informazioni di debug solo per il numero di riga non sono più supportate.Line-number only debugging information is no longer supported. In alternativa, usare /Zi. Per altre informazioni, vedere /Z7, /Zi, /ZI (formato informazioni di debug).Use /Zi instead (see /Z7, /Zi, /ZI (Debug Information Format) for more information).
  • L'opzione /Zg ora è valida solo per i file di codice sorgente C e non per i file di codice sorgente C++./Zg is now only valid on C source code files, and not on C++ source code files.
  • Aggiunta l'opzione del compilatore /Zx (debug del codice Itanium ottimizzato)./Zx (Debug Optimized Itanium Code) compiler option has been added.

Nuove funzionalità del linguaggioNew Language Features

  • Deprecato l'attributo attribute.The attributeattribute is now deprecated.
  • Aggiunto il modificatore appdomain__declspec.appdomain__declspec modifier has been added.
  • Aggiunta la convenzione di chiamata __clrcall.__clrcall calling convention has been added.
  • Il modificatore deprecated (C++)declspec consente ora di specificare una stringa che verrà visualizzata in fase di compilazione, quando un utente tenta di accedere a una classe o funzione deprecata.deprecated (C++)declspec modifier now allows you to specify a string that will be displayed at compile time, when a user tries to access a deprecated class or function.
  • L'operatore dynamic_cast include modifiche di rilievo.dynamic_cast Operator has breaking changes.
  • Le enumerazioni native ora consentono di specificare il tipo sottostante.Native enums now allow you to specify the underlying type.
  • Aggiunto il modificatore jitintrinsicdeclspec.jitintrinsicdeclspec modifier has been added.
  • Aggiunto il modificatore noaliasdeclspec.noaliasdeclspec modifier has been added.
  • Aggiunto il modificatore process__declspec.process__declspec modifier has been added.
  • abstract, override e sealed sono valide per le compilazioni native.abstract, override, and sealed are valid for native compilations.
  • Aggiunta la parola chiave __restrict.__restrict keyword has been added.
  • Aggiunto il modificatore restrictdeclspec.restrictdeclspec modifier has been added.
  • __thiscall è ora una parola chiave.__thiscall is now a keyword.
  • La parola chiave __unaligned è ora documentata.__unaligned keyword is now documented.
  • volatile (C++) presenta un nuovo comportamento rispetto alle ottimizzazioni.volatile (C++) has updated behavior with respect to optimizations.

Nuove funzionalità del preprocessoreNew Preprocessor Features

  • Aggiunta la macro predefinita __CLR_VER.__CLR_VER predefined macro added.
  • Il pragma comment (C/C++) ora accetta /MANIFESTDEPENDENCY come commento del linker.The comment (C/C++) pragma now accepts /MANIFESTDEPENDENCY as a linker comment. L'opzione exestr per comment è ora deprecata.The exestr option to comment is now deprecated.
  • L'attributo embedded_idl (direttiva #import) accetta ora un parametro facoltativo.embedded_idl attribute (The #import Directive) now takes an optional parameter.
  • fenv_access (pragma)fenv_access pragma
  • float_control (pragma)float_control pragma
  • fp_contract (pragma)fp_contract pragma
  • Le variabili globali non verranno inizializzate nell'ordine in cui sono dichiarate se sono presenti variabili globali nel pragma managed, unmanaged e nelle sezioni non gestite.Global variables will not be initialized in the order they are declared if you have global variables in pragma managed, unmanaged and unmanaged sections. La modifica può avere un grande impatto se, ad esempio, una variabile globale non gestita viene inizializzata con variabili globali gestite ed è richiesto un oggetto gestito completamente costruito.This is a potential breaking change if, for example, an unmanaged global variable is initialized with a managed global variables, and a fully constructed managed object is required.
  • Le sezioni specificate con init_seg sono ora di sola lettura e non di lettura/scrittura come nelle versioni precedenti.Sections specified with init_seg are now read only, and not read/write as in previous versions.
  • Il valore predefinito di inline_depth ora è 16.inline_depth default is now 16. Il valore predefinito 16 era usato anche in Visual C++ .NET 2003.A default of 16 was also in effect in Visual C++ .NET 2003.
  • Aggiunta la macro predefinita _INTEGRAL_MAX_BITS, vedere Macro predefinite._INTEGRAL_MAX_BITS predefined macro added, see Predefined Macros.
  • Aggiunte le macro predefinite M_CEE M_CEE_PURE e M_CEE_SAFE, vedere Macro predefinite._M_CEE, _M_CEE_PURE, and _M_CEE_SAFE predefined macros added, see Predefined Macros.
  • Aggiunta la macro predefinita _M_IX86_FP._M_IX86_FP predefined macro added.
  • Aggiunta la macro predefinita _M_X64._M_X64 predefined macro added.
  • make_public (pragma)make_public pragma
  • Aggiornata la sintassi del pragma managed, unmanaged (ora include push e pull)managed, unmanaged pragma syntax updated (now has push and pop)
  • La direttiva #using fa ora riferimento a mscorlib.dll in modo implicito in tutte le compilazioni /clr.mscorlib.dll is now implicitly referenced by The #using Directive in all /clr compilations.
  • Aggiunta la macro predefinita _OPENMP._OPENMP predefined macro added.
  • Il pragma optimize è stato aggiornato, a e w non sono più parametri validi.optimize pragma has been updated, a and w are no longer valid parameters.
  • Aggiunto l'attributo no_registry#import.no_registry#import attribute has been added.
  • Aggiunti i pragma region, endregionregion, endregion pragmas added
  • Aggiunta la macro predefinita VC_NODEFAULTLIB._VC_NODEFAULTLIB predefined macro added.
  • Le macro variadic vengono ora implementate.Variadic Macros are now implemented.
  • vtordisp è deprecato e verrà rimosso in una futura versione di Visual C++.vtordisp is deprecated and will be removed in a future release of Visual C++.
  • Il pragma warning include ora l'identificatore suppress.The warning pragma now has the suppress specifier.

Nuove funzionalità del linkerNew Linker Features

  • I moduli (file di output MSIL non di assembly) sono ora consentiti come input per il linker.Modules (non-assembly MSIL output files) are now allowed as input to the linker.
  • Aggiunta l'opzione del linker /ALLOWISOLATION (ricerca di manifesti)./ALLOWISOLATION (Manifest Lookup) linker option has been added.
  • L'opzione /ASSEMBLYRESOURCE (incorpora una risorsa gestita) è stata aggiornata per fare in modo che sia possibile specificare il nome della risorsa nell'assembly e per specificare che la risorsa è privata nell'assembly./ASSEMBLYRESOURCE (Embed a Managed Resource) has been updated to now allow you to specify the name of the resource in the assembly, and to specify that the resource is private in the assembly.
  • Aggiunta l'opzione del linker /CLRIMAGETYPE (specifica il tipo di immagine CLR)./CLRIMAGETYPE (Specify Type of CLR Image) linker option has been added.
  • Aggiunta l'opzione del linker /CLRSUPPORTLASTERROR (mantiene l'ultimo codice di errore per le chiamate PInvoke)./CLRSUPPORTLASTERROR (Preserve Last Error Code for PInvoke Calls) linker option has been added.
  • Aggiunta l'opzione del linker /CLRTHREADATTRIBUTE (imposta l'attributo thread CLR)./CLRTHREADATTRIBUTE (Set CLR Thread Attribute) linker option has been added.
  • Aggiunta l'opzione del linker /CLRUNMANAGEDCODECHECK (aggiunge SupressUnmanagedCodeSecurityAttribute)./CLRUNMANAGEDCODECHECK (Add SupressUnmanagedCodeSecurityAttribute) linker option has been added.
  • Aggiunta l'opzione del linker /ERRORREPORT (segnala errori interni del linker)./ERRORREPORT (Report Internal Linker Errors) linker option has been added.
  • Rimossa l'opzione del linker /EXETYPE./EXETYPE linker option has been removed. Il linker non supporta più la creazione di driver di dispositivo per Windows 95 e Windows 98.The linker no longer supports creating Windows 95 and Windows 98 device drivers. Usare un DDK appropriato per creare i driver di dispositivo.Use an appropriate DDK to create these device drivers. La parola chiave EXETYPE non è più valida per i file di definizione del modulo.The EXETYPE keyword is no longer valid for module definition files.
  • Aggiunta l'opzione del linker /FUNCTIONPADMIN (crea immagine con patch a caldo)./FUNCTIONPADMIN (Create Hotpatchable Image) linker option has been added.
  • L'opzione del linker /LTCG è ora supportata nei moduli compilati con /clr./LTCG linker option is now supported on modules compiled with /clr. /LTCG è stata aggiornata anche per supportare le ottimizzazioni PGO./LTCG has also been updated to support profile-guided optimizations.
  • Aggiunta l'opzione del linker /MANIFEST (crea manifesto dell'assembly affiancato)./MANIFEST (Create Side-by-Side Assembly Manifest) linker option has been added.
  • Aggiunta l'opzione del linker /MANIFESTDEPENDENCY (specifica le dipendenze tra manifesti)./MANIFESTDEPENDENCY (Specify Manifest Dependencies) linker option has been added.
  • Aggiunta l'opzione del linker /MANIFESTFILE (denominazione file manifesto)./MANIFESTFILE (Name Manifest File) linker option has been added.
  • Rimossa l'opzione del linker /MAPINFO:LINES./MAPINFO:LINES linker option has been removed.
  • Aggiunta l'opzione del linker /NXCOMPAT (compatibile con la protezione esecuzione programmi)./NXCOMPAT (Compatible with Data Execution Prevention) linker option has been added.
  • Aggiunta l'opzione del linker /PGD (specifica il database per le ottimizzazioni PGO)./PGD (Specify Database for Profile-Guided Optimizations) linker option has been added.
  • Aggiunta l'opzione del linker /PROFILE (profiler strumenti di prestazioni)./PROFILE (Performance Tools Profiler) linker option has been added.
  • L'opzione del linker /SECTION (specifica attributi di sezione) ora supporta la negazione dell'attributo e non supporta più gli attributi L o D (correlati a VxD)./SECTION (Specify Section Attributes) linker option now supports attribute negation and no longer supports the L or D (VxD-related) attributes.
  • Supporto Unicode nel compilatore e nel linkerUnicode Support in the Compiler and Linker
  • L'opzione del linker /VERBOSE (stampa messaggi di stato) ora accetta anche ICF e REF./VERBOSE (Print Progress Messages) linker option now also accepts ICF and REF.
  • Rimossa l'opzione del linker /VXD./VXD linker option has been removed. Il linker non supporta più la creazione di driver di dispositivo per Windows 95 e Windows 98.The linker no longer supports creating Windows 95 and Windows 98 device drivers. Usare un DDK appropriato per creare i driver di dispositivo.Use an appropriate DDK to create these device drivers. La parola chiave VXD non è più valida per i file di definizione del modulo.The VXD keyword is no longer valid for module definition files.
  • Rimossa l'opzione del linker /WS./WS linker option has been removed. /WS veniva usata per modificare le immagini con destinazione Windows NT 4.0./WS was used to modify images targeted for Windows NT 4.0. Anziché /WS si può usare il nome file -R IMAGECFG.exe.IMAGECFG.exe -R filename can be used instead of /WS. IMAGECFG.exe è reperibile nel CD di Windows NT 4.0 in SUPPORT\DEBUG\I386\IMAGECFG. FILE EXE.IMAGECFG.exe can be found on the Windows NT 4.0 CD-ROM in SUPPORT\DEBUG\I386\IMAGECFG.EXE.
  • L'opzione del linker /WX (considera gli avvisi del linker come errori) è ora documentata./WX (Treat Linker Warnings as Errors) linker option is now documented.

Nuove funzionalità delle utilità del linkerNew Linker Utility Features

  • Aggiunta l'opzione editbin /ALLOWISOLATION/ALLOWISOLATION editbin option had been added
  • Rimossa l'istruzione del file di definizione moduli DESCRIPTION.DESCRIPTION module definition file statement is removed. Il linker non supporta la compilazione di driver di dispositivo virtuale.The linker no longer supports building virtual device drivers.
  • Aggiunta l'opzione /ERRORREPORT a bscmake.exe, dumpbin.exe, editbin.exe e lib.exe./ERRORREPORT option has been added to bscmake.exe, dumpbin.exe, editbin.exe, and lib.exe.
  • Aggiunta l'opzione lib /LTCG./LTCG lib option has been added.
  • Aggiunta l'opzione editbin /NXCOMPAT./NXCOMPAT editbin option has been added.
  • Aggiunta l'opzione dumpbin /RANGE./RANGE dumpbin option has been added.
  • Aggiunta l'opzione dumpbin /TLS./TLS dumpbin option has been added.
  • Rimossa l'opzione editbin /WS./WS editbin option has been removed. /WS veniva usata per modificare le immagini con destinazione Windows NT 4.0./WS was used to modify images targeted for Windows NT 4.0. Anziché /WS si può usare il nome file -R IMAGECFG.exe.IMAGECFG.exe -R filename can be used instead of /WS. IMAGECFG.exe è reperibile nel CD di Windows NT 4.0 in SUPPORT\DEBUG\I386\IMAGECFG. FILE EXE.IMAGECFG.exe can be found on the Windows NT 4.0 CD-ROM in SUPPORT\DEBUG\I386\IMAGECFG.EXE.
  • Aggiunta l'opzione lib /WX[:NO]./WX[:NO] lib option has been added.

Nuove funzionalità NMAKENew NMAKE Features

  • Aggiunta l'opzione /ERRORREPORT./ERRORREPORT has been added.
  • Aggiunta l'opzione /G./G has been added.
  • Le regole predefinite sono state aggiornate.The predefined rules have been updated.
  • La macro $(MAKE), documentata nelle macro di ricorsione, ora specifica il percorso completo per nmake.exe.The $(MAKE) macro, which is documented in Recursion Macros, now gives the full path to nmake.exe.

Nuove funzionalità MASMNew MASM Features

  • Le espressioni MASM sono ora valori a 64 bit.MASM expressions are now 64-bit values. Nelle versioni precedenti le espressioni MASM sono valori a 32 bit.In previous versions MASM expressions were 32-bit values.
  • L'istruzione __asm int 3 ora determina la compilazione di una funzione per il codice nativo.The instruction __asm int 3 now causes a function to be compiled to native.
  • ALIAS (MASM) è ora documentata.ALIAS (MASM) is now documented.
  • Aggiunta l'opzione /ERRORREPORT di ml.exe e ml64.exe./ERRORREPORT ml.exe and ml64.exe option is added.
  • .FPO è ora documentato..FPO is now documented.
  • H2INC.exe non è incluso in Visual C++ 2005.H2INC.exe will not ship in Visual C++ 2005. Per continuare a usare H2INC, usare H2INC.exe da una versione precedente di Visual C++.If you need to continue to use H2INC, use H2INC.exe from a previous version of Visual C++.
  • Aggiunto l'operatore IMAGEREL.operator IMAGEREL has been added.
  • Aggiunto l'operatore HIGH32.operator HIGH32 has been added.
  • Aggiunto l'operatore LOW32.operator LOW32 has been added.
  • ml64.exe è una versione di MASM per l'architettura x64.ml64.exe is a version of MASM for the x64 architecture. Consente di assemblare i file ASM x64 in file oggetto x64.It assembles x64 .asm files into x64 object files. Il linguaggio dell'assembly inline non è supportato nel compilatore x64.Inline assembly language is not supported in the x64 compiler. Le seguenti direttive MASM sono state aggiunte per ml64.exe (x64):The following MASM directives have been added for ml64.exe (x64):
  • .ALLOCSTACK.ALLOCSTACK
  • .ENDPROLOG.ENDPROLOG
  • .PUSHFRAME.PUSHFRAME
  • .PUSHREG.PUSHREG
  • .SAVEREG.SAVEREG
  • .SAVEXMM128.SAVEXMM128
  • .SETFRAME Inoltre, la direttiva PROC è stata aggiornata con la sola sintassi x64..SETFRAME In addition, the PROC directive was updated with x64-only syntax.
  • Aggiunta la direttiva MMWORDMMWORD directive has been added
  • /omf (opzione della riga di comando ML.exe) ora implica /c./omf (ML.exe command line option) now implies /c. ML.exe non supporta il collegamento di oggetti in formato OMF.ML.exe does not support linking OMF format objects.
  • La direttiva SEGMENT supporta ora gli attributi aggiuntivi.The SEGMENT directive now supports additional attributes.
  • Aggiunto l'operatore SECTIONREL.operator SECTIONREL has been added.
  • Aggiunta la direttiva XMMWORDXMMWORD directive has been added

Nuove funzionalità CRTNew CRT Features

  • Sono state aggiunte le versioni protette di diverse funzioni.Secure versions of several functions have been added. Queste funzioni gestiscono gli errori in modo più efficace e applicano controlli più severi dei buffer per evitare difetti comuni della sicurezza.These functions handle errors in a better way and enforce stricter controls on buffers to help avoid common security flaws. Le nuove versioni protette sono identificate dal suffisso _s.The new secure versions are identified by the _s suffix.
  • Le versioni meno sicure di molte funzioni sono state deprecate.Existing less secure versions of many functions have been deprecated. Per disabilitare gli avvisi di deprecazione, definire CRT_SECURE_NO_WARNINGS.To disable the deprecation warnings, define _CRT_SECURE_NO_WARNINGS.
  • Molte funzioni esistenti ora convalidano i relativi parametri e richiamano il gestore di parametri non validi quando viene passato un parametro non valido.Many existing functions now validate their parameters and invoke the invalid parameter handler when an invalid parameter is passed.
  • Molte funzioni esistenti ora impostano errno dove in precedenza non lo facevano.Many existing functions now set errno where they did not before.
  • Aggiunto il typedef errno_t con tipo integer.The typedef errno_t with type integer was added. errno_t viene usato ogni volta che un parametro o un tipo restituito di una funzione riguarda i codici di errore da errno.errno_t is used whenever a function return type or parameter deals with error codes from errno. errno_t sostituisce errcode.errno_t replaces errcode.
  • Le funzioni dipendenti dalle impostazioni locali ora hanno versioni che accettano le impostazioni locali come parametro anziché usare le impostazioni locali correnti.Locale-dependent functions now have versions which take the locale as a parameter rather than using the current locale. Queste nuove funzioni hanno il suffisso _l.These new functions have the _l suffix. Sono state aggiunte diverse nuove funzioni per gestire gli oggetti delle impostazioni locali.Several new functions were added to work with locale objects. Le nuove funzioni includono _get_current_locale, _create_locale e _free_locale.New functions include _get_current_locale, _create_locale and _free_locale.
  • Sono state aggiunte nuove funzioni per supportare gli handle di file di blocco e sblocco.New functions were added to support locking and unlocking file handles.
  • La famiglia di funzioni _spawn non reimposta errno su zero in caso di esito positivo, come accadeva nelle versioni precedenti.The _spawn family of functions does not reset errno to zero on success, as it did in previous versions.
  • Sono disponibili le versioni della famiglia di funzioni printf che consentono di specificare l'ordine in cui vengono usati gli argomenti.Versions of the printf family of functions that allow you to specify the order in which the arguments are used are available.
  • Unicode è ora un formato di testo supportato.Unicode is now a supported text format. La funzione _open supporta gli attributi O_TEXTW, O_UTF8 e O_UTF16.The function _open supports _O_TEXTW, _O_UTF8 and _O_UTF16 attributes. La funzione fopen supporta il metodo "ccs=ENCODING" per specificare un formato Unicode.The fopen function supports the "ccs=ENCODING" method of specifying a Unicode format.
  • Una nuova versione delle librerie CRT create nel codice gestito (MSIL) è ora disponibile e viene usata durante la compilazione con l'opzione /clr (Common Language Runtime).A new version of the CRT libraries built in managed code (MSIL) is now available and is used when compiling with the /clr (Common Language Runtime Compilation) option.
  • Rimosso l'oggetto _fileinfo._fileinfo has been removed.
  • La dimensione predefinita per time_t è ora 64 bit, che espande l'intervallo di time_t e di molte funzioni di ora fino all'anno 3000.The default size for time_t is now 64 bits, which expands the range of time_t and several of the time functions out to the year 3000.
  • CRT supporta ora la definizione delle impostazioni locali in base a ogni singolo thread.The CRT now supports setting the locale on a per thread basis. Per supportare questa funzionalità, è stata aggiunta la funzione _configthreadlocale.The function _configthreadlocale was added to support this feature.
  • Aggiunte le funzioni _statusfp2 e __control87_2 per consentire l'accesso e controllo della parola di controllo a virgola mobile per i processori a virgola mobile sia x87 che SSE2.The _statusfp2 and __control87_2 functions were added to allow access to and control of the floating point control word on both the x87 and SSE2 floating point processor.
  • Aggiunte le funzioni _mkgmtime e _mkgmtime64 per consentire il supporto della conversione degli orari (struct tm) nell'ora di Greenwich (GMT).The_mkgmtime and _mkgmtime64 functions were added to provide support for converting times (struct tm) to Greenwich Mean Time (GMT).
  • Sono state apportate modifiche a swprintf e vswprintf per migliorare la conformità allo standard.Changes were made to swprintf and vswprintf to better conform with the standard.
  • Un nuovo file di intestazione, INTRIN.H, specifica i prototipi per alcune funzioni intrinseche.A new header file, INTRIN.H, provides prototypes for some intrinsic functions.
  • La funzione fopen include ora un attributo N.The fopen function now has an N attribute.
  • La funzione _open include ora un attributo _O_NOINHERIT.The _open function now has an _O_NOINHERIT attribute.
  • La funzione atoi ora restituisce INT_MAX e imposta errno su ERANGE per l'overflow.The atoi function now returns INT_MAX and sets errno to ERANGE on overflow. Nelle versioni precedenti, il comportamento dell'overflow non era definito.In previous versions, the overflow behavior was undefined.
  • La famiglia di funzioni printf supporta l'output esadecimale a virgola mobile implementato in base allo standard ANSI C99 usando gli identificatori del tipo di formato %a e %A.The printf family of functions supports hexadecimal floating point output implemented according to the ANSI C99 standard using the format type specifiers %a and %A.
  • La famiglia printf supporta ora il prefisso di dimensione "ll" (long long).The printf family now supports the "ll" (long long) size prefix.
  • La funzione _controlfp è stata ottimizzata per migliorare le prestazioni.The _controlfp function has been optimized for better performance.
  • Sono state aggiunte le versioni di debug di alcune funzioni.Debug versions of some functions have been added.
  • Aggiunte _chgsignl e _cpysignl (versioni long double).Added _chgsignl and _cpysignl (long double versions).
  • Aggiunto il tipo _locale_t alla tabella dei tipi.Added _locale_t type to type table.
  • Aggiunta una nuova macro, Macro _countof, per il calcolo del numero di elementi in una matrice.New macro _countof Macro added for computing number of elements in an array.
  • In ogni argomento della funzione, è stata aggiunta una sezione di equivalenti di .NET Framework.In each function topic, a section on .NET Framework equivalents has been added.
  • Diverse funzioni di stringa sono ora in grado di troncare le stringhe in modo da non avere esito negativo quando i buffer di output sono troppo piccoli. Vedere TRUNCATE.Several string functions now have the option of truncating strings rather than failing when output buffers are too small; see _TRUNCATE.
  • set_se_translator richiede ora l'uso dell'opzione del compilatore /EHa._set_se_translator now requires the use of the /EHa compiler option.
  • fpos_t ora è int64 in /Za (per il codice C) e quando __STDC è impostato manualmente (per il codice C++).fpos_t is now int64 under /Za (for C code) and when __STDC is set manually (for C++ code). In precedenza era uno struct.It used to be a struct.
  • CRT_DISABLE_PERFCRIT_LOCKS è in grado di migliorare le prestazioni di I/O dei programmi a thread singolo._CRT_DISABLE_PERFCRIT_LOCKS can improve the I/O performance of single-threaded programs.
  • I nomi POSIX sono stati deprecati a favore di nomi conformi a ISO C++ (ad esempio, usare _getch anziché getch).POSIX names have been deprecated in favor of ISO C++ conformant names (for example, use _getch rather than getch).
  • Sono disponibili nuovi file OBJ delle opzioni di collegamento per la modalità pureNew link options .obj files are available for pure mode
  • _recalloc combina le caratteristiche di realloc e calloc._recalloc combines features of realloc and calloc.

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

CompilatoreCompiler

  • Informazioni su come eseguire un'applicazione delle estensioni gestite per C++ compilata con il compilatore della versione corrente in una versione precedente del runtime.Information on how to run a Managed Extensions for C++ application built with the current version's compiler on a previous version of the runtime.
  • Domande frequenti sulle estensioni gestite per C++.Managed Extensions for C++ Frequently Asked Questions.
  • È stata aggiunta una procedura dettagliata che illustra come eseguire il porting di un'applicazione nativa esistente delle estensioni gestite per C++ per consentire l'interazione con i componenti di .NET Framework.A walkthrough has been added showing how to port an existing, native application to use Managed Extensions for C++: Walkthrough: Porting an Existing Native C++ Application to Interoperate with .NET Framework Components.
  • È ora possibile creare un delegato per un metodo di un tipo di valore.You can now create a delegate on a method of a value type.
  • La conformità del compilatore con lo standard C++ è stata notevolmente migliorata per Visual C++ .NET 2003.The compiler's conformance with the C++ standard has been significantly enhanced for Visual C++ .NET 2003.
  • Aggiunta l'opzione del compilatore /arch./arch compiler option is added.
  • Deprecata l'opzione /GF, che verrà rimossa nella prossima versione di Visual C++./Gf is deprecated and will be removed in the next version of Visual C++.
  • Aggiunta l'opzione del compilatore /G7./G7 compiler option is added.
  • Ottimizzata l'opzione del compilatore /GS per proteggere le variabili locali da sovraccarichi del buffer diretti.The /GS compiler option has been enhanced to help protect local variables from direct buffer overruns.
  • Rimossa l'opzione del compilatore /noBool.The /noBool compiler option has been removed. Il compilatore ora consente di visualizzare bool solo come parola chiave, non come identificatore, in un file di codice sorgente C++.The compiler now allows bool to appear only as a keyword (and not an identifier) in a C++ source code file.
  • Il tipo long long è ora disponibile come typedef di __int64. Si noti che non è ancora disponibile il supporto per long long in CRT.The long long type is now available as a typedef of __int64 Note that there is not yet support for long long in the CRT.
  • L'opzione del compilatore /Zm ora specifica il limite di allocazione di memoria delle intestazioni precompilate.The /Zm compiler option now specifies the precompiled header memory allocation limit.
  • Documentata la funzione intrinseca _InterlockedCompareExchange._InterlockedCompareExchange intrinsic now documented.
  • Documentata la funzione intrinseca _InterlockedDecrement._InterlockedDecrement intrinsic now documented.
  • Documentata la funzione intrinseca _InterlockedExchange._InterlockedExchange intrinsic now documented.
  • Documentata la funzione intrinseca _InterlockedExchangeAdd._InterlockedExchangeAdd intrinsic now documented.
  • Documentata la funzione intrinseca _InterlockedIncrement._InterlockedIncrement intrinsic now documented.
  • Aggiunta la funzione intrinseca _ReadWriteBarrier._ReadWriteBarrier intrinsic added.

AttributiAttributes

  • L'attributo implements è ora documentato.implements attribute is now documented.

Funzionalità del linkerLinker features

Sono state aggiunte le seguenti opzioni del linker:The following linker switches have been added:

  • /ASSEMBLYDEBUG/ASSEMBLYDEBUG
  • /ASSEMBLYLINKRESOURCE/ASSEMBLYLINKRESOURCE
  • DELAYSIGNDELAYSIGN
  • /KEYFILE/KEYFILE
  • /KEYCONTAINER/KEYCONTAINER
  • /SAFESEH/SAFESEH

MASMMASM

Aggiunte la direttiva .SAFESEH e l'opzione /safeseh di ml.exe.The .SAFESEH directive and /safeseh ml.exe option were added.

Vedere ancheSee Also

Guida al porting e aggiornamento in Visual C++Visual C++ Porting and Upgrading Guide