Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00153 013972 11052405 na godz. na dobę w sumie
Visual C++ dla programujących w Visual Basicu - książka
Visual C++ dla programujących w Visual Basicu - książka
Autor: Liczba stron: 400
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-793-X Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> visual basic - programowanie
Porównaj ceny (książka, ebook, audiobook).
C i C++ to języki dla profesjonalnych programistów, którzy nie znoszą ograniczeń. Za ich ogromne możliwości (w C/C++ napisano większość systemów operacyjnych i aplikacji użytkowych, jakie są obecnie wykorzystywane) trzeba jednak zapłacić słoną cenę: nie jest łatwo nauczyć się C/C++, a jeszcze trudniej jest w nich efektywnie programować. Dlatego nie są one polecane jako narzędzia dla początkujących. Skoro jednak -- jak sugeruje tytuł tej książki -- znasz już Visual Basic, pierwsze kroki masz już za sobą.

Dla chcącego nic trudnego, zwłaszcza, że współczesne, wizualne środowiska programistyczne, takie jak Visual C++ Microsoftu, ułatwiają tworzenie i uruchamianie aplikacji. Dodatkowo, na rynku pojawił się kolejny język z rodziny C: C#. Znosi on wiele trudności, jakie stawiały przed programistą C i C++, stanowiąc jednocześnie podstawowy język w technologii .NET, polecanej przez Microsoft jako przyszłościowy model tworzenia aplikacji, także sieciowych.

