Classes de Visual C++ no Class Designer
Class Designer oferece suporte a classes C++ e visualiza as classes de C++ nativas da mesma forma como as formas de classe de Visual Basic e C# Visual, exceto pelo fato de 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 contraí-lo para economizar espaço.
.gif "Observação") Observação |
|---|
O Class Designer não oferece suporte para uniões (um tipo especial de classe na qual a memória alocada é apenas a quantidade necessária para o membro de dados maior da união). |
Herança Simple
Quando você arrastar mais de uma classe em um diagrama de classes e as classes têm uma relação de herança de classe, uma seta conecta-los.Os pontos de direção na direção da classe base.Por exemplo, quando as seguintes classes são exibidas em um diagrama de classe, uma seta conecta-los, apontando de b para a:.
class A {};
class B : A {};
Pode também arrastar única classe b para o diagrama de classe, com o botão direito na forma de classe b e em Mostrar Classes de Base.Isso exibe a sua classe base: a.
Herança múltipla
O Class Designer oferece suporte a visualização das relações de herança de classe de múltiplo.Herança múltipla é usado 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ê arrastar mais de uma classe para o diagrama de classes e as classes têm uma relação de herança de classe de vários, uma seta conecta-los.Os pontos de direção na direção das classes base.
Clicando com o botão direito na forma de uma classe e, em seguida, clicando em Classes Base mostram exibe as classes base para a classe selecionada.
| Observação |
|---|
O Mostrar Classes derivadas de comando não é suportado para código C++.Você pode exibir classes derivadas, vá para Class View, expandindo o nó do tipo, expandindo o Tipos derivados de subpasta e, em seguida, arrastar esses tipos para o diagrama de classes. |
Para obter mais informações sobre herança de classe de múltiplos, consulte Herança múltipla e Várias Classes Base.
Classes abstratas
O Class Designer oferece suporte a classes abstratas (também chamados de "classes base abstratas").Essas são classes que você instancia nunca, mas do qual você pode derivar outras classes.Usando um exemplo de "Herança múltipla", anteriormente neste documento, você pode instanciar o Bird classe como objetos individuais, como a seguir:
int main()
{
Bird sparrow;
Bird crow;
Bird eagle;
}
No entanto, talvez não pretende criar uma instância de Swimmer classe como objetos individuais.Pode pretender apenas derivar outros tipos de classes animais, por exemplo, Penguin, Whale, e Fish.Nesse caso, você deve declarar o Swimmer classe como uma classe base abstrata.
Para declarar uma classe como abstrata, você pode usar o abstract palavra-chave.Membros marcado como abstract ou incluídos em uma classe abstrata, são virtuais e devem ser implementados pelas classes que derivam da classe abstrata.
class Swimmer abstract
{
virtual void swim();
void dive();
};
Você pode também declarar uma classe como abstrata, incluindo pelo menos um de 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 da classe Swimmer e sua função virtual pura swim são no exibido em itálico na forma de uma classe abstrata, juntamente com a notação Classe abstrata.Observe que a forma de tipo de classe abstrata é igual de uma classe regular, exceto pelo fato de 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.Assim, por exemplo, se você derivar um Fish classe a partir do Swimmer classe, Fish deve 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 Class Designer desenha uma linha de herança de Fish para Swimmer.
Classes anônimas
O Class Designer oferece suporte a classes anônimas.Tipos de classe anônima classes declarados sem um identificador.Eles não podem ter um construtor ou destrutor, não podem ser passados como argumentos para funções e não podem ser retornados como valores de retorno de funções.Você pode usar uma classe anônima para substituir um nome de classe com um nome de typedef, como no exemplo a seguir:
typedef struct
{
unsigned x;
unsigned y;
} POINT;
Estruturas também podem ser anônimas.Class Designer exibe anônimos classes e estruturas o mesmo ao exibir o respectivo tipo.Embora você possa declarar e exibir as estruturas e classes anônimas, o Class Designer não usará o nome da marca que você especificar.Ele usará o nome que gera de modo de exibição de classe.A classe ou estrutura aparece no modo de exibição de classe e o Class Designer como um elemento chamado __unnamed.
Para obter mais informações sobre classes anônimas, consulte Tipos de classe anônima.
Classes de modelo
O Class Designer oferece suporte a visualização das classes de modelo.Dá suporte a declarações aninhadas.A tabela a seguir mostra algumas declarações típicas.
Elemento de código |
O modo de exibição de 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 |
O modo de exibição de 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 na especialização parcial.
Elemento de código |
O modo de exibição de 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 Classe (aponta para a classe A) C Classe (aponta para a classe A) |
A tabela a seguir mostra alguns exemplos de especialização parcial de funções do modelo.
Elemento de código |
O modo de exibição de 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 dentro de classe a em Tipos aninhados) |
template <class T> class C {}; class A : C<int> {}; |
A Classe -> C <int> C<T> Classe de modelo |
A tabela a seguir mostra alguns exemplos de herança do modelo.
Elemento de código |
O modo de exibição de Designer de classe |
|---|---|
template <class T> class C {}; template<> class C<int> { class B {}; } class A : C<int>::B {}; |
A Classe -> b C<int> Classe (B está contido dentro de classe c em Tipos aninhados) C<T> Classe de modelo |
A tabela a seguir mostra alguns exemplos de conexão com a classe especializado canônico.
Elemento de código |
O modo de exibição de Designer de classe |
|---|---|
template <class T> class C {}; template<> class C<int> {}; class A : C<int> {}; class D : C<float> {}; |
A Classe -> c <int> C<int> Classe C<T> Classe de modelo D Classe -> c <float> |
class B { template <class T> T min (const T &a, const T &b); }; |
B min <T> |
Consulte também
Referência
Conceitos
Trabalhando com o código do Visual C++ (Designer de classe)