V Φlßnku o Microsoft Visual Studiu .NET v ΦervnovΘm Chipu jsme slφbili, ₧e se k podporovan²m jazyk∙m vrßtφme v samostatn²ch Φlßncφch. Na prost°edφ Visual C# .NET doÜlo hned o m∞sφc pozd∞ji, nynφ se podφvßme na Visual C++ .NET.
Recenze softwarovΘho produktu obvykle zaΦφnajφ srovnßnφm novΘ verze s p°edchozφ. V p°φpad∞ Visual C++ .NET by takovΘ srovnßnφ zabralo cel² Φlßnek, nebo¥ od vydßnφ p°edchozφ verze, Visual C++ 6, uplynuly ji₧ Φty°i dlouhΘ roky. Zde proto upozornφme jen na nejd∙le₧it∞jÜφ rozdφly:
* Visual C++ .NET umo₧≥uje generovat jak programy s ne°φzen²m k≤dem, tj. s k≤dem pro prost°edφ Win32, tak i programy s °φzen²m k≤dem pro platformu .NET Framework (NF). Ve skuteΦnosti jde o jedinou souΦßst Visual Studia .NET, kterß umφ vytvß°et "klasick²" k≤d urΦen² pro Win32.
* Implementace jazyka C++ se p°iblφ₧ila standardu ISO 14882 - 1998.
* Visual C++ .NET umo₧≥uje vytvß°et °adu nov²ch typ∙ projekt∙, mimo jinΘ i webovΘ slu₧by v C++.
Provedenφ
Visual C++ lze zφskat samostatn∞ pod oznaΦenφm Visual C++ Standard Edition nebo jako souΦßst n∞kterΘho z provedenφ Visual Studia .NET. (Visual Studio .NET se, jak u₧ vφme, v provedenφ Standard nedodßvß; jeho nejni₧Üφ verze je oznaΦena Professional.)
Visual C++ Standard Edition obsahuje pouze zßkladnφ v²vojovΘ nßstroje, tedy integrovanΘ v²vojovΘ prost°edφ, p°ekladaΦ, ladicφ nßstroje a knihovny. Toto provedenφ je urΦeno p°edevÜφm pro zßkladnφ v²uku programovßnφ. Teprve vyÜÜφ provedenφ lze pou₧φt k v²voji vß₧n∞ mφn∞n²ch aplikacφ.
Tato recenze vychßzφ ze zkuÜenosti s prost°edφm Visual C++, kterΘ je souΦßstφ provedenφ Enterprise Architect. Nebudeme se v nφ u₧ vracet k v∞cem, o nich₧ byla °eΦ v Chipu 6/02 (VÜechno je jinak, str. 104).
IntegrovanΘ v²vojovΘ prost°edφ
IntegrovanΘ v²vojovΘ prost°edφ (IDE) je v podstat∞ stejnΘ jako u ostatnφch jazyk∙, kterΘ jsou souΦßstφ novΘho Visual Studia. Rozdφly najdeme pouze v podru₧n²ch detailech - nap°φklad ve srovnßnφ s Visual C# .NET v nabφdce nenajdeme p°φkaz pro generovßnφ dokumentace na zßklad∞ dokumentaΦnφch komentß°∙, liÜφ se i implicitnφ zp∙sob automatickΘho odsazovßnφ atd.
Nßpov∞da
Podobn∞ jako ve Visual C# je i zde vedle konvenΦnφ nßpov∞dy k dispozici takΘ dynamickß nßpov∞da. To znamenß, ₧e v jednom z pomocn²ch oken se v pr∙b∞hu psanφ programu neustßle zobrazujφ tΘmata odpovφdajφcφ prßv∞ zapisovanΘmu klφΦovΘmu slovu nebo knihovnφmu identifikßtoru. V p°φpad∞, ₧e napφÜeme jmΘno t°φdy nebo prostoru jmen a za n∞ n∞kter² z operßtor∙ ::, . nebo -> (podle toho, co dovolujφ syntaktickß pravidla), nabφdne nßm IDE v bublin∞ seznam mo₧n²ch slo₧ek. Podobn∞ po napsßnφ otevφracφ zßvorky za jmΘnem funkce nebo metody nßm IDE nabφdne seznam typ∙ jejφch parametr∙. Musφme ale mφt na pam∞ti, ₧e vÜechny tyto mechanismy fungujφ sprßvn∞ pouze tehdy, mß-li prost°edφ v mφst∞ zßpisu vÜechny pot°ebnΘ informace, tj. p°edchßzφ-li odpovφdajφcφ deklarace nebo direktiva using.
Lad∞nφ
Integrovan² ladicφ program Visual Studia .NET samoz°ejm∞ podporuje obvykl² komfort: krokovßnφ na ·rovni zdrojovΘho k≤du a disasemblovanΘho strojnφho k≤du (nikoli vÜak mezijazyka IL), a to se vstupem do procedur i bez n∞j, kontextov∞ zßvislΘ sledovßnφ hodnot lokßlnφch prom∞nn²ch a nßvratov²ch hodnot funkcφ, pou₧φvßnφ zarß₧ek (breakpoints) vßzan²ch na mφsto ve zdrojovΘm k≤du, na spln∞nφ urΦitΘ podmφnky, na p°φstup k dat∙m atd. K dispozici jsou i nßstroje pro vzdßlenΘ lad∞nφ, tedy pro lad∞nφ distribuovan²ch aplikacφ.
Podobn∞ jako p°edchozφ verze, i Visual Studio .NET podporuje takΘ editaci zdrojovΘho k≤du v pr∙b∞hu lad∞nφ (edit and continue). Tato schopnost je u₧iteΦnß zejmΘna p°i lad∞nφ velice rozsßhl²ch projekt∙, nebo¥ po zßsahu do zdrojovΘho k≤du v pr∙b∞hu lad∞nφ se p°elo₧φ jen nezbytnß Φßst a ta se p°ipojφ k hotovΘmu spustitelnΘmu programu, ani₧ se p°eruÜφ lad∞nφ.
Existujφ samoz°ejm∞ situace, kdy tento mechanismus pou₧φt nelze a je nutno p°elo₧it a znovu sestavit cel² program. NicmΘn∞ i tak tato schopnost znamenß v²znamnou ·sporu Φasu p°i lad∞nφ. (Editace zdrojovΘho k≤du v pr∙b∞hu lad∞nφ je k dispozici pouze ve Visual C++ .NET, ostatnφ souΦßsti Visual Studia .NET ji bohu₧el postrßdajφ.)
Vizußlnφ v²voj
Na rozdφl od Visual C# .NET a Visual Basic .NET nenabφzφ Visual C++ .NET mo₧nost vizußlnφho v²voje aplikacφ s grafick²m u₧ivatelsk²m rozhranφm, a to ani pro °φzen², ani pro ne°φzen² k≤d. (Vizußlnφ nßvrhß° pro °φzen² k≤d by vÜak m∞l b²t souΦßstφ p°ipravovanΘ novΘ verze Visual C++.)
Je jasnΘ, ₧e vytvo°it nßstroj pro vizußlnφ nßvrh jen s pou₧itφm samotnΘho C++ je pom∞rn∞ obtφ₧nΘ. NicmΘn∞ v p°φpad∞ C++ pro °φzen² k≤d jsou k dispozici stejnΘ knihovny jako ve Visual C# .NET nebo ve Visual Basic .NET a postup by se liÜil jen v detailech vygenerovanΘho k≤du, tak₧e mi nenφ jasnΘ, proΦ tato mo₧nost ve Visual C++ chybφ.
Sprßva projekt∙
Podobn∞ jako v p°edchozφ verzi je zßkladnφ jednotkou v²voje projekt. V p°edchozφ verzi jsme projekty seskupovali do pracovnφch prostor∙ (workspace), ve Visual C++ .NET mφsto nich pou₧φvßme °eÜenφ (solution). Rozdφl je - alespo≥ z hlediska b∞₧nΘho u₧ivatele - jen formßlnφ. ╪eÜenφ je popsßno v souboru .sln, co₧ je textov² soubor se zßkladnφmi informacemi o projektech v n∞m obsa₧en²ch. JednotlivΘ projekty jsou popsßny v souborech .vcproj, a to ve formßtu XML. IDE samoz°ejm∞ umφ bez problΘm∙ otev°φt i projekty a pracovnφ prostory z p°edchozφ verze Visual C++. P°ibyly novΘ typy projekt∙ pro °φzen² k≤d.
Programovacφ jazyky
Visual C++ .NET v sob∞ skr²vß t°i vzßjemn∞ blφzkΘ, ale p°esto rozdφlnΘ programovacφ jazyky: jazyk C podle normy ISO 9899, jazyk C++ podle normy ISO 14882 (tj. pro ne°φzen² k≤d) a jazyk C++ s rozÜφ°enφmi pro platformu .NET (°φzen² k≤d - tato rozÜφ°enφ jsou natolik zßva₧nß, ₧e stojφ za to hovo°it o nich jako o samostatnΘm programovacφm jazyku).
Jazyk C
Implementace jazyka C vyhovuje mezinßrodnφ norm∞ ISO 9899 - 1990 s n∞kter²mi pozd∞jÜφmi dodatky a s microsoftsk²mi rozÜφ°enφmi. Neodpovφdß ovÜem druhΘ verzi standardu z roku 1999, nebo¥ neimplementuje nap°. celoΦφseln² typ long long, nelze pou₧φvat pojmenovanΘ inicializßtory pro slo₧ky struktur a polφ, nelze pou₧φvat slo₧enΘ literßly, nenφ k dispozici modifikßtor restrict, v p°φkazu cyklu for nelze deklarovat prom∞nnou, nelze deklarovat pole s prom∞nnou dΘlkou atd. Mφsto klφΦovΘho slova inline zavedenΘho nov²m standardem jazyka C je t°eba pou₧φt __inline.
Najdeme tu ovÜem funkce pro prßci s "Üirok²mi" znaky (tedy s vφcebajtov²mi znaky a s k≤dem UNICODE). V souladu se standardem jsou umφst∞ny v hlaviΦkov²ch souborech wctype.h a wchar.h.
Z rozÜφ°enφ jsou nepochybn∞ nejv²znamn∞jÜφ strukturovanΘ v²jimky (SEH - Structured Exception Handling) a mo₧nost pou₧φvat asembler. Ani jedno ovÜem nenφ niΦφm nov²m strukturovanΘ v²jimky se objevily ji₧ v prvnφch microsoftsk²ch p°ekladaΦφch jazyka C pro Win32 a klφΦovΘ slovo __asm je v microsoftsk²ch p°ekladaΦφch jeÜt∞ daleko starÜφ.
Jazyk C++ pro ne°φzen² k≤d
Implementace jazyka C++ se ve srovnßnφ s p°edchozφ verzφ p°iblφ₧ila standardu ISO 14882 1998. Hlavnφ novinky v tomto oboru m∙₧eme shrnout do nßsledujφcφch bod∙:
* Visual C++ .NET podporuje vno°enΘ Üablony.
* Visual C++ .NET podporuje p°et∞₧ovßnφ Üablon funkcφ.
* Operßtor new vyvolßvß - alespo≥ za jist²ch okolnostφ - v p°φpad∞ ne·sp∞ÜnΘ alokace v²jimku typu bad_alloc.
* Prom∞nnß deklarovanß v p°φkazu cyklu for m∙₧e b²t lokßlnφ v t∞le cyklu, pokud nastavφme odpovφdajφcφ p°epφnaΦ.
* T∞lo funkce nebo konstruktoru m∙₧e b²t tvo°eno blokem try/catch.
Z∙stala ovÜem °ada mφst, kde se implementace jazyka C++ ve Visual C++ .NET odchyluje od souΦasnΘho standardu. Podrobn² rozbor by vydal na menÜφ serißl, a proto se omezφme na pouh² v²Φet p°φpad∙, kdy Visual C++ .NET nenφ kompatibilnφ se standardem. ╚ßst z nßsledujφcφch informacφ je p°evzata z dokumentace, Φßst pochßzφ z vlastnφ zkuÜenosti a Φßst z Φlßnk∙ uve°ejn∞n²ch na webov²ch strßnkßch MSDN.
* Standard jazyka C++ doporuΦuje v dodatku B minimßlnφ hodnoty omezenφ pro urΦitΘ veliΦiny; implementace by nap°φklad m∞la povolovat alespo≥ 256 ·rovnφ vno°enφ direktiv #if. P°ekladaΦ Visual C++
* .NET n∞kterΘ z doporuΦen²ch hodnot nerespektuje. Jde nap°. o poΦet ·rovnφ vno°enφ slo₧en²ch p°φkaz∙, poΦet parametr∙ v definici a v pou₧itφ makra, poΦet parametr∙ v deklaraci Üablony atd.
* Visual C++ .NET nepodporuje klφΦovΘ slovo asm. Mφsto n∞j se podobn∞ jako v p°edchozφch verzφch - pou₧φvß klφΦovΘ slovo __asm, za nφm₧ nßsledujφ p°φkazy asembleru ve slo₧en²ch zßvorkßch.
* Visual C++ .NET sice podporuje vno°enΘ Üablony, ale n∞kterß sprßvnß pou₧itφ nedokß₧e p°elo₧it. Mn∞ se nap°. nepoda°ilo p°elo₧it uΦebnicov² p°φklad t°φdy obsahujφcφ Üablonu operßtoru p°etypovßnφ. (P°ekladaΦ hlßsil chyby p°i implicitnφm pou₧itφ tohoto operßtoru.)
* Lze najφt p°φklady, kdy p°ekladaΦ p°i vytvß°enφ instance Üablony nesprßvn∞ urΦφ externφ jmΘna pou₧itß v jejφ deklaraci.
* P°ekladaΦ neznß klφΦovß slova and, not, xor_eq a dalÜφ, jimi₧ lze nahradit operßtory &&, ~, ^= atd. (Pokud chceme tyto nßhrady pou₧φvat, musφme pou₧φt hlaviΦkov² soubor iso646.h, co₧ je v rozporu s normou.)
* Visual C++ .NET implementuje vyhledßvßnφ p°etφ₧en²ch operßtor∙ v zßvislosti na parametrech (tzv. Koenigovo vyhledßvßnφ), ovÜem pouze v p°φpad∞, ₧e byl pou₧it operßtorov² zßpis (nap°. a + b).
* V p°φpad∞ zßpisu operßtorovΘ funkce (nap°. a.operator+(b)), se Koenigovo vyhledßvßnφ nepou₧ije, stejn∞ jako p°i volßnφ "obyΦejn²ch" (neoperßtorov²ch) funkcφ a metod.
Visual C++ .NET umo₧≥uje deklarovat v podmφnce p°φkazu if prom∞nnou, ale nesprßvn∞ interpretuje jejφ oblast platnosti.
* Visual C++ .NET neimplementuje klφΦovΘ slovo export pro Üablony. (Pokud vφm, neimplementuje ho ₧ßdn² souΦasn² komerΦnφ p°ekladaΦ, a to p°esto, ₧e je souΦßstφ standardu ji₧ Φty°i roky. Jde z°ejm∞ o jednu z nejproblematiΦt∞jÜφch konstrukcφ ve standardu C++.)
* T°φdu, kterou deklarujeme jako slo₧ku Üablony t°φdy, musφme v jejφm t∞le takΘ definovat. Visual C++ .NET nedovoluje uvΘst v t∞le Üablony t°φdy jen deklaraci t°φdy a definici zapsat mimo t∞lo.
* Visual C++ .NET nepodporuje parcißlnφ specializaci Üablon t°φd.
* Visual C++ .NET nepodporuje parcißlnφ °azenφ Üablon funkcφ.
* Visual C++ .NET sice umo₧≥uje zapsat za hlaviΦku funkce nebo metody specifikaci typ∙ v²jimek, kterΘ se z nφ mohou rozÜφ°it, avÜak respektuje pouze specifikaci throw() s prßzdn²m seznamem. (To platilo i v p°edchozφ verzi.)
* Funkce uncaught_exception() vracφ v₧dy false.
* Visual C++ .NET nepodporuje univerzßlnφ jmΘna znak∙ zapisovanß pomocφ \uXXXX, nebo \UXXXXXXXX, tj. v k≤dovßnφ UNICODE, a to ani ve znakov²ch konstantßch, ani v identifikßtorech.
* Visual C++ nedovoluje prßzdn² inicializßtor struktur a polφ.
RozÜφ°enφ C++ pro °φzen² k≤d
Tv∙rci p°ekladaΦe C++ pro °φzen² k≤d ve Visual Studiu .NET stßli p°ed nelehk²m ·kolem: P°izp∙sobit jazyk C++ po₧adavk∙m prost°edφ NF tak, aby programy v C++ mohly vyu₧φvat komponent napsan²ch v jin²ch programovacφch jazycφch - a naopak, abychom mohli v C++ psßt komponenty pou₧itelnΘ v jakΘmkoli jinΘm jazyku v tomto prost°edφ. To znamenß, ₧e datovΘ typy musφ nap°. mφt spoleΦnΘho p°edka, t°φdu System::Object, musφ b²t zalo₧eny na jednoduchΘ d∞diΦnosti, musφ podporovat uklßdßnφ metadat do p°elo₧en²ch soubor∙ atd. P°esn∞ji °eΦeno, musφ mj. vyhovovat po₧adavk∙m spoleΦnΘho typovΘho systΘmu (CTS) prost°edφ NF.
V²sledkem t∞chto ·prav jsou rozÜφ°enφ jazyka C++ pro °φzen² k≤d, anglicky oznaΦovanß Managed Extensions. Podrobn² v²klad o nich by byl dalÜφm nßm∞tem na serißl, nebo¥ jen jejich specifikace dopln∞nß struΦn²mi p°φklady zabφrß p°es sto stran formßtu A4. Proto se omezφme alespo≥ na zßkladnφ informace.
Na jazyk C++ pro °φzen² k≤d se m∙₧eme dφvat jako na C# zapsanΘ pomocφ vyjad°ovacφch prost°edk∙ obvykl²ch v C++. Posu∩te sami:
V programech pro NF musφme mφt k dispozici nejen datovΘ typy z knihoven tohoto prost°edφ (BCL, knihovny pro "okna", pro prßci s databßzemi atd.), ale i ve°ejn∞ p°φstupnΘ datovΘ typy z ostatnφch program∙ a knihoven pro NF. Aby s nimi bylo mo₧nΘ pracovat, musφ si p°ekladaΦ um∞t p°eΦφst jejich metadata. K tomu slou₧φ direktiva #using, je₧ umo₧≥uje pou₧φt dynamickΘ knihovny z NF podobn∞ jako hlaviΦkovΘ soubory. Nap°φklad tΘm∞° vÜechny programy pro NF zaΦφnajφ direktivou
#using <mscorlib.dll>
Standardnφ knihovny jsou v prost°edφ NF rozd∞leny do velkΘho mno₧stvφ hierarchicky uspo°ßdan²ch prostor∙ jmen. Jim odpovφdajφ knihovny, na kterΘ lze v direktiv∞ #using odkazovat zßpisem slo₧en²m z jednotliv²ch vno°en²ch prostor∙ jmen spojen²ch teΦkami. Nap°φklad nßstroje pro tvorbu grafickΘho u₧ivatelskΘho rozhranφ, kterΘ najdeme v prostoru jmen System::Windows::Forms, zp°φstupnφme zßpisem
#using <System.Windows.Forms.dll> using namespace System::Windows::Forms;
T°φdy v prost°edφ NF vyhovujφcφ specifikaci CTS majφ spoleΦnΘho p°edka, t°φdu System::Object. Jejich instance jsou ruÜeny automatickou sprßvou pam∞ti (garbage collector), zatφmco t°φdy v C++ nemusφ le₧et v ₧ßdnΘ d∞dickΘ hierarchii a jejich instance musφ programßtor ruÜit sßm. Abychom mohli v programech pro °φzen² k≤d pou₧φvat jak t°φdy vyhovujφcφ CTS, tak i "klasickΘ" t°φdy z C++, zavßdφ Visual C++ .NET modifikßtor __gc. T°φdy s tφmto modifikßtorem odpovφdajφ po₧adavk∙m CTS. Takovßto t°φda smφ mφt jen jedinΘho p°edka, a to op∞t t°φdu s modifikßtorem __gc; pokud u nφ p°edka nespecifikujeme, doplnφ si p°ekladaΦ t°φdu System::Object. Jejφ instance musφme vytvß°et dynamicky, pomocφ operßtoru __gc new, a platφ pro n∞ jeÜt∞ n∞kterß dalÜφ omezenφ - nap°φklad nesm∞jφ mφt kopφrovacφ konstruktor. Na druhΘ stran∞ mohou mφt nap°. statick² konstruktor, kter² se volß p°i zavedenφ t°φdy do pam∞ti a slou₧φ k inicializaci statick²ch datov²ch slo₧ek. (Jde o analogii statickΘho konstruktoru z C# nebo statickΘho inicializßtoru z Javy.)
K oznaΦenφ "klasick²ch" t°φd lze (a za jist²ch okolnostφ je t°eba) pou₧φt modifikßtor __nogc. Vedle toho m∙₧eme deklarovat t°φdy s modifikßtorem __value. Jde o analogii struktur z C#, tedy o t°φdy, jejich₧ instance se budou vytvß°et v zßsobnφku a kterΘ p°itom budou kompatibilnφ s CTS.
T°φdy s modifikßtorem __gc m∙₧eme takΘ deklarovat jako "zapeΦet∞nΘ" (sealed classes), tj. jako t°φdy, od nich₧ nelze odvodit potomka; v jejich deklaraci lze pou₧φt i modifikßtor __abstract, i kdy₧ je zbyteΦn².
K deklaraci t°φdy s modifikßtorem __gc lze p°ipojit specifikaci p°φstupov²ch prßv. Tyto t°φdy mohou vedle datov²ch slo₧ek, metod, konstruktor∙ a destruktoru obsahovat takΘ vlastnosti, udßlosti a operßtory p°etφ₧enΘ jako statickΘ metody (tedy podle pravidel jazyka C#; tyto operßtory ovÜem nelze v C++ pou₧φvat v infixovΘm zßpisu, tedy jako operßtory p°etφ₧enΘ podle pravidel C++).
Novinkou jsou takΘ tzv. delegßty, co₧ jsou vlastn∞ objektov∞ zapouzd°enΘ ukazatele na metody t°φd s modifikßtorem __gc. Nejde ovÜem o ukazatele v ₧ßdnΘm ze smysl∙ pou₧φvan²ch v C++, nebo¥ delegßt obsahuje bu∩ adresu nestatickΘ metody spolu s adresou objektu, pro n∞j₧ ji chceme volat, nebo adresu statickΘ metody. Delegßty typu void mohou obsahovat vφce ukazatel∙, co₧ je v²hodnΘ p°i zpracovßnφ udßlostφ.
P°i zpracovßnφ udßlostφ se pou₧φvß dnes u₧ klasick² nßvrhov² vzor "vydavatel-p°edplatitel" (publisher-subscriber), znßm² mj. z Javy.
K deklaracφm datov²ch typ∙, metod, parametr∙ atd. lze p°ipojit tzv. atributy, deklarativnφ informace, kterΘ se ulo₧φ v podob∞ metadat do p°elo₧enΘho souboru.
Knihovny
SouΦßstφ instalace je samoz°ejm∞ i °ada knihoven. Vedle standardnφ knihovny jazyka C je nepominutelnou souΦßstφ ka₧dΘ implementace jazyka C++ standardnφ Üablonovß knihovna (STL). Vzhledem k tomu, ₧e se souΦasnß implementace jazyka C++ ve Visual C++ .NET znaΦn∞ p°iblφ₧ila standardu, p°iblφ₧ila se standardu i implementace STL (to se t²kß mj. implementace alokßtoru). U₧ivatele knihovny se dotknou zejmΘna zm∞ny jmen t°φd n∞kter²ch reverznφch iterßtor∙. ProblΘmy m∙₧e zp∙sobit i skuteΦnost, ₧e n∞kterΘ iterßtory - nap°. pro t°φdu string - ji₧ nejsou implementovßny jako ukazatele. Autorem souΦasnΘ verze 3.10, stejn∞ jako p°edchozφch verzφ microsoftskΘ implementace knihovny STL, je P. J. Plauger.
Vedle toho zde najdeme tradiΦnφ knihovnu MFC verze 7.0. Krom∞ nßstroj∙ pro programovßnφ grafickΘho u₧ivatelskΘho rozhranφ v nφ najdeme prost°edky pro p°φstup k databßzφm prost°ednictvφm DAO a ODBC, pro sφ¥ovΘ programovßnφ zalo₧enΘ na Windows Sockets a pro programovßnφ pro internet. NovΘ t°φdy zapouzd°ujφ takΘ novΘ mo₧nosti, kterΘ p°inesly Windows 2000 a Windows XP. Pro vytvß°enφ komponent COM je k dispozici Üablonovß knihovna ATL verze 7. V aplikacφch pro °φzen² k≤d m∙₧eme samoz°ejm∞ pou₧φvat knihovnu BCL a dalÜφ knihovny z prost°edφ NF.
Po₧adavky
Nßroky Visual C++ .NET jsou podobnΘ jako u celΘho Visual Studia .NET. Minimum p°edstavuje PC vybaven² procesorem Intel Pentium II/450 MHz nebo kompatibilnφm, grafickou kartou SVGA s rozliÜenφm 600 x 800 pixel∙ a s dalÜφm b∞₧n²m p°φsluÜenstvφm. Nezbytn² je operaΦnφ systΘm Windows NT 4 Workstation, Windows NT 4 Server, Windows 2000 Professional, Windows 2000 Server nebo Windows XP Professional. Minimßlnφ nßroky na operaΦnφ pam∞¥ se liÜφ podle operaΦnφho systΘmu, a to od 64 MB RAM pro Windows NT 4 Workstation po 192 MB pro Windows 2000 Server. Plnß instalace zabere 600 MB na systΘmovΘm disku a 2 GB na instalaΦnφm disku.
Dojem
Celkov² dojem je t∞₧kΘ shrnout v jednΘ v∞t∞. Je to impozantnφ software, ovÜem ne zcela dokonΦen². Jeho nespornou v²hodou je ·zkß nßvaznost na operaΦnφ systΘm Windows a na platformu NF, stejn∞ jako snadnß spoluprßce s ostatnφmi v²vojov²mi nßstroji Visual Studia .NET.
Dß se vÜak i leccos vytknout: chybφ nßstroje pro vizußlnφ v²voj aplikacφ s grafick²m u₧ivatelsk²m rozhranφm a takΘ nßroky tohoto produktu jsou dosti kolosßlnφ. Rovn∞₧ shoda jazyka C++ se standardem (pokud jde o ne°φzen² k≤d) je pon∞kud menÜφ ne₧ u jin²ch konkurenΦnφch produkt∙, co₧ m∙₧e ovlivnit p°enositelnost program∙.
