Trabalhar com código C++ no Designer de Classe

O Designer de Classe exibe uma superfície de design visual chamada diagrama de classe que fornece uma representação visual dos elementos de código em seu projeto. Você pode usar diagramas de classe para projetar e visualizar classes e outros tipos em um projeto.

O Designer de Classe dá suporte aos seguintes elementos de código C++:

• Classe (se assemelha a uma forma de classe gerenciada, exceto que ela pode ter várias relações de herança)

• Classe anônima (exibe o nome gerado pelo Class View para o tipo anônimo)

• Classe de modelo

• Estrutura

• Enum

• Macro (exibe a visualização pós-processada da macro)

• Typedef

Observação

Isso não é o mesmo que o diagrama de classe UML, que você pode criar em um Projeto de Modelagem. Para obter mais informações, consulte Diagramas de Classe UML: Referência.

Classes C++ no Designer de Classe

O Designer de Classe dá suporte a classes C++ e visualiza classes C++ nativas da mesma forma que as formas de classe Do Visual Basic e C#, exceto que as classes C++ podem ter várias relações de herança. Você pode expandir a forma de classe para mostrar mais campos e métodos na classe ou recolhê-la para conservar o espaço.

Observação

O Designer de Classe não dá suporte a uniões (um tipo especial de classe na qual a memória alocada é apenas a quantidade necessária para o maior membro de dados do sindicato).

Herança simples

Quando você arrasta mais de uma classe para um diagrama de classe e as classes têm uma relação de herança de classe, uma seta as conecta. A seta aponta na direção da classe base. Por exemplo, quando as seguintes classes são exibidas em um diagrama de classe, uma seta as conecta, apontando de B para A:

class A {};
class B : A {};

Você também pode arrastar somente a classe B para o diagrama de classe, clicar com o botão direito do mouse na forma de classe para B e, em seguida, clicar em Mostrar Classes Base. Isso exibe sua classe base: A.

Herança múltipla

O Designer de Classe dá suporte à visualização de relações de herança de várias classes. A herança múltipla é usada quando uma classe derivada tem atributos de mais de uma classe base. Veja a seguir um exemplo de herança múltipla:

class Bird {};
class Swimmer {};
class Penguin : public Bird, public Swimmer {};

Quando você arrasta mais de uma classe para o diagrama de classe e as classes têm uma relação de herança de várias classes, uma seta as conecta. A seta aponta na direção das classes base.

Clicar com o botão direito do mouse em uma forma de classe e clicar em Mostrar Classes Base exibe as classes base da classe selecionada.

Observação

Não há suporte para o comando Mostrar Classes Derivadas para código C++. Você pode exibir classes derivadas acessando o Modo de Exibição de Classe, expandindo o nó de tipo, expandindo a subpasta Tipos Derivados e arrastando esses tipos para o diagrama de classe.

Para obter mais informações sobre herança de várias classes, consulte Herança Múltipla e Várias Classes Base.

Classes abstratas

O Designer de Classe dá suporte a classes abstratas (também chamadas de "classes base abstratas"). Estas são classes que você nunca instancia, mas das quais você pode derivar outras classes. Usando um exemplo de "Herança Múltipla" anteriormente neste documento, você pode criar uma instância da Bird classe como objetos individuais da seguinte maneira:

int main()
{
   Bird sparrow;
   Bird crow;
   Bird eagle;
}

No entanto, talvez você não pretenda instanciar a Swimmer classe como objetos individuais. Talvez você pretenda derivar apenas outros tipos de classes animais dele, por exemplo, Penguine WhaleFish. Nesse caso, você declararia a Swimmer classe como uma classe base abstrata.

Para declarar uma classe como abstrata, você pode usar a abstract palavra-chave. Os membros marcados como abstratos ou incluídos em uma classe abstrata são virtuais e devem ser implementados por classes que derivam da classe abstrata.

class Swimmer abstract
{
   virtual void swim();
   void dive();
};

Você também pode declarar uma classe como abstrata incluindo pelo menos uma função virtual pura:

class Swimmer
{
   virtual void swim() = 0;
   void dive();
};

