Visual C++ O que há de novo de 2003 a 2015

Esta página reúne todas as páginas "Novidades" para todas as versões do Visual C++ do Visual Studio 2015 até 2003. Essas informações são fornecidas como uma conveniência no caso de que possa ser útil ao atualizar de versões anteriores do Visual Studio.

Observação

Para obter informações sobre a versão atual do Visual Studio, consulte Novidades do Visual C++ no Visual Studio e Melhorias de conformidade no Visual C++ no Visual Studio.

O que há de novo no C++ no Visual Studio 2015

No Visual Studio 2015 e posteriores, melhorias contínuas na conformidade do compilador às vezes podem alterar como o compilador entende seu código-fonte existente. Quando isso acontece, você pode encontrar erros novos ou diferentes durante sua compilação, ou até mesmo diferenças comportamentais no código que foi criado anteriormente e parecia funcionar corretamente.

Felizmente, essas diferenças têm pouco ou nenhum impacto na maioria do seu código-fonte e quando o código-fonte ou outras alterações são necessárias para resolver essas diferenças, as correções geralmente são pequenas e diretas. Incluímos muitos exemplos de código-fonte anteriormente aceitável que podem precisar ser alterados (antes) e as correções para corrigi-los (depois).

Embora essas diferenças possam afetar seu código-fonte ou outros artefatos de compilação, elas não afetam a compatibilidade binária entre atualizações para versões do Visual C++. Um tipo mais severo de alteração, a alteração disruptiva pode afetar a compatibilidade binária, mas essas quebras de compatibilidade binária só ocorrem entre as versões principais do Visual C++. Por exemplo, entre Visual C++ 2013 e Visual C++ 2015. Para obter informações sobre as alterações recentes que ocorreram entre o Visual C++ 2013 e o Visual C++ 2015, consulte Visual C++ change history 2003 - 2015.

Melhorias de conformidade no Visual Studio 2015
Melhorias de conformidade no Visual Studio 2015 Atualização 1
Melhorias de conformidade no Visual Studio 2015 Atualização 2
Melhorias de conformidade no Visual Studio 2015 Atualização 3

Melhorias de conformidade no Visual Studio 2015

opção /Zc:forScope-

A opção /Zc:forScope- do compilador foi preterida e será removida em uma versão futura.
```
  Command line warning  D9035: option 'Zc:forScope-' has been deprecated and will be removed in a future release
```
A opção foi geralmente usada para permitir código não padrão que usa variáveis de loop após o ponto em que, de acordo com o padrão, elas deveriam ter saído do escopo. Só foi necessário quando você está compilando com a /Za opção, já que sem /Za, usar uma variável for loop após o fim do loop é sempre permitido. Se você não se importa com a conformidade de padrões (por exemplo, se seu código não se destina a ser portátil para outros compiladores), você pode desativar a /Za opção (ou definir a propriedade Desativar extensões de idioma como Não). Se você se preocupa em escrever código portátil e em conformidade com os padrões, você deve reescrever seu código para que ele esteja em conformidade com o padrão, movendo a declaração de tais variáveis para um ponto fora do 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
  }
```
Opção de compilador Zg.

A /Zg opção do compilador (Gerar protótipos de função) não está mais disponível. Esta opção do compilador foi preterida anteriormente.
Não é mais possível executar testes de unidade com C++/CLI a partir da linha de comando com mstest.exe. Em vez disso, use vstest.console.exe
palavra-chave mutável.

O mutable especificador de classe de armazenamento não é mais permitido em locais onde anteriormente era compilado sem erro. Agora, o compilador dá erro C2071 (classe de armazenamento ilegal). De acordo com a norma, o especificador mutável pode ser aplicado apenas a nomes de membros de dados de classe, e não pode ser aplicado a nomes declarados const ou estáticos, e não pode ser aplicado a membros de referência.

Por exemplo, considere o seguinte código:
```
  struct S {
      mutable int &r;
  };
```
Versões anteriores do compilador Microsoft C++ aceitaram isso, mas agora o compilador dá o seguinte erro:
```
  error C2071: 'S::r': illegal storage class
```
Para corrigir o erro, basta remover a palavra-chave redundante mutable .
char_16_t e char32_t

Você não pode mais usar char16_t ou char32_t como apelidos num typedef, porque esses tipos agora são tratados como nativos. Era comum que usuários e autores de bibliotecas definissem char16_t e char32_t como pseudônimos de uint16_t e uint32_t, respectivamente.
```
  #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;
  }
