Usare il codice C++ in Progettazione classi

Progettazione classi visualizza un'area di progettazione visiva denominata diagramma classi che fornisce una rappresentazione visiva degli elementi di codice nel progetto. È possibile usare diagrammi classi per progettare e visualizzare classi e altri tipi in un progetto.

Progettazione classi supporta gli elementi di codice C++ seguenti:

• Classe (simile a una forma di classe gestita, ad eccezione del fatto che può avere più relazioni di ereditarietà)

• Classe anonima (visualizza il nome generato da Visualizzazione classi per il tipo anonimo)

• Classe modello

• Struttura

• Enum

• Macro (visualizza la visualizzazione post-elaborata della macro)

• Definizione di tipo

Annotazioni

Questo non equivale al diagramma classi UML, che è possibile creare in un progetto di modellazione. Per altre informazioni, vedere Diagrammi classi UML: Riferimento.

Classi C++ nel Class Designer

Il Progettazione Classi supporta le classi C++ e visualizza le classi C++ native nello stesso modo delle forme di classe in Visual Basic e C#, ad eccezione del fatto che le classi C++ possono avere più relazioni di ereditarietà. È possibile espandere la forma della classe per visualizzare più campi e metodi nella classe o comprimerlo per risparmiare spazio.

Annotazioni