Quando você exibe essas declarações em um Diagrama de Classe, o nome Swimmer da classe e sua função swim virtual pura são exibidos em itálico em uma forma de classe abstrata, juntamente com a Classe Abstrata de notação. Observe que a forma do tipo de classe abstrata é a mesma de uma classe regular, exceto que sua borda é uma linha pontilhada.

Uma classe derivada de uma classe base abstrata deve substituir cada função virtual pura na classe base ou a classe derivada não pode ser instanciada. Portanto, por exemplo, se você derivar uma Fish classe da Swimmer classe, Fish deverá substituir o swim método:

class Fish : public Swimmer
{
   void swim(int speed);
};

int main()
{
   Fish guppy;
}

Quando você exibe esse código em um Diagrama de Classe, o Designer de Classe desenha uma linha de herança de Fish para Swimmer.

Classes anônimas

O Designer de Classe dá suporte a classes anônimas. Tipos de classe anônimos são classes declaradas sem um identificador. Eles não podem ter um construtor ou destruidor, não podem ser passados como argumentos para funções e não podem ser retornados como valores retornados de funções. Você pode usar uma classe anônima para substituir um nome de classe por um nome typedef, como no exemplo a seguir:

typedef struct
{
    unsigned x;
    unsigned y;
} POINT;

As estruturas também podem ser anônimas. O Designer de Classe exibe classes e estruturas anônimas da mesma forma que exibe o respectivo tipo. Embora você possa declarar e exibir classes e estruturas anônimas, o Designer de Classe não usará o nome da tag que você especificar. Ele usará o nome gerado pelo Class View. A classe ou estrutura aparece no Modo de Exibição de Classe e no Designer de Classe como um elemento chamado __unnamed.

Para obter mais informações sobre classes anônimas, consulte Tipos de Classe Anônimos.

Classes de modelo

O Designer de Classe dá suporte à visualização de classes de modelo. Há suporte para declarações aninhadas. A tabela a seguir mostra algumas declarações típicas.

Elemento de código	Exibição do Designer de Classe
template <class T> class A {};	A<T> Classe de modelo
template <class T, class U> class A {};	A<T, U> Classe de modelo
template <class T, int i> class A {};	A<T, i> Classe de modelo
template <class T, template <class K> class U> class A {};	A<T, U> Classe de modelo

A tabela a seguir mostra alguns exemplos de especialização parcial.

Elemento de código	Exibição do Designer de Classe
template<class T, class U> class A {};	A<T, U> Classe de modelo
template<class T> class A<T, T> {};	A<T, T> Classe de modelo
template <class T> class A<T, int> {};	A<T, int> Classe de modelo
template <class T1, class T2> class A<T1*, T2*> {};	A<T1*, T2*> Classe de modelo

A tabela a seguir mostra alguns exemplos de herança em especialização parcial.

Elemento de código	Exibição do Designer de Classe
template <class T, class U> class A {}; template <class TC> class A<T, int> {}; class B : A<int, float> {}; class C : A<int, int> {};	A<T, U> Classe de modelo B Class (aponta para a classe A) C Class (aponta para a Classe A)

A tabela a seguir mostra alguns exemplos de funções de modelo de especialização parciais.

Elemento de código	Exibição do Designer de Classe
class A { template <class T, class U> void func(T a, U b); template <class T> void func(T a, int b); };	A func<T, U> (+ 1 sobrecarga)
template <class T1> class A { template <class T2> class B {}; }; template<> template<> class A<type>::B<type> {};	A<T1> Classe de modelo B<T2> Classe de modelo (B está contido na classe A em Tipos Aninhados)
template <class T> class C {}; class A : C<int> {};	A Class -> C<int> C<T> Classe de modelo

A tabela a seguir mostra alguns exemplos de herança de templates.

Elemento de código	Exibição do Designer de Classe
template <class T> class C {}; template<> class C<int> { class B {}; } class A : C<int>::B {};	A Class ->B C<int> Class (B está contido na classe C em Tipos Aninhados) C<T> Classe de modelo

A tabela a seguir mostra alguns exemplos de conexão de classe especializada canônica.

Elemento de código	Exibição do Designer de Classe
template <class T> class C {}; template<> class C<int> {}; class A : C<int> {}; class D : C<float> {};	A Class ->C<int> C<int> Class C<T> Classe de modelo D Class ->C<float>
class B { template <class T> T min (const T &a, const T &b); };	B min <T>