```
Para atualizar seu código, remova as typedef declarações e renomeie quaisquer outros identificadores que colidam com esses nomes.
Parâmetros de modelo não tipo

Determinado código que envolve parâmetros de modelo que não são do tipo agora é verificado corretamente quanto à compatibilidade de tipo quando você fornece argumentos de modelo explícitos. Por exemplo, o código a seguir compilado sem erro em versões anteriores do 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>();
  }
```
O compilador atual retorna corretamente um erro, porque o tipo de parâmetro do template não corresponde ao argumento do template (o parâmetro é um ponteiro para um membro const, mas a função f não é 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'
```
Para resolver esse erro em seu código, certifique-se de que o tipo do argumento de modelo que você usa corresponde ao tipo declarado do parâmetro de modelo.
__declspec(align)

O compilador já não aceita __declspec(align) em funções. Isso sempre foi ignorado, mas agora produz um erro de compilador.
```
  error C3323: 'alignas' and '__declspec(align)' are not allowed on function declarations
```
Para corrigir esse problema, remova __declspec(align) da declaração de função. Como não surtiu efeito, removê-lo não muda nada.
Tratamento de exceções

Há algumas mudanças no tratamento de exceções. Em primeiro lugar, os objetos de exceção têm de ser copiáveis ou móveis. O código a seguir compilado no Visual Studio 2013, mas não compila no Visual Studio 2015:
```
  struct S {
  public:
      S();
  private:
      S(const S &);
  };

  int main()
  {
      throw S(); // error
  }
```
O problema é que o construtor de cópia é privado, portanto, o objeto não pode ser copiado como normalmente ocorre ao lidar com uma exceção. O mesmo se aplica quando o construtor copy é declarado explicit.
```
  struct S {
      S();
      explicit S(const S &);
  };

  int main()
  {
      throw S(); // error
  }
```
Para atualizar seu código, certifique-se de que o construtor de cópia para seu objeto de exceção é público e não marcado explicit.

Capturar uma exceção por valor também requer que o objeto de exceção seja copiável. O código a seguir compilado no Visual Studio 2013, mas não compila no Visual Studio 2015:
```
  struct B {
  public:
      B();
  private:
      B(const B &);
  };

  struct D : public B {
  };

  int main()
  {
      try
      {
      }
      catch (D d) // error
      {
      }
  }
```
Você pode corrigir esse problema alterando o tipo de parâmetro para o catch para uma referência.
```
  catch(D& d)
  {
  }
```
Literais de cadeia de caracteres seguidos por macros

O compilador agora suporta literais definidos pelo usuário. Como consequência, literais de string seguidos por macros sem espaço em branco entre eles são interpretados como literais definidos pelo utilizador, o que pode causar erros ou resultados inesperados. Por exemplo, em compiladores anteriores, o seguinte código compilado com êxito:
```
  #define _x "there"
  char* func() {
      return "hello"_x;
  }
  int main()
  {
      char * p = func();
      return 0;
  }
```
O compilador interpretou isso como um literal de string "hello" seguido por uma macro, que é expandida para "there", e então os dois literais de string foram concatenados em um único. No Visual Studio 2015, o compilador interpreta isso como um literal definido pelo usuário, mas como não há nenhuma correspondência literal definida pelo usuário _x definida, ele fornece um erro.
```
  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?
```
Para corrigir esse problema, adicione um espaço entre a cadeia de caracteres literal e a macro.
Literais de strings adjacentes

Da mesma forma que no anterior, devido a alterações relacionadas na análise de strings, literais de cadeia de caracteres adjacentes (literais de cadeia de caracteres largos ou de caracteres estreitos) sem qualquer espaço em branco foram interpretados como uma única cadeia de caracteres concatenada em versões anteriores do Visual C++. No Visual Studio 2015, agora você deve adicionar espaço em branco entre as duas cadeias de caracteres. Por exemplo, o seguinte código deve ser alterado:
```
  char * str = "abc""def";
```
Basta adicionar um espaço entre as duas cadeias de caracteres.
```
  char * str = "abc" "def";
```
Posicionamento novo e exclusão

Uma alteração foi feita no operador para colocá-lo em conformidade com o delete padrão C++14. Detalhes da mudança de padrões podem ser encontrados em C++ Sized Deallocation. As alterações adicionam uma forma do operador global delete que usa um parâmetro size. A mudança de ruptura é que, se anteriormente estavas a usar um operador delete com a mesma assinatura (para corresponder com um operador placement new), receberás um erro de compilador (C2956, que ocorre no ponto em que o placement new é utilizado, já que é nessa posição no código que o compilador tenta identificar um operador delete adequado correspondente).

A função void operator delete(void *, size_t) era um operador placement delete correspondente à função placement newvoid * operator new(size_t, size_t) em C++11. Com a desalocação C++14, esta delete função é agora uma função de desalocação comum (operador global delete). O padrão requer que, se o uso de um novo posicionamento procura uma função correspondente delete e encontra uma função de desalocação usual, o programa está mal formado.

Por exemplo, suponha que o seu código defina tanto um placement new como um placement delete:
```
  void * operator new(std::size_t, std::size_t);
  void operator delete(void*, std::size_t) noexcept;
```
O problema ocorre devido à correspondência nas assinaturas de função entre um operador placement delete que definiu, e o novo operador global dimensionado delete. Considere se tu podes usar um tipo diferente de size_t para qualquer placement new e delete operadores. Observe que o tipo do size_ttypedef depende do compilador; é um typedef para unsigned int no Visual C++. Uma boa solução é usar um tipo enumerado como este:
```
  enum class my_type : size_t {};
```
Em seguida, altere a sua definição de posicionamento new e delete para usar esse tipo como o segundo argumento em vez de usar size_t. Você também precisará atualizar as chamadas para o placement new para passar o novo tipo (por exemplo, usando static_cast<my_type> para converter do valor inteiro) e atualizar a definição de new e delete para converter de volta para o tipo inteiro. Você não precisa usar um enum para isso, um tipo de classe com um size_t membro também funcionaria.

Uma solução alternativa é que você pode ser capaz de eliminar completamente o placement new. Se o seu código usa placement new para implementar um pool de memória onde o argumento de posicionamento é o tamanho do objeto que está a ser alocado ou eliminado, o recurso de desalocação dimensionada pode ser adequado para substituir o seu próprio código de pool de memória personalizado, e pode simplesmente usar o seu próprio operador de dois argumentos delete em vez das funções de posicionamento.

Se você não quiser atualizar seu código imediatamente, você pode reverter para o comportamento antigo usando a opção /Zc:sizedDealloc-de compilador . Se você usar essa opção, as funções de dois argumentos delete não existirão e não causarão um conflito com o operador de exclusão de posicionamento .
Membros de dados da União

Os dados dos membros dos sindicatos já não podem ter tipos de referência. O código a seguir compilado com êxito no Visual Studio 2013, mas produz um erro no Visual Studio 2015.
```
  union U1 {
      const int i;
  };
  union U2 {
     int &i;
  };
  union U3 {
      struct {int &i;};
  };
```
O código anterior produz os seguintes erros:
```
  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
```
Para resolver esse problema, altere os tipos de referência para um ponteiro ou um valor. Alterar o tipo para um ponteiro requer alterações no código que usa o campo união. Alterar o código para um valor alteraria os dados armazenados na união, o que afeta outros campos, uma vez que os campos em tipos de união compartilham a mesma memória. Dependendo do tamanho do valor, também pode alterar o tamanho da união.

Sindicatos anónimos

estão agora mais em conformidade com a norma. Versões anteriores do compilador geraram um construtor explícito e um destruidor para uniões anônimas. Eles são excluídos no Visual Studio 2015.

struct S {
    S();
};

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

O código anterior gera o seguinte erro no 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

Para resolver esse problema, forneça suas próprias definições do construtor e/ou destruidor.

  struct S {
     // Provide a default constructor by adding an empty function body.
     S() {}
  };

  union {
     struct {
        S s;
     };
  } u;

Sindicatos com estruturas anónimas

A fim de estar em conformidade com o padrão, o comportamento em tempo de execução mudou para membros de estruturas anônimas em uniões. O construtor para membros anônimos da estrutura em um sindicato não é mais implicitamente chamado quando tal união é criada. Além disso, o destrutor para membros anónimos da estrutura numa união não é mais implicitamente chamado quando a união sai do escopo. Considere o código a seguir, no qual uma união U contém uma estrutura anônima que contém um membro que é uma estrutura nomeada S que tem um destruidor.

  #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;
  }

No Visual Studio 2013, o construtor para S é chamado quando a união é criada, e o destruidor para S é chamado quando a pilha para a função f é limpa. Mas no Visual Studio 2015, o construtor e o destruidor não são chamados. O compilador dá um aviso sobre essa mudança de comportamento.

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

Para restaurar o comportamento original, dê um nome à estrutura anônima. O comportamento de tempo de execução de estruturas não anônimas é o mesmo, independentemente da versão do compilador.

  #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;
  }

Como alternativa, tente mover o código do construtor e do destruidor para novas funções e adicione chamadas a essas funções do construtor e do destruidor para a união.

  #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;
  }

Resolução do modelo

Alterações foram realizadas na resolução de nomes para modelos. Em C++, ao considerar candidatos para a resolução de um nome, pode acontecer que um ou mais nomes em consideração como potenciais correspondências resultem numa instanciação inválida de template. Essas instanciações inválidas normalmente não causam erros do compilador, um princípio que é conhecido como SFINAE (Substitution Failure Is Not An Error).

Agora, se o SFINAE exigir que o compilador instancie a especialização de um modelo de classe, então quaisquer erros que ocorram durante esse processo são erros do compilador. Em versões anteriores, o compilador ignorava tais erros. Por exemplo, considere o seguinte código:
```
  #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 você compilar com o compilador atual, você receberá o seguinte erro:
```
  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
          ]
```
Isto porque no momento da primeira invocação do is_base_of a classe 'D' ainda não foi definida.

Neste caso, a correção é não usar tais características de tipo até que a classe tenha sido definida. Se você mover as definições de B e D para o início do arquivo de código, o erro será resolvido. Se as definições estiverem em arquivos de cabeçalho, verifique a ordem das instruções include para os arquivos de cabeçalho para garantir que todas as definições de classe sejam compiladas antes que os modelos problemáticos sejam usados.
Construtores de cópia

No Visual Studio 2013 e no Visual Studio 2015, o compilador gera um construtor de cópia para uma classe se essa classe tiver um construtor de movimento definido pelo utilizador, mas não tiver um construtor de cópia definido pelo utilizador. No Dev14, esse construtor de cópia gerado implicitamente também está marcado como "= delete".

Melhorias de conformidade no Visual Studio 2015 Atualização 1

Classes base virtuais privadas e herança indireta

As versões anteriores do compilador permitiam que uma classe derivada chamasse funções de membro das suas classes base indiretamente derivadasprivate virtual. Esse comportamento antigo estava incorreto e não está em conformidade com o padrão C++. O compilador não aceita mais código escrito dessa maneira e emite o erro de compilador C2280 como resultado.

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

Exemplo (antes)

  class base
  {
  protected:
      base();
      ~base();
  };

  class middle: private virtual base {};class top: public virtual middle {};

  void destroy(top *p)
  {
      delete p;  //
  }

Exemplo (depois)

  class base;  // as above

  class middle: protected virtual base {};
  class top: public virtual middle {};

  void destroy(top *p)
  {
      delete p;
  }

-ou-

  class base;  // as above

  class middle: private virtual base {};
  class top: public virtual middle, private virtual bottom {};

  void destroy(top *p)
  {
      delete p;
  }

Operador sobrecarregado novo e operador excluído

As versões anteriores do compilador permitiam que o operador não-membro new e o non-member operator delete fossem declarados estáticos e declarados em namespaces diferentes do namespace global. Esse comportamento antigo criava um risco de que o programa não chamasse a implementação do operador new ou delete que o programador pretendia, resultando silenciosamente em um mau comportamento em tempo de execução. O compilador não aceita mais o código escrito dessa maneira e emite o erro do compilador C2323.
```
  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.
```
Exemplo (antes)
```
  static inline void * __cdecl operator new(size_t cb, const std::nothrow_t&)  // error C2323
```
Exemplo (depois)
```
  void * __cdecl operator new(size_t cb, const std::nothrow_t&)  // removed 'static inline'
```
Além disso, embora o compilador não forneça um diagnóstico específico, o operador inline new é considerado mal formado.
Chamando 'operator type()' (conversão definida pelo usuário) em tipos não-classe As versões anteriores do compilador permitiam que 'operator type()' fosse chamado em tipos não-classe, ignorando-o silenciosamente. Esse comportamento antigo criava um risco de geração silenciosa de código ruim, resultando em comportamento de tempo de execução imprevisível. O compilador não aceita mais o código escrito dessa maneira e emite o erro do compilador C2228.
```
  error C2228: left of '.operator type' must have class/struct/union
```
Exemplo (antes)
```
  typedef int index_t;

  void bounds_check(index_t index);

  void login(int column)
  {
      bounds_check(column.operator index_t());  // error C2228
  }
```
Exemplo (depois)
```
  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 de tipo redundante em especificadores de tipo elaborados Versões anteriores do compilador permitiam typename em especificadores de tipo elaborados; código escrito desta forma anteriormente está semanticamente incorreto agora. O compilador não aceita mais o código escrito dessa maneira e emite o erro do compilador C3406.
```
  error C3406: 'typename' cannot be used in an elaborated type specifier
```
Exemplo (antes)
```
  template <typename class T>
  class container;
```
Exemplo (depois)
```
  template <class T>  // alternatively, could be 'template <typename T>'; 'typename' is not elaborating a type specifier in this case
  class container;
```

Dedução de tipo de matrizes de uma lista de inicializadores As versões anteriores do compilador não suportavam a dedução de tipo de matrizes de uma lista de inicializadores. O compilador agora suporta essa forma de dedução de tipo e, como resultado, chamadas para modelos de função usando listas de inicializadores podem agora ser ambíguas ou uma sobrecarga diferente pode ser escolhida do que em versões anteriores do compilador. Para resolver esses problemas, o programa deve agora especificar explicitamente a sobrecarga que o programador pretendia.

Quando esse novo comportamento faz com que a resolução de sobrecarga considere um candidato adicional que é tão bom quanto o candidato histórico, a chamada torna-se ambígua e o compilador emite o erro de compilador C2668 como resultado.

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

Exemplo 1: Chamada ambígua para função sobrecarregada (antes)

  // 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
  }

Exemplo 1: chamada ambígua para função sobrecarregada (depois)

  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 esse novo comportamento faz com que a resolução de sobrecarga considere um candidato adicional que é melhor do que o candidato histórico, a chamada resolve inequivocamente para o novo candidato, causando uma mudança no comportamento do programa que provavelmente é diferente do que o programador pretendia.

Exemplo 2: alteração na resolução de sobrecarga (antes)

  // 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});
  }

Exemplo 2: alteração na resolução de sobrecarga (após)

  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});
  }

Restauração dos avisos de instrução do interruptor

Uma versão anterior do compilador removeu avisos anteriormente existentes relacionados a switch instruções, esses avisos agora foram restaurados. O compilador agora emite os avisos restaurados, e os avisos relacionados a casos específicos (incluindo o caso padrão) agora são emitidos na linha que contém o caso ofensivo, em vez de na última linha da instrução switch. Como resultado de emitir agora esses avisos em linhas diferentes das anteriores, os avisos anteriormente suprimidos pelo uso de #pragma warning(disable:####) podem já não ser suprimidos como se pretendia. Para suprimir estas advertências conforme pretendido, poderá ser necessário transferir a diretiva #pragma warning(disable:####) para uma linha acima do caso potencialmente ofensivo mais próximo. A seguir estão os avisos restaurados.

  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

Exemplo de C4063 (antes)

  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;
      }
  }

Exemplo de C4063 (após)

  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;
      }
  };

Exemplos de outros avisos restaurados são fornecidos em sua documentação.

#include: uso do especificador de diretório pai '..' em nome do caminho (afeta apenas /Wall/WX)

As versões anteriores do compilador não detetavam o uso do especificador de diretório pai '..' no nome do caminho das #include diretivas. O código escrito dessa maneira geralmente se destina a incluir cabeçalhos que existem fora do projeto usando incorretamente caminhos relativos ao projeto. Esse comportamento antigo criava um risco de que o programa pudesse ser compilado incluindo um arquivo de origem diferente do que o programador pretendia, ou que esses caminhos relativos não seriam portáteis para outros ambientes de compilação. O compilador agora deteta e notifica o programador de código escrito desta forma e emite um aviso opcional do compilador C4464, se ativado.
```
  warning C4464: relative include path contains '..'
```
Exemplo (antes)
```
  #include "..\headers\C4426.h"  // emits warning C4464
```
Exemplo (depois)
```
  #include "C4426.h"  // add absolute path to 'headers\' to your project's include directories
```
Além disso, embora o compilador não forneça um diagnóstico específico, também recomendamos que o especificador de diretório pai ".." seja usado para especificar os diretórios de inclusão do seu projeto.
#pragma optimize() estende-se além do final do ficheiro de cabeçalho (apenas afeta /Wall/WX)

As versões anteriores do compilador não detetaram alterações nas configurações do sinalizador de otimização que escapam de um arquivo de cabeçalho incluído em uma unidade de tradução. O compilador agora deteta e notifica o programador do código escrito desta forma e emite um aviso opcional do compilador C4426 no local da infração #include, se ativado. Esse aviso só é emitido se as alterações entrarem em conflito com os sinalizadores de otimização definidos por argumentos de linha de comando para o compilador.
```
  warning C4426: optimization flags changed after including header, may be due to #pragma optimize()
```
Exemplo (antes)
```
  // C4426.h
  #pragma optimize("g", off)
  ...
  // C4426.h ends

  // C4426.cpp
  #include "C4426.h"  // warning C4426
```
Exemplo (depois)
```
  // 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"
```

Incompatibilidade de #pragma warning(push) e #pragma warning(pop) (afeta apenas /Wall/WX)

As versões anteriores do compilador não detetavam alterações de estado #pragma warning(push) sendo emparelhadas com alterações de estado #pragma warning(pop) num ficheiro de origem diferente, o que raramente é pretendido. Esse comportamento antigo criava um risco de que o programa fosse compilado com um conjunto diferente de avisos habilitados do que o programador pretendia, possivelmente resultando em um mau comportamento silencioso de tempo de execução. O compilador agora deteta e notifica o programador sobre o código escrito dessa forma e emite um aviso opcional do compilador C5031 na localização da correspondência #pragma warning(pop), se ativado. Este aviso inclui uma nota que faz referência à localização do correspondente #pragma warning(push).

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

Exemplo (antes)

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

Exemplo (depois)

  // 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"
  ...

Embora incomum, o código escrito dessa maneira às vezes é intencional. O código escrito desta forma é sensível a alterações na #include ordem, sempre que possível, recomendamos que os arquivos de código-fonte gerenciem o estado de aviso de forma independente.

Aviso de #pragma incomparável (push) (afeta /Wall/WXapenas )

As versões anteriores do compilador não detetavam alterações de estado não correspondentes no final de uma unidade de tradução. O compilador agora deteta e notifica o programador de código escrito desta forma, e emite um aviso opcional do compilador C5032 no local do elemento #pragma warning(push) não correspondido, caso esteja ativado. Este aviso só é emitido se não houver erros de compilação na unidade de tradução.

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

Exemplo (antes)

  // 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

Exemplo (depois)

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

Avisos adicionais podem ser emitidos como resultado de um melhor rastreamento do estado de aviso #pragma

Versões anteriores do compilador não acompanharam suficientemente bem as alterações de estado de #pragma warning para emitir todos os avisos pretendidos. Esse comportamento criou um risco de que certos avisos seriam efetivamente suprimidos em circunstâncias diferentes do que o programador pretendia. O compilador agora rastreia #pragma warning o estado de forma mais robusta - especialmente relacionada a #pragma warning mudanças de estado dentro dos modelos - e, opcionalmente, emite novos avisos C5031 e C5032 que se destinam a ajudar o programador a localizar usos não intencionais de #pragma warning(push) e #pragma warning(pop).

Como resultado de um melhor #pragma warning controle de alterações de estado, avisos anteriormente suprimidos incorretamente ou avisos relacionados a problemas anteriormente diagnosticados incorretamente podem agora ser emitidos.
Melhor identificação de código inacessível

As alterações na biblioteca padrão do C++ e a capacidade aprimorada de inserir chamadas de função em relação às versões anteriores do compilador podem permitir que o compilador prove que determinado código agora está inacessível. Esse novo comportamento pode resultar em novas instâncias de avisos C4720 emitidas com mais frequência.
```
  warning C4720: unreachable code
```
Em muitos casos, esse aviso só pode ser emitido ao compilar com otimizações habilitadas, uma vez que as otimizações podem inserir mais chamadas de função, eliminar código redundante ou tornar possível determinar que determinado código está inacessível. Observamos que novos casos de aviso C4720 têm ocorrido com frequência em blocos try/catch , especialmente em relação ao uso de std::find.

Exemplo (antes)
```
  try
  {
      auto iter = std::find(v.begin(), v.end(), 5);
  }
  catch(...)
  {
      do_something();  // ok
  }
```
Exemplo (depois)
```
  try
  {
      auto iter = std::find(v.begin(), v.end(), 5);
  }
  catch(...)
  {
      do_something();  // warning C4702: unreachable code
  }
```
Remoção da otimização de pow(T, int) desenrolamento

Versões anteriores da biblioteca padrão C++ definiam um pow(T, int) modelo de função que desenrolaria uma pow chamada de função em uma série de operações de multiplicação. Esta técnica acumularia uma grande quantidade de imprecisão devido à natureza das operações de ponto flutuante, causando resultados finais que poderiam ser significativamente imprecisos. No Visual Studio 2015 Atualização 1, esse comportamento foi removido para evitar a perda não intencional de precisão ao usar a pow função. No entanto, esta versão do pow foi muito mais rápido do que o cálculo correto. Se essa alteração causar uma regressão de desempenho significativa e seu projeto não exigir resultados precisos de ponto flutuante (por exemplo, seu projeto já compila com /fp:fast), considere substituir chamadas para pow por esta função de solução alternativa:
```
template <class T> 
inline T pow_int(T x, int y) throw() {
     unsigned int n;
     if (y >= 0) {
         n = (unsigned int)(y);
     } else {
         n = (unsigned int)(-y);
     }
     for (T z = T(1); ; x *= x) {
         if ((n & 1) != 0) {
             z *= x;
         }
         if ((n >>= 1) == 0) {
             return (y < 0 ? T(1) / z : z);
         }
     }
}
```
Essa implementação é idêntica ao que foi incluído em versões anteriores do Visual Studio.

Melhorias de conformidade no Visual Studio 2015 Atualização 2

Avisos e erros adicionais podem ser emitidos como resultado do suporte parcial para a expressão SFINAE

As versões anteriores do compilador não analisavam certos tipos de expressões dentro decltype de especificadores devido à falta de suporte para a expressão SFINAE. Esse comportamento antigo estava incorreto e não está em conformidade com o padrão C++. O compilador agora analisa essas expressões e tem suporte parcial para a expressão SFINAE devido a melhorias contínuas de conformidade. Como resultado, o compilador agora emite avisos e erros encontrados em expressões que as versões anteriores do compilador não analisavam.

Quando esse novo comportamento analisa uma decltype expressão que inclui um tipo que ainda não foi declarado, o compilador emite o erro de compilador C2039 como resultado.
```
  error C2039: 'type': is not a member of 'global namespace'
```
Exemplo 1: utilização de um tipo não declarado (antes)
```
  struct s1
  {
    template <typename T>
    auto f() -> decltype(s2<T>::type::f());  // error C2039

    template<typename>
    struct s2 {};
  }
```
Exemplo 1 (depois)
```
  struct s1
  {
    template <typename>  // forward declare s2struct s2;

    template <typename T>
    auto f() -> decltype(s2<T>::type::f());

    template<typename>
    struct s2 {};
  }
```
Quando este novo comportamento analisa uma expressão decltype em que falta o uso necessário da palavra-chave typename para especificar que um nome dependente é um tipo, o compilador emite o aviso do compilador C4346 juntamente com o erro do compilador 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'
```
Exemplo 2: nome dependente não é um tipo (antes)
```
  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
  };
```
Exemplo 2 (após)
```
  template <typename T> struct s1 {...};  // as above
  template <typename T> struct s2 {...};  // as above

  template <typename T>
  T declval();

  struct s
  {
    template <typename T>
    auto f(T t) -> decltype(t(declval<S1<typename S2<T>::type>::type>()));
  };
```
volatile As variáveis de membro impedem construtores e operadores de atribuição definidos implicitamente As versões anteriores do compilador permitiam que uma classe que tem volatile variáveis membro tivesse construtores de cópia/movimentação padrão e operadores de atribuição de cópia/movimentação padrão gerados automaticamente. Esse comportamento antigo estava incorreto e não está em conformidade com o padrão C++. O compilador agora considera uma classe que tem variáveis de membro voláteis para ter operadores de construção e atribuição não triviais, o que impede que implementações padrão desses operadores sejam geradas automaticamente. Quando tal classe é um membro de uma união (ou uma união anônima dentro de uma classe), os construtores copy/move e operadores de atribuição copy/move da união (ou a classe que contém a união unônima) serão implicitamente definidos como excluídos. Tentar construir ou copiar a união (ou classe que contém a união anônima) sem defini-los explicitamente é um erro e o compilador emite o erro do compilador C2280 como resultado.
```
  error C2280: 'B::B(const B &)': attempting to reference a deleted function
```
Exemplo (antes)
```
  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
```
Exemplo (depois)
```
  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
```
As funções de membro estático não suportam qualificadores cv.

As versões anteriores do Visual C++ 2015 permitiam que as funções de membro estático tivessem qualificadores cv. Esse comportamento é devido a uma regressão no Visual C++ 2015 e Visual C++ 2015 Atualização 1; Visual C++ 2013 e versões anteriores do Visual C++ rejeitam código escrito dessa maneira. O comportamento do Visual C++ 2015 e Visual C++ 2015 Update 1 está incorreto e não está em conformidade com o padrão C++. O Visual Studio 2015 Update 2 rejeita o código escrito dessa maneira e emite o erro de compilador C2511.
```
  error C2511: 'void A::func(void) const': overloaded member function not found in 'A'
```
Exemplo (antes)
```
  struct A
  {
    static void func();
  };

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

  void A::func() {}  // removed const
```

Declaração antecipada de enumeração não é permitida no código WinRT (afeta somente /ZW )

O código compilado para o Tempo de Execução do Windows (WinRT) não permite que enum os tipos sejam declarados para frente, da mesma forma que quando o código C++ gerenciado é compilado para o .Net Framework usando a opção do /clr compilador. Esse comportamento garante que o tamanho de uma enumeração é sempre conhecido e pode ser projetado corretamente para o sistema de tipo WinRT. O compilador rejeita o código escrito desta forma e emite o erro do compilador C2599 juntamente com o erro do compilador C3197.

  error C2599: 'CustomEnum': the forward declaration of a WinRT enum is not allowed

  error C3197: 'public': can only be used in definitions

Exemplo (antes)

  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;
    }
  };