Progettazione di classi non supporta le union (un tipo speciale di classe in cui la memoria allocata è esattamente la quantità necessaria per il membro di dati più grande dell'union).

Ereditarietà semplice

Quando si trascinano più classi in un diagramma classi e le classi hanno una relazione di ereditarietà della classe, una freccia le connette. La freccia punta nella direzione della classe base. Ad esempio, quando le classi seguenti vengono visualizzate in un diagramma classi, una freccia le connette, puntando da B a A:

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

È anche possibile trascinare solo la classe B nel diagramma classi, fare clic con il pulsante destro del mouse sulla forma della classe per B e quindi scegliere Mostra classi base. Viene visualizzata la relativa classe di base: A.

Ereditarietà multipla

Progettazione classi supporta la visualizzazione delle relazioni di ereditarietà a più classi. L'ereditarietà multipla viene usata quando una classe derivata ha attributi di più classi di base. Di seguito è riportato un esempio di ereditarietà multipla:

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

Quando si trascinano più classi nel diagramma classi e le classi hanno una relazione di ereditarietà a più classi, una freccia le connette. La freccia punta nella direzione delle classi di base.

Fare clic con il pulsante destro del mouse su una forma di classe e quindi scegliere Mostra classi base per visualizzare le classi di base per la classe selezionata.

Annotazioni

Il comando Mostra classi derivate non è supportato per il codice C++. È possibile visualizzare le classi derivate passando a Visualizzazione classi, espandendo il nodo del tipo, espandendo la sottocartella Tipi derivati e trascinandoli nel diagramma classi.

Per altre informazioni sull'ereditarietà a più classi, vedere Ereditarietà multipla e più classi base.

Classi astratte

Designer di Classi supporta classi astratte (note anche come "classi base astratte"). Si tratta di classi che non si istanziano mai, ma da cui è possibile derivare altre classi. Usando un esempio di "Ereditarietà multipla" in precedenza in questo documento, è possibile creare un'istanza della classe Bird come oggetti distinti come segue:

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

Tuttavia, potresti non avere l'intenzione di creare istanze della classe Swimmer come oggetti singoli. Si potrebbe voler derivare solo altri tipi di classi animali da esso, ad esempio , PenguinWhale, e Fish. In tal caso, si dichiara la Swimmer classe come classe base astratta.

Per dichiarare una classe come astratta, è possibile usare la abstract parola chiave . I membri contrassegnati come astratti o inclusi in una classe astratta sono virtuali e devono essere implementati da classi che derivano dalla classe astratta.

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

È anche possibile dichiarare una classe come astratta includendo almeno una funzione virtuale pura:

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

Quando si visualizzano queste dichiarazioni in un diagramma classi, il nome Swimmer della classe e la relativa funzione swim virtuale pura vengono visualizzati in corsivo in una forma di classe astratta, insieme alla notazione Abstract Class. Si noti che la forma del tipo di classe astratta è uguale a quella di una classe regolare, ad eccezione del fatto che il bordo è una linea tratteggiata.

Una classe derivata da una classe base astratta deve eseguire l'override di ogni funzione virtuale pura nella classe di base oppure non è possibile creare un'istanza della classe derivata. Ad esempio, se si crea una classe Fish derivata dalla classe Swimmer, Fish deve eseguire l'override del metodo swim.

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

int main()
{
   Fish guppy;
}

Quando si visualizza questo codice in un diagramma classi, Progettazione classi disegna una linea di ereditarietà da Fish a Swimmer.

Classi anonime

Class Designer supporta le classi anonime. I tipi di classe anonimi sono classi dichiarate senza identificatore. Non possono avere un costruttore o un distruttore, non possono essere passati come argomenti alle funzioni e non possono essere restituiti come valori restituiti dalle funzioni. È possibile usare una classe anonima per sostituire un nome di classe con un nome typedef, come nell'esempio seguente:

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

Le strutture possono anche essere anonime. Class Designer visualizza le classi e le strutture anonime nello stesso modo in cui visualizza il rispettivo tipo. Sebbene sia possibile dichiarare e visualizzare classi e strutture anonime, Class Designer non userà il nome del tag che si specifica. Userà il nome generato da Visualizzazione Classi. La classe o la struttura viene visualizzata in Visualizzazione classi e Progettazione classi come elemento denominato __unnamed.

Per altre informazioni sulle classi anonime, vedere Tipi di classi anonime.

Classi modello

Progettazione classi supporta la visualizzazione delle classi modello. Le dichiarazioni annidate sono supportate. La tabella seguente illustra alcune dichiarazioni tipiche.

Elemento di codice	Visualizzazione del progettista di classi
template <class T> class A {};	A<T> Classe modello
template <class T, class U> class A {};	A<T, U> Classe modello
template <class T, int i> class A {};	A<T, i> Classe modello
template <class T, template <class K> class U> class A {};	A<T, U> Classe modello

La tabella seguente illustra alcuni esempi di specializzazione parziale.

Elemento di codice	Visualizzazione Designer di classi
template<class T, class U> class A {};	A<T, U> Classe modello
template<class T> class A<T, T> {};	A<T, T> Classe modello
template <class T> class A<T, int> {};	A<T, int> Classe modello
template <class T1, class T2> class A<T1*, T2*> {};	A<T1*, T2*> Classe modello

La tabella seguente illustra alcuni esempi di ereditarietà nella specializzazione parziale.

Elemento di codice	Visualizzazione Progettazione classi
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 modello B Class (punta alla classe A) C Class (punta alla classe A)

La tabella seguente illustra alcuni esempi di funzioni modello di specializzazione parziale.

Elemento di codice	Visualizzazione Designer di classi
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 overload)
template <class T1> class A { template <class T2> class B {}; }; template<> template<> class A<type>::B<type> {};	A<T1> Classe modello B<T2> Classe modello (B è contenuto nella classe A in Tipi annidati)
template <class T> class C {}; class A : C<int> {};	A Class -> C<int> C<T> Classe modello

La tabella seguente illustra alcuni esempi di ereditarietà dei modelli.

Elemento di codice	Visualizzazione Designer di classi
template <class T> class C {}; template<> class C<int> { class B {}; } class A : C<int>::B {};	A Class ->B C<int> Class (B è contenuto nella classe C in Tipi annidati) C<T> Classe modello

La seguente tabella mostra alcuni esempi di collegamento canonico di classi specializzate.

Elemento di codice	Visualizzazione Progettazione Classi
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 modello D Class ->C<float>
class B { template <class T> T min (const T &a, const T &b); };	B min <T>

Enumerazioni C++ in Progettazione classi