Enumerações C++ no Designer de Classe

O Designer de Classe dá suporte a tipos C++ enum e com escopo enum class . Segue-se um exemplo:

enum CardSuit {
   Diamonds = 1,
   Hearts = 2,
   Clubs = 3,
   Spades = 4
};

// or...
enum class CardSuit {
   Diamonds = 1,
   Hearts = 2,
   Clubs = 3,
   Spades = 4
};

Uma forma de enumeração C++ em um diagrama de classe parece e funciona como uma forma de estrutura, exceto que o rótulo lê a classe Enum ou Enum, é rosa em vez de azul e tem uma borda colorida nas margens esquerda e superior. As formas de enumeração e as formas de estrutura têm cantos quadrados.

Para obter mais informações sobre como usar o enum tipo, consulte Enumerações.

Declarações typedef C++ no Designer de Classe

As instruções Typedef criam uma ou mais camadas de indireção entre um nome e seu tipo subjacente. O Designer de Classe dá suporte a tipos typedef C++, que são declarados com a palavra-chave typedef, por exemplo:

typedef class coord
{
   void P(x,y);
   unsigned x;
   unsigned y;
} COORD;

Em seguida, você pode usar esse tipo para declarar uma instância:

COORD OriginPoint;

Formas de classe e struct

No Designer de Classe, um typedef em C++ assume a forma do tipo especificado no typedef. Se a origem declarar typedef class, a forma terá cantos arredondados e o rótulo será Class. Para typedef struct, a forma tem cantos quadrados e o rótulo Struct.

Classes e estruturas podem ter typedefs aninhados declarados dentro delas. No Designer de Classe, as formas de classe e estrutura podem exibir declarações typedef aninhadas como formas aninhadas.

As formas Typedef dão suporte aos comandos Mostrar como Associação e Mostrar como Associação de Coleção no menu com o botão direito do mouse (menu de contexto).

Exemplo de typedef de classe

class B {};
typedef B MyB;

Exemplo de typedef de struct

typedef struct mystructtag
{
    int   i;
    double f;
} mystruct;

Typedefs sem nome

Embora você possa declarar um typedef sem um nome, o Designer de Classe não usa o nome da tag especificado. O Designer de Classe usa o nome gerado pelo Class View. Por exemplo, a declaração a seguir é válida, mas aparece no Modo de Exibição de Classe e no Designer de Classe como um objeto chamado __unnamed:

typedef class coord
{
   void P(x,y);
   unsigned x;
   unsigned y;
};

Observação

O Designer de Classe não exibe typedefs cujo tipo de origem é um ponteiro de função.

Saiba mais sobre as limitações para elementos de código C++

• Quando um projeto C++ é carregado, o Designer de Classe funciona em modo somente leitura. Você pode alterar o diagrama de classe, mas não pode salvar as alterações do diagrama de classe de volta para o código-fonte.

• O Designer de Classe dá suporte apenas à semântica C++ nativa. Para projetos C++ compilados em código gerenciado, o Designer de Classe visualizará apenas elementos de código que são tipos nativos. Portanto, você pode adicionar um diagrama de classe a um projeto, mas o Designer de Classe não permitirá visualizar elementos nos quais a IsManaged propriedade está definida true (ou seja, tipos de valor e tipos de referência).

• Para projetos C++, o Designer de Classe lê apenas a definição do tipo. Por exemplo, suponha que você defina um tipo em um arquivo de cabeçalho (.h) e defina seus membros em um arquivo de implementação (.cpp). Se você invocar "Exibir Diagrama de Classe" no arquivo de implementação (.cpp), o Designer de Classe não exibirá nada. Como outro exemplo, se você invocar "Exibir Diagrama de Classe" em um arquivo .cpp que usa uma instrução #include para incluir outros arquivos, mas não contém nenhuma definição de classe real, o Designer de Classe novamente não exibirá nada.

• Os arquivos IDL (.idl), que definem interfaces COM e bibliotecas de tipos, não são exibidos em diagramas, a menos que sejam compilados para código C++ nativo.

• O Designer de Classe não dá suporte a funções e variáveis globais.

• O Designer de Classe não dá suporte a uniões. Esse é um tipo especial de classe em que a memória alocada é apenas a quantidade necessária para o maior membro de dados do sindicato.

• O Designer de Classe não exibe tipos de dados básicos, como int e char.

• O Designer de Classe não exibirá tipos definidos fora do projeto atual se o projeto não tiver referências corretas a esses tipos.

• O Designer de Classe pode exibir tipos aninhados, mas não as relações entre um tipo aninhado e outros tipos.

• O Designer de Classe não pode exibir tipos que são nulos ou que derivam de um tipo nulo.

Solucionar problemas de resolução de tipos e de exibição

Local dos arquivos de origem

O Designer de Classe não controla o local dos arquivos de origem. Portanto, se você modificar sua estrutura de projeto ou mover arquivos de origem em seu projeto, o Designer de Classe poderá perder o controle do tipo (especialmente o tipo de origem de um typedef, classes base ou tipos de associação). Você pode receber um erro, como o Designer de Classe, não pode exibir esse tipo. Se você fizer isso, arraste o código-fonte modificado ou realocado novamente para o diagrama de classe para que ele seja exibido novamente.

Problemas de atualização e desempenho

Para projetos C++, pode levar de 30 a 60 segundos para que uma alteração no arquivo de origem apareça no diagrama de classe. Esse atraso também pode fazer com que o Designer de Classe gere o erro Nenhum tipo foi encontrado na seleção. Se você receber um erro como este, clique em Cancelar na mensagem de erro e aguarde até que o elemento de código apareça no Modo de Exibição de Classe. Depois de fazer isso, o Designer de Classe deverá ser capaz de exibir o tipo.

Se um diagrama de classe não for atualizado com as alterações feitas no código, talvez seja necessário fechar o diagrama e abri-lo novamente.

Problemas de resolução de tipos

O Designer de Classe pode não ser capaz de resolver tipos pelos seguintes motivos:

• O tipo está em um projeto ou assembly que não é referenciado pelo projeto que contém o diagrama de classe. Para corrigir esse erro, adicione uma referência ao projeto ou assembly que contém o tipo. Para obter mais informações, consulte Gerenciando referências em um projeto.

• O tipo não está no escopo correto, portanto, o Designer de Classe não pode localizá-lo. Verifique se no código não está faltando uma instrução using, imports ou #include. Verifique também se você não moveu o tipo (ou um tipo relacionado) para fora do namespace no qual ele foi localizado originalmente.

• O tipo não existe (ou foi comentado). Para corrigir esse erro, verifique se você não comentou ou excluiu o tipo.

• O tipo está localizado em uma biblioteca referenciada por uma diretiva #import. Uma possível solução alternativa é adicionar manualmente o código gerado (o arquivo .tlh) a uma diretiva #include no arquivo de cabeçalho.

• Verifique se o Designer de Classe dá suporte ao tipo que você inseriu. Consulte Limitações para elementos de código C++.

O erro que você provavelmente verá para um problema de resolução de tipo é que o Código não pôde ser encontrado para uma ou mais formas no diagrama de classe '<elemento>'. Essa mensagem de erro não indica necessariamente que o código está em erro. Indica apenas que o designer de classe não pôde exibir seu código. Experimente as seguintes medidas:

• Certifique-se de que o tipo exista. Verifique se você não comentou ou excluiu o código-fonte sem querer.

• Tente resolver o tipo. O tipo pode estar em um projeto ou assembly que não é referenciado pelo projeto que contém o diagrama de classes. Para corrigir esse erro, adicione uma referência ao projeto ou assembly que contém o tipo. Para obter mais informações, consulte Gerenciando referências em um projeto.

• Verifique se o tipo está no escopo correto para que o Class Designer possa localizá-lo. Verifique se não está faltando no código uma instrução using, imports ou #include. Verifique também se você não moveu o tipo (ou um tipo relacionado) para fora do namespace no qual ele foi localizado originalmente.

Dica

Para obter informações adicionais de solução de problemas, consulte erros do Designer de Classe.

Conteúdo relacionado

• O que é o Designer de Classe?