C, C++, C# -- więcej możliwości, więcej satysfakcji:

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Visual C++ dla programuj¹cych w Visual Basicu Autor: Bill Locke T³umaczenie: Przemys³aw Steæ ISBN: 83-7197-793-X Tytu³ orygina³u: Visual C++ for VB Programmers Format: B5, stron: 376 C i C++ to jêzyki dla profesjonalnych programistów, którzy nie znosz¹ ograniczeñ. Za ich ogromne mo¿liwoġci (w C/C++ napisano wiêkszoġæ systemów operacyjnych i aplikacji u¿ytkowych, jakie s¹ obecnie wykorzystywane) trzeba jednak zap³aciæ s³on¹ cenê: nie jest ³atwo nauczyæ siê C/C++, a jeszcze trudniej jest w nich efektywnie programowaæ. Dlatego nie s¹ one polecane jako narzêdzia dla pocz¹tkuj¹cych. Skoro jednak — jak sugeruje tytu³ tej ksi¹¿ki — znasz ju¿ Visual Basic, pierwsze kroki masz ju¿ za sob¹. Dla chc¹cego nic trudnego, zw³aszcza, ¿e wspó³czesne, wizualne ġrodowiska programistyczne, takie jak Visual C++ Microsoftu, u³atwiaj¹ tworzenie i uruchamianie aplikacji. Dodatkowo, na rynku pojawi³ siê kolejny jêzyk z rodziny C: C#. Znosi on wiele trudnoġci, jakie stawia³y przed programist¹ C i C++, stanowi¹c jednoczeġnie podstawowy jêzyk w technologii .NET, polecanej przez Microsoft jako przysz³oġciowy model tworzenia aplikacji, tak¿e sieciowych. C, C++, C# — wiêcej mo¿liwoġci, wiêcej satysfakcji: • Podstawy jêzyków C i C++ • Ró¿nice miêdzy C a Visual Basic • C++ a Windows • Pisanie bibliotek DLL • Komponenty COM, formanty ActiveX, technologia .NET • Programowanie w jêzyku C# Spis treści Rozdział 1. Rozdział 2. O Autorze ...........................................................................................................................................................11 Wstęp................................................................................................................................................................... 13 Najpierw trochę historii .............................................................................................................................17 Historia Visual Basica i C++...................................................u..........................................19 Środowisko 16-bitowe ...................................................u.............................................19 Środowisko 32-bitowe ...................................................u.............................................24 .NET...............................................u...................................................u..........................26 Znaczenie języka Visual Basic...................................................u.......................................27 Mocne strony Visual Basica ...................................................u....................................27 Słabości języka Visual Basic ...................................................u...................................28 Znaczenie języka C++...................................................u...................................................u.30 Mocne strony C++ ...................................................u...................................................u30 Słabości języka C++ ...................................................u................................................31 Język C# ...................................................u...................................................u......................32 Podstawy języka C.......................................................................................................................................33 Elementy leksykalne ...................................................u...................................................u...34 Słowa kluczowe ...................................................u...................................................u....34 Identyfikatory...................................................u...................................................u........36 Stałe...................................................u...................................................u.................... ...37 Literały...................................................u...................................................u..................40 Predefiniowane stałe i makropolecenia ...................................................u...................42 ......43 Struktura ...................................................u...................................................u................ Funkcje ...................................................u...................................................u.................. Dyrektywy...................................................u...................................................u.............43 Struktura programu ...................................................u..................................................52 Czas życia ...................................................u...................................................u.............53 Zakres i widoczność...................................................u.................................................53 ......56 Prototypy...................................................u...................................................u...............56 Definicje...................................................u...................................................u................57 Wywoływanie funkcji...................................................u..............................................58 main, wmain, DllMain ...................................................u.............................................58 Wskaźniki funkcji ...................................................u...................................................u.60 Podsumowanie ...................................................u...................................................u............60 6 Rozdział 3. Rozdział 4. Rozdział 5. Visual C++ dla programujących w Visual Basicu Programowanie w języku C......................................................................................................................61 Zmienne oraz dane ...................................................u...................................................u......62 Specyfikatory oraz kwalifikatory typu...................................................u.....................62 Zmienne oraz ich deklaratory ...................................................u..................................63 Inicjalizacja ...................................................u...................................................u...........73 Wyrażenia...................................................u...................................................u....................76 Operatory oraz ich priorytety...................................................u...................................76 Priorytety operatorów ...................................................u..............................................78 Konwersje i rzutowanie typów ...................................................u................................81 Instrukcje...................................................u...................................................u.....................86 Instrukcje przypisania ...................................................u..............................................86 Instrukcje sterujące przebiegiem programu ...................................................u.............87 Pętle...................................................u...................................................u.................... ...90 Podsumowanie ...................................................u...................................................u............92 Podstawy języka C++..................................................................................................................................93 Elementy leksykalne ...................................................u...................................................u...94 Słowa kluczowe języka C++...................................................u....................................94 Identyfikatory...................................................u...................................................u........97 Stałe oraz literały ...................................................u...................................................u..97 Struktura ...................................................u...................................................u................ ......97 Dyrektywy...................................................u...................................................u.............98 Zakres, widoczność oraz czas życia...................................................u.......................100 Łączność ...................................................u...................................................u.............101 Funkcje ...................................................u...................................................u.................. ....102 Prototypy...................................................u...................................................u.............102 Zmienna liczba parametrów...................................................u...................................102 Przeciążanie funkcji ...................................................u...............................................103 Zmienne oraz dane ...................................................u...................................................u....104 RTTI — informacja o typie czasu wykonania...................................................u.......105 Definicje oraz deklaracje w języku C++...................................................u................106 Zmienne oraz ich deklaratory ...................................................u................................108 Przestrzeń nazw ...................................................u...................................................u..110 Wyrażenia...................................................u...................................................u..................112 Operatory ...................................................u...................................................u............112 Rzutowanie typów ...................................................u.................................................116 Instrukcje...................................................u...................................................u...................117 Obsługa błędów ...................................................u...................................................u..117 Obsługa wyjątków języka C++...................................................u..............................118 Strukturalna obsługa wyjątków...................................................u..............................120 Podsumowanie ...................................................u...................................................u..........120 Klasy w języku C++ ..................................................................................................................................121 Klasy...............................................u...................................................u..............................121 Pojęcia dotyczące programowania obiektowego ...................................................u...122 Podstawowe informacje o klasach ...................................................u.........................123 Nazwy ...................................................u...................................................u.................124 Składowe klasy ...................................................u...................................................u...125 Zmienne składowe ...................................................u.................................................126 Funkcje składowe...................................................u...................................................u126 Sterowanie dostępem do składowych ...................................................u....................136 Funkcje zaprzyjaźnione ...................................................u.........................................137 Spis treści Rozdział 6. Rozdział 7. 7 Klasy pochodne ...................................................u...................................................u.........138 Podstawy ...................................................u...................................................u.............139 Wielokrotne klasy bazowe...................................................u.....................................143 Deklaracja using...................................................u...................................................u..147 Klasy abstrakcyjne ...................................................u.................................................149 Podsumowanie ...................................................u...................................................u..........149 Język C++ a Windows............................................................................................................................. 151 Jak działa system Windows...................................................u..........................................152 Procesy oraz wątki ...................................................u.................................................152 Podsystem komunikatów ...................................................u.......................................152 Jak działa program dla Windows ...................................................u.................................157 Klasa Window...................................................u...................................................u.....157 Tworzenie głównego okna...................................................u.....................................157 Usługi podstawowe...................................................u................................................158 GDI ...................................................u...................................................u.....................167 Podsumowanie ...................................................u...................................................u..........172 Biblioteki DLL w języku C ...................................................................................................................173 Kurs tworzenia prostej biblioteki DLL w języku C ...................................................u.....174 Tworzenie biblioteki DLL z wykorzystaniem Visual C++ ......................................174 Eksportowanie funkcji z biblioteki DLL ...................................................u...............175 Tworzenie prototypu funkcji...................................................u..................................177 Definiowanie treści funkcji...................................................u....................................178 Uruchamianie Visual Basica z poziomu środowiska C++........................................179 Deklarowanie i wywoływanie funkcji z poziomu Visual Basica .............................182 Testowanie kodu C++...................................................u............................................184 Podsumowanie kursu ...................................................u.............................................186 Przekazywanie zmiennych liczbowych...................................................u........................186 Typy całkowite 4-bajtowe (Long) ...................................................u.........................186 Typy całkowite 2-bajtowe (Integer)...................................................u.......................188 Typy rzeczywiste 4-bajtowe (Single) ...................................................u....................188 Typy rzeczywiste 8-bajtowe (Double)...................................................u...................189 Typ logiczny (Boolean) ...................................................u.........................................189 Typ Currency ...................................................u...................................................u......190 Korzystanie z danych łańcuchowych ...................................................u...........................190 Przekazywanie łańcuchów w formacie języka C (ByVal)........................................190 Obsługa łańcuchów typu BSTR...................................................u.............................191 Przekazywanie tablic bajtów...................................................u..................................193 Przekazywanie i używanie struktur (typów UDT)...................................................u.......194 Przekazywanie i używanie zmiennych wariantowych ...................................................u.198 Przekazywanie i używanie tablic ...................................................u.................................199 Format Unicode a ANSI...................................................u...............................................201 Podsumowanie ...................................................u...................................................u..........203 Rozdział 8. Biblioteki DLL w języku C — praktyczne przykłady............................................................. 205 Biblioteki typów a biblioteki DLL ...................................................u...............................205 Kurs tworzenia biblioteki DLL zawierającej informacje biblioteki typów ..............206 Kilka ciekawych cech pliku IDL ...................................................u...........................210 Dodawanie zasobów do biblioteki DLL...................................................u.......................212 8 Visual C++ dla programujących w Visual Basicu Rozdział 9. Rozdział 10. Przykłady biblioteki DLL w języku C ...................................................u.........................213 Subclassing ...................................................u...................................................u.........213 Rozszerzenie możliwości programu instalacyjnego InstallShield............................218 Rozszerzone procedury przechowywane...................................................u...............219 Wywołania zwrotne, haki i inne paskudztwa ...................................................u........225 Podsumowanie ...................................................u...................................................u..........228 Komponenty i kontrolki .........................................................................................................................229 Podstawowe wiadomości na temat komponentów...................................................u.......230 Komponenty a dziedziczenie ...................................................u.......................................230 Dziedziczenie — definicja...................................................u.....................................231 Abstrakcja ...................................................u...................................................u...........231 Kapsułkowanie...................................................u...................................................u....231 Polimorfizm ...................................................u...................................................u........232 Dziedziczenie...................................................u...................................................u......232 Delegacja...................................................u...................................................u.............233 Agregacja ...................................................u...................................................u............234 COM...................................................u...................................................u..........................235 Interfejsy ...................................................u...................................................u.............235 Niestandardowe kontrolki ...................................................u............................................240 Metody wykorzystywane do tworzenia kontrolek ...................................................u.......242 Visual Basic 5 oraz 6 ...................................................u.............................................242 MFC ...................................................u...................................................u....................243 Visual Studio .NET...................................................u................................................243 Kontrolki ATL w szczegółach ...................................................u.....................................244 Tworzenie projektu kontrolki ...................................................u................................244 Dodawanie właściwości...................................................u.........................................252 Dodawanie metod ...................................................u..................................................258 Implementacja zdarzeń ...................................................u..........................................260 Mapy komunikatów systemu Windows...................................................u.................261 Obsługa myszy...................................................u...................................................u....262 Obsługa klawiatury ...................................................u................................................267 Strony właściwości ...................................................u................................................269 Poprawna trwałość właściwości ...................................................u............................274 Właściwości wyliczeniowe...................................................u....................................278 Kategoryzacja właściwości...................................................u....................................283 Zwracanie błędów...................................................u..................................................285 Bezpieczny w kontekście inicjalizacji i wykonywania skryptów.............................285 Licencjonowanie ...................................................u...................................................u.286 Interfejs ISimpleFrame ...................................................u..........................................287 Tworzenie kontrolki w oparciu o kontrolkę Windows...................................................u.291 Złożone kontrolki ...................................................u...................................................u......293 Podstawy języka C#..................................................................................................................................297 System typów języka C# ...................................................u..............................................298 Typy wartościowe w praktyce ...................................................u...............................298 Typy referencyjne ...................................................u..................................................302 Opakowywanie i odpakowywanie ...................................................u.........................304 Koncepcje programistyczne ...................................................u.........................................305 Przestrzenie nazw...................................................u...................................................u305 Instrukcje...................................................u...................................................u.............308 Operatory ...................................................u...................................................u............312 Spis treści 9 Rozdział 11. Tablice...................................................u...................................................u.......................314 Struktury...................................................u...................................................u................ ....316 Klasy...............................................u...................................................u..............................319 Klasa Object...................................................u...................................................u........320 Metody ...................................................u...................................................u................321 Właściwości ...................................................u...................................................u........325 Operatory ...................................................u...................................................u............326 Dziedziczenie...................................................u...................................................u......331 Interfejsy............................................u...................................................u...........................333 Delegaty ...................................................u...................................................u....................335 Podsumowanie ...................................................u...................................................u..........336 Język C# w praktyce............................................................................................................................... 337 Kontrolki Windows Forms w języku C#...................................................u......................337 Tworzenie projektu obiektu sterującego...................................................u................338 Programowanie kontrolki...................................................u.......................................339 Elementy kontrolki...................................................u...................................................u....349 Przestrzenie nazw...................................................u...................................................u349 Właściwości i metody ...................................................u............................................350 Zdarzenia...................................................u...................................................u.............353 Pomoc na etapie projektowania ...................................................u.............................356 Rysowanie...................................................u...................................................u...........363 Podsumowanie ...................................................u...................................................u..........364 Dodatek A Słowniczek...................................................................................................................................................... 365 Dodatek B Tabele kodów znaków.............................................................................................................................. 369 Dodatek C Słowa kluczowe języka C oraz C++.................................................................................................... 373 Skorowidz....................................................................................................................................................... 377 Najpierw trochę historii W tym rozdziale: G G Historia Visual Basica i C++ Znaczenie języka Visual Basic Znaczenie języka C++ Język C# G G Celem książki jest nauczenie czytelnika programowania w języku C, a ściślej — programo- wania w językach C, C++ oraz C# w celu rozszerzenia możliwości, jakie oferuje Visual Basic. Z tego względu przedstawiona poniżej historia VB jest ukierunkowana na rozwój narzędzi programistycznych. Zanim rozpoczniemy naszą wyprawę w świat języka C, należy uświado- mić sobie, co nas do niej skłoniło. Otóż historia nieraz już pokazała, że każdy programista powinien być elastyczny. Niezależnie od aktualnych tendencji w informatyce czy osobistych preferencji, prędzej czy później pojawia się konieczność zmiany narzędzia programowania i trzeba być na to przygotowanym. Ważne jest, aby w miarę możliwości programować w „naj- mniejszym wspólnym mianowniku”, czyli korzystać z narzędzi uniwersalnych, które umożliwią wykorzystanie stworzonych fragmentów kodu w przyszłościu. Do takich z pewnością należy „czysty” język C. Nawet w kodzie źródłowym nowoczesnych 32-bitowych obiektów sterujących, które autor książki ma w swoim dorobku, występują fragmenty napisane w klasycznym C, które powstały w czasach Visual Basica 1 i 2. Co ważne, w nowych warunkach, poddane niewielkim zmianom, działają równie dobrze jak dawniej w środowisku 16-bitowym. Rozważmy na przykład programowanie interfejsu graficznego (GDI – Graphics Device Interface). Na ile różnych sposobów można stworzyć kod interfejsu — „czysty” język C, biblioteki MFC, WFC, procedury graficzne Visual Basica, obecnie klasy .NET i z pewnością wiele innych, których nie sposób tutaj wymienić. Wiele z tych technologii opiera się na abstrakcjach technologii niższego poziomu. W jakim celu? Zwykle po to, aby ułatwić korzystanie z funkcji oferowanych przez warstwę niższego 18 Visual C++ dla programujących w Visual Basicu poziomu, a także po to, aby umożliwić dokonywanie modyfikacji tej warstwy bez konieczności wprowadzania zmian w programach, które z niej korzystuają. Z drugiej strony, jeśli modyfikacjom poddawana jest stale warstwa abstrakcji, zaprzeczamy w ten sposób jej idei. Przyjdzie co prawda taki moment, kiedy warstwa niższego poziomu (tutaj: Windows) będzie wymagała gruntownej przeróbki przestarzałego kodu, musimy jednak przyznać, że warstwa abstrakcji zmienia się znacznie częściej. Swego czasu autor książki użył „czystego” C do stworzenia interfejsu GDI dla 16-bitowych kontrolek VBX. Nadeszła era obiektów OLE i powstała presja, aby zmodyfikować kod GDI (i nie tylko GDI) tak, aby korzystał z biblioteki MFC. W pewnym zakresie zmiany te zostały dokonane. Po jakimś czasie pojawiła się biblioteka ATL i kuolejna potrzeba modyfikacji kodu. W większości przypadków powrócono wówczas do 16-bitowego kodu w C i poddano go kon- wersji. Kod ten był prostszy i łatwiejszy w zastosowaniu niż kod wykorzystujący MFC. W tej postaci prawdopodobnie już pozostanie, gdyż nie przewiduje się jego kolejnej modyfikacji w związku z pojawieniem się nowej technologii (.NET). Uwaga Termin .NET odnosi się do najnowszego środowiska programiustycznego firmy Microsoft. Programy stworzone za pomocą tego systemu uruchamianue są we wspólnym środowisku uruchomieniowym CLR (Common Language Runtime). Wszystkie funkcje udostępniane przez platformę systemową zostały zawarte w bibliotekauch klas utworzonych w dostępnych językach (zwykle jest to C#, VB.NET lub C++), które wykorzyustują CLR. Oczywiście postępując w ten sposób, traci się możliwość uruchomienia kodu na wielu plat- formach. Co może istotniejsze, rezygnuje się również z zalet, jakie zapewnia mechanizm kodu zarządzanego (managed code) w technologii .NET. Należy więc rozważyć, czy korzyści, jakie dałoby zastosowanie najnowszych technologii, zrekompensuują koszt modyfikacji kodu. Dzięki środowisku CLR programiści mają z pewnością więcej możliwości programowania wieloplatformowego, lecz nie należy chyba oczekiwać boomu wieloplatformowych aplikacji. Programiści będą prawdopodobnie nadal tworzyć kod specyficzny dla konkretnej platformy uruchomieniowej, aby móc w pełni wykorzystać jej możliwości. Tak więc wspomniane wyżej fragmenty kodu w C, składające się na kod źródłowy 32-bitowych komponentów, pozostaną chyba bezpieczne. Dzięki Internetowi nastąpił jednak zwrot w kwestii wieloplatformowości. Większość kodu aplikacji internetowych wykonywana jest bowiem przez przeglądarki, które zapewniają (lub przynajmniej powinny zapewniać) niezależność od platformy systemowej. Część kodu znaj- dująca się natomiast po stronie serwera (odpowiedzialnua za dostarczanie interfejsu aplikacji do przeglądarek użytkowników) nie musi być przecież niezależna od platformy. Uruchamiana jest bowiem na wydzielonym serwerze pod kontrolą systemu NT, UNIX lub jego pochodnych. Aplikacja stworzona dla konkretnej platformy systemowej generuje uniwersalny kod HTML (w idealnym przypadku). W praktyce, oczywiście, rzadko ograniczamy się do zwykłego języka HTML. W celu uzyska- nia pożądanego efektu sięgamy po język DHTML, skrypty czy też wykorzystujemy obiekty sterujące po stronie klienta. W wielu przypadkach ograniczamy w ten sposób liczbę typów przeglądarek, które potrafią obsłużyć naszą witrynę i zuaoferować użytkownikowi wszystkie jej funkcje i możliwości. Łatwo się w tej sieci zaplątać. Rozdział 1. G Najpierw trochę historii 19 Znajdujemy się na etapie ewolucji i równocześnie w trakcie rewolucji. Dynamicznie rozwijają się technologie internetowe, a jednocześnie wciąż jest dużo do zrobienia w WIN32. Tam bo- wiem są korzenie większości z nas i z pewnością technuologia ta nie straci szybko na znaczeniu. Historia Visual Basica i C++ Historia tych dwóch języków sięga zamierzchłych czasów; zamierzchłych w odniesieniu do stosunkowo krótkiej historii komputerów. Początków VB, jak i C++, upatrywać należy w śro- dowisku DOS (doświadczenie autora książki związane z programowaniem w systemie DOS dotyczy głównie języka Basic; w jego dorobku jest niewiele programów stworzonych w C i prze- znaczonych dla tego systemu). Linia graniczna między tymi językami została wytyczona właśnie w epoce DOS-a. Język C uchodził wówczas za narzędzie profesjonalistów, natomiast Basic traktowano jak zabawkę dla dzieci. Opinię tę Basic „zawdzięcza” w znacznej mierze jednej z jego interpretowanych wersji, GWBasic, która w owych czasach zyskała znaczną popularnouść. Przezywano go Gee Wiz1 Basic, co charakteryzuje go całkiem dobrze. Od tamtego czasu Basic toczy mozolną walkę o zdobycie uznania w oczach programistów. Po pojawieniu się systemu Windows programiści C znowu mogli się czuć jak u siebie w domu. Do tego systemu programiści Basica nie mieli bowiem dostępu. Do czasu, gdy na arenę wkro- czył Visual Basic. Środowisko 16-bitowe Naszą historię musimy rozpocząć od systemów 16-bitowych, ponieważ początki Visual Basi- ca związane są właśnie z takim środowiskiem. Trzy pierwsze edycje VB przeznaczone były dla wersji 16-bitowych. Dopiero Visual Basic 4 był wersją 32u-bitową. Grom, czyli Visual Basic 1 Thunder2 (kryptonim projektu Visual Basic 1) oznaczał duży krok naprzód. Padały wówczas komentarze, że to tylko chwilowa moda, zabawka i tym podobne. Okazało się, że narzędzie to nie było ani przejściową modą, ani tym bardziej błahostką. Autor książki pracował wówczas w firmie MicroHelp, która stworzyła kilka z pierwszych bibliotek dla Visual Basica. To była wówczas ab- solutna nowość; wiele osób myślało, że to właśnie my scaliuliśmy narzędzia w pasek narzędziowy! Pierwsza wersja VB miała jeszcze wiele ograniczeń — kompilacja wyłącznie do pseudokodu, ograniczony zestaw narzędzi, zapis formularzy tylko w formacie binarnym, brak możliwości roz- budowy o dodatkowe moduły czy funkcje. Lecz bardzo ważny pierwszy krok został wykonany. Zwrot gee wiz (właśc. gee whiz) w potocznej angielszczyźnie (USA) wyraża zaskoczenie lub entuzjazm, 1 w wolnym tłumaczeniu odpowiadają mu polskie: ojej!, rety! — przyp. tłum. 2 Z angielskiego: grzmot, grom — przyp. tłum. 20 Visual C++ dla programujących w Visual Basicu Narodziła się bowiem koncepcja niestandardowych kontrolek (custom controls). Były to po- czątki programowania opartego na komponentach, w formuie jaką znamy obecnie. W pierwszym zestawie firmy MicroHelp znalazło się kilka ciekawych i popularnych kontrolek. Jednym z nich było pole listy z możliwością wielokrotnego wyboru, podczas gdy pierwsze pole listy Visual Basica pozwalało na zaznaczenie tylko jednego elementu. Zestaw suwaków cechował się ciągłą reakcją, natomiast oryginalne suwaki Visual Basica aktualizowały swoją wartość dopiero po zwolnieniu przycisku myszy. Jak teu czasy się zmieniają... Idea programowania opartego na komponentach zapoczątkowała rozwój największego rynku „dodatków” do kompilatorów, jaka kiedykolwiek istniała. Oprócz komponentów, w Visual Basicu 1 programiści Basica zetknęli się po raz pierwszy z ideą programowania przez zdarzenia (ang. event-driven programming). Do tej pory nie mieli raczej takiej okazji, chyba że ktoś zajmował się konstrukcją uoprogramowania języka C/SDK. Dla programistów przechodzących z systemu DOS do Windows programowanie przez zdarzenia było zupełną nowością. I właśnie dzięki VB liczba „przesiadających” się na system Windows była pokaźna. Ni stąd, ni zowąd programiści, którzy do tej pory nie marzyli nawet o progra- mowaniu w Windows, otrzymali taką szansę i wielu z niuej skorzystało. To dopiero rewolucja. Pierwszymi komponentami były obiekty VBX. Mimo że w porównaniu do dzisiejszych kompo- nentów były nieco prymitywne, miały wiele zalet. Ich tworzenie przebiegało stosunkowo prosto. Posiadały dane egzemplarza oraz dane współdzielone. Były pierwszymi elementami programo- wania, dla których można było definiować niestandardowe właściwości i zdarzenia. Obiekty VBX miały postać 16-bitowej biblioteki DLL wraz ze wszystkiumi jej zaletami i wadami. W środowisku 32-bitowym biblioteki DLL umieszczane są w przestrzeni pamięci programu wykonywalnego. Biblioteki 16-bitowe ładowane były natomiast do pamięci tylko przy pierwszym wywołaniu. Co prawda zachodziły przy tym komplikacje z segmentem danych oraz stosem, lecz właściwość ta miała również swoje zalety. Dzięki niej 16-bitowe biblioteki DLL mogły służyć do realizacji szybkiej komunikacji międzyprocesowej. Można było bowiem wykorzy- stać fakt, że w pamięci obecny jest tylko jeden egzemplarz biblioteki i wspólna dla progra- mów przestrzeń danych, i odpowiednio dostosować swój kod. Okazuje się, że to właśnie 16-bitowe biblioteki DLL były najbliższe pierwotnej koncepcji bi- blioteki dołączanej dynamicznie. Przewodnią ideą, jaka przyświecała jej twórcom, była oszczędność miejsca, zarówno w pamięci, jak i na dysku. Z biegiem czasu mieliśmy do czy- nienia ze stałym wzrostem poziomu złożoności obsługi bibliotek DLL (niezależnie od tego, czy nazywano je obiektami VBX, OCX, COM czy jeszcze inaczej). Obecnie inicjatywa firmy Microsoft w postaci technologii .NET zdaje się być zwrotem ku czasom, kiedy biblioteki nie były rejestrowane, lecz umieszczane razem z plikami EXuE. Pod hasłem rozwiązywania problemu określanego mianem „DLL Hell” („Piekło DLL”) wprowadzano coraz to nowe innowacje, które pogłębiały złożoność mechanizmu DLL, a których większość była zupełnie niepotrzebna. Aby rozwiązać ten pruoblem, należało przede wszystkim instalować prywatne biblioteki DLL we wspólnym katalogu z programem, który z nich korzy- sta. W przypadku środowiska 16-bitowego nie rozwiązało to jednak problemu „piekła DLL”, gdyż tylko jedna kopia biblioteki DLL mogła znajdować się w danej chwili w pamięci. W efekcie mieliśmy do czynienia z częstym zjawiskiem zawieszania się programów w obecności innych działających aplikacji. Rozdział 1. G Najpierw trochę historii 21 Rozważmy następujący przykład: 16 bitowy program ładuje bibliotekę DLL wymaganą przez inną aplikację. Może to być wcześniejsza wersja biblioteki, która nie jest zgodna z tym drugim programem. Jeśli teraz uruchomiony zostanie program korzystający z nowszej wersji biblioteki, w pamięci obecna będzie jej starsza, niewłaściwa wersja załadowana przez pierwszą aplikację. Problem ten nie dotyczy programów 32-bitowych, ponieważ w ich przypadku biblioteki DLL umieszczane są w przestrzeni kodu danego programu, mogą więc ze sobą współistnieć. Waru- nek jest tylko jeden — muszą zostać zapisanie na dysku w sposób gwarantujący załadowanie odpowiedniej wersji biblioteki. W środowisku 32-bitowym umieszczenie biblioteki wraz z plikiem EXE dałoby więc pozytywny rezultat. Różne wersje bibliotek DLL mogą bowiem zostać umieszczone w pamięci i nie „przeszkadzać” sobie nawzajem. Wprowadzenie rejestru wraz z całą jego złożonością i kło- potami stanowiło więc rozwiązanie problemu, który jużu nie istniał. Lecz zanim „przesiądziemy” się na platformę 32-bitową, musimy jeszcze poznać kilka faktów związanych z platformą 16-bitową. Visual Basic 2 Ulepszenia dokonane w drugiej wersji VB nie były co prawda znaczne, lecz wprowadzona zo- stała między innymi wyjątkowa możliwość „łamania” obiektów sterujących. Opisany wyżej problem „piekła DLL” coraz bardziej dawał się programistom we znaki. Prawdopodobnie to właśnie wtedy w firmie Microsoft zdecydowano, że wszystkie informacje należy przenieść do rejestru, a na dysku pozostanie tylko jedna kopia każdej biblioteki DLL umieszczona w kata- logu systemowym. Sprawy przybrały zły obrót. Jako zaletę Visual Basica 2 można wskazać możliwość użycia kolorów w trybie high-color w obrębie kontrolek. Wówczas określano to mianem obsługi trybu 256-kolorowego, lecz naj- ważniejszy był sposób obsługi palety dla kontrolki zawierającej obraz. Oczywiście, zapewniała ona operacje na większej liczbie kolorów niż 256. Nadal można było jednak korzystać wy- łącznie z bitmap, ikon oraz metaplików. Sytuacja ta nieuprędko miała się zmienić. Inną nowością VB 2 były kontrolki w wersji „light” (light controls). Wszystkie komunikaty przeznaczone dla tych kontrolek docierały do nich za pośrednictwem formularza lub innego obiektu, na którym owa „lekka” kontrolka został umieszczony. Ponieważ kontrolki te nie po- siadały uchwytu okna, zarządzanie nimi było nieco skompluikowane. Wraz z językiem Visual Basic 2 pojawiła się funkcja VBFormat, dostępna z poziomu kodu C w obrębie obiektu VBX. Umożliwiła ona formatowanie łańcuchów za pomocą procedur Visual Basica. Cecha ta przydawała się w przypadku wielu kontrolek, lecz jej działanie było ograniczone wyłącznie do Visual Basica. Powróćmy teraz do zmian, które dały możliwość „łamania” kontrolek. W przypadku gdy nasza kontrolka korzystała z funkcji Visual Basica 2, „musiała” sprawdzać wersję VB i ograniczać w jakiś sposób swoje możliwości podczas pracy w Visual Basicu 1. Wydaje się to całkiem oczywiste, lecz w zależności od funkcji danego obiektu unie zawsze takim było. 22 Visual C++ dla programujących w Visual Basicu Ponadto niektóre właściwości kontrolki mogą być związane z funkcjami dostępnymi wyłącz- nie w VB 2. Problem pojawić się może kilka miesięcy po utworzeniu kontrolki, gdy zechcemy dodać do niego jakąś właściwość, która działać powinna w każdej wersji VB. Na drodze stają wówczas właściwości obsługiwane wyłącznie przez Visual Basic 2. W VB 1 należy zastąpić te właściwości ich atrapami, aby umożliwić działanie konturolki. Visual C++ 1 Kontrolki dla Visual Basica 1 oraz 2 były tworzone za pomocą DOS-owego edytora i DOS- owego kompilatora C++ (przynajmniej tak postępował autor niniejszej książki). Kompilowane były z linii poleceń i testowane przy użyciu programu CodeView. Wszystko uległo zmianie wraz z pojawieniem się Visual C++ 1.5. Warto przede wszystkim wspomnieć o Visual C++1.52, który obsługiwał (chociaż obsługa ta była bardzo skromna) niestandardowe kontrolki, ponieważ ma to związek z naszą dyskusją na temat programowania komponentów. Trzeba również wymienić tę wersję tylko z tego względu, że dzięki niej została zachowana do dziś pierwotna specyfikacja niestandardowych kontrolek Visual Basica w wersji 1.0. W składzie aktualnego pakietu dystrybucyjnego MSDN język C++1.52 występuje jako obowiązująca realizacja 16-bitoweguo C++. Z biegiem lat programiści powoli zapominali o tym, że pewne procedury nie były zgodne z pierw- szą wersją Visual Basica. Niby nie ma się czym przejmować, gdyż Visual Basic 1.0 dawno już przeszedł do historii, prawda? Niezupełnie! W chwili pojawienia się Visual Basica 2.0 wersja 1.0 była nadal bardzo rozpowszechniona. Mniej więcej w tym samym czasie Microsoft podjął decyzję o rozszerzeniu języka C++ o obsługę standardu VBX. Zadecydowano, że obsługa ta będzie zgodna ze specyfikacją Visual Basica 1.0. Kto mógł wtedy przewidzieć, że będzie to ostatnia 16-bitowa wersja Visual C++. Tym samym specyfikacja kontrolek Visual Basica 1.0 przetrwała nadal w VC++ 1.52. Tak więc pierwsza edycja Visual C++ okazała się jednocześnie jego ostatnią 16-bitową wersją. Visual Basic 3 Wersja ta była świadectwem postępu w tej dziedzinie. Wyposażono ją bowiem w mechanizm obsługi bazy danych. W porównaniu do możliwości systemu SQL Server lub innego zaawan- sowanego mechanizmu bazy danych nie była to właściwie pełna obsługa, lecz mimo to wielu programistów z niej korzystało. Innowacją w zakresie niestandardowych kontrolek było pojawienie się po raz pierwszy możliwości wiązania danych (data binding). Mechanizm ten był jednak stosunkowo prymitywny i nie wy- korzystywano go w poważnych projektach realizowanych uw języku Visual Basic 3. Większość osób programujących w Visual Basic 3 nadal korzystała ze znacznego wsparcia w postaci narzędzi dostarczanych przez niezależne firmy. Przykładowo w 16-bitowej wersji programu UnInstaller firmy MicroHelp zastosowano 13 niestandardowych kontrolek VBX oraz kilka bibliotek DLL stworzonych w języku C. W przypadku wersji 32-bitowej sytuacja była całkiem inna, ponieważ 32-bitowe środowisko programistyczne oferowało znacznie więcej standardowych narzędzi. Rozdział 1. G Najpierw trochę historii 23 W opinii autora książki Visual Basic 3 jest najlepszą 16-bitową wersją tego języka. Jeśli ist- nieje potrzeba stworzenia kodu 16-bitowego, to należy skorzystać właśnie z tej wersji Visual Basica. Do czasu pojawienia się Windows 2000 kod stworzony za jego pomocą spisywał się nawet lepiej na wielu platformach (WIN9X/NT) niż niejeden 32-bitowy. Zawdzięczano to całkiem niezłej emulacji środowiska 16-bitowego, jaką oferował Windows NT, oraz istnieniu dość poważnych rozbieżności pomiędzy WIN9X a NT po stronie 32-bitowej, które były przy- czyną problemów ze zgodnością w przypadku programów 32-bituowych. Visual Basic 4 W zakresie programowania 16-bitowego Visual Basic 4 okazał się porażką. Dodano wpraw- dzie obsługę 16-bitowego standardu OLE, ale właściwie nie wiadomo, po co Microsoft zadał sobie cały ten trud. W owym czasie Microsoft opuszczał już platformę 16-bitową, więc 16- bitowy Visual Basic 4, a szczególnie jego dodatkowe narzędzia, nigdy nie zostały dokładnie przetestowane. Tak więc czwarta wersja VB nigdy nie stała się poważnym narzędziem programistycznym dla środowiska 16-bitowego. Z powodu przerobienia kodu i zastosowania mechanizmu OLE, w wielu przypadkach okazywała się wolniejsza w porównaniu do analogicznego kodu stworzonego w Visual Basicu 3. Visual Basic 4 w wersji 16-bitowej obsługiwał standard VBX. Obsługiwał również 16-bitowe kontrolki OLE (OLE Controls), czyli kontrolki OCX. Technologia ta narodziła się i nadal „umiera” wraz z VB4-16. Specyfikacja VBX nie została poddana modyfikacji w języku Visu- al Basic 4, więc ostatnia jej wersja dotyczy Visual Buasica 3. Z uwagi na fakt, że jest to najbardziej „aktualna” wersja 16-bitowego języka Visual Basic, obowiązującymi do dziś standardami dla środowiska 16-bitowego są: specyfikacja VBX z Visual Basica 3 oraz specyfikacja 16-bitowych obiektów OCX z VB4. Tak więc jedyną 16-bitową specyfikacją kontrolek Visual Basica, która została całkowicie wycofana, jest wersja 2 standardu VBX. Wszystkie pozostałe przetrwały do dziś — VBX 1.0 w Visual C++ 1.52, VBX 3.0 oraz 16-bitowe OCX w Visual Basicu 4. Visual Basic 4 — pierwsze podejście Największy nacisk w czwartej wersji Visual Basica położono na oprogramowanie działające w środowisku 32-bitowym. Oprogramowanie to sprawiało niestety sporo problemów, podobnie jak obsługa 32-bitowych obiektów OCX. Mimo to należy uszanować spory wysiłek, jaki podjęto w związku z czwartą wersją Visual Basica, która była jedyną edycją tego języka za- wierającą obie jego realizacje, 16- i 32-bitową. Nie wiadomo właściwie, dlaczego Microsoft podjął decyzję o uwzględnieniu obydwu wersji Visual Basica w jednej edycji. Było to trudne przedsięwzięcie zarówno dla samego Microsoftu, jak i dla innych firm, producentów różnych dodatków do Visual Basica. Pojawiła się bowiem konieczność tworzenia i testowania dwóch wersji każdego produktu. Ucierpiały na tym przede wszystkim wersje 16-bitowe, a i dla 32-bitowych nie była to usytuacja korzystna. 24 Visual C++ dla programujących w Visual Basicu Microsoft jasno dał do zrozumienia, że ścieżka dalszego rozwoju związana będzie ze środowi- skiem 32-bitowym. Dziwi zatem fakt, że firma w ogóle wzięła pod uwagę 16-bitową wersję tego kompilatora. Visual Basic 3 był 16-bitowym środowiskiem o całkiem sporych możliwościach. Tylko nieliczne zadania wymagały użycia Visual Basica 4-16, gdyż nie można ich było zreali- zować w VB 3. Jedynie w takich przypadkach warto było sięugnąć po Visual Basica 4. Jedną z takich nowości był mechanizm automatyzacji OLE (OLE automation). Visual Basic 3 nie posiadał wbudowanej obsługi tej technologii. Jeśli wymagane było stworzenie 16-bitowego serwera automatyzacji OLE, pomocny okazywał się VB 4. Jednym z zastosowań 16-bitowej automatyzacji mogło być stworzenie swego rodzaju thunkera (thunking to metoda umożli- wiająca wywoływanie procedur z 16-bitowych bibliotek DLL z poziomu 32-bitowego kodu3). System nie dokonywał bowiem sprawdzenia, czy serwer automatyzacji OLE jest 16- czy 32- bitowy, nie było więc przeszkód do wykorzystania 16-bitowego serwera automatyzacji OLE z poziomu programu 32-bitowego. Mechanizm automatyzacji OLE Visual Basica 4 dawał zatem możliwość użycia 16-bitowego kodu z poziomu 32-bitowego programu. Nie był to oczywiście najszybszy sposób wywoływania procedur, więc w miarę możliwości lepiej było stosować u„prawdziwy” thunking. Thunking jest jednak silnie zależny od platformy systemowej, natomiaust automatyzacja OLE — przeciwnie. Można oczywiście podawać powody, dla których warto było użyć Visual Bascia 4-16, lecz realna konieczność pojawiała się bardzo rzadko, a sama platforma sprawiała zbyt dużo pro- blemów. Nie warto było się zatem „przesiadać” na VB4-16 bez wyraźnego powodu. Znacznie lepszym rozwiązaniem dla programisty była bezpośrednia u„migracja” do świata 32 bitów. Środowisko 32-bitowe Środowisko programowania WIN32 jest dziś „miejscem pracy” dla większości z nas. Pozostało niewiele zadań realizowanych z wykorzystaniem 16-bitowycuh technologii języka Visual Basic. Visual Basic 4 Jak już wcześniej wspomniano, w czwartej wersji Visual Basica największy nacisk położono na oprogramowanie działające w środowisku 32-bitowym. Ten kompilator nie był niczym niezwykłym w porównaniu do postępów dokonanych w wersjiu 3. Visual Basic 4 był pierwszą próbą przeniesienia tego języka na platformę 32-bitową. Kompilator ten oferował ponadto niewiele funkcji, aby warto było z niego korzystać. Nadal był jedynie kompilatorem pseudokodu. Visual Basic 5 — Visual Studio 5 W postaci piątej wersji Visual Basica programiści otrzymali bardzo solidne narzędzie. Możli- wość kompilacji do kodu macierzystego oraz spory zestaw narzędzi uzupełniających, dzięki I odwrotnie — procedur 32-bitowych z poziomu 16-bitowego kodu — przyp. tłum. 3 Rozdział 1. G Najpierw trochę historii 25 któremu w większości przypadków dodatkowe zakupy nie były konieczne, składały się na kompletny system programowania. Po raz pierwszy w języku Visual Basic pojawia się możli- wość tworzenia kontrolek ActiveX. Trudno zrozumieć, dlaczego możliwość tworzenia formantów ActiveX w Visual Basicu nigdy nie była wykorzystywana na szerszą skalę. To przecież wspaniały sposób na hermetyzację kodu, zarówno w przypadku pracy nad komercyjnym projektem, jak i przy projektach wewnętrz- nych. Od momentu pojawienia się Visual Basica 5 tworzenie niestandardowych formantów stanowiło nieodłączny element prac we wszystkich istotnych projektach realizowanych przez autora książki. Być może dopiero technologia .NET sprawi, że tworzenie formantów stanie się popularną praktyką. Wraz z wprowadzeniem języka Visual Basic 5 firma Microsoft umieściła kilka produktów programistycznych w jednym pakiecie. Pakiet Visual Studio 5 był pierwszym systemem ofe- rującym kompletne rozwiązanie, włącznie z kompilatorem C++. W ten sposób kompilator C++ trafił „pod strzechy”. Pierwszym 32-bitowym kompilatorem C++ był Visual C++ 2.0, ale dopiero wersja 4.0 była częściej używana przez autora książki. Z numeracji kolejnych wersji języka — od 2.0 do 5.0 — wynika, że w środowisku 32-bitowym borykano się z pewnymi po- czątkowymi kłopotami. Wersja oznaczona numerem 5 była pierwszą, która weszła w skład nowego zestawu Visual Studio. Skoro więc podarowano nam wspaniałe narzędzie w postaci C++, to dlaczego go nie wyko- rzystać? Rodziły się przeróżne pomysły stosowania kompilatora lub środowiska programi- stycznego Visual C++ 5 — od tych prostych po bardziej zauawansowaane. Jednym z „delikatnych” sposobów wykorzystania środowiska Visual C++ było użycie takich funkcji, jak Find in Files (wyszukiwanie słów lub fraz w plikach). Dla samej tej funkcji warto było uruchomić edytor Visual C++ 5. Realizuje ona wyszukiwanie określonych łańcuchów tek- stowych w plikach. Można ograniczać zakres poszukiwań do plików określonego typu. Podczas wyszukiwania przeglądane są również podkatalogi. Po jego zakończeniu wyświetlana jest lista wierszy z plików, które odpowiadają wzorcowi. Dwukrotne kliknięcie pozycji na liście powo- duje załadowanie pliku do edytora i ustawienie kursora w miejscu wystąpienia szukanego tekstu. Możliwość rejestracji makropoleceń w edytorze do celów zaawansowanej edycji występuje dopiero w najnowszej wersji Visual Basica. W Visual C++ można nawet uruchamiać i testować programy napisane za pomocą Visual Basica, jeśli tylko zostały skompilowane z odpowied- nimi ustawieniami. Bardziej zaawansowane metody wykorzystania C oraz C++ są tematem tej książki. Visual Studio 5 jest pierwszym systemem, dzięki któremu wszystkie przedstawione tu pomysły moż- na realizować w praktyce, bowiem wraz z tą wersją programiści po raz pierwszy otrzymali wszelkie niezbędne kompilatory. Oczywiście większość programistów Visual Basica nadal nie używa samego kompilatora C++. Visual Studio 6 W Visual Basicu 6 wzbogacono możliwości dostępu do danych. Dodano również nowe kon- trolki oraz narzędzia w formie kreatorów. Jednakże środowisko programistyczne nie uległo zasadniczej zmianie w porównaniu do jego piątej wersjui. 26 Visual C++ dla programujących w Visual Basicu W Visual Basicu 6 pojawiła się funkcja raportowania. Trzeba przyznać, że nie była to rewelacja, o czym świadczy chociażby fakt, że sam Microsoft w technologii .NET powrócił do narzędzi firmy Crystal4. Całkiem udaną nowością było natomiast wprowadzenie struktury hierarchicznej do zestawu rekordów oraz komponentu FlexGrid. Hierarchiczne zestawy rekordów zdobyły wielu zwolenników. Inną przydatną innowacją była możliwość tworzenia źródeł danych. Rozłączone zestawy re- kordów oraz możliwość przekazywania zestawu rekordów w wywołaniu procedury, nawet pomiędzy procesami, oznaczały wyraźny postęp. Umożliwiało to prostą konstrukcję wielo- warstwowego kodu (multi-tier code). Z punktu widzenia autora tej książki najbardziej pożyteczną zmianą w Visual Studio 6 było pojawienie się trzeciej wersji biblioteki ATL. Od tej pory tworzenie kontrolek w tej technologii stało się praktyczniejsze i łatwiejsze w porównaniu duo wcześniejszych wersji ATL. Można by jeszcze wymienić kilka zmian, jakie dokonane zostały w Visual Studio 6, lecz żadna z nich z pewnością nie okazała się rewelacją. Po rekompilacji projektu stworzonego w Visual Basicu 5 nie czekało nas nic szczególnego. Ot, zwykła coudzienność. .NET Najnowsza technologia pochodząca z firmy Microsoft burzy dotychczasowe reguły. Jedynie język Visual C/C++ funkcjonuje zasadniczo tak jak dawniej. Nie ma już ani Visual J++, ani Visual Interdev, a Visual Basic został oparty na modelu klas (tak jak wszystkie języki .NET). To nie jest już stary, poczciwy Visual Basic, znany nam do tej pory. Wymagany jest poziom zaawansowania, jakiego VB nigdy dotąd nie wymagał. Konieczne jest również dostosowanie lub wręcz ponowne napisanie większości fragmentów kodu w celu uruchomienia ich na nowej platformie. Gdy Microsoft poinformował, że Visual Basic korzystać będzie z mechanizmu dziedziczenia implementacji, wydawało się, że będzie to opcjonalna możliwość (podobnie jak w Visual C++). Można przecież programować zarówno w C, jak i w C++. Nic podobnego. Języki .NET oparte zostały na klasach i jest to jedyna akceptowana metodau programowania. Podobnie jest z językiem C#. „Migracja” ze środowiska Visual Basic 6 do Visual Basic .NET mo- że być równie trudna, co bezpośrednie przejście na język C#. Wielce prawdopodobne jest, że wielu programistów właśnie tak postąpi — „przesiądzie” się wpruost na język C#. Jeśli podnosimy kwestię programowania w językach, które korzystają ze wspólnego środowiska uruchomieniowego CLR (Common Runtime Language), to poruszamy zagadnienie tworzenia kodu zarządzanego oraz kodu niezarządzanego. Kod zarządzany (managed code) działa pod kontrolą środowiska CLR; nosi taką nazwę, ponieważ środowisko zwalnia programistę z obo- wiązku „odśmiecania” (ang. garbage) pamięci z niepotrzebnych obiektów i wykonuje za niego całą niewdzięczną pracę. Kod niezarządzany natomiast to klasyczny kod wykonywany poza Przypis: Crystal Reports jest obecnie najczęściej używanym narzędziem do tworzenia raportów, wiecej 4 można znależć na stronie http://www.crystaldecisions.com/ Rozdział 1. G Najpierw trochę historii 27 środowiskiem CLR. W językach C oraz C++ tworzyć można kod niezarządzany (chociaż do- stępne są rozszerzenia do C++ umożliwiające tworzenie kodu dla CLR), natomiast w Visual Basicu oraz w C#, które korzystają z nowej technologiui, tworzony jest kod zarządzany. Znaczenie języka Visual Basic Język Visual Basic zrewolucjonizował metody tworzenia programów dla systemu Windows. Łatwość konstruowania interfejsu użytkownika oraz prostota programowania nie mają sobie równych wśród dostępnych narzędzi, być może z wyjątkiem tworzenia kodu zarządzanego w technologii .NET. Visual Basic jest niewątpliwie wspaniałym środowiskiem, mimo to nie należy przeceniać jego możliwości. Wielu programistów popełnia błąd, próbując w tym języ- ku zrealizować zadania, które nie są zgodne z jego przeznaczeniem. Najczęściej efekt jest taki, że powstaje kod skomplikowany, trudny zarówno w modyfikacji, jak i w testowaniu, a po- nadto zwykle występują również problemy z jego stabilunością. Użycie właściwego narzędzia przynosi zwykle efekt w postaci lepszego rezultatu końcowego. Są zadania, w których dobór narzędzia nie jest aż tak istotny, w przypadku innych zaś to kwestia kluczowa. Nie należy unikać zastosowania języka C czy C++, jeśli sytuacja tego wymaga. Celem tej książki jest właśnie zapoznanie i „oswojeniue” czytelnika z tymi narzędziami. Mocne strony Visual Basica Mechanizm kodu zarządzanego w systemie .NET wyrównał możliwości wielu języków. W celu porównania cech poszczególnych narzędzi należy łącznie potraktować większość języków opartych na kodzie zarządzanym. Pod względem oferowanych możliwości język C#, na przykład, jest bliższy językowi Visual Basic niż C++. Środowisko projektowe .NET wywodzi się z po- przednich wersji Visual Basica. Bezapelacyjnie najlepsze narzędzie do projektowania intterfejsu Visual Basic jest prawdopodobnie najpotężniejszym narzędziem programistycznym typu RAD dla WIN32. Programiści zawsze chętnie po nie sięgali z tej prostej przyczyny, że stworzenie w nim interfejsu zajmuje zaledwie kilka minut. Dzięki technologii .NET możliwości te stały się dostępne również dla wielu innych języków, lecz C oraz uC++ pozostały nadal nie zmienione. Ścisła kontrola typów W języku Visual Basic od zawsze była stosowana ścisła kontrola typów zmiennych (strong typing). Unika się w ten sposób potencjalnych błędów wynikających ze stosowania wskaźników oraz kłopotów związanych z rzutowaniem typów. Oba te meuchanizmy nie są bowiem dostępne w Visual Basicu. 28 Visual C++ dla programujących w Visual Basicu W Visual Basicu możliwa jest natomiast konwersja typów. Automatyczna konwersja typu zmiennej przeprowadzana jest wszędzie tam, gdzie kompilator „uzna” to za właściwe. Ponie- waż mechanizm taki stanowi potencjalne źródło niezamierzonych błędów, lepiej jest dokony- wać jawnej konwersji zmiennych. Nie należy mylić zmiennych typu Variant oraz mechanizmu konwersji typów z tzw. luźną kontrolą typów (loose typing), ponieważ jedno z drugim nie ma nic wspólnego. Zarówno dla zmiennych typu Variant, jak i dla konwersji typów zdefiniowany jest ścisły zbiór zasad dotyczących konwersji, natomiast w przypadku luźnej kontroli typów takie reguły nie istnieją. Interaktywne środowisko uruchomieniowe Interaktywne środowisko w połączeniu z bogatymi możliwościami w zakresie projektowania inter- fejsu — to właśnie Visual Basic, jaki znamy. Wielu programistów wybiera to narzędzie ze względu na możliwość tworzenia, uruchamiania, testowania oraz modyfikowania kodu „na gorąco”, bez konieczności opuszczania środowiska. Pod tym względem VBu nie ma sobie równych. Wsparcie ze strony producentów narzędzi Programiści Visual Basica zawsze mogli liczyć na silne wsparcie ze strony niezależnych firm. Liczba tych dostawców wzrosła z 8 – 10 na samym początku do setek w chwili obecnej. Oferta wszelkiego rodzaju dodatków przeznaczonych dla Visual Basica jest niezwykle bogata, a trend ten utrzyma się również w przypadku platformyu .NET. Wszystko to znacznie ułatwia i usprawnia pracę programisty VB. Otrzymuje bowiem staran- nie napisane i przetestowane narzędzia, stworzone w języku C przez specjalistów z danej dzied
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Visual C++ dla programujących w Visual Basicu
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: