Práce s kódem C++ v Návrháři tříd

Návrhář tříd zobrazí vizuální návrhovou plochu označovanou jako diagram tříd , který poskytuje vizuální znázornění prvků kódu v projektu. Diagramy tříd můžete použít k návrhu a vizualizaci tříd a dalších typů v projektu.

Návrhář tříd podporuje následující prvky kódu C++:

Třída (podobá se obrazci spravované třídy s tím rozdílem, že může mít více vztahů dědičnosti)
Anonymní třída (zobrazí vygenerovaný název zobrazení třídy pro anonymní typ)
Třída šablony
Struktura
Enum
Makro (zobrazí zobrazení makra po zpracování)
Typedef

Poznámka:

Není to stejné jako diagram tříd UML, který můžete vytvořit v projektu modelování. Další informace naleznete v tématu Diagramy tříd UML: Referenční informace.

Třídy C++ v Návrháři tříd

Návrhář tříd podporuje třídy C++ a vizualizuje nativní třídy C++ stejným způsobem jako obrazce tříd jazyka Visual Basic a C#, s tím rozdílem, že třídy C++ mohou mít více vztahů dědičnosti. Obrazec třídy můžete rozšířit tak, aby zobrazoval více polí a metod ve třídě, nebo ho sbalit, aby se ušetřilo místo.

Poznámka:

Návrhář tříd nepodporuje unie (speciální typ třídy, ve které je přidělena paměť pouze na množství potřebné pro největší datový člen unie).

Jednoduchá dědičnost

Když přetáhnete více než jednu třídu do diagramu tříd a třídy mají vztah dědičnosti tříd, šipka je spojí. Šipka ukazuje ve směru základní třídy. Když se například v diagramu tříd zobrazí následující třídy, spojí je šipka, která ukazuje z B na A:

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

Do diagramu třídy můžete také přetáhnout pouze třídu B, kliknout pravým tlačítkem myši na obrazec třídy pro B a potom kliknout na zobrazit základní třídy. Zobrazí se její základní třída: A.

Vícenásobná dědičnost

Návrhář tříd podporuje vizualizaci vztahů dědičnosti více tříd. Vícenásobná dědičnost se používá, když odvozená třída má atributy více než jedné základní třídy. Následuje příklad vícenásobné dědičnosti:

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

Když přetáhnete více než jednu třídu do diagramu tříd a tyto třídy mají vztah vícenásobné dědičnosti tříd, šipka je spojí. Šipka ukazuje ve směru základních tříd.

Po kliknutí pravým tlačítkem myši na obrazec třídy a po kliknutí na příkaz Zobrazit základní třídy se zobrazí základní třídy pro vybranou třídu.

Poznámka:

Příkaz Zobrazit odvozené třídy není podporován pro kód jazyka C++. Odvozené třídy můžete zobrazit tak, že přejdete do zobrazení třídy, rozbalíte uzel typu, rozbalíte podsložku Odvozené typy a potom tyto typy přetáhnete do diagramu tříd.

Další informace o dědičnosti více tříd naleznete v tématu Více dědičnost a Více základních tříd.

Abstraktní třídy

Návrhář tříd podporuje abstraktní třídy (označované také jako abstraktní základní třídy). Jedná se o třídy, které nikdy neinstancujete, ale z nichž můžete odvodit jiné třídy. Pomocí příkladu z "Více dědičnosti" dříve v tomto dokumentu můžete vytvořit instanci třídy Bird jako samostatné objekty následujícím způsobem:

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

Možná ale nebudete chtít vytvořit instanci Swimmer třídy jako jednotlivé objekty. Můžete mít v úmyslu odvozovat pouze jiné typy tříd zvířat, například Penguin, Whale a Fish. V takovém případě byste třídu deklarovala Swimmer jako abstraktní základní třídu.

Chcete-li deklarovat třídu jako abstraktní, můžete použít abstract klíčové slovo. Členy označené jako abstraktní nebo zahrnuté v abstraktní třídě jsou virtuální a musí být implementovány třídami odvozenými z abstraktní třídy.

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

Třídu můžete také deklarovat jako abstraktní zahrnutím alespoň jedné čistě virtuální funkce:

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