Class Designer supporta i tipi C++ enum e i tipi con ambito enum class. Di seguito è riportato un esempio:

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

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

Una forma di enumerazione C++ in un diagramma classi è simile a una forma di struttura, ad eccezione del fatto che l'etichetta recita Enum o Enum class, è rosa anziché blu e ha un bordo colorato sui margini sinistro e superiore. Entrambe le forme di enumerazione e le forme della struttura hanno angoli quadrati.

Per altre informazioni sull'uso del enum tipo, vedere Enumerazioni.

Typedef di C++ nel Designer di Classi

Le istruzioni Typedef creano uno o più livelli di riferimento indiretto tra un nome e il relativo tipo sottostante. Progettazione classi supporta i tipi typedef C++, dichiarati con la parola chiave typedef, ad esempio:

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

È quindi possibile usare questo tipo per dichiarare un'istanza:

COORD OriginPoint;

Classi e forme struct

In Progettazione classi un typedef C++ ha la forma del tipo specificato nel typedef. Se l'origine dichiara typedef class, la forma ha angoli arrotondati e l'etichetta Classe. Per typedef struct, la forma ha angoli quadrati ed è etichettata come Struct.

Le classi e le strutture possono avere typedef annidati dichiarati al loro interno. In Progettazione classi le forme di classe e struttura possono mostrare dichiarazioni typedef annidate come forme annidate.

Le forme Typedef supportano i comandi Mostra come associazione e Mostra come associazione di raccolta nel menu di scelta rapida.

Esempio typedef di classe

class B {};
typedef B MyB;

Esempio di typedef Struct

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

Typedef senza nome

Sebbene sia possibile dichiarare un typedef senza un nome, Progettazione classi non usa il nome del tag specificato. Progettazione classi usa il nome generato da Visualizzazione classi . Ad esempio, la dichiarazione seguente è valida, ma viene visualizzata in Visualizzazione classi e Progettazione classi come oggetto denominato __unnamed:

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

Annotazioni

Class Designer non visualizza i typedef il cui tipo di origine è un puntatore a funzione.

Informazioni sulle limitazioni per gli elementi di codice C++

• Quando viene caricato un progetto C++, Progettazione classi funziona in modo di sola lettura. È possibile modificare il diagramma classi, ma non è possibile salvare le modifiche dal diagramma classi al codice sorgente.

• Class Designer supporta solamente la semantica C++ nativa. Per i progetti C++ compilati in codice gestito, Progettazione classi visualizzerà solo gli elementi di codice che sono tipi nativi. Pertanto, è possibile aggiungere un diagramma classi a un progetto, ma Progettazione classi non consente di visualizzare gli elementi in cui la IsManaged proprietà è impostata su true (ovvero tipi valore e tipi riferimento).

• Nei progetti C++, il Class Designer legge solo la definizione del tipo. Si supponga, ad esempio, di definire un tipo in un file di intestazione (h) e di definirne i membri in un file di implementazione (.cpp). Se si richiama "Visualizza diagramma classi" nel file di implementazione (.cpp), Progettazione classi non visualizza nulla. Come altro esempio, se si richiama "Visualizza diagramma classi" in un file .cpp che usa un'istruzione #include per includere altri file, ma non contiene definizioni di classe effettive, Progettazione classi non visualizza di nuovo nulla.

• I file IDL (.idl), che definiscono interfacce COM e librerie di tipi, non sono visualizzati nei diagrammi a meno che non vengano compilati in codice C++ nativo.

• Progettazione classi non supporta funzioni e variabili globali.

• Progettazione classi non supporta le unioni. Si tratta di un tipo speciale di classe in cui la memoria allocata è solo la quantità necessaria per il membro dati più grande dell'unione.

• Class Designer non visualizza i tipi di dati di base, come int e char.

• Progettazione classi non visualizza i tipi definiti all'esterno del progetto corrente se il progetto non dispone di riferimenti corretti a tali tipi.

• Progettazione classi può visualizzare tipi annidati, ma non le relazioni tra un tipo annidato e altri tipi.