Exemplo (depois)

            // forward declaration of CustomEnum removed
  namespace A {
    public enum class CustomEnum: int32
    {
      Value1
    };
  }

  public ref class Component sealed
  {
  public:
    CustomEnum f()
    {
      return CustomEnum::Value1;
    }
  };

O operador não-membro sobrecarregado novo e o operador excluído não podem ser declarados em linha (Nível 1 (/W1) on-by-default)

As versões anteriores do compilador não emitem um aviso quando as funções operator new e operator delete não-membro são declaradas em linha. O código escrito desta forma é mal formado (não é necessário diagnóstico) e pode causar problemas de memória resultantes de operadores new e delete incompatíveis (especialmente quando usados em conjunto com deslocamento dimensionado) que podem ser difíceis de detetar. O compilador agora emite o aviso do compilador C4595 para ajudar a identificar o código escrito dessa maneira.
```
  warning C4595: 'operator new': non-member operator new or delete functions may not be declared inline
```
Exemplo (antes)
```
  inline void* operator new(size_t sz)  // warning C4595
  {
    ...
  }
```
Exemplo (depois)
```
  void* operator new(size_t sz)  // removed inline
  {
    ...
  }
```
A correção do código escrito dessa maneira pode exigir que as definições do operador sejam movidas de um arquivo de cabeçalho para um arquivo de origem correspondente.

Melhorias de conformidade no Visual Studio 2015 Atualização 3

std::is_convertable agora deteta autoatribuição (biblioteca padrão) As versões anteriores do característica-tipo não detetavam corretamente a std::is_convertable autoatribuição de um tipo de classe quando seu construtor de cópia é excluído ou privado. Agora, std::is_convertable<>::value está corretamente definido como false quando aplicado a um tipo de classe com um construtor de cópia excluído ou particular.

Não há nenhum diagnóstico de compilador associado a essa alteração.

Exemplo
```
  #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");
```
Em versões anteriores do Visual C++, as asserções estáticas na parte inferior deste exemplo passam porque std::is_convertable<>::value foi definido incorretamente como true. Agora, std::is_convertable<>::value está corretamente definido como false, fazendo com que as asserções estáticas falhem.
Os construtores de cópia e movimentação triviais padrão ou excluídos respeitam os especificadores de acesso

As versões anteriores do compilador não verificavam o especificador de acesso de construtores de cópia e movimentação triviais padrão ou excluídos antes de permitir que eles fossem chamados. Esse comportamento antigo estava incorreto e não está em conformidade com o padrão C++. Em alguns casos, esse comportamento antigo criava um risco de geração silenciosa de código ruim, resultando em um comportamento de tempo de execução imprevisível. O compilador agora verifica o especificador de acesso de construtores triviais de cópia e movimentação padrão ou excluídos para determinar se podem ser chamados e, caso não possa, emite o aviso de compilador C2248.
```
  error C2248: 'S::S' cannot access private member declared in class 'S'
```
Exemplo (antes)
```
  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
  }
```
Exemplo (depois)
```
  class S {
  public:
     S() = default;
  private:
      S(const S&) = default;
  };

  void f(const S&);  // pass S by reference

  int main()
  {
      S s;
      f(s);
  }
```

Descontinuação do suporte ao código ATL atribuído (Nível 1 (/W1) on-by-default)

Versões anteriores do compilador suportavam código ATL atribuído. Como a próxima fase de remoção do suporte para código ATL atribuído que começou no Visual C++ 2008, o código ATL atribuído foi preterido. O compilador agora emite um aviso do compilador C4467 para ajudar a identificar esse tipo de código preterido.

  warning C4467: Usage of ATL attributes is deprecated

Se você quiser continuar usando o código ATL atribuído até que o suporte seja removido do compilador, você pode desativar esse aviso passando os argumentos da /Wv:18 linha de comando ou /wd4467 para o compilador ou adicionando #pragma warning(disable:4467) seu código-fonte.

Exemplo 1 (antes)

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

Exemplo 1 (depois)

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

Às vezes, você pode precisar ou querer criar um arquivo IDL para evitar o uso de atributos ATL preteridos, como no código de exemplo abaixo

Exemplo 2 (antes)

  [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
  {
      // ...
  };

Primeiro, crie o arquivo *.idl; O arquivo gerado VC140.idl pode ser usado para obter um arquivo *.idl contendo as interfaces e anotações.

Em seguida, adicione uma etapa MIDL à sua compilação para garantir que as definições de interface C++ sejam geradas.

Exemplo 2 IDL (depois)

  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;
      };
  }

Em seguida, use ATL diretamente no arquivo de implementação, como no código de exemplo abaixo.

Implementação do Exemplo 2 (após)

  #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()
  };

Arquivos de cabeçalho (PCH) pré-compilados e diretivas #include incompatíveis (afeta /Wall/WXapenas )

As versões anteriores do compilador aceitavam diretivas #include incompatíveis em ficheiros de origem ao utilizar ficheiros de cabeçalho (PCH) pré-compilados entre compilações -Yc e -Yu. O código escrito desta forma não é mais aceito pelo compilador. O compilador agora emite o aviso do compilador CC4598 para ajudar a identificar diretivas #include incompatíveis ao usar arquivos PCH.
```
  warning C4598: 'b.h': included header file specified for Ycc.h at position 2 does not match Yuc.h at that position
```
Exemplo (antes):

X.cpp (-Ycc.h)
```
  #include "a.h"
  #include "b.h"
  #include "c.h"
```
Z.cpp (-Yuc.h)
```
  #include "b.h"
  #include "a.h"  // mismatched order relative to X.cpp
  #include "c.h"
```
Exemplo (depois)

X.cpp (-Ycc.h)
```
  #include "a.h"
  #include "b.h"
  #include "c.h"
```
Z.cpp (-Yuc.h)
```
  #include "a.h"
  #include "b.h" // matched order relative to X.cpp
  #include "c.h"
```
Arquivos de cabeçalho (PCH) pré-compilados e diretórios de inclusão incompatíveis (afeta apenas /Wall/WX)

As versões anteriores do compilador aceitas incompatíveis incluem argumentos de linha de comando de diretório (-I) para o compilador entre e -Yc compilações ao -Yu usar arquivos de cabeçalho pré-compilados (PCH). O código escrito desta forma não é mais aceito pelo compilador. O compilador agora emite aviso do compilador CC4599 para ajudar a identificar argumentos de linha de comando de diretório (-I) de inclusão incompatíveis ao usar arquivos PCH.
```
  warning C4599: '-I..' : specified for Ycc.h at position 1 does not match Yuc.h at that position
```
Exemplo (antes)
```
  cl /c /Wall /Ycc.h -I.. X.cpp
  cl /c /Wall /Yuc.h Z.cpp
```
Exemplo (depois)
```
  cl /c /Wall /Ycc.h -I.. X.cpp
  cl /c /Wall /Yuc.h -I.. Z.cpp
```

O que há de novo no C++ no Visual Studio 2013

Suporte melhorado às normas ISO C/C++

Compilador

O MSVC suporta estes recursos de linguagem ISO C++11:

Argumentos de modelo padrão para modelos de função.
Delegação de construtores
Operadores de conversão explícitos.
Listas de inicializadores e inicialização uniforme.
Literais de cadeia de texto bruta.
Modelos variádicos.
Modelos de alias.
Funções excluídas.
Inicializadores de membros de dados não estáticos (NSDMIs).
Funções predefinidas. *
Suporta estes recursos de linguagem ISO C99:
_Bool
Literais compostos.
Inicializadores designados.
Misturando declarações com código.
A conversão literal de cadeia de caracteres para valores modificáveis pode ser proibida usando a nova opção /Zc:strictStringsde compilador. Em C++98, a conversão de literais de cadeia de caracteres para char* (e literais de cadeia de caracteres larga para wchar_t*) foi considerada obsoleta. Em C++11, a conversão foi totalmente removida. Embora o compilador possa estar estritamente em conformidade com o padrão, ele fornece a opção /Zc:strictStrings para que você possa controlar a conversão. Por padrão, a opção está desativada. Observe que quando você estiver usando essa opção no modo de depuração, o STL não será compilado.
Moldes de referência rvalue/lvalue. Graças às referências de rvalue, o C++11 consegue distinguir claramente entre lvalues e rvalues. Anteriormente, o compilador não fornecia isso em cenários de transmissão específicos. Uma nova opção de compilador, /Zc:rvalueCast, foi adicionada para tornar o compilador compatível com o documento de trabalho da linguagem C++ (veja a seção 5.4, [expr.cast]/1). O comportamento padrão quando essa opção não é especificada é o mesmo que no Visual Studio 2012.

Observação

Para funções padrão, não há suporte para o uso de =default para solicitar construtores de movimentação de membros e operadores de atribuição de movimento.

Bibliotecas C99

Declarações e implementações são adicionadas para funções ausentes nesses cabeçalhos: math.h, ctype.h, wctype.h, stdio.h, stdlib.h e wchar.h. Também são adicionados os novos cabeçalhos complex.h, stdbool.h, fenv.h e inttypes.h, e implementações para todas as funções declaradas neles. Existem novos cabeçalhos de wrapper C++ (ccomplex, cfenv, cinttypes, ctgmath) e vários outros são atualizados (ccomplex, cctype, clocale, cmath, cstdint, cstdio, cstring, cwchar e cwctype).

Biblioteca de modelos padrão

Suporte para operadores de conversão explícitos C++11, listas de inicializadores, enums com escopo e modelos variádicos. Todos os contêineres agora suportam os requisitos de elementos refinados do C++11. Suporte para estes recursos do C++14:

"Functores de operador transparentes" menos<>, maior<>, mais<>, multiplica,<> e assim por diante.
<make_unique T>(args...) e make_unique<T[]>(n)
cbegin()/cend(), rbegin()/rend() e crbegin()/crend() funções não-membros.
<A Atomic> recebeu inúmeras melhorias de desempenho.
< > type_traits recebeu grandes estabilizações e correções de código.

Alterações Disruptivas