Když tyto deklarace zobrazíte v diagramu tříd, název Swimmer třídy a jeho čistě virtuální funkce swim se zobrazí v kurzívě v abstraktním obrazci třídy spolu s notací Abstraktní třída. Všimněte si, že obrazec abstraktního typu třídy je stejný jako obrazec normální třídy s tím rozdílem, že jeho ohraničení je tečkovaná čára.

Třída odvozená z abstraktní základní třídy musí přepsat každou čistě virtuální funkci v základní třídě, jinak nelze odvozenou třídu instanciovat. Pokud například odvozujete Fish třídu z Swimmer třídy, Fish musí přepsat metodu swim :

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

int main()
{
   Fish guppy;
}

Když tento kód zobrazíte v diagramu tříd, Návrhář tříd nakreslí čáru dědičnosti z Fish do Swimmer.

Anonymní třídy

Návrhář tříd podporuje anonymní třídy. Anonymní typy tříd jsou třídy deklarované bez identifikátoru. Nemohou mít konstruktor nebo destruktor, nelze je předat jako argumenty funkcím a nelze je vrátit jako návratové hodnoty z funkcí. Anonymní třídu můžete použít k nahrazení názvu třídy názvem typedef, jako v následujícím příkladu:

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

Struktury mohou být také anonymní. Návrhář tříd zobrazuje anonymní třídy a struktury stejné jako u příslušného typu. I když můžete deklarovat a zobrazovat anonymní třídy a struktury, Návrhář tříd nebude používat zadaný název značky. Použije název, který vygeneruje Class View. Třída nebo struktura se zobrazí v zobrazení třídy a Návrhář tříd jako prvek s názvem __unnamed.

Další informace o anonymních třídách naleznete v tématu Anonymní typy tříd.

Třídy šablon

Návrhář tříd podporuje vizualizaci tříd šablon. Podporují se vnořené deklarace. Následující tabulka uvádí některé typické deklarace.

Element kódu	Pohled návrháře tříd
`template <class T>` `class A {};`	`A<T>` Třída šablony
`template <class T, class U>` `class A {};`	`A<T, U>` Třída šablony
`template <class T, int i>` `class A {};`	`A<T, i>` Třída šablony
`template <class T, template <class K> class U>` `class A {};`	`A<T, U>` Třída šablony

Následující tabulka uvádí několik příkladů částečné specializace.

Element kódu	Návrhář tříd – Zobrazení
`template<class T, class U>` `class A {};`	`A<T, U>` Třída šablony
`template<class T>` `class A<T, T> {};`	`A<T, T>` Třída šablony
`template <class T>` `class A<T, int> {};`	`A<T, int>` Třída šablony
`template <class T1, class T2>` `class A<T1, T2> {};`	`A<T1, T2>` Třída šablony

Následující tabulka uvádí některé příklady dědičnosti v částečné specializaci.

Element kódu	Zobrazení návrháře tříd
`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>` Třída šablony `B` Class (odkazuje na třídu A) `C` Class (odkazuje na třídu A)

Následující tabulka uvádí některé příklady částečných funkcí šablon specializace.