• Class Designer non può visualizzare tipi "void" o che derivano da un tipo "void".

Risolvere i problemi di risoluzione e visualizzazione dei tipi

Percorso dei file di origine

Class Designer non tiene traccia della posizione dei file di origine. Pertanto, se si modifica la struttura del progetto o si spostano i file di origine nel progetto, Progettazione classi può perdere traccia del tipo (in particolare il tipo di origine di un typedef, classi di base o tipi di associazione). È possibile che venga visualizzato un errore, come Class Designer non riesce a visualizzare questo tipo. In tal caso, trascinare nuovamente il codice sorgente modificato o rilocato nel diagramma classi per riprodurre nuovamente il codice sorgente.

Problemi di aggiornamento e prestazioni

Per i progetti C++, potrebbero essere necessari da 30 a 60 secondi per visualizzare una modifica nel file di origine nel diagramma classi. Questo ritardo potrebbe causare anche la generazione dell'errore Nessun tipo trovato nella selezione. Se viene visualizzato un errore di questo tipo, fare clic su Annulla nel messaggio di errore e attendere che l'elemento di codice venga visualizzato in Visualizzazione classi. Dopo aver eseguito questa operazione, Progettazione classi dovrebbe essere in grado di visualizzare il tipo.

Se un diagramma classi non viene aggiornato con le modifiche apportate nel codice, potrebbe essere necessario chiudere il diagramma e aprirlo di nuovo.

Problemi di risoluzione dei tipi

Progettazione classi potrebbe non essere in grado di risolvere i tipi per i motivi seguenti:

• Il tipo si trova in un progetto o in un assembly a cui non viene fatto riferimento dal progetto che contiene il diagramma classi. Per correggere l'errore, aggiungere un riferimento al progetto o all'assembly che contiene il tipo . Per altre informazioni, vedere Gestione dei riferimenti in un progetto.

• Il tipo non è nell'ambito corretto, quindi Progettazione classi non può individuarlo. Assicurarsi che il codice non sia mancante di un'istruzione using, importso #include . Assicurarsi inoltre di non aver spostato il tipo (o un tipo correlato) dallo spazio dei nomi in cui si trovava originariamente.

• Il tipo non esiste (o è stato commentato). Per correggere l'errore, assicurarsi di non aver commentato o eliminato il tipo.

• Il tipo si trova in una libreria a cui fa riferimento una direttiva #import. Una possibile soluzione alternativa consiste nell'aggiungere manualmente il codice generato (file con estensione tlh) a una direttiva #include nel file di intestazione.

• Assicurati che Class Designer supporti il tipo immesso. Vedere Limitazioni per gli elementi di codice C++.

L'errore che si verifica più probabilmente per un problema di risoluzione dei tipi è Il codice non è stato trovato per una o più forme nel diagramma delle classi '<element>'. Questo messaggio di errore non indica necessariamente che il codice è in errore. Indica solo che il designer di classi non è in grado di visualizzare il tuo codice. Provare le misure seguenti:

• Verificare che il tipo esista. Assicurati di non aver involontariamente impostato come commento o eliminato il codice sorgente.

• Provare a risolvere il tipo. Il tipo potrebbe trovarsi in un progetto o in un assembly a cui non viene fatto riferimento dal progetto che contiene il diagramma classi. Per correggere l'errore, aggiungere un riferimento al progetto o all'assembly che contiene il tipo . Per altre informazioni, vedere Gestione dei riferimenti in un progetto.

• Assicurarsi che il tipo sia nel corretto scope in modo che il Designer di classi possa individuarlo. Assicurarsi che il codice non sia mancante di un'istruzione using, importso #include . Assicurarsi inoltre di non aver spostato il tipo (o un tipo correlato) dallo spazio dei nomi in cui si trovava originariamente.

Suggerimento

Per altre informazioni sulla risoluzione dei problemi, vedere Errori del Designer di classi.

Contenuti correlati

• Che cos'è Class Designer?