Esse suporte aprimorado para padrões ISO C/C++ pode exigir alterações no código existente para que ele esteja em conformidade com C++11 e compile corretamente no Visual C++ no Visual Studio 2013.

Aprimoramentos da biblioteca do Visual C++

C++ REST SDK é adicionado. Tem uma implementação C++ moderna de serviços REST.
O suporte a textura C++ AMP é aprimorado. Agora inclui suporte para mipmaps e novos modos de amostragem.
As tarefas PPL suportam várias tecnologias de agendamento e depuração assíncrona. Novas APIs permitem a criação de tarefas PPL para resultados normais e condições de exceção.

Desempenho de aplicativos C++

O Auto-Vectorizer agora reconhece e otimiza mais padrões C++ para tornar seu código executado mais rapidamente.
Melhorias na qualidade do código da plataforma ARM e da microarquitetura Atom.
A convenção de chamada __vectorcall foi adicionada. Passe argumentos de tipo de vetor usando a convenção de chamada __vectorcall para usar registros de vetor.
Novas opções de vinculação. Os interruptores /Gw (compilador) e /Gy (assembler) permitem otimizações do vinculador para produzir binários mais enxutos.
Suporte de memória partilhada do C++ AMP para reduzir ou eliminar a troca de dados entre CPU e GPU.

Aprimoramentos de otimização guiada por perfil (PGO)

Melhorias no desempenho resultantes da redução no conjunto de trabalho das aplicações que são otimizadas utilizando Otimização Orientada por Perfil (PGO).
Novo PGO para desenvolvimento de aplicações no Runtime do Windows.

Suporte ao Desenvolvimento de Apps para o Windows Runtime

Suporte para tipos encapsulados em estruturas de valor.

Agora você pode definir tipos de valor usando campos que podem ser nulos, por exemplo, IBox<int>^ em vez de int. Isso significa que os campos podem ter um valor ou ser igual a nullptr.
Informações de exceção mais ricas.

C++/CX suporta o novo modelo de erro do Windows que permite a captura e propagação de informações de exceção avançadas através da interface binária do aplicativo (ABI); Isso inclui pilhas de chamadas e cadeias de caracteres de mensagens personalizadas.
Object::ToString() agora é virtual.

Agora pode substituir ToString em tipos ref do Windows Runtime definidos pelo utilizador.
Suporte para APIs obsoletas.

As APIs públicas do Tempo de Execução do Windows agora podem ser marcadas como preteridas e receber uma mensagem personalizada que aparece como um aviso de compilação e pode fornecer diretrizes de migração.
Melhorias do Depurador.

Suporte para depuração de interoperabilidade nativa/JavaScript, diagnóstico de exceção do Tempo de Execução do Windows e depuração de código assíncrono (Tempo de Execução do Windows e PPL).

Observação

Além dos recursos e aprimoramentos específicos do C++ descritos nesta seção, outros aprimoramentos no Visual Studio também podem ajudá-lo a escrever melhores aplicativos do Tempo de Execução do Windows.

Aprimoramentos de diagnóstico

Melhorias no depurador. Suporte para depuração assíncrona e depuração "Just My Code" (apenas o meu código).
Categorias de análise de código. Agora você pode visualizar a saída categorizada do Analisador de Código para ajudá-lo a encontrar e corrigir defeitos de código.
Diagnóstico XAML. Agora você pode diagnosticar problemas de capacidade de resposta da interface do usuário e uso de bateria em seu XAML.
Melhorias na depuração de gráficos e GPU.
Captura e reprodução remotas em dispositivos reais.
Depuração simultânea de C++ AMP e CPU.
Diagnóstico de tempo de execução C++ AMP melhorado.
Debug de rastreamento de shader de computação HLSL.

Aprimoramentos gráficos 3D

Suporte ao Image Content Pipeline para o formato alfa DDS pré-multiplicado.
O Editor de Imagens usa alfa pré-multiplicado internamente para renderização e, assim, evita artefatos de renderização, como halos escuros.
Editores de Imagem e Modelo. A criação de filtros definidos pelo usuário agora é suportada no Shader Designer no Editor de Imagens e no Editor de Modelos.

IDE e Produtividade

Formatação de código melhorada. Você pode aplicar mais configurações de formatação ao seu código C++. Usando essas configurações, você pode controlar o posicionamento de novas linhas de chaves e palavras-chave, recuo, espaçamento e quebra de linha. O código é formatado automaticamente quando você conclui instruções e blocos e quando cola o código em um arquivo.

Conclusão da cinta. O código C++ agora completa automaticamente os caracteres de fechamento que correspondem a esses caracteres de abertura:

{ (cinta encaracolada)
[ (colchete)
( (parênteses)
' (aspas simples)
" (aspas duplas)

Recursos adicionais de preenchimento automático do C++.

Adiciona um ponto-e-vírgula para tipos de classe.
Completa parênteses para literais de cadeia de caracteres brutos.
Completa comentários de várias linhas (/* */)

Localizar Todas as Referências agora resolve e filtra automaticamente as referências em segundo plano depois de exibir a lista de correspondências textuais.

Context-Based filtragem da lista de membros. Os membros inacessíveis são filtrados das listas de membros do IntelliSense. Por exemplo, os membros privados não são exibidos na lista de membros, a menos que você esteja modificando o código que implementa o tipo. Enquanto a lista de membros estiver aberta, você pode pressionar Ctrl+J para remover um nível de filtragem (aplica-se apenas à janela atual da lista de membros). Você pode pressionar Ctrl+J novamente para remover a filtragem de texto e mostrar todos os membros.

Parâmetro Ajuda a rolagem. A assinatura de função exibida na dica de ferramenta de ajuda de parâmetros agora muda com base no número de parâmetros que você realmente digitou, em vez de apenas mostrar uma assinatura arbitrária e não atualizá-la com base no contexto atual. A assistência para parâmetros também funciona corretamente quando exibida em funções aninhadas.

Alterne o arquivo de cabeçalho/código. Agora você pode alternar entre um cabeçalho e seu arquivo de código correspondente usando um comando no menu de atalho ou um atalho de teclado.

Janela de propriedades do projeto C++ redimensionável

Geração automática de código do manipulador de eventos em C++/CX e C++/CLI. Quando você estiver digitando código para adicionar um manipulador de eventos em um arquivo de código C++/CX ou C++/CLI, o editor pode gerar automaticamente a instância delegada e a definição do manipulador de eventos. Uma janela de tooltip aparece quando o código do manipulador de eventos pode ser gerado automaticamente.

Aprimoramento da conscientização do DPI. A configuração de reconhecimento de DPI para ficheiros de manifesto de aplicações agora admite a configuração "Per Monitor High DPI Aware".

Comutação de configuração mais rápida. Para aplicações grandes, as configurações de comutação, especialmente as operações de comutação subsequentes, são executadas muito mais rapidamente.

Eficiência do tempo de construção. Inúmeras otimizações e utilização de vários núcleos tornam as compilações mais rápidas, especialmente para grandes projetos. Compilações incrementais para aplicativos C++ que têm referências ao C++ WinMD também são muito mais rápidas.

O que há de novo no C++ no Visual Studio 2012

Suporte aprimorado aos padrões C++11

Biblioteca de modelos padrão

Suporte para novos cabeçalhos STL: <atomic>, <chrono>, <condition_variable>, <filesystem>, <future>, <mutex>, <ratio> e <thread>.
Para otimizar o uso de recursos de memória, os contêineres agora são menores. Por exemplo, no modo de lançamento x86 com configurações padrão, std::vector diminuiu de 16 bytes no Visual Studio 2010 para 12 bytes no Visual Studio 2012 e std::map encolheu de 16 bytes no Visual Studio 2010 para 8 bytes no Visual Studio 2012.
Conforme permitido, mas não exigido pelo padrão C++11, os iteradores SCARY foram implementados.

Outros aprimoramentos do C++11

Loops baseados em intervalos. Você pode escrever loops mais robustos que funcionam com matrizes, contentores STL e coleções do Runtime do Windows no formato for ( for-range-declaration : expression ). Isso faz parte do suporte ao idioma principal.
Lambdas sem estado, que são blocos de código que começam com um introdutor lambda vazio [] e não capturam variáveis locais, agora são implicitamente conversíveis em ponteiros de função, conforme exigido pelo padrão C++11.

Suporte a enumerações delimitadas. A classe enum C++ enum-key agora é suportada. O código a seguir demonstra como essa chave de enum difere do comportamento anterior de enum.

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

Suporte ao Desenvolvimento de Apps para o Windows Runtime

Modelo de interface do usuário nativo baseado em XAML. Para aplicativos do Tempo de Execução do Windows, você pode usar o novo modelo de interface do usuário nativo baseado em XAML.
Extensões de componente do Visual C++. Essas extensões simplificam o consumo de objetos Windows Runtime, que são uma parte necessária dos aplicativos Windows Runtime. Para obter mais informações, consulte Roteiro para apps do Windows Runtime em C++ e referência de linguagem do Visual C++ (C++/CX)
Jogos DirectX. Você pode desenvolver jogos atraentes usando o novo suporte a DirectX para aplicativos do Tempo de Execução do Windows.
Interoperabilidade XAML/DirectX. Os aplicativos do Tempo de Execução do Windows que usam XAML e DirectX agora interoperam de forma eficiente.
Desenvolvimento de DLL de Componentes de Tempo de Execução do Windows. O desenvolvimento de DLL de componentes torna o ambiente do Tempo de Execução do Windows extensível.

Compilador e Ligador

Auto-vetorizador. O compilador analisa loops em seu código e, sempre que possível, emite instruções que usam os registradores vetoriais e instruções que estão presentes em todos os processadores modernos. Isso faz com que os loops sejam executados mais rapidamente. (As instruções do processador são conhecidas como SSE, para extensões Streaming SIMD). Não é necessário ativar ou solicitar essa otimização porque ela é aplicada automaticamente.
Auto-paralelizador. O compilador pode analisar loops em seu código e emitir instruções que distribuem os cálculos por vários núcleos ou processadores. Isso pode fazer com que os loops sejam executados mais rapidamente. Você deve solicitar essa otimização porque ela não está habilitada por padrão. Em muitos casos, ajuda incluir um #pragma loop(hint_parallel(N)) em seu código imediatamente antes dos loops que você deseja paralelizar.
O autovetorizador e o auto-paralelizador podem trabalhar em conjunto, permitindo que os cálculos sejam realizados em múltiplos núcleos, com o código em cada núcleo utilizando seus registradores vetoriais.

Novo no Visual Studio 2012 Atualização 1

Defina o Windows XP como alvo ao compilar código C++. Você pode usar o compilador e as bibliotecas do Microsoft C++ para direcionar o Windows XP e o Windows Server 2003.

Suporte à programação paralela

Paralelismo Maciço Acelerado (AMP) em C++

O C++ AMP acelera a execução do seu código C++ aproveitando o hardware paralelo de dados que normalmente está presente como uma GPU em uma placa gráfica discreta. O modelo de programação AMP C++ inclui matrizes multidimensionais, indexação, transferência de memória, mosaico e uma biblioteca de funções matemáticas. Usando extensões de linguagem AMP C++ e restrições do compilador, você pode controlar como os dados são movidos da CPU para a GPU e vice-versa.

Depuração. A experiência de depuração para aplicações que utilizam C++ AMP para direcionar a GPU é semelhante à depuração de outras aplicações C++. Isso inclui as novas adições de depuração paralela mencionadas anteriormente.

Definição de perfis. Agora há suporte de criação de perfil para atividade de GPU baseada em C++ AMP e outros modelos de programação baseados em Direct3D.

Aprimoramentos gerais de programação paralela

Com o hardware a mudar para arquiteturas multi-núcleo e muitos-núcleos, os desenvolvedores não podem mais confiar em velocidades de relógio cada vez maiores de núcleos únicos. O suporte de programação paralela no Concurrency Runtime permite que os desenvolvedores aproveitem essas novas arquiteturas. No Visual Studio 2010, poderosas bibliotecas de paralelização C++, como a Biblioteca de Padrões Paralelos, foram introduzidas, juntamente com recursos para aproveitar a simultaneidade expressando pipelines de fluxo de dados sofisticados. No Visual Studio 2012, essas bibliotecas foram estendidas para fornecer melhor desempenho, mais controle e suporte mais avançado para os padrões paralelos de que os desenvolvedores mais precisam. A amplitude da oferta agora inclui:

Um modelo de programação rico baseado em tarefas que suporta assincronia e continuações.
Algoritmos paralelos, que suportam paralelismo fork-join (parallel_for, parallel_for com afinidade, parallel_for_each, parallel_sort, parallel_reduce, parallel_transform).
Contêineres seguros para simultaneidade, que fornecem versões thread-safe de estruturas de dados std, como priority_queue, fila, vetor e mapa.
A Biblioteca de Agentes Assíncronos, que os desenvolvedores podem usar para expressar pipelines de fluxo de dados que naturalmente se decompõem em unidades simultâneas.
Um agendador personalizável e um gerenciador de recursos para facilitar a composição suave dos padrões nesta lista.

Aprimoramentos gerais de depuração paralela

Além da janela Tarefas paralelas e da janela Pilhas paralelas, o Visual Studio 2012 oferece uma nova janela Observação Paralela para que possa examinar os valores de uma expressão em todos os threads e processos, e ordenar e filtrar o resultado. Você também pode usar seus próprios visualizadores para estender a janela e pode aproveitar o novo suporte a vários processos em todas as janelas de ferramentas.

IDE

Suporte a modelos do Visual Studio. Agora você pode usar a tecnologia de modelos do Visual Studio para criar modelos de projeto e item C++.

Carga assíncrona da solução. Os projetos agora são carregados de forma assíncrona — as principais partes da solução primeiro — para que você possa começar a trabalhar mais rapidamente.

Implantação automatizada para debugging remoto. A implantação de arquivos para depuração remota no Visual C++ foi simplificada. A opção Implantar no menu de contexto do projeto copia automaticamente para o computador remoto os arquivos especificados nas propriedades de configuração de depuração. Não é mais necessário copiar arquivos manualmente para o computador remoto.

C++/CLI IntelliSense. C++/CLI agora tem suporte total ao IntelliSense. Os recursos do IntelliSense, como Informações Rápidas, Ajuda de Parâmetros, Membros da Lista e Conclusão Automática, agora funcionam para C++/CLI. Além disso, os outros aprimoramentos do IntelliSense e do IDE listados neste documento também funcionam para C++/CLI.

Dicas de ferramentas mais ricas do IntelliSense. As dicas de ferramentas C++ IntelliSense Quick Info agora mostram informações de estilo de comentários de documentação XML mais ricas. Se estiver a usar uma API de uma biblioteca, por exemplo, C++ AMP, que tenha comentários de documentação XML, o tooltip do IntelliSense mostrará mais informações do que apenas a declaração. Além disso, se o seu código tiver comentários da documentação XML, as dicas do IntelliSense mostrarão informações mais detalhadas.

Construções de código C++. O código esqueleto está disponível para switch, if-else, for loop e outras construções de código básico, na lista suspensa List Members. Selecione um pedaço de código da lista para inseri-lo em seu código e, em seguida, preencha a lógica necessária. Você também pode criar suas próprias partes personalizadas de código para uso no editor.

Aprimoramentos em listas de membros. A lista suspensa Membros da lista aparece automaticamente quando você digita o código no editor de códigos. Os resultados são filtrados, para que apenas os membros relevantes sejam exibidos enquanto você digita. Você pode controlar o tipo de lógica de filtragem usada pela Lista de Membros — na caixa de diálogo Opções em Editor de Texto>C/C++>Avançado.

Coloração Semântica. Tipos, enumerações, macros e outros tokens C++ agora têm colorização por padrão.

Destaque de referência. A seleção de um símbolo agora realça todas as ocorrências do símbolo no arquivo atual. Pressione Ctrl+Shift+Seta para cima ou Ctrl+Shift+Seta para baixo para mover-se entre as referências realçadas. Você pode desativar esse recurso na caixa de diálogo Opções, em Editor> de TextoC/C++>Avançado.

Ferramentas de gerenciamento do ciclo de vida do aplicativo

Análise estática de código

A análise estática para C++ foi atualizada para fornecer informações de contexto de erro mais ricas, mais regras de análise e melhores resultados de análise. Na nova janela Análise de código, você pode filtrar mensagens por palavra-chave, projeto e gravidade. Quando você seleciona uma mensagem na janela, a linha no código onde a mensagem foi acionada é realçada no editor de código. Para determinados avisos C++, a mensagem lista linhas de origem que mostram o caminho de execução que leva ao aviso; Os pontos de decisão e as razões para tomar esse caminho específico são destacados. A análise de código está incluída na maioria das edições do Visual Studio 2012. Nas edições Professional, Premium e Ultimate, todas as regras estão incluídas. Nas edições Express para Windows 8 e Windows Phone, apenas os avisos mais críticos estão incluídos. A análise de código não está incluída na edição Express para Web. Aqui estão alguns outros aprimoramentos de análise de código:

Novos avisos de simultaneidade ajudam a evitar bugs de simultaneidade, certificando-se de que você está usando as disciplinas de bloqueio corretas em programas C/C++ multithreaded. O analisador detecta possíveis condições de corrida, inversões de ordem de bloqueio, violações de contrato de bloqueio de chamador/receptor, operações de sincronização incompatíveis e outros bugs de concorrência.
Você pode especificar as regras C++ que deseja aplicar a execuções de análise de código usando conjuntos de regras.
Na janela Análise de código , você pode inserir no código-fonte um pragma que suprime um aviso selecionado.
Você pode melhorar a precisão e a integridade da análise de código estático usando a nova versão da linguagem de anotação de código-fonte (SAL) da Microsoft para descrever como uma função usa seus parâmetros, as suposições que faz sobre eles e as garantias que faz quando termina.
Suporte para projetos C++ de 64 bits.

Estrutura de teste de unidade atualizada

Use a nova estrutura de teste de unidade C++ no Visual Studio para escrever testes de unidade C++. Adicione um novo projeto de teste de unidade à sua solução C++ existente localizando o modelo Projeto de Teste de Unidade C++ na categoria Visual C++ na caixa de diálogo Novo Projeto. Comece a escrever seus testes de unidade no stub de código de TEST_METHOD gerado no arquivo Unittest1.cpp. Quando o código de teste for escrito, crie a solução. Quando quiser executar os testes, abra uma janela do Explorer de Testes de Unidade escolhendo Exibir>Outras Janelas>Explorer de Testes de Unidade, e, em seguida, no menu de atalho para o caso de teste desejado, escolha Executar teste selecionado. Após a conclusão da execução do teste, você pode exibir os resultados do teste e informações adicionais de rastreamento de pilha na mesma janela.

Gráficos de dependência de arquitetura

Para entender melhor seu código, agora você pode gerar gráficos de dependência para o binário, classe, namespace e incluir arquivos em uma solução. Na barra de menus, escolha Architecture>Generate Dependency Graph e, em seguida, For Solution ou For Include File para gerar um gráfico de dependência. Quando a geração do gráfico estiver concluída, você poderá explorá-lo expandindo cada nó, aprender relações de dependência movendo-se entre nós e procurar o código-fonte escolhendo Exibir conteúdo no menu de atalho de um nó. Para gerar um gráfico de dependência para arquivos de inclusão, no menu de atalho para um arquivo de código-fonte *.cpp ou arquivo de cabeçalho *.h, escolha Gerar gráfico de arquivos de inclusão.

Explorador de Arquitetura

Usando o Architecture Explorer, você pode explorar os ativos em sua solução, projetos ou arquivos C++. Na barra de menus, escolha Architecture>Windows>Architecture Explorer. Você pode selecionar um nó em que está interessado, por exemplo, Modo de Exibição de Classe. Nesse caso, o lado direito da janela da ferramenta é expandido com uma lista de namespaces. Se você selecionar um namespace, uma nova coluna mostrará uma lista das classes, structs e enums nesse namespace. Você pode continuar a explorar esses ativos ou voltar para a coluna à esquerda para iniciar outra consulta. Consulte Localizar código com o Architecture Explorer.

Cobertura de código

A cobertura de código foi atualizada com a finalidade de instrumentar os binários de forma dinâmica durante a execução. Isso reduz a sobrecarga de configuração e fornece melhor desempenho. Você também pode recolher dados de cobertura de código dos testes unitários para aplicações C++. Depois de criar testes de unidade C++, você pode usar o Gerenciador de Teste de Unidade para descobrir testes em sua solução. Para executar os testes de unidade e coletar dados de cobertura de código para eles, no Gerenciador de Teste de Unidade, escolha Analisar Cobertura de Código. Você pode examinar os resultados da cobertura de código na janela Resultados da cobertura de código — na barra de menus, escolha Testar>resultados da cobertura de código>.

O que há de novo no C++ no Visual Studio 2010

Compilador e vinculador C++

auto Palavra-chave. A auto palavra-chave tem uma nova finalidade. Use o significado padrão da auto palavra-chave para declarar uma variável cujo tipo é deduzido da expressão de inicialização na declaração da variável. A /Zc:auto opção do compilador invoca o significado novo ou anterior da auto palavra-chave.

Especificador de tipo decltype. O decltype especificador de tipo retorna o tipo de uma expressão especificada. Use o decltype especificador de tipo em combinação com a auto palavra-chave para declarar um tipo que é complexo ou conhecido apenas pelo compilador. Por exemplo, use a combinação para declarar uma função de modelo cujo tipo de retorno depende dos tipos de seus argumentos de modelo. Ou, declare uma função de modelo que chama outra função e, em seguida, retorna o tipo de retorno da função chamada.

Expressões Lambda. As funções do Lambda têm um corpo de função, mas não um nome. As funções do Lambda combinam as melhores características de ponteiros de função e objetos de função. Use uma função lambda por si só, como um parâmetro de função de modelo em vez de um objeto de função, ou junto com a auto palavra-chave para declarar uma variável cujo tipo é um lambda.

Referência Rvalue. O declarador de referência rvalue (&&) declara uma referência a um rvalue. Uma referência rvalue permite que você use semântica de movimento e encaminhamento perfeito para escrever construtores, funções e modelos mais eficientes.

static_assert Declaração. Uma static_assert declaração testa uma asserção de software em tempo de compilação, ao contrário de outros mecanismos de asserção que testam em tempo de execução. Se a asserção falhar, a compilação falhará e uma mensagem de erro especificada será emitida.

nullptr e __nullptr Palavras-chave. MSVC permite que você use a nullptr palavra-chave com código nativo ou com código gerenciado. A nullptr palavra-chave indica que um identificador de objeto, ponteiro interior ou tipo de ponteiro nativo não aponta para um objeto. O compilador interpreta nullptr como código gerenciado quando você usa a /clr opção de compilador e código nativo quando você não usa a /clr opção. A palavra-chave __nullptr específica da Microsoft tem o mesmo significado nullptrque , mas aplica-se apenas ao código nativo. Se você compilar código C/C++ nativo usando a /clr opção de compilador, o compilador não poderá determinar se a nullptr palavra-chave é um termo nativo ou gerenciado. Para deixar sua intenção clara para o compilador, use a palavra-chave nullptr para especificar o termo gerenciado e __nullptr para especificar o termo nativo.

/Zc:trigraphs Opção do compilador. Por padrão, o suporte para trígrafos está desativado. Use a opção do compilador /Zc:trigraphs para ativar o suporte a trigrafos. Um trígrafo consiste em dois pontos de interrogação consecutivos (??) seguidos por um terceiro caractere único. O compilador substitui um trígrafo com o caractere de pontuação correspondente. Por exemplo, o compilador substitui o ?? = trígrafo com o caractere # (sinal numérico). Use trígrafos em ficheiros de código fonte C que utilizam o conjunto de caracteres que não contém certos caracteres de pontuação.

Nova Opção de Otimização Profile-Guided. O PogoSafeMode é uma nova opção de otimização guiada por perfil que permite especificar se deseja usar o modo de segurança ou o modo rápido ao otimizar seu aplicativo. O modo de segurança é thread-safe, mas é mais lento do que o modo rápido. O modo rápido é o comportamento padrão.

Nova opção CLR (Common Language Runtime) /clr:nostdlib. Uma nova opção é adicionada para /clr (Common Language Runtime Compilation). Se diferentes versões das mesmas bibliotecas forem incluídas, um erro de compilação será emitido. A nova opção permite excluir as bibliotecas CLR padrão para que seu programa possa usar uma versão especificada.

Nova diretiva pragma detect_mismatch (detetar_incompatibilidade). A diretiva pragma detect_mismatch permite que você coloque uma tag em seus arquivos que é comparada a outras tags que têm o mesmo nome. Se houver vários valores para o mesmo nome, o vinculador emitirá um erro.

XOP Intrinsics, FMA4 Intrinsics e LWP Intrinsics. Novas funções intrínsecas foram adicionadas para suportar o XOP Intrinsics Adicionado para Visual Studio 2010 SP1, FMA4 Intrinsics Adicionado para Visual Studio 2010 SP1 e LWP Intrinsics Adicionado para tecnologias de processador Visual Studio 2010 SP1. Use __cpuid __cpuidex para determinar quais tecnologias de processador são suportadas em um determinado computador.

Projetos do Visual Studio C++ e o sistema de compilação

MSBuild. Soluções e projetos do Visual C++ agora são criados usando MSBuild.exe, que substitui VCBuild.exe. MSBuild é a mesma ferramenta de compilação flexível, extensível e baseada em XML que é usada por outras linguagens do Visual Studio e tipos de projeto. Devido a essa alteração, os arquivos de projeto do Visual Studio C++ agora usam um formato de arquivo XML e têm a extensão de nome de arquivo .vcxproj. Os arquivos de projeto do Visual Studio C++ de versões anteriores do Visual Studio são convertidos automaticamente para o novo formato de arquivo.

Diretórios VC++. A configuração de diretórios VC++ agora está localizada em dois locais. Use páginas de propriedades do projeto para definir valores por projeto para diretórios VC++. Use o Gerenciador de propriedades e uma folha de propriedades para definir valores globais por configuração para diretórios VC++.

Dependências de projeto para projeto. Em versões anteriores, dependências definidas entre projetos eram armazenadas no arquivo de solução. Quando essas soluções são convertidas para o novo formato de arquivo de projeto, as dependências são convertidas em referências de projeto para projeto. Essa alteração pode afetar os aplicativos porque os conceitos de dependências de solução e referências de projeto para projeto são diferentes.

Macros e variáveis de ambiente. A nova macro _ITERATOR_DEBUG_LEVEL invoca o suporte de depuração para iteradores. Use esta macro em vez das macros _SECURE_SCL e _HAS_ITERATOR_DEBUGGING mais antigas.

Bibliotecas do Visual C++

Bibliotecas de tempo de execução de concorrência. A estrutura Concurrency Runtime oferece suporte a aplicativos e componentes que são executados simultaneamente e é a estrutura para programação de aplicativos simultâneos no Visual C++. Para dar suporte à programação de aplicativos simultâneos, a Biblioteca de Padrões Paralelos (PPL) fornece contêineres e algoritmos de uso geral para executar paralelismo refinado. A Biblioteca de Agentes Assíncronos fornece um modelo de programação baseado em ator e interfaces de passagem de mensagens para tarefas de fluxo de dados e pipelining de granularidade grosseira.

Biblioteca C++ padrão. A lista a seguir descreve muitas das alterações que foram feitas na biblioteca C++ padrão.

O novo recurso de linguagem C++ de referência rvalue foi usado para implementar semântica de movimento e encaminhamento perfeito para muitas funções na Biblioteca de Modelos Padrão. A semântica de movimento e o encaminhamento perfeito melhoram muito o desempenho de operações que alocam ou atribuem variáveis ou parâmetros.
As referências Rvalue também são usadas para implementar a nova unique_ptr classe, que é um tipo de ponteiro inteligente mais seguro do que a auto_ptr classe. A unique_ptr classe é movível, mas não copiável; implementa uma semântica de propriedade estrita sem afetar a segurança e funciona bem com contentores que reconhecem referências de rvalue. A auto_ptr classe foi preterida.
Quinze novas funções, por exemplo, find_if_not, copy_if, e is_sorted, foram adicionadas ao cabeçalho do <algoritmo>.
No cabeçalho de <memória>, a nova função make_shared é uma maneira conveniente, robusta e eficiente de criar um ponteiro partilhado para um objeto, simultaneamente à construção do objeto.
As listas vinculadas individualmente são suportadas <pelo cabeçalho forward_list> .
As novas funções membro cbegin, cend, crbegin e crend fornecem um const_iterator que se move para a frente ou para trás através de um contentor.
O <cabeçalho de erro_do_sistema> e os modelos relacionados suportam o processamento de erros de nível baixo do sistema. Os membros da exception_ptr classe podem ser usados para transportar exceções entre threads.
O <cabeçalho codecvt> suporta a conversão de várias codificações de caracteres Unicode para outras codificações.
O <cabeçalho dos alocadores> define vários modelos que ajudam a alocar e liberar blocos de memória para contêineres baseados em nós.
Existem inúmeras atualizações do <cabeçalho aleatório>.

Biblioteca do Microsoft Foundation Class (MFC)

Recursos do Windows 7. O MFC suporta muitos recursos do Windows 7, por exemplo, a interface do usuário (UI) da Faixa de Opções, a Barra de Tarefas, listas de atalhos, miniaturas com guias, visualizações de miniaturas, a barra de progresso, a sobreposição de ícones e a indexação de pesquisa. Como o MFC suporta automaticamente muitos recursos do Windows 7, talvez não seja necessário modificar seu aplicativo existente. Para oferecer suporte a outros recursos em novos aplicativos, use o MFC Application Wizard para especificar a funcionalidade que você deseja usar.

Deteção Multi-touch. O MFC suporta aplicações que têm uma interface de utilizador multitoque, por exemplo, aplicações que são escritas para o sistema operativo Microsoft Surface. Um aplicativo multitoque pode lidar com mensagens de toque do Windows e mensagens de gestos, que são combinações de mensagens de toque. Basta registrar seu aplicativo para eventos de toque e gesto e o sistema operacional encaminhará eventos multitoque para seus manipuladores de eventos.

High-DPI Consciencialização. Por padrão, os aplicativos MFC agora reconhecem alto DPI. Se um aplicativo estiver ciente de High-DPI (pontos altos por polegada), o sistema operacional poderá dimensionar janelas, texto e outros elementos da interface do usuário para a resolução de tela atual. Isso significa que é mais provável que uma imagem dimensionada seja corretamente formatada e não seja cortada ou pixelizada.

Reinicie o Gestor. O gerenciador de reinicialização salva automaticamente documentos e reinicia seu aplicativo se ele fechar ou reiniciar inesperadamente. Por exemplo, você pode usar o gerenciador de reinicialização para iniciar seu aplicativo depois que ele for fechado por uma atualização automática. Para obter mais informações sobre como configurar seu aplicativo para usar o gerenciador de reinicialização, consulte Como adicionar suporte ao gerenciador de reinicialização.

CTaskDialog. A CTaskDialog classe pode ser usada em vez da caixa de mensagem padrão AfxMessageBox . A CTaskDialog classe exibe e reúne mais informações do que a caixa de mensagem padrão.

Biblioteca SafeInt

A nova Biblioteca SafeInt executa operações aritméticas seguras que levam em conta o estouro de inteiros. Esta biblioteca também compara diferentes tipos de inteiros.

Novas macros ATL (Ative Template Library)

Novas macros foram adicionadas à ATL para expandir a funcionalidade de PROP_ENTRY_TYPE e PROP_ENTRY_TYPE_EX. PROP_ENTRY_INTERFACE e PROP_ENTRY_INTERFACE_EX permitem adicionar uma lista de CLSIDs válidos. PROP_ENTRY_INTERFACE_CALLBACK e PROP_ENTRY_INTERFACE_CALLBACK_EX permitem especificar uma função de retorno de chamada para determinar se um CLSID é válido.

/analisar Avisos

A maioria dos /analyze avisos (Enterprise Code Analysis) foram removidos das bibliotecas C Run-Time (CRT), MFC e ATL.

Animação e suporte D2D

MFC agora suporta animação e gráficos Direct2D. A biblioteca MFC tem várias novas classes MFC e funções para suportar esta funcionalidade. Há também duas novas instruções passo a passo para mostrar como adicionar um objeto D2D e um objeto de animação a um projeto. Estas instruções passo a passo são Passo a passo: Adicionando um objeto D2D a um projeto MFC e Passo a passo: Adicionando animação a um projeto MFC.

IDE

IntelliSense melhorado. O IntelliSense para Visual C++ foi completamente redesenhado para ser mais rápido, preciso e capaz de lidar com projetos maiores. Para alcançar essa melhoria, o IDE faz uma distinção entre como um desenvolvedor visualiza e modifica o código-fonte e como o IDE usa o código-fonte e as configurações do projeto para criar uma solução. Devido a esta separação de tarefas, as funcionalidades de navegação, como a Vista de Classes e a nova caixa de diálogo Navegar para, são geridas por um sistema baseado num novo ficheiro de base de dados de ambiente de trabalho (.sdf) do SQL Server que substitui o antigo ficheiro de navegação sem compilação (.ncb). Os recursos do IntelliSense, como Informações rápidas, Preenchimento automático e Ajuda de parâmetros, analisam unidades de tradução somente quando necessário. Recursos híbridos, como a nova janela Hierarquia de chamadas , usam uma combinação dos recursos de navegação e IntelliSense. Como o IntelliSense processa apenas as informações necessárias no momento, o IDE é mais responsivo. Além disso, como as informações são mais atualizadas, as visualizações e janelas do IDE são mais precisas. Finalmente, como a infraestrutura IDE é melhor organizada, mais capaz e mais escalável, ela pode lidar com projetos maiores.

Erros do IntelliSense melhorados. A IDE deteta melhor os erros que podem causar a perda do IntelliSense e exibe sublinhados ondulados vermelhos sob estes. Além disso, o IDE relata erros do IntelliSense na janela Lista de erros. Para exibir o código que está causando o problema, clique duas vezes no erro na janela Lista de erros.

#include função de preenchimento automático. O IDE suporta preenchimento automático para a #include palavra-chave. Quando você digita #include, o IDE cria uma caixa de listagem suspensa de arquivos de cabeçalho válidos. Se você continuar digitando um nome de arquivo, o IDE filtrará a lista com base na sua entrada. A qualquer momento, você pode selecionar na lista o arquivo que deseja incluir. Isso permite que você inclua arquivos rapidamente sem saber o nome exato do arquivo.

Ir Para A caixa de diálogo Navegar para permite pesquisar todos os símbolos e arquivos em seu projeto que correspondem a uma cadeia de caracteres especificada. Os resultados da pesquisa são imediatamente revistos à medida que escreve carateres adicionais na cadeia de pesquisa. O campo Comentários dos resultados indica-lhe o número de itens encontrados e ajuda-o a decidir se pretende restringir a sua pesquisa. Os campos Tipo/Escopo, Localização e Pré-visualização ajudam a desambiguar itens que têm nomes semelhantes. Além disso, você pode estender esse recurso para suportar outras linguagens de programação.

Depuração paralela e criação de perfis. O depurador do Visual Studio está ciente do Concurrency Runtime e ajuda você a solucionar problemas de aplicativos de processamento paralelo. Você pode usar a nova ferramenta de criação de perfil de simultaneidade para visualizar o comportamento geral do seu aplicativo. Além disso, você pode usar novas janelas de ferramentas para visualizar o estado das tarefas e suas pilhas de chamadas.

Designer de Faixa de Opções. O Designer da Faixa de Opções é um editor gráfico que permite criar e modificar uma interface de utilizador da faixa de opções MFC. A IU final da faixa de opções é representada por um ficheiro de recursos baseado em XML (.mfcribbon-ms). Para aplicativos existentes, você pode capturar sua interface do usuário atual da faixa de opções adicionando temporariamente algumas linhas de código e, em seguida, invocando o Designer da Faixa de Opções. Depois que o arquivo de recurso da faixa de opções for criado, você poderá substituir o código manuscrito da interface do usuário da faixa de opções por algumas instruções que carregam o recurso da faixa de opções.

Hierarquia de chamadas. A janela Hierarquia de chamadas permite navegar para todas as funções que são chamadas por uma função específica ou para todas as funções que chamam uma função específica.

Ferramentas

Assistente de classe MFC. Visual C++ 2010 traz de volta a bem conceituada ferramenta MFC Class Wizard. O MFC Class Wizard é uma maneira conveniente de adicionar classes, mensagens e variáveis a um projeto sem ter que modificar manualmente conjuntos de arquivos de origem.

Assistente de controle ATL. O ATL Control Wizard não preenche mais automaticamente o ProgID campo. Se um controle ATL não tiver um ProgID, outras ferramentas podem não funcionar com ele. Um exemplo de uma ferramenta que requer que os controles tenham um ProgID é a caixa de diálogo Inserir Controle Ativo . Para obter mais informações sobre a caixa de diálogo, consulte Inserir controles ActiveX.

Referência do Microsoft Macro Assembler

A adição do tipo de dados YMMWORD suporta os operandos multimídia de 256 bits incluídos nas instruções Intel Advanced Vetor Extensions (AVX).

O que há de novo no C++ no Visual Studio 2008

Ambiente de desenvolvimento integrado (IDE) do Visual C++

As caixas de diálogo criadas em aplicativos ATL, MFC e Win32 agora estão em conformidade com as diretrizes de estilo do Windows Vista. Quando você cria um novo projeto usando o Visual Studio 2008, todas as caixas de diálogo inseridas em seu aplicativo estarão em conformidade com a diretriz de estilo do Windows Vista. Se você recompilar um projeto que você criou com uma versão anterior do Visual Studio, todas as caixas de diálogo existentes manterão a mesma aparência que tinham anteriormente. Para obter mais informações sobre como inserir caixas de diálogo em seu aplicativo, consulte Editor de diálogo.
O assistente do projeto ATL agora tem uma opção para o registo de componentes para todos os utilizadores. A partir do Visual Studio 2008, os componentes COM e as bibliotecas de tipos criados pelo assistente de Projeto ATL são registrados no nó HKEY_CURRENT_USER do Registro, a menos que você selecione Registrar componente para todos os usuários.
O assistente de projeto ATL já não disponibiliza uma opção para criar projetos ATL atribuídos. A partir do Visual Studio 2008, o assistente de projeto ATL não tem uma opção para alterar o status atribuído de um novo projeto. Todos os novos projetos ATL criados pelo assistente agora não são atribuídos.
A gravação no registro pode ser redirecionada. Com a introdução do Windows Vista, escrever em determinadas áreas do registro requer que o programa seja executado em modo elevado. Não é desejável sempre executar o Visual Studio no modo elevado. O redirecionamento por usuário redireciona automaticamente as gravações do registro de HKEY_CLASSES_ROOT para HKEY_CURRENT_USER sem alterações de programação.
O Class Designer agora tem suporte limitado para código C++ nativo. Em versões anteriores do Visual Studio, o Class Designer funcionava apenas com Visual C# e Visual Basic. Os usuários do C++ agora podem usar o Class Designer, mas somente no modo somente leitura. Para obter mais informações sobre como usar o Class Designer com C++, consulte Trabalhando com código do Visual C++ no Class Designer.
O assistente de projeto não tem mais uma opção para criar um projeto C++ SQL Server. A partir do Visual Studio 2008, o assistente de criação de novo projeto não inclui uma opção para criar um projeto de C++ SQL Server. Os projetos do SQL Server criados usando uma versão anterior do Visual Studio ainda serão compilados e funcionarão corretamente.

Bibliotecas do Visual C++

Geral

Os aplicativos podem ser vinculados a versões específicas das bibliotecas do Visual C++. Às vezes, um aplicativo depende de atualizações que foram feitas para as bibliotecas do Visual C++ após uma versão. Nesse caso, executar o aplicativo em um computador que tenha versões anteriores das bibliotecas pode causar um comportamento inesperado. Agora você pode vincular um aplicativo a uma versão específica das bibliotecas para que ele não seja executado em um computador que tenha uma versão anterior das bibliotecas.

Biblioteca STL/CLR

Visual C++ agora inclui a biblioteca STL/CLR. A biblioteca STL/CLR é um empacotamento da STL (Standard Template Library), um subconjunto da biblioteca C++ padrão, para uso com C++ e CLR (Common Language Runtime) do .NET Framework. Com STL/CLR, agora você pode usar todos os contêineres, iteradores e algoritmos de STL em um ambiente gerenciado.

Biblioteca MFC

O Windows Vista oferece suporte a controles comuns. Mais de 150 métodos em 18 classes novas ou existentes foram adicionados para oferecer suporte a recursos no Windows Vista ou para melhorar a funcionalidade nas classes MFC atuais.
A nova CNetAddressCtrl classe permite que você insira e valide endereços IPv4 e IPv6 ou nomes DNS.
A nova CPagerCtrl classe simplifica o uso do controle de pager do Windows.
A nova CSplitButton classe simplifica o uso do controle splitbutton do Windows para selecionar uma ação padrão ou opcional.

Biblioteca de suporte C++

C++ apresenta a biblioteca de empacotamento. A biblioteca de marshaling fornece uma maneira fácil e otimizada de transferir dados entre ambientes nativos e geridos. A biblioteca é uma alternativa a abordagens mais complexas e menos eficientes, como o uso do PInvoke. Consulte Visão geral do Marshaling em C++ para obter mais informações.

Servidor ATL

ATL Server é lançado como um projeto de origem compartilhada.
A maioria da base de código do ATL Server foi lançada como um projeto de código-fonte compartilhado no CodePlex e não está instalada como parte do Visual Studio 2008. Vários arquivos associados ao ATL Server não fazem mais parte do Visual Studio. Para obter a lista de arquivos removidos, consulte Arquivos de servidor ATL removidos.
Classes de codificação e decodificação de dados de atlenc.h e funções de utilidade e classes de atlutil.h e atlpath.h agora fazem parte da biblioteca ATL.
A Microsoft continuará a oferecer suporte a versões do ATL Server incluídas em versões anteriores do Visual Studio, desde que essas versões do Visual Studio sejam suportadas. O CodePlex continuará o desenvolvimento do código do ATL Server como um projeto comunitário. A Microsoft não suporta uma versão CodePlex do ATL Server.

Compilador e vinculador do Visual C++

Alterações no compilador

O compilador suporta compilações incrementais gerenciadas. Quando você especifica essa opção, o compilador não recompilará o código quando um assembly referenciado for alterado. Em vez disso, ele executará uma compilação incremental. Os arquivos são recompilados somente se as alterações afetarem o código dependente.
Os atributos relacionados ao ATL Server não são mais suportados. O compilador não suporta mais vários atributos que estavam diretamente relacionados ao ATL Server. Para obter uma lista completa dos atributos removidos, consulte Quebrando alterações.
O compilador suporta microarquitetura Intel Core. O compilador contém ajuste para a microarquitetura Intel Core durante a geração de código. Por padrão, esse ajuste está ativado e não pode ser desativado, pois também ajuda o Pentium 4 e outros processadores.
Intrinsics suporta processadores AMD e Intel mais recentes. Várias novas instruções intrínsecas suportam a maior funcionalidade nos processadores AMD e Intel mais recentes. Para obter mais informações sobre os novos intrínsecos, consulte Supplemental Streaming SIMD Extensions 3 Instructions, Streaming SIMD Extensions 4 Instructions, SSE4A and Advanced Bit Manipulation Intrinsics, AES Intrinsics, _mm_clmulepi64_si128 e __rdtscp.
A __cpuid função é atualizada. As funções __cpuid, __cpuidex agora suportam vários novos recursos das últimas revisões dos processadores AMD e Intel. O __cpuidex intrínseco é novo e reúne mais informações de processadores recentes.
A opção /MP do compilador reduz o tempo total de compilação. A /MP opção pode reduzir significativamente o tempo total para compilar vários arquivos de origem, criando vários processos que compilam os arquivos simultaneamente. Esta opção é especialmente útil em computadores que suportam hyperthreading, vários processadores ou vários núcleos.
A opção do compilador /Wp64 e a palavra-chave __w64 são obsoletos. A /Wp64 opção do compilador e __w64 a palavra-chave, que detetam problemas de portabilidade de 64 bits, foram preteridas e serão removidas em uma versão futura do compilador. Em vez dessa opção de compilador e palavra-chave, use um MSVC que tenha como alvo uma plataforma de 64 bits.
/Qfast_transcendentals gera código embutido para funções transcendentais.
/Qimprecise_fwaits remove os comandos fwait internos aos blocos try quando utiliza a opção de compilador /fp:except.

Alterações no vinculador

As informações de Controle de Conta de Usuário agora são incorporadas em arquivos de manifesto para executáveis pelo vinculador do Visual C++ (link.exe). Este recurso é ativado por padrão. Para obter mais informações sobre como desabilitar esse recurso ou como modificar o comportamento padrão, consulte /MANIFESTUAC (Incorpora informações do UAC no manifesto).
O vinculador agora tem a /DYNAMICBASE opção de habilitar o recurso de Randomização de Layout de Espaço de Endereço do Windows Vista. Esta opção modifica o cabeçalho de um executável para indicar se o aplicativo deve ser rebaseado aleatoriamente no momento do carregamento.

O que há de novo no C++ no Visual Studio 2005

Os seguintes recursos eram novos no Visual C++ 2005 Service Pack 1:

Intrínsecos para x86 e x64

__halt
__lidt
__nop
__readcr8
__sidt
__svm_clgi
__svm_invlpga
__svm_skinit
__svm_stgi
__svm_vmload
__svm_vmrun
__svm_vmsave
__ud2
__vmx_off
__vmx_vmptrst
__writecr8

Apenas para x64: Intrínsecos

__vmx_on
__vmx_vmclear
__vmx_vmlaunch
__vmx_vmptrld
__vmx_vmread
__vmx_vmresume
__vmx_vmwrite

Palavras-chave de novos idiomas

__sptr, __uptr

Novos recursos do compilador

O compilador tem alterações significativas nesta versão.

Compiladores nativos e cruzados de 64 bits.
/analyze A opção do compilador (Enterprise Code Analysis) foi adicionada.
/bigobj A opção do compilador foi adicionada.
/clr:pure, /clr:safee /clr:oldSyntax foram adicionados. (Mais tarde preterido no Visual Studio 2015 e removido no Visual Studio 2017.)
Opções de compilador preteridas: muitas opções de compilador foram preteridas nesta versão; consulte Opções de compilador preteridas para obter mais informações.
Double thunking no /clr código é reduzido, consulte Double Thunking (C++) para obter mais informações.
/EH (Modelo de Tratamento de Exceções) ou /EHs não pode mais ser usado para capturar uma exceção que é levantada com algo diferente de um lançamento; use /EHa.
/errorReport (Reportar Erros Internos do Compilador) a opção de compilador foi adicionada.
/favor A opção do compilador (Otimize for 64) foi adicionada.
/FA, /Fa opção de compilador de arquivo de listagem foi adicionada.
/FC A opção do compilador (Caminho Completo do Arquivo de Código-Fonte nas Diagnósticas) foi adicionada.
/fp A opção do compilador (Specify Floating-Point Behavior) foi adicionada.
/G (Otimizar para processador) A opção do compilador de opções foi adicionada.
/G (Otimizar para processador) A opção do compilador de opções foi adicionada.
/G3, /G4, /G5, /G6, , /G7e /GB as opções do compilador foram removidas. O compilador agora usa um "modelo combinado" que tenta criar o melhor arquivo de saída para todas as arquiteturas.
/Gf foi removido. Use /GF (Eliminar cadeias de caracteres duplicadas) em vez disso.
/GL (Otimização de todo o programa) agora é compatível com /CLRHEADER.
/GR agora está ativado por padrão.
/GS (Buffer Security Check) agora fornece proteção de segurança para parâmetros de ponteiro vulneráveis. /GS agora está ativado por padrão. /GS agora também trabalha em funções compiladas para MSIL com /clr (Common Language Runtime Compilation).
/homeparams (Copiar Parâmetros de Registo para a Pilha) a opção do compilador foi adicionada.
/hotpatch A opção do compilador (Create Hotpatchable Image) foi adicionada.
A heurística da função em linha foi atualizada; Consulte inline, __inline__forceinline e inline_depth para obter mais informações
Muitas novas funções intrínsecas foram adicionadas, e muitas intrínsecas anteriormente não documentadas estão agora documentadas.
Por padrão, qualquer chamada ao operador "new" que falhar lançará uma exceção.
/ML e /MLd as opções do compilador foram removidas. O Visual C++ não oferece mais suporte a bibliotecas CRT de thread único e vinculadas estaticamente.
O compilador implementou a Named Return Value Optimization, que é ativada quando se compila com /O1, /O2 (Minimizar Tamanho, Maximizar Velocidade), /Og (Otimizações Globais) e /Ox (Otimização Completa).
/Oa a opção do compilador foi removida, mas será silenciosamente ignorada; Use os noalias modificadores OR restrict__declspec para especificar como o compilador faz aliasing.
/Op A opção do compilador foi removida. Use /fp (Especificar o Comportamento Floating-Point) em vez disso.
OpenMP agora é suportado pelo Visual C++.
/openmp (Ativar Suporte OpenMP 2.0) opções de compilador foram adicionadas.
/Ow A opção do compilador foi removida, mas será silenciosamente ignorada. Use os noalias modificadores ou restrict__declspec para especificar como o compilador faz aliasing.

Profile-Guided Otimizações

/QI0f foi removido.
/QIfdiv foi removido.
/QIPF_B (Errata for B CPU Stepping) opção de compilador foi adicionada.
/QIPF_C (Errata for C CPU Stepping) a opção de compilador foi adicionada.
/QIPF_fr32 (Não utilize os registadores de ponto flutuante 96 superiores) foi adicionada a opção de compilador.
/QIPF_noPIC A opção do compilador (Generate Position Dependent Code) foi adicionada.
/QIPF_restrict_plabels (Assuma que nenhuma função seja criada em tempo de execução) opção do compilador foi adicionada.

Suporte a Unicode no compilador e linkador

/vd (Desativar Deslocamentos de Construção) agora permite que se use o operador dynamic_cast em um objeto que está a ser construído (/vd2)
/YX A opção do compilador foi removida. Use /Yc (Criar arquivo de cabeçalho pré-compilado) ou /Yu (Usar arquivo de cabeçalho pré-compilado) em vez disso. Se você remover /YX de suas configurações de compilação e substituí-lo por nada, isso pode resultar em compilações mais rápidas.
/Zc:forScope agora está ativado por padrão.
/Zc:wchar_t agora está ativado por padrão.
/Zd A opção do compilador foi removida. Não há mais suporte para informações de depuração que usam apenas o número de linha. Use /Zi em vez disso (consulte /Z7, /Zi, /ZI (Debug Information Format) para obter mais informações).
/Zg agora só é válido em arquivos de código-fonte C, e não em arquivos de código-fonte C++.
/Zx A opção do compilador (Debug Optimized Itanium Code) foi adicionada.

Novos recursos de idioma

O attributeattribute agora foi preterido.
O modificador appdomain__declspec foi adicionado.
__clrcall A convenção de chamada foi adicionada.
O modificador declspec obsoleto (C++) agora permite especificar uma cadeia de caracteres que será exibida em tempo de compilação, quando um utilizador tentar aceder a uma classe ou função obsoleta.
dynamic_cast O operador tem alterações significativas.
Enums nativos agora permitem que você especifique o tipo subjacente.
O modificador jitintrinsicdeclspec foi adicionado.
O modificador noaliasdeclspec foi adicionado.
O modificador process__declspec foi adicionado.
Abstract, Override e Sealed são válidos para compilações nativas.
__restrict palavra-chave foi adicionada.
O modificador restrictdeclspec foi adicionado.
__thiscall é agora uma palavra-chave.
__unaligned A palavra-chave agora está documentada.
volatile (C++) atualizou o comportamento em relação às otimizações.

Novos recursos do pré-processador

__CLR_VER macro predefinida adicionada.
O comentário (C/C++) pragma agora aceita /MANIFESTDEPENDENCY como um comentário do linker. A opção exestr para comentar foi preterida.
embedded_idl atributo (A #import Diretiva) agora usa um parâmetro opcional.
fenv_access Pragma
float_control Pragma
fp_contract Pragma
As variáveis globais não serão inicializadas na ordem em que são declaradas se você tiver variáveis globais nas seções gerenciadas, não gerenciadas e não gerenciadas do pragma. Essa é uma alteração importante se, por exemplo, uma variável global não gerida for inicializada com variáveis globais geridas, e for necessário um objeto gerido totalmente construído.
As seções especificadas com init_seg agora são somente leitura e não leitura/gravação como nas versões anteriores.
inline_depth padrão agora é 16. Um valor pré-definido de 16 também estava em vigor no Visual C++ .NET 2003.
_INTEGRAL_MAX_BITS macro predefinida adicionada, consulte Macros predefinidas.
_M_CEE, _M_CEE_PURE e _M_CEE_SAFE macros predefinidas adicionadas, consulte Macros predefinidas.
A macro predefinida _M_IX86_FP foi adicionada.
_M_X64 macro predefinida adicionada.
make_public Pragma
managed, unmanaged sintaxe pragma atualizada (agora tem push e pop)
mscorlib.dll é agora implicitamente referenciado pela Diretiva #using em todas as compilações /clr.
_OPENMP macro predefinida adicionada.
Otimize Pragma foi atualizado, A e W não são mais parâmetros válidos.
no_registry#import atributo foi adicionado.
region, endregion pragmas adicionados
_VC_NODEFAULTLIB macro predefinida adicionada.
Macros variádicas foram agora implementadas.
vtordisp foi preterido e será removido em uma versão futura do Visual C++.
O warning pragma agora tem o especificador supressor.

Novos recursos do Linker

Módulos (arquivos de saída MSIL não montados) agora são permitidos como entrada para o vinculador.
/ALLOWISOLATION A opção de vinculador (Pesquisa de manifesto) foi adicionada.
/ASSEMBLYRESOURCE (Incorporar um recurso gerenciado) foi atualizado para permitir que você especifique o nome do recurso no assembly e especifique que o recurso é privado no assembly.
/CLRIMAGETYPE A opção do vinculador (Especificar tipo de imagem CLR) foi adicionada.
/CLRSUPPORTLASTERROR (Preservar o Último Código de Erro para Chamadas PInvoke) opção de ligador foi adicionada.
/CLRTHREADATTRIBUTE A opção do vinculador (set CLR Thread Attribute) foi adicionada.
/CLRUNMANAGEDCODECHECK (Add SuppressUnmanagedCodeSecurityAttribute) foi adicionada a opção do vinculador.
/ERRORREPORT foi adicionada a opção "Relatar Erros Internos do Ligador".
/EXETYPE A opção de vinculação foi removida. O vinculador não suporta mais a criação de drivers de dispositivo do Windows 95 e Windows 98. Use um DDK apropriado para criar esses drivers de dispositivo. A palavra-chave EXETYPE não é mais válida para arquivos de definição de módulo.
/FUNCTIONPADMIN A opção de vinculador (Create Hotpatchable Image) foi adicionada.
/LTCG opção Linker agora é suportada em módulos compilados com /clr. /LTCG também foi atualizado para suportar otimizações guiadas por perfil.
/MANIFEST A opção de vinculador (Create Side-by-Side Assembly Manifest) foi adicionada.
/MANIFESTDEPENDENCY A opção de vinculador (Especificar dependências de manifesto) foi adicionada.
/MANIFESTFILE A opção do vinculador (Manifesto de Nome do Arquivo) foi adicionada.
/MAPINFO:LINES A opção de vinculação foi removida.
/NXCOMPAT Foi adicionada a opção de vinculação (compatível com a Prevenção de Execução de Dados).
/PGD (Especificar banco de dados para otimizações de Profile-Guided) foi adicionada a opção do vinculador.
/PROFILE A opção de vinculador (Performance Tools Profiler) foi adicionada.
/SECTION (Especificar atributos de seção) a opção do vinculador agora suporta negação de atributos e não suporta mais os atributos L ou D (relacionados com VxD).
Suporte a Unicode no compilador e linkador
/VERBOSE (Opção do Linker para Imprimir Mensagens de Progresso) agora também aceita ICF e REF.
/VXD A opção de vinculação foi removida. O vinculador não suporta mais a criação de drivers de dispositivo do Windows 95 e Windows 98. Use um DDK apropriado para criar esses drivers de dispositivo. A palavra-chave VXD não é mais válida para arquivos de definição de módulo.
/WS A opção de vinculação foi removida. /WS foi usado para modificar imagens direcionadas para o Windows NT 4.0. IMAGECFG.exe -R nome do arquivo pode ser usado em vez de /WS. IMAGECFG.exe pode ser encontrado no CD-ROM do Windows NT 4.0 em SUPPORT\DEBUG\I386\IMAGECFG.EXE.
/WX (Tratar avisos do vinculador como erros) a opção do vinculador agora está documentada.

Novos recursos do utilitário Linker

/ALLOWISOLATION A opção editbin foi adicionada
A instrução do arquivo de definição do módulo DESCRIPTION foi removida. O vinculador não suporta mais a criação de drivers de dispositivo virtual.
/ERRORREPORT opção foi adicionada a bscmake.exe, dumpbin.exe, editbin.exee lib.exe.
/LTCG A opção lib foi adicionada.
/NXCOMPAT A opção editbin foi adicionada.
/RANGE A opção dumpbin foi adicionada.
/TLS A opção dumpbin foi adicionada.
/WS A opção editbin foi removida. /WS foi usado para modificar imagens direcionadas para o Windows NT 4.0. IMAGECFG.exe -R nome do arquivo pode ser usado em vez de /WS. IMAGECFG.exe pode ser encontrado no CD-ROM do Windows NT 4.0 em SUPPORT\DEBUG\I386\IMAGECFG.EXE.
A opção lib /WX[:NO] foi adicionada.

Novos recursos NMAKE

/ERRORREPORT foi adicionado.
/G foi adicionado.
As regras predefinidas foram atualizadas.
A macro $(MAKE), que está documentada em Macros de recursão, agora fornece o caminho completo para nmake.exe.

Novos recursos do MASM

As expressões MASM agora são valores de 64 bits. Nas versões anteriores, as expressões MASM eram valores de 32 bits.
A instrução __asm int 3 agora faz com que uma função seja compilada como nativa.
Agora, o ALIAS (MASM) está documentado.
/ERRORREPORT A opção ml.exe e a opção ml64.exe são adicionadas.
. O FPO está agora documentado.
H2INC.exe não será fornecido no Visual C++ 2005. Se você precisar continuar a usar H2INC, use H2INC.exe de uma versão anterior do Visual C++.
O operador IMAGEREL foi adicionado.
operador HIGH32 foi adicionado.
operador LOW32 foi adicionado.
ml64.exe é uma versão do MASM para a arquitetura x64. Ele monta arquivos .asm x64 em arquivos de objeto x64. A linguagem de montagem em linha não é suportada no compilador x64. As seguintes diretivas MASM foram adicionadas para ml64.exe (x64):
. ALLOCSTACK
. ENDPROLOG
. PUSHFRAME
. PUSHREG
. SAVEREG
. SAVEXMM128
.SETFRAME Além disso, a diretiva PROC foi atualizada com sintaxe exclusiva para x64.
A diretiva MMWORD foi adicionada
/omf (ML.exe opção de linha de comando) agora implica /c. ML.exe não suporta a vinculação de objetos de formato OMF.
A diretiva SEGMENT agora suporta atributos adicionais.
operador SECTIONREL foi adicionado.
A diretiva XMMWORD foi adicionada

Novas funcionalidades do CRT

Foram adicionadas versões seguras de várias funções. Essas funções lidam com erros de uma maneira melhor e impõem controles mais rígidos em buffers para ajudar a evitar falhas de segurança comuns. As novas versões seguras são identificadas pelo sufixo _s .
As versões menos seguras existentes de muitas funções foram preteridas. Para desativar os avisos de descontinuação, defina _CRT_SECURE_NO_WARNINGS.
Muitas funções existentes agora validam seus parâmetros e invocam o manipulador de parâmetros inválido quando um parâmetro inválido é passado.
Muitas funções existentes agora estão definidas errno onde não eram antes.
O typedef errno_t com número inteiro de tipo foi adicionado. errno_t é usado sempre que um tipo de retorno de função ou parâmetro lida com códigos de erro de errno. errno_t substitui errcode.
As funções dependentes de localidade agora têm versões que usam a localidade como um parâmetro em vez de usar a localidade atual. Estas novas funções têm o sufixo _l . Várias novas funções foram adicionadas para trabalhar com objetos de localidade. As novas funções incluem _get_current_locale, _create_locale e _free_locale.
Novas funções foram adicionadas para suportar o bloqueio e desbloqueio de manipuladores de ficheiros.
A _spawn família de funções não redefine o errno a zero quando bem-sucedidas, como fazia nas versões anteriores.
Estão disponíveis versões da printf família de funções que permitem especificar a ordem em que os argumentos são usados.
Unicode é agora um formato de texto suportado. A função _open suporta atributos _O_TEXTW, _O_UTF8 e _O_UTF16. A fopen função suporta o método "ccs=ENCODING" de especificar um formato Unicode.
Uma nova versão das bibliotecas CRT construídas em código gerido (MSIL) está agora disponível e é utilizada ao compilar com a opção /clr (Compilação em Tempo de Execução Comum).
_fileinfo foi removido.
O tamanho padrão para time_t agora é de 64 bits, o que expande o intervalo de time_t e várias das funções de tempo para o ano 3000.
O CRT agora suporta a configuração da localidade por thread. A função _configthreadlocale foi adicionada para suportar este recurso.
As funções _statusfp2 e __control87_2 foram adicionadas para permitir o acesso e controle da palavra de controle de ponto flutuante nos processadores de ponto flutuante x87 e SSE2.
As funções _mkgmtime e _mkgmtime64 foram adicionadas para fornecer suporte para converter tempos (struct tm) para Greenwich Mean Time (GMT).
Foram feitas alterações em swprintf e vswprintf para melhor conformidade com a norma.
Um novo arquivo de cabeçalho, INTRIN. H, fornece protótipos para algumas funções intrínsecas.
A fopen função agora tem um atributo N.
A _open função agora tem um atributo _O_NOINHERIT.
A atoi função agora retorna INT_MAX e define errno como ERANGE no caso de overflow. Nas versões anteriores, o comportamento de estouro era indefinido.
A printf família de funções suporta saída de ponto flutuante hexadecimal implementada de acordo com o padrão ANSI C99 usando os especificadores de tipo de formato %a e %A.
A printf família agora suporta o prefixo de tamanho "long long" ("ll").
A _controlfp função foi otimizada para um melhor desempenho.
Foram adicionadas versões de depuração para algumas funções.
Adicionado _chgsignl e _cpysignl (versões duplas longas).
Tipo _locale_t adicionado à tabela de tipos.
Nova macro _countof Macro adicionada para calcular o número de elementos em uma matriz.
Em cada tópico de função, uma seção sobre equivalentes do .NET Framework foi adicionada.
Várias funções de cadeia de caracteres agora têm a opção de truncar cadeias de caracteres em vez de falhar quando os buffers de saída são muito pequenos; ver _TRUNCATE.
_set_se_translator agora requer o uso da opção do /EHa compilador.
fpos_t está agora __int64 sob /Za (para código C) e quando __STDC__ é definido manualmente (para código C++). Costumava ser um struct.
_CRT_DISABLE_PERFCRIT_LOCKS pode melhorar o desempenho de E/S de programas monofilamentares.
Os nomes POSIX foram preteridos em favor de nomes conformes com ISO C++ (por exemplo, use _getch em vez de getch).
Novas opções de ligação para arquivos .obj estão disponíveis para o modo puro.
_recalloc combina características de realloc e calloc.

O que há de novo no C++ no Visual Studio 2003

Compilador

Informações sobre como executar um aplicativo Managed Extensions for C++ criado com o compilador da versão atual em uma versão anterior do tempo de execução.
Extensões gerenciadas para perguntas frequentes sobre C++.
Um passo a passo foi adicionado mostrando como portar um aplicativo nativo existente para usar extensões gerenciadas para C++: Passo a passo: Portando um aplicativo C++ nativo existente para interoperar com componentes do .NET Framework.
Agora é possível criar um delegado em um método de um tipo de valor.
A conformidade do compilador com o padrão C++ foi significativamente melhorada para o Visual C++ .NET 2003.
/arch opção de compilador é adicionada.
/Gf foi preterido e será removido na próxima versão do Visual C++.
/G7 opção de compilador é adicionada.
A /GS opção do compilador foi aprimorada para ajudar a proteger as variáveis locais contra saturações diretas de buffer.
A /noBool opção do compilador foi removida. O compilador agora permite bool aparecer apenas como uma palavra-chave (e não um identificador) em um arquivo de código-fonte C++.
O long long tipo agora está disponível como um typedef de __int64. Note que ainda não há suporte para long long no CRT.
A /Zm opção do compilador agora especifica o limite de alocação de memória de cabeçalho pré-compilado.
A função intrínseca _InterlockedCompareExchange agora está documentada.
A função intrínseca _InterlockedDecrement está agora documentada.
O intrínseco _InterlockedExchange agora está documentado.
A função _InterlockedExchangeAdd agora está documentada.
_InterlockedIncrement função intrínseca agora documentada.
_ReadWriteBarrier intrínseco foi adicionado.

Atributos

implements agora está documentado.

Recursos do vinculador

As seguintes opções de vinculador foram adicionadas:

/ASSEMBLYDEBUG
/ASSEMBLYLINKRESOURCE
SINAL DE ATRASO
/ARQUIVO CHAVE
/KEYCONTAINER
/SAFESEH

MASM

Foram acrescentados a diretiva .SAFESEH e a opção /safeseh ml.exe.

Ver também

Guia de portabilidade e atualização do Visual C++

Feedback

Esta página foi útil?

Last updated on 2025-11-07

Partilhar via

Visual C++ O que há de novo de 2003 a 2015

O que há de novo no C++ no Visual Studio 2015

Melhorias de conformidade no Visual Studio 2015

Melhorias de conformidade no Visual Studio 2015 Atualização 1

Melhorias de conformidade no Visual Studio 2015 Atualização 2

Melhorias de conformidade no Visual Studio 2015 Atualização 3

O que há de novo no C++ no Visual Studio 2013

Suporte melhorado às normas ISO C/C++

Compilador

Bibliotecas C99

Biblioteca de modelos padrão

Alterações Disruptivas

Aprimoramentos da biblioteca do Visual C++

Desempenho de aplicativos C++

Aprimoramentos de otimização guiada por perfil (PGO)

Suporte ao Desenvolvimento de Apps para o Windows Runtime

Aprimoramentos de diagnóstico

Aprimoramentos gráficos 3D

IDE e Produtividade

O que há de novo no C++ no Visual Studio 2012

Suporte aprimorado aos padrões C++11

Biblioteca de modelos padrão

Outros aprimoramentos do C++11

Suporte ao Desenvolvimento de Apps para o Windows Runtime

Compilador e Ligador

Novo no Visual Studio 2012 Atualização 1

Suporte à programação paralela

Paralelismo Maciço Acelerado (AMP) em C++

Aprimoramentos gerais de programação paralela

Aprimoramentos gerais de depuração paralela

IDE

Ferramentas de gerenciamento do ciclo de vida do aplicativo

Análise estática de código

Estrutura de teste de unidade atualizada

Gráficos de dependência de arquitetura

Explorador de Arquitetura

Cobertura de código

O que há de novo no C++ no Visual Studio 2010

Compilador e vinculador C++

Projetos do Visual Studio C++ e o sistema de compilação

Bibliotecas do Visual C++

Biblioteca do Microsoft Foundation Class (MFC)

Biblioteca SafeInt

Novas macros ATL (Ative Template Library)

/analisar Avisos

Animação e suporte D2D

IDE

Ferramentas

Referência do Microsoft Macro Assembler

O que há de novo no C++ no Visual Studio 2008

Ambiente de desenvolvimento integrado (IDE) do Visual C++

Bibliotecas do Visual C++

Geral

Biblioteca STL/CLR

Biblioteca MFC

Biblioteca de suporte C++

Servidor ATL

Compilador e vinculador do Visual C++

Alterações no compilador

Alterações no vinculador

O que há de novo no C++ no Visual Studio 2005

Intrínsecos para x86 e x64

Apenas para x64: Intrínsecos

Palavras-chave de novos idiomas

Novos recursos do compilador

Profile-Guided Otimizações

Suporte a Unicode no compilador e linkador

Novos recursos de idioma

Novos recursos do pré-processador

Novos recursos do Linker

Novos recursos do utilitário Linker

Novos recursos NMAKE

Novos recursos do MASM

Novas funcionalidades do CRT

O que há de novo no C++ no Visual Studio 2003

Compilador

Atributos

Recursos do vinculador

MASM