Element kódu	Zobrazení Návrháře tříd
`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 přetížení)
`template <class T1>` `class A {` `template <class T2>` `class B {};` `};` `template<> template<>` `class A<type>::B<type> {};`	`A<T1>` Třída šablony `B<T2>` Třída šablony (B je obsažen v třídě A v rámci vnořených typů)
`template <class T>` `class C {};` `class A : C<int> {};`	`A` Class -> C<int> `C<T>` Třída šablony

Následující tabulka uvádí některé příklady dědičnosti šablon.

Element kódu	Návrhář tříd: Zobrazení
`template <class T>` `class C {};` `template<>` `class C<int> {` `class B {};` `}` `class A : C<int>::B {};`	`A` Class ->B `C<int>` Class (B je obsažen v třídě C v rámci vnořených typů) `C<T>` Třída šablony

Následující tabulka uvádí některé příklady standardního specializovaného propojení třídy.

Element kódu	Návrhář tříd - zobrazení
`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>` Třída šablony `D` Class ->C<float>
`class B {` `template <class T>` `T min (const T &a, const T &b);` `};`	`B` min <T>

Výčty jazyka C++ v Návrháři tříd

Návrhář tříd podporuje typy C++ enum a vymezené enum class typy. Následuje příklad:

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

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

Obrazec výčtu jazyka C++ v diagramu tříd má podobný vzhled a funkci jako obrazec struktury s tím rozdílem, že popisek obsahuje Enum nebo Enum class, je růžová místo modré a má barevné ohraničení na levém a horním okraji. Obrazce výčtu i obrazce struktury mají čtvercové rohy.

Další informace o použití enum typu naleznete v tématu Výčty.

Definice typedef jazyka C++ v Návrháři tříd

Příkazy Typedef vytvářejí jednu nebo více vrstev nepřímého rozdělení mezi názvem a jeho základním typem. Návrhář tříd podporuje typy typedef jazyka C++, které jsou deklarovány klíčovým slovem typedef, například:

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

Tento typ pak můžete použít k deklaraci instance:

COORD OriginPoint;

Obrazce tříd a struktur

V Návrháři tříd má typedef jazyka C++ tvar typu zadaného v typedef. Pokud zdroj deklaruje typedef class, obrazec má zaoblené rohy a štítek Class. Obrazec typedef struct má čtvercové rohy a popisek Struct.

Třídy a struktury můžou mít vnořené definice typedef deklarované v rámci nich. V Návrháři tříd mohou tvary tříd a struktur zobrazovat vnořené deklarace typedef jako vnořené tvary.

Tvary Typedef podporují příkazy Zobrazit jako asociaci a Zobrazit jako asociaci kolekce v místní nabídce (kontextové).

Příklad typedef třídy

class B {};
typedef B MyB;

Typedef třídy C++ v Návrháři tříd

Příklad typedef struktury

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

Typedef struktury C++ v Návrháři tříd

Nepojmenované typedefs

I když můžete deklarovat typedef bez názvu, Class Designer nepoužívá název značky, který zadáte. Návrhář tříd používá název, který je generován nástrojem Zobrazení tříd. Například následující deklarace je platná, ale zobrazí se v Zobrazení tříd a Návrhář tříd jako objekt s názvem __unnamed:

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

Poznámka:

Návrhář tříd nezobrazuje definice typedef, jejichž zdrojovým typem je ukazatel funkce.

Informace o omezeních elementů kódu jazyka C++

Při načtení projektu C++, Návrhář tříd funguje jen pro čtení. Diagram tříd můžete změnit, ale změny z diagramu tříd nelze uložit zpět do zdrojového kódu.
Návrhář tříd podporuje pouze nativní sémantiku jazyka C++. Pro projekty C++, které jsou zkompilovány do spravovaného kódu, Návrhář tříd vizualizuje pouze prvky kódu, které jsou nativními typy. Proto můžete do projektu přidat diagram tříd, ale Návrhář tříd neumožňuje vizualizovat prvky, na kterých IsManaged je vlastnost nastavena true (to znamená typy hodnot a odkazové typy).
V případě projektů C++ návrhář tříd čte pouze definici typu. Předpokládejme například, že definujete typ v souboru hlavičky (.h) a definujete jeho členy v souboru implementace (.cpp). Pokud v souboru implementace (.cpp) vyvoláte "Zobrazit diagram tříd", Návrhář tříd nezobrazí nic. Jako další příklad, pokud vyvoláte "View Class Diagram" v souboru .cpp, který používá #include příkaz k zahrnutí jiných souborů, ale neobsahuje žádné skutečné definice třídy, Návrhář tříd znovu nezobrazí nic.
Soubory IDL (.idl), které definují rozhraní MODELU COM a knihovny typů, se nezobrazují v diagramech, pokud nejsou kompilovány do nativního kódu C++.
Návrhář tříd nepodporuje globální funkce a proměnné.
Návrhář tříd nepodporuje unie. Jedná se o speciální typ třídy, ve které je přidělena paměť pouze v množství potřebném pro největší datový člen unie.
Návrhář tříd nezobrazuje základní datové typy, například int a char.
Návrhář tříd nezobrazuje typy definované mimo aktuální projekt, pokud projekt nemá správné odkazy na tyto typy.
Návrhář tříd může zobrazit vnořené typy, ale ne vztahy mezi vnořeným typem a jinými typy.
Návrhář tříd nemůže zobrazit typy, které jsou void nebo které jsou odvozeny od typu void.

Řešení potíží s rozlišením typů a zobrazením

Umístění zdrojových souborů

Návrhář tříd nesleduje umístění zdrojových souborů. Proto pokud upravíte strukturu projektu nebo přesunete zdrojové soubory v projektu, Návrhář tříd může ztratit přehled o typu (zejména zdrojový typ typedef, základní třídy nebo typy přidružení). Může se zobrazit chyba, jako je návrhář tříd, nemůže zobrazit tento typ. Pokud to uděláte, přetáhněte upravený nebo přemísťovaný zdrojový kód do diagramu tříd znovu a znovu ho zobrazte.

Problémy s aktualizací a výkonem

U projektů C++ může trvat 30 až 60 sekund, než se změna zdrojového souboru zobrazí v diagramu tříd. Toto zpoždění může také způsobit , že Návrhář tříd vyvolá chybu Žádné typy nebyly nalezeny ve výběru. Pokud se zobrazí například chyba, klepněte v chybové zprávě na tlačítko Storno a počkejte, až se prvek kódu zobrazí v zobrazení třídy. Jakmile to uděláte, návrhář tříd by měl být schopen zobrazit typ.

Pokud se diagram tříd neaktualizuje změnami, které jste v kódu provedli, možná budete muset diagram zavřít a znovu ho otevřít.

Problémy s určováním typů

Návrhář tříd nemusí být schopen rozpoznat typy z následujících důvodů:

Typ je v projektu nebo sestavení, na který se neodkazuje z projektu, který obsahuje diagram tříd. Chcete-li tuto chybu opravit, přidejte odkaz na projekt nebo sestavení obsahující typ. Další informace naleznete v tématu Správa odkazů v projektu.
Typ není ve správném oboru, takže ho Návrhář tříd nemůže najít. Ujistěte se, že v kódu nechybí příkaz using, imports nebo #include. Také se ujistěte, že jste nepřesunuli typ (nebo související typ) z oboru názvů, ve kterém byl původně umístěn.
Typ neexistuje (nebo byl zakomentován). Chcete-li tuto chybu opravit, ujistěte se, že jste typ neodkomentovali nebo odstranili.
Typ se nachází v knihovně, na kterou se odkazuje příkazem #import. Možným alternativním řešením je ruční přidání vygenerovaného kódu (souboru .tlh) do direktivy #include do hlavičkového souboru.
Ujistěte se, že Návrhář tříd podporuje zadaný typ. Viz Omezení pro elementy kódu jazyka C++.

Chyba, kterou pravděpodobně uvidíte při problému s rozlišením typu, je, že kód nelze najít pro jeden nebo více obrazců v diagramu tříd element<>. Tato chybová zpráva nemusí nutně znamenat, že váš kód je chybný. Označuje pouze, že návrhář tříd nemohl zobrazit váš kód. Vyzkoušejte následující míry:

Ujistěte se, že typ existuje. Ujistěte se, že jste neúmyslně neodkomentovali nebo odstranili zdrojový kód.
Pokuste se vyřešit typ. Typ může být v projektu nebo sestavení, na které se neodkazuje z projektu obsahujícího diagram tříd. Chcete-li tuto chybu opravit, přidejte odkaz na projekt nebo sestavení obsahující typ. Další informace naleznete v tématu Správa odkazů v projektu.
Ujistěte se, že typ je ve správném rozsahu, aby jej Návrhář tříd mohl vyhledat. Ujistěte se, že kódu nechybí using, imports, nebo #include příkaz. Také se ujistěte, že jste nepřesunuli typ (nebo související typ) z oboru názvů, ve kterém byl původně umístěn.

Návod

Další informace o řešení potíží najdete v tématu Chyby Návrháře tříd.

Co je Návrhář tříd?

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-10-31

Sdílet prostřednictvím

Práce s kódem C++ v Návrháři tříd

Třídy C++ v Návrháři tříd

Jednoduchá dědičnost

Vícenásobná dědičnost

Abstraktní třídy

Anonymní třídy

Třídy šablon

Výčty jazyka C++ v Návrháři tříd

Definice typedef jazyka C++ v Návrháři tříd

Obrazce tříd a struktur

Příklad typedef třídy

Příklad typedef struktury

Nepojmenované typedefs

Informace o omezeních elementů kódu jazyka C++

Řešení potíží s rozlišením typů a zobrazením

Umístění zdrojových souborů

Problémy s aktualizací a výkonem

Problémy s určováním typů

Související obsah

Váš názor

Další materiály