Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00185 003852 22407193 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
C++Builder i Turbo C++. Podstawy - książka
C++Builder i Turbo C++. Podstawy - książka
Autor: Liczba stron: 280
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0642-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj

Wizualne środowiska projektowe od dłuższego czasu cieszą się uznaniem programistów. Możliwość budowania aplikacji z gotowych komponentów, realizujących typowe funkcje, pozwala skoncentrować się na jej funkcjonalności bez potrzeby ponownego wymyślania koła. Najbardziej znanym środowiskiem tego typu jest Delphi, jednak jego producent, firma Borland, wypuścił na rynek kolejne narzędzie: C++Builder. To wizualne środowisko projektowe oparte na języku C++ pozwala tworzyć aplikacje dla platformy Win32 z wykorzystaniem komponentów VCL. W sieci dostępna jest również jego bezpłatna wersja o nazwie Turbo C++ Explorer.

'C++Builder i Turbo C++. Podstawy' to podręcznik programowania w tych środowiskach. Czytając go, nauczysz się tworzyć aplikacje w języku C++ dla systemu Windows z wykorzystaniem C++Buildera lub Turbo C++. Dowiesz się, jak zainstalować i skonfigurować środowisko programistyczne oraz jak utworzyć w nim projekt. Poznasz elementy języka C++, zasady programowania obiektowego i korzystania z komponentów VCL. Stworzysz własne komponenty i aplikacje, zaimplementujesz mechanizm przeciągania i upuszczania, a także zapiszesz dane aplikacji w rejestrze systemu Windows.

Poznaj nowoczesne narzędzia programistyczne.

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. Koœciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl C++Builder i Turbo C++. Podstawy Autor: Jacek Matulewski ISBN: 83-246-0642-4 Format: B5, stron: 280 Przyk³ady na ftp: 4122 kB Wizualne œrodowiska projektowe od d³u¿szego czasu ciesz¹ siê uznaniem programistów. Mo¿liwoœæ budowania aplikacji z gotowych komponentów, realizuj¹cych typowe funkcje, pozwala skoncentrowaæ siê na jej funkcjonalnoœci bez potrzeby ponownego wymyœlania ko³a. Najbardziej znanym œrodowiskiem tego typu jest Delphi, jednak jego producent, firma Borland, wypuœci³ na rynek kolejne narzêdzie: C++Builder. To wizualne œrodowisko projektowe oparte na jêzyku C++ pozwala tworzyæ aplikacje dla platformy Win32 z wykorzystaniem komponentów VCL. W sieci dostêpna jest równie¿ jego bezp³atna wersja o nazwie Turbo C++ Explorer. „C++Builder i Turbo C++. Podstawy” to podrêcznik programowania w tych œrodowiskach. Czytaj¹c go, nauczysz siê tworzyæ aplikacje w jêzyku C++ dla systemu Windows z wykorzystaniem C++Buildera lub Turbo C++. Dowiesz siê, jak zainstalowaæ i skonfigurowaæ œrodowisko programistyczne oraz jak utworzyæ w nim projekt. Poznasz elementy jêzyka C++, zasady programowania obiektowego i korzystania z komponentów VCL. Stworzysz w³asne komponenty i aplikacje, zaimplementujesz mechanizm przeci¹gania i upuszczania, a tak¿e zapiszesz dane aplikacji w rejestrze systemu Windows. (cid:129) Instalacja œrodowiska programistycznego (cid:129) Pierwszy projekt (cid:129) Zmienne i instrukcje w C++ (cid:129) Programowanie zorientowane obiektowo (cid:129) Wyszukiwanie i usuwanie b³êdów w kodzie (cid:129) Komponenty VCL oferowane przez C++Buildera (cid:129) Tworzenie interfejsu u¿ytkownika dla aplikacji (cid:129) Drukowanie (cid:129) Operacje na plikach (cid:129) Przechowywanie informacji w rejestrze systemowym (cid:129) Tworzenie w³asnych komponentów VCL Poznaj nowoczesne narzêdzia programistyczne Wstęp............................................................................................. 11 O czym jest ta książka? .................................................................................................... 11 Jak zdobyć C++Builder? .................................................................................................. 11 Część I Zintegrowane środowisko programistyczne i język programowania C++............................................ 13 Rozdział 1. Poznajemy możliwości C++Buildera 2006......................................... 15 Platforma Win32............................................................................................................... 16 Pierwszy projekt ............................................................................................................... 17 Projekt VCL Forms Application — C++Builder ....................................................... 17 Jak umieścić komponent na formie? .......................................................................... 18 Co to jest inspektor obiektów? ................................................................................... 18 Jak za pomocą inspektora obiektów zmieniać własności komponentów? ................. 19 Jak dopasować położenie komponentu? .................................................................... 21 Jak umieszczać na formie wiele komponentów tego samego typu? .......................... 21 Jak zaznaczyć wiele komponentów jednocześnie? .................................................... 22 Jak zaprogramować reakcję programu na kliknięcie panelu przez użytkownika?..... 22 Jak uruchomić projektowaną aplikację? .................................................................... 24 Jak przełączać między widokiem projektowania i edytorem? ................................... 24 Jak ustalić pozycję okna po uruchomieniu aplikacji? ................................................ 25 Jak zmieniać własności obiektów programowo? ....................................................... 25 Jak zapisać projekt na dysku? .................................................................................... 27 Pliki projektu .............................................................................................................. 28 Filozofia RAD ............................................................................................................ 28 Ustawienia projektu .......................................................................................................... 29 Jak zmienić tytuł i ikonę aplikacji? ............................................................................ 29 Informacje o wersji aplikacji dołączane do skompilowanego pliku .exe................... 30 Dystrybucja programów ................................................................................................... 31 Konfiguracja środowiska C++Builder 2006..................................................................... 33 Okno postępu kompilacji ........................................................................................... 33 Automatyczne zapisywanie plików projektu ............................................................. 34 Edytor kodu ...................................................................................................................... 34 Opcje edytora ............................................................................................................. 35 4 C++Builder i Turbo C++. Podstawy Rozdział 2. Analiza kodu pierwszej aplikacji, czyli wprowadzenie do C++ ............ 37 Jak wczytać wcześniej zapisany projekt?................................................................... 37 Plik modułu formy Unit1.cpp ........................................................................................... 38 Komentarze ................................................................................................................ 39 Zmienne globalne ....................................................................................................... 40 Dyrektywy prekompilatora ........................................................................................ 40 Plik nagłówkowy modułu Unit1.h.................................................................................... 40 Klasa TForm1............................................................................................................. 41 Czym jest moduł?....................................................................................................... 42 Plik Unit1.dfm .................................................................................................................. 42 Plik Kolory.cpp................................................................................................................. 43 Rozdział 3. Typy zmiennych i instrukcje sterujące, czyli o tym, co każdy programista umieć musi................................ 45 Podstawy........................................................................................................................... 45 Równanie kwadratowe ............................................................................................... 46 Przygotowanie interfejsu............................................................................................ 47 Deklarowanie zmiennych ........................................................................................... 48 Inicjacja i przypisanie wartości zmiennej .................................................................. 49 Dygresja na temat typów rzeczywistych w C++Builderze ........................................ 49 Konwersja łańcucha na liczbę .................................................................................... 50 Obliczenia arytmetyczne i ich kolejność.................................................................... 51 Operatory upraszające zapis operacji arytmetycznych wykonywanych na zmiennej ...... 52 Typ logiczny i operatory logiczne.............................................................................. 53 Instrukcja warunkowa if............................................................................................. 53 Jak wyłączyć podpowiadanie szablonów instrukcji w edytorze? .............................. 55 O błędach w kodzie i części else instrukcji warunkowej ........................................... 55 Słowo kluczowe return............................................................................................... 57 Na tym nie koniec............................................................................................................. 58 Typy całkowite C++................................................................................................... 58 Instrukcja wielokrotnego wyboru switch ................................................................... 60 Funkcja ShowMessage ............................................................................................... 61 Obsługa wyjątków ............................................................................................................ 62 Czym są i do czego służą wyjątki?............................................................................. 63 Przechwytywanie wyjątków....................................................................................... 63 Zgłaszanie wyjątków.................................................................................................. 65 Pętle .................................................................................................................................. 66 Pętla for ...................................................................................................................... 66 Pętla for w praktyce, czyli tajemnica pitagorejczyków ................................................ 67 Dzielenie liczb naturalnych ........................................................................................ 69 Pętla do..while ............................................................................................................ 70 Pętla while .................................................................................................................. 71 Instrukcje break i continue ......................................................................................... 72 Podsumowanie.................................................................................................................. 73 Typy złożone .................................................................................................................... 73 Tablice statyczne ........................................................................................................ 74 Tablice dwuwymiarowe ............................................................................................. 75 Definiowanie aliasów do typów ................................................................................. 76 Tablice dynamiczne.................................................................................................... 77 Typy wyliczeniowe .................................................................................................... 77 Zbiory ......................................................................................................................... 78 Struktury..................................................................................................................... 81 Jak sprawdzić zawartość tablicy rekordów? .............................................................. 83 Kilka słów o konwersji i rzutowaniu typów ..................................................................... 84 Spis treści 5 Łańcuchy .......................................................................................................................... 85 Dyrektywy preprocesora................................................................................................... 87 Dyrektywa #include ................................................................................................... 87 Dyrektywy kompilacji warunkowej ........................................................................... 85 Stałe preprocesora ...................................................................................................... 88 Makra ......................................................................................................................... 88 Zadania ............................................................................................................................. 89 Zdegenerowane równanie kwadratowe ...................................................................... 89 Silnia........................................................................................................................... 89 Pętle ............................................................................................................................ 89 Ikony formy................................................................................................................ 89 Typ wyliczeniowy i zbiór........................................................................................... 90 Struktury..................................................................................................................... 90 Rozdział 4. Wskaźniki i referencje ..................................................................... 91 Wskaźniki do zmiennych i obiektów. Stos i sterta ........................................................... 91 Operatory dostępu............................................................................................................. 93 Zagrożenia związane z wykorzystaniem wskaźników ..................................................... 94 Referencje ......................................................................................................................... 96 Rozdział 5. Programowanie modularne............................................................... 99 Funkcja niezwracająca wartości............................................................................... 100 Definiowanie funkcji................................................................................................ 100 Interfejs modułu ....................................................................................................... 102 Plik nagłówkowy modułu......................................................................................... 103 Argumenty funkcji ................................................................................................... 104 Większa ilość argumentów....................................................................................... 104 Wartości domyślne argumentów .............................................................................. 105 Referencje jako argumenty funkcji .......................................................................... 105 Wskaźniki jako argumenty funkcji .......................................................................... 106 Wartość zwracana przez funkcję.............................................................................. 106 Wskaźniki do funkcji ............................................................................................... 107 Rozdział 6. Programowanie zorientowane obiektowo ........................................ 109 Pojęcia obiekt i klasa ...................................................................................................... 109 Klasa......................................................................................................................... 110 Wskaźniki do komponentów jako pola klasy........................................................... 111 Tworzenie obiektów ................................................................................................. 111 Jeden obiekt może mieć wiele wskaźników............................................................. 113 Interfejs i implementacja klasy....................................................................................... 113 Definicja klasy.......................................................................................................... 113 Projektowanie klasy — ustalanie zakresu dostępności pól i metod......................... 114 Pola........................................................................................................................... 116 Konstruktor klasy — inicjowanie stanu obiektu ...................................................... 116 Wskaźnik this ........................................................................................................... 117 „Bardziej” poprawna inicjacja pól obiektu w konstruktorze ................................... 117 Tworzenie obiektu.................................................................................................... 118 Usuwanie obiektów z pamięci.................................................................................. 119 Metoda prywatna...................................................................................................... 120 Metoda typu const .................................................................................................... 120 Zbiór metod publicznych udostępniających wyniki................................................. 121 Testowanie klasy ...................................................................................................... 122 Metody statyczne...................................................................................................... 122 6 C++Builder i Turbo C++. Podstawy Rozdział 7. Podstawy debugowania kodu ......................................................... 125 Ukryty błąd............................................................................................................... 125 Aktywowanie debugowania ..................................................................................... 126 Kontrolowane uruchamianie i śledzenie działania aplikacji .................................... 126 Breakpoint ................................................................................................................ 128 Obserwacja wartości zmiennych .............................................................................. 129 Obsługa wyjątków przez środowisko BDS .............................................................. 129 Wyłączanie debugowania......................................................................................... 131 Część II Biblioteka komponentów VCL ...................................... 133 Rozdział 8. Podstawowe komponenty VCL ....................................................... 135 Komponent TShape — powtórzenie wiadomości .......................................................... 135 Jak umieszczać komponenty na formie? .................................................................. 135 Jak modyfikować złożone własności komponentów za pomocą inspektora obiektów?............................................................................................................... 136 Jak reagować na zdarzenia? ..................................................................................... 137 Komponent TImage. Okna dialogowe............................................................................ 138 Automatyczne adaptowanie rozmiarów komponentów do rozmiaru formy ............ 138 Jak wczytać obraz w trakcie projektowania aplikacji?............................................... 138 Konfigurowanie komponentu TOpenDialog............................................................ 138 Jak za pomocą okna dialogowego wczytać obraz podczas działania programu? .... 140 Jak odczytać plik w formacie JPEG? ....................................................................... 141 Kontrola programu za pomocą klawiatury............................................................... 141 Wczytywanie dokumentu z pliku wskazanego jako parametr linii komend ............ 142 Jak uruchomić projektowaną aplikację w środowisku BDS z parametrem linii komend? .................................................................................. 143 Komponent TMediaPlayer ............................................................................................. 144 Odtwarzacz plików wideo ........................................................................................ 144 Panel jako ekran odtwarzacza wideo ....................................................................... 145 Wybór filmu za pomocą okna dialogowego w trakcie działania programu............. 146 Odtwarzacz CDAudio .............................................................................................. 147 Komponenty sterujące .................................................................................................... 147 Suwak TScrollBar i pasek postępu TProgressBar.................................................... 147 Pole opcji TCheckBox ............................................................................................. 148 Pole wyboru TRadioButton...................................................................................... 149 Niezależna grupa pól wyboru................................................................................... 150 TTimer ............................................................................................................................ 151 Czynności wykonywane cyklicznie ......................................................................... 151 Czynność wykonywana z opóźnieniem ................................................................... 152 Aplikacja z wieloma formami ........................................................................................ 153 Dodawanie form do projektu.................................................................................... 153 Dostęp do nowej formy z formy głównej................................................................. 153 Show versus ShowModal ......................................................................................... 155 Zmiana własności Visible formy w trakcie projektowania ...................................... 156 Dostęp do komponentów formy z innej formy ........................................................ 156 Właściciel i rodzic .......................................................................................................... 157 Własności Owner i Parent komponentów ................................................................ 157 Zmiana rodzica w trakcie działania programu ......................................................... 158 Co właściwie oznacza zamknięcie dodatkowej formy? ............................................. 159 Tworzenie kontrolek VCL w trakcie działania programu ............................................. 160 Zadania ........................................................................................................................... 161 Komponent TSaveDialog ......................................................................................... 161 Komponenty TMemo, TRichEdit ............................................................................ 161 Komponent TRadioGroup........................................................................................ 161 Spis treści 7 Rozdział 9. Więcej komponentów VCL… .......................................................... 163 Menu aplikacji ................................................................................................................ 163 Menu główne aplikacji i edytor menu...................................................................... 164 Rozbudowywanie struktury menu............................................................................ 166 Tworzenie nowych metod związanych z pozycjami menu ...................................... 166 Wiązanie pozycji menu z istniejącymi metodami.................................................... 167 Wstawianie pozycji do menu. Separatory ................................................................ 167 Usuwanie pozycji z menu ........................................................................................ 168 Klawisze skrótu ........................................................................................................ 168 Ikony w menu........................................................................................................... 169 Pasek stanu ..................................................................................................................... 170 Sztuczki z oknami........................................................................................................... 172 Jak uzyskać dowolny kształt formy?........................................................................ 172 Jak poradzić sobie z niepoprawnym skalowaniem formy w systemach z różną wielkością czcionki? .............................................................................................. 173 Jak ograniczyć rozmiary formy? .............................................................................. 174 Jak przygotować wizytówkę programu (splash screen)? ......................................... 174 Zadania ........................................................................................................................... 177 Menu kontekstowe ................................................................................................... 177 Pasek narzędzi .......................................................................................................... 177 Rozdział 10. Prosta grafika............................................................................... 179 Klasa TCanvas.......................................................................................................... 179 Odświeżanie formy. Zdarzenie OnPaint formy........................................................ 179 Linie................................................................................................................................ 180 Metoda mieszająca kolory........................................................................................ 180 Rysowanie linii......................................................................................................... 182 ClientHeight i Height, czyli obszar użytkownika formy ............................................ 183 Okno dialogowe wyboru koloru TColorDialog ....................................................... 184 Punkty............................................................................................................................. 186 Wykorzystanie tablicy TCanvas::Pixels................................................................... 186 Negatyw ................................................................................................................... 186 Jak umożliwić edycję obrazów z plików JPEG?...................................................... 188 Kilka słów o operacjach na bitach............................................................................ 190 Własność TBitmap::ScanLine.................................................................................. 191 Inne możliwości płótna................................................................................................... 192 Tekst na płótnie ........................................................................................................ 192 Obraz na płótnie ....................................................................................................... 194 Zadanie ........................................................................................................................... 196 Rozdział 11. Operacje na plikach i drukowanie z poziomu VCL i VCL.NET ............ 197 Automatyczne dopasowywanie rozmiaru komponentów............................................... 198 Własność Align, czyli o tym, jak przygotować interfejs aplikacji, który będzie automatycznie dostosowywał się do zmian rozmiarów formy .................. 198 Komponent TSplitter................................................................................................ 199 Komponenty VCL pomagające w obsłudze plików ....................................................... 199 Jak połączyć komponenty TDriveComboBox, TDirectoryListBox i TFileListBox tak, żeby stworzyć prostą przeglądarkę plików?........................... 199 Jak filtrować zawartość komponentu TFileListBox?............................................... 200 Prezentowanie na komponencie TLabel nazwy katalogu wybranego za pomocą TDirectoryListBox................................................................................................. 200 Prezentowanie na komponencie TLabel pliku wybranego za pomocą TFileListBox.......................................................................................................... 201 Jak z łańcucha wyodrębnić nazwę pliku, jej rozszerzenie lub ścieżkę dostępu?......... 202 8 C++Builder i Turbo C++. Podstawy Wczytywanie plików graficznych wskazanych w FileListBox ............................... 203 Przeglądanie katalogów w TFileListBox ................................................................. 204 Obsługa plików z poziomu C++..................................................................................... 206 Tworzenie pliku tekstowego .................................................................................... 206 Test funkcji zapisującej do pliku.............................................................................. 207 Dopisywanie do pliku............................................................................................... 208 Odczytywanie plików tekstowych ........................................................................... 208 O funkcjach tworzących obiekty i o tym, dlaczego nie jest to najszczęśliwsze rozwiązanie ............................................................................................................ 209 Co jeszcze potrafi klasa ifstream? ............................................................................ 210 System plików ................................................................................................................ 212 Operacje na plikach .................................................................................................. 212 Operacje na katalogach ............................................................................................ 212 Jak z łańcucha wyodrębnić nazwę pliku, jego rozszerzenie lub katalog, w którym się znajduje? ........................................................................................... 213 Jak sprawdzić ilość wolnego miejsca na dysku?...................................................... 213 Drukowanie „automatyczne”.......................................................................................... 214 Drukowanie tekstu znajdującego się w komponencie TRichEdit. Okno dialogowe TPrintDialog............................................................................... 214 Wybór drukarki z poziomu kodu aplikacji............................................................... 216 Drukowanie „ręczne” ..................................................................................................... 216 Tworzenie i przygotowanie modułu Drukowanie .................................................... 217 Jak w trybie graficznym wydrukować tekst przechowywany w klasie TStrings? ...... 217 Testowanie drukowania tekstu w trybie graficznym................................................ 220 Jak wydrukować obraz z pliku? ............................................................................... 221 Dodawanie kodu źródłowego modułu do projektu .................................................. 223 Powtórka z edycji menu aplikacji ............................................................................ 223 Testowanie funkcji drukującej obraz ....................................................................... 224 Zadania ........................................................................................................................... 224 Klasa TStringList ..................................................................................................... 224 Rozwijanie funkcji Drukuj ....................................................................................... 225 Rozdział 12. Przechowywanie informacji w rejestrze systemu Windows .............. 227 Przechowywanie danych aplikacji w rejestrze ............................................................... 228 Jak utworzyć nowy moduł na funkcje odczytujące i zapisujące dane do rejestru? ........ 228 Deklarowanie funkcji w pliku nagłówkowym modułu ............................................ 229 Jak odczytywać dane z rejestru? .............................................................................. 229 Jak zapisać dane do rejestru? ................................................................................... 231 Odczyt z rejestru pozycji i rozmiaru okna po uruchomieniu aplikacji i ich zapis w trakcie jej zamykania ......................................................................................... 233 Automatyczne uruchamianie aplikacji w momencie logowania użytkownika .............. 234 Zapisywanie do rejestru informacji o uruchamianiu aplikacji w momencie logowania użytkownika ......................................................................................... 235 Usuwanie zapisu o automatycznym uruchamianiu .................................................. 235 Sprawdzanie, czy istnieje zapis o automatycznym uruchomieniu ........................... 236 Udostępnianie funkcji z modułu .............................................................................. 236 Test funkcji............................................................................................................... 237 Zadania ........................................................................................................................... 238 Przenoszenie modułu Rejestr do innych projektów ................................................. 238 Lista ostatnio otwartych plików w rejestrze............................................................. 238 Spis treści 9 Rozdział 13. Mechanizm drag drop................................................................. 239 Drag Drop z biblioteką VCL ...................................................................................... 240 Przygotowanie interfejsu z dwiema listami ............................................................. 240 Faza pierwsza: rozpoczęcie przenoszenia ................................................................ 241 Faza druga: akceptacja upuszczenia......................................................................... 241 Faza trzecia: upuszczenie przenoszonego elementu ................................................ 241 Usprawnienia .................................................................................................................. 242 Umieszczanie elementu w miejscu upuszczenia ...................................................... 242 Uelastycznianie kodu. Wykorzystanie wskaźnika Sender ....................................... 243 Rzutowanie wskaźnika Sender................................................................................. 243 Jak przenosić wiele elementów? .............................................................................. 244 Rozdział 14. Projektowanie własnego komponentu VCL ..................................... 247 Projektowanie i testowanie komponentu ........................................................................ 248 Tworzenie modułu komponentu............................................................................... 248 Funkcja Register....................................................................................................... 249 Metoda testująca komponent.................................................................................... 249 Dodawanie metod do komponentu........................................................................... 250 Krótka uwaga na temat metod statycznych i stałych ............................................... 251 Konstruktor komponentu.......................................................................................... 251 Dodawanie własności komponentu .......................................................................... 252 Zalety własności ....................................................................................................... 254 Testowanie własności............................................................................................... 254 Metoda prawie zdarzeniowa..................................................................................... 254 Funkcja ShellExecute ............................................................................................... 255 Uzupełnianie konstruktora ....................................................................................... 255 Wskaźniki do metod................................................................................................. 256 Udostępnianie niektórych ukrytych własności......................................................... 257 Pakiet dla komponentu i jego instalacja w BDS............................................................. 258 Aby stworzyć projekt pakietu .................................................................................. 258 Instalowanie komponentu VCL ............................................................................... 260 Ostateczne testowanie komponentu ......................................................................... 261 Zadania ........................................................................................................................... 262 Własności w klasie TRownanieKwadratowe ........................................................... 262 Rozwijanie komponentu TLinkLabel....................................................................... 262 Klasa abstrakcyjna.................................................................................................... 262 Skorowidz........................................................................................ 263 Rozdział 3. Żeby nie zanudzać Czytelnika suchym wykładem o poszczególnych typach zmiennych predefiniowanych w C++, instrukcjach sterujących i tym podobnych rzeczach, których tak czy inaczej trzeba się nauczyć, od razu proponuję zająć się programowaniem — wie- dza o języku pojawiać się będzie jako niezbędny element składowy opisywanych progra- mów. Przy okazji nauczymy się też, jak korzystać z najbardziej podstawowych kom- ponentów: pola edycyjnego TEdit, etykiety TLabel i przycisku TButton. Nie zamierzam bowiem zmuszać nikogo do tworzenia aplikacji konsolowych, na których zwykle uczy się programowania, co w przypadku narzędzi RAD jest mało naturalne i raczej nieatrakcyjne. Podstawy Zacznijmy od spraw podstawowych. Na przykład od powtórzenia informacji, że w C++ wielkość liter ma podstawowe znaczenie. Możemy na przykład zadeklarować trzy zmienne: zmienna, Zmienna i ZMIENNA, i każda z nich będzie przez kompilator trakto- wana jako oddzielna, zupełnie niezależna zmienna. Nie ma natomiast znaczenia sposób ułożenia kodu. Oznacza to, że pomiędzy słowa kodu można wstawić dowolną ilość spacji i zrobić dowolnie wielkie wcięcia — kompilator nie zwróci na to uwagi. Wszystkie zmienne w C++ są inicjowane. Jeżeli przy deklarowaniu zmiennej nie wska- żemy jej wartości, to zostanie ona zainicjowana wartością domyślną. W przypadku większości typów jest to zero. 46 Część I ¨ Zintegrowane środowisko programistyczne i język programowania C++ W rozdziale pierwszym do zmiany koloru panelu, a więc do przypisania nowej warto- ści własności Panel1- Color, użyliśmy operatora =. W C++ jest to właśnie operator przypisania. To tym operatorem nadajemy nową wartość wszelkiego typu zmiennym. Do porównywania dwóch zmiennych służy natomiast operator ==, który zwraca war- tość true (prawda), gdy zmienne są równe, i false (fałsz) w przeciwnym przypadku. Równanie kwadratowe Przygotujmy program rozwiązujący równanie kwadratowe. Jest to przykład na tyle prosty, żeby był łatwo zrozumiały bez większego wysiłku, a jednocześnie informatycz- nie na tyle złożony, żeby możliwe było przedstawienie wielu aspektów języka pro- gramowania. Jest to wręcz idealny przykład na zastosowanie instrukcji wyboru if i operacji arytmetycznych. Najpierw jednak trochę teorii dla tych, którzy zdążyli już zapomnieć, jak oblicza się pierwiastki równania kwadratowego i czym one w ogóle są. Równanie kwadratowe to równanie, w którym wyrażenie typu ax2+bx+c przyrównuje się do zera, a więc ax2+bx+c=0. Współczynniki równania a, b i c są ustalone i możemy założyć, że je znamy. Zakładamy dodatkowo, że współczynnik a jest różny od zera1. Naszym zada- niem jest natomiast wyznaczenie takich wartości liczby x, dla których równanie będzie spełnione, tzn. że po wstawieniu znalezionego x do lewej strony będzie ona równa zero. Jeżeli pozwolimy, żeby x było liczbą zespoloną, to równanie kwadratowe ma zawsze dwa, choć niekoniecznie różne, rozwiązania. W C++ liczby zespolone nie są jednak jednym z typów wbudowanych, choć obecny jest on w dołączonych do C++Buildera bibliotekach. Proponuję zatem ograniczyć się do liczb rzeczywistych, a wówczas rów- nanie kwadratowe może mieć dwa różne rozwiązania, jedno rozwiązanie „podwójne” lub nie mieć rozwiązań. Wszystko zależy od wartości parametrów, a dokładnie od . Jest to wyróżnik równania kwa- wartości ich następującej kombinacji: dratowego nazywany popularnie deltą, bo takiego symbolu używa się zazwyczaj do jego oznaczenia. Jeżeli wartość delty jest dodatnia, to równanie ma dwa różne roz- wiązania (pierwiastki). Jeżeli równa jest zero, to pierwiastki stają się sobie równe i mówimy, że równanie ma jedno rozwiązanie będące pierwiastkiem podwójnym. Na- tomiast jeżeli delta jest ujemna, to równanie nie ma rozwiązań w dziedzinie liczb rze- czywistych. Obliczenie delty to już połowa sukcesu, bo o ile nie jest ujemna, pozwala na bezpośrednie obliczenie wartości pierwiastków, które są równe: =D 2 - b 4 ac x 1 = D-- b 2 a i x 2 = D+- b 2 a Widać, że jeżeli wartość delty równa jest zero, a więc znika pierwiastek w liczniku, to x1 i x2 mają taką samą wartość i są równe –b/2a. To wspomniany pierwiastek po- dwójny. 1 Jeżeli a jest równe zero, to równanie kwadratowe degraduje się do równania bx+c = 0, którego rozwiązaniem jest x = –c /b (wówczas b musi być różne od zera). Rozdział 3. ¨ Typy zmiennych i instrukcje sterujące 47 Algorytm obliczania rozwiązań równania kwadratowego jest zatem następujący: 1. Odczytujemy wartości współczynników równania 2. Obliczamy wartość delty D. 3. Sprawdzamy, czy wartość delty jest mniejsza od zera: jeżeli tak, kończymy, pokazując komunikat o braku pierwiastków. 4. Jeżeli delta jest nieujemna, obliczamy pierwiastki i prezentujemy je użytkownikowi. Przygotowanie interfejsu Aby umożliwić użytkownikowi podanie współczynników równania, zastosujemy je- den z najbardziej podstawowych komponentów biblioteki VCL, a mianowicie TEdit — pole edycyjne. A dokładniej trzy tego typu komponenty, po jednym dla każdego współczynnika. Z każdym polem edycyjnym związana będzie etykieta informująca, który współczynnik należy wpisać do pola. Etykieta to komponent TLabel. Wynik po- każemy natomiast w okienku dialogowym, a ponadto na dodatkowym komponencie TEdit. Obliczenia uruchamiane będą za pomocą przycisku TButton. TEdit, TLabel i TButton to trzy chyba najczęściej używane komponenty biblioteki VCL. Świadomie pominąłem komponent TSpinEdit z zakładki Samples, który byłby z pew- nością wygodniejszy do kontroli liczb, którymi są współczynniki równania. Chciałem po prostu przedstawić Czytelnikowi komponent TEdit. Stwórzmy zatem nowy projekt aplikacji. Dokładniejszy opis czynności, które należy w tym celu wykonać, znajdzie Czytelnik w pierwszym rozdziale, ale ograniczają się one w zasadzie do wybrania pozycji VCL Forms Application — C++Builder z menu File/New. W widoku projektowania na formie należy umieścić trzy komponenty TEdit według wzoru na rysunku 3.1. Za pomocą inspektora własności zmieniamy ich własności Text odpowiadające zawartości pól na np. 1 w przypadku pierwszego i zera w przy- padku pozostałych (zob. rysunek 3.1). Nad każdym z nich warto umieścić komponent TLabel. Ich dokładne pozycje można dopasować za pomocą własności Left i Top wi- docznych w inspektorze obiektów. Etykiety tych komponentów zmieniamy kolejno na a, b i c. Można też zmienić ich własność Font w taki sposób, żeby powiększyć ety- kiety i użyć kursywy2. Dzięki temu będzie jasne, jaką wartość należy wpisać do każ- dego pola edycyjnego. Umieszczamy tam także jeszcze jedno pole edycyjne, w którym pokażemy wynik. Jego własność ReadOnlR (z ang. tylko do odczytu) zmieniamy na true. Żeby wyraźnie za- znaczyć, że nie jest to pole, którego wartość będzie dostępna do edycji, proponuję zmienić kolor jego tła na identyczny z kolorem formy (rysunek 3.1). W tym celu z rozwijanej listy w inspektorze obiektów przy własności Color wybieramy pozycję clBtnFace. Tę samą domyślną wartość ma własność Color formy. O tym, jak wykonać te czynności, dowiedzieliśmy się w pierwszym rozdziale. 2 48 Część I ¨ Zintegrowane środowisko programistyczne i język programowania C++ Rysunek 3.1. Interfejs aplikacji znajdującej rozwiązania równania kwadratowego Obok tych komponentów kładziemy jeszcze przycisk TButton. Za pomocą inspektora własności zmieniamy jego własność Caption np. na Oblicz (rysunek 3.1). Następnie klikamy go dwukrotnie, aby utworzyć domyślną metodę zdarzeniową. Przeniesieni zo- staniemy do edytora, gdzie zobaczymy utworzoną metodę — przez najbliższy czas bę- dzie to nasz cały ogródek, w którym będziemy uczyć się programowania w C++. Deklarowanie zmiennych W C++ nie ma wydzielonego miejsca, w którym należy deklarować zmienne. Ogromne znaczenie ma jednak to, czy zadeklarujemy ją wewnątrz, czy na zewnątrz metody Button1Click. W drugim przypadku będziemy mieli do czynienia ze zmienną globalną istniejącą przez cały czas działania programu. W pierwszym — ze zmienną lokalną tworzoną tylko na czas wykonywania metody Button1Click. Rozwiązanie drugie ogra- nicza ilość wykorzystywanej pamięci. Jest również znacznie bezpieczniejsze, bo ła- twiej kontrolować wartość zmiennej, która nie może być zmieniana nigdzie indziej jak tylko w metodzie Button1Click. Musimy obliczyć wartość delty. Zadeklarujmy więc w metodzie Button1Click zmienną lokalną Delta typu double. W tym celu w metodzie wpisujemy typ double, a po spacji nazwę zmiennej Delta (listing 3.1). Typ double potrafi przechowywać liczby rzeczy- wiste. Na ich przechowywanie posiada 64-bity (8 bajtów), co daje mu możliwość przechowywania liczb o wartości ponad ±10300. Listing 3.1. Deklaracja zmiennej Delta typu Double void __fastcall TForm1::Button1Click(TObject *Sender) { double Delta; } Jeżeli więcej zmiennych ma ten sam typ, to możemy je zadeklarować razem. Dodajmy jeszcze trzy zmienne o nazwach a, b i c typu double (listing 3.2). Zmienne te będą przechowywać wartości współczynników równania kwadratowego. Listing 3.2. W metodzie zadeklarowane są teraz cztery zmienne lokalne void __fastcall TForm1::Button1Click(TObject *Sender) { double a,b,c,Delta; } Rozdział 3. ¨ Typy zmiennych i instrukcje sterujące 49 Podkreślmy, że są to zmienne lokalne metody Button1Click. To znaczy, że powstają w momencie wywołania tej metody, a usuwane są z pamięci w momencie jej zakoń- czenia. Jak wspomniałem, można również tworzyć zmienne globalne, tzn. zmienne, których życie trwa przez cały okres działania programu. Przykładem takiej zmiennej jest Form1 zadeklarowane w interfejsie modułu Unit1. Ogólnie rzecz biorąc, należy jednak ograniczać korzystanie ze zmiennych globalnych, a wszystkie niezbędne dane przesyłać przez argumenty funkcji i metod. Żeby dać Czytelnikowi dobry przykład, w tym rozdziale i w całej książce w ogóle nie będziemy używać zmiennych globalnych. Inicjacja i przypisanie wartości zmiennej Zmienne zadeklarowane w listingu 3.1 i 3.2 nie są automatycznie inicjowane! To oznacza, że rezerwowana jest pamięć, w której przechowywana będzie zmienna, ale jej zawartość nie jest czyszczona. W konsekwencji wartość tak zadeklarowanej zmiennej jest przy- padkowa. Każda deklarowana zmienna powinna być inicjowana, tj. powinniśmy przypi- sać jej wartość w momencie utworzenia (takie sformułowanie dotyczy zmiennych lokal- nych, do których ograniczamy się w tej książce). Należy to zrobić w następujący sposób: double a=1; Zmienna, która została zainicjowana, może oczywiście zmieniać wartość w trakcie działania programu. W takiej sytuacji mówimy o operacji przypisania, np. double a=1; a=2; W przypadku typów prostych, jak int, obie te czynności można utożsamiać. Różnice pojawiają się w przypadku klas, ale to temat wykraczający poza zakres tej książki3. Dygresja na temat typów rzeczywistych w C++Builderze C++Builder nie ma zbyt wielu typów rzeczywistych, ale są one w zupełności wystar- czające. Wszystkie (raptem trzy) wymienione zostały w tabeli 3.1. Tabela 3.1. Typy rzeczywiste w C++Builder 2006 Nazwa typu Float Double long double Zakres (najmniejsza i największa absolutna wartość liczby) Liczba bajtów (bitów) 4 zajmowana przez zmienną Postać literału 1,5 · 10–45 .. 3,4 · 1038 5,0 · 10–324 .. 1,7 · 10308 3,4 · 10–4932 .. 1,1 · 104932 4 (32) 8 (64) 10 (80) 1.0F 1.0 1.0L 3 Omówienie różnic między inicjacją i przypisaniem w przypadku klas znajdzie Czytelnik w książce Stephena C. Dewhursta C++. Kanony wiedzy programistycznej, Helion 2005 4 Liczbę bajtów zajmowaną przez typ można sprawdzić następującą instrukcją: ShowMessage(IntToStr(sizeof(typ)));. 50 Część I ¨ Zintegrowane środowisko programistyczne i język programowania C++ Konwersja łańcucha na liczbę Pole edycyjne TEdit pozwala użytkownikowi na wpisanie łańcucha. Łańcuch ten może być następnie wykorzystany przez program, który może odczytać go z własno- ści Text typu AnsiString. AnsiString jest najbardziej „typowym typem” łańcuchów w C++Builderze i stosunkowo rzadko zachodzi potrzeba, żeby korzystać z łańcucha typowego dla C i C++, a więc tablicy znaków, tj. tablicy zmiennych typu char, który jest znacznie mniej wygodny w użyciu. Łańcuchy AnsiString są w C++Builderze identyfikowane za pomocą cudzysłowu, np. Helion . Nie ma w łańcuchach problemu z polskimi znakami, można ich swobodnie używać. Zakładamy (zapewne naiwnie), że użytkownik domyśli się, iż w pola edycyjne należy wpisać współczynniki równania kwadratowego, a więc liczby rzeczywiste. Wówczas będziemy mogli skonwertować łańcuchy z własności Text każdego pola edycyjnego na liczby rzeczywiste i zapisać je do zmiennych a, b i c. Na szczęście nie ma żadnego problemu z konwertowaniem łańcuchów na liczby (rzeczywiste lub naturalne). W przy- padku liczb rzeczywistych należy do tego użyć funkcji StrToFloat. Listing 3.3 zawiera przykład konwersji łańcucha z pierwszego pola edycyjnego do zmiennej a. Listing 3.3. Konwersja łańcucha na liczbę void __fastcall TForm1::Button1Click(TObject *Sender) { double a,b,c,Delta; a=StrToFloat(Edit1- Text); } Podobnie zróbmy z pozostałymi współczynnikami (listing 3.4). Zrezygnujemy przy tym z deklaracji ich we wspólnej linii na rzecz czytelności kodu: Listing 3.4. Konwersja wszystkich danych wejściowych void __fastcall TForm1::Button1Click(TObject *Sender) { double a=StrToFloat(Edit1- Text); double b=StrToFloat(Edit2- Text); double c=StrToFloat(Edit3- Text); double Delta; } Do konwersji łańcucha na liczbę naturalną służy funkcja StrToInt. Z konwersją łańcuchów do liczb rzeczywistych wiążą się problemy. Jednym z pod- stawowych jest sposób rozdzielania części całkowitej od dziesiętnej, a więc tzw. „prze- cinek”. W Polsce jako przecinka zgodnie ze standardami powinno używać się… prze- cinka. Wiem, to trochę masło maślane. Ale mniej maślane okazuje się w krajach anglosaskich, w których jako przecinka używa się kropki. Funkcja StrToFloat auto- Rozdział 3. ¨ Typy zmiennych i instrukcje sterujące 51 matycznie wykrywa ustawienia systemowe i odpowiednio do nich interpretuje wsta- wione znaki, w tym kropkę lub przecinek. Programista może też wymusić, jaki znak ma być podczas konwersji interpretowany jako „przecinek”5. Jeżeli konwersja nie powiedzie się, to znaczy gdy użytkownik do pola edycyjnego wpisze tekst, który mimo najszczerszych chęci nie może być zinterpretowany przez funkcję StrToFloat jako liczba, to zgłosi ona wyjątek informujący o błędzie. To da nam możliwość zareagowania na błąd bez zawieszania aplikacji, ale tym zajmiemy się póź- niej. Na razie załóżmy, że użytkownik naszej aplikacji będzie posłuszny i rzeczywiście w polach edycyjnych umieści liczby. Obliczenia arytmetyczne i ich kolejność Jeżeli konwersja powiedzie się, otrzymamy trzy współczynniki równania, które sta- nowią dane wejściowe naszego algorytmu. Możemy zatem zabrać się za obliczenie delty według wzoru . Do tego konieczne będzie mnożenie i odejmowanie b współczynników od siebie. =D 2 - 4 ac Do podstawowych operacji arytmetycznych, czyli do dodawania, odejmowania, mno- żenia i dzielenia, służą operatory: +, –, * i / (zob. tabela 3.2), które pozwalają kolejno na dodawanie, odejmowanie, mnożenie i dzielenie liczb. Typ liczby zwracanej przez te operatory zależy od typów jego argumentów. Zatem dodając dwie liczby int, otrzy- mamy wynik typu int. To naturalne także dla operatora odejmowania i mnożenia. Kło- poty sprawia jednak operator dzielenia. Bo przecież iloraz dwóch liczb całkowitych nie musi być liczbą całkowitą. Wręcz przeciwnie — częściej nią nie jest. A jednak operator / również przestrzega zasady, według której typ wyniku zależy od typu ar- gumentów. W związku z tym 1/2 ma wartość 0 (zaokrąglenie wyniku następuje zaw- sze w kierunku zera), ale 1/(double)2 lub 1/2.0 równy jest 0.5. Należy na to zwracać uwagę, bo to jedno z częstszych źródeł błędów logicznych w programach. Tabela 3.2. Operatory arytmetyczne w C++ Operator Opis Przykłady Priorytet * / + – mnożenie (jeżeli argumenty są rzeczywiste, to zwracany przez operator typ też jest rzeczywisty) dzielenie (jeżeli argumenty są całkowite, to zwracany przez operator typ też jest zaokrąglony do liczby całkowitej) reszta z dzielenia całkowitego (nie może być użyta z liczbami rzeczywistymi) dodawanie (zwracany typ zależy od typu argumentów) odejmowanie (operator dwuargumentowy) i zmiana znaku (operator jednoargumentowy) 2*2 daje 4, 2.0*2.0 daje 4.0 2.0/4.0 daje 0.5, 2/4 daje 0 2 4 daje 2, 4 2 daje 0 2+4 daje 6, 2.0+4.0 daje 6.0 2–4 daje –2, –2 daje… –2 4 4 4 5 5 5 Opis tego zagadnienia znajduje się w książce J. Matulewskiego C++Builder 2006. 222 gotowe rozwiązania, Helion 2006. 52 Część I ¨ Zintegrowane środowisko programistyczne i język programowania C++ Jeżeli w operatorach / i drugi argument będzie miał wartość 0, to podczas wy- konywania jednej z tych operacji zgłoszony zostanie wyjątek EDivBEDero. Aby obliczyć deltę, wystarczy odjąć od siebie dwa iloczyny, co w C++ należy zapisać jako: b*b–4*a*c. Przyjrzyjmy się temu wyrażeniu. Wiemy dobrze, że oznacza ono różnicę dwóch iloczynów, a więc (b*b)–(4*a*c). Kolejność działań wyznaczona jest przez priorytet każdej operacji arytmetycznej. Wszyscy zostaliśmy nauczeni jeszcze w szkole podstawowej, że mnożenie i dzielenie ma pierwszeństwo przed dodawaniem i odejmowaniem. Ale czy wie o tym kompilator C++Buildera? Na szczęście tak. Prio- rytety operatorów arytmetycznych w C++ (ostatnia kolumna w tabeli 3.2) całkowicie zgadzają się z tymi, jakie obowiązują w algebrze. Możemy zatem bez obaw dopisać do metody Button1Click wyrażenie obliczające war- tość pola Delta zgodnie ze wzorem z poniższego listingu: Listing 3.5. Obliczanie wyróżnika równania kwadratowego void __fastcall TForm1::Button1Click(TObject *Sender) { double a=StrToFloat(Edit1– Text); double b=StrToFloat(Edit2- Text); double c=StrToFloat(Edit3- Text); double Delta=b*b–4*a*c; } Operatory upraszające zapis operacji arytmetycznych wykonywanych na zmiennej Mówiąc o operatorach arytmetycznych, warto wspomnieć o charakterystycznych dla C++ operatorach przypisania, które zastępują operatory arytmetyczne w szczególnych, ale często spotykanych sytuacjach. Załóżmy, że w naszym programie jest zmienna n, której wartość chcemy zwiększyć o dwa. Możemy napisać instrukcję n=n+2; Odczytuje ona bieżącą wartość zmiennej n, dodaje do niej 2 i zapisuje nową wartość z powrotem do tej samej zmiennej. Instrukcja z operatorem = wykonywana jest bo- wiem od prawej do lewej, a więc najpierw obliczana jest wartość wyrażenia stojącego po prawej stronie tego operatora, a dopiero potem następuje przypisanie. C++ oferuje jednak operator, który upraszcza powyższą instrukcję: n+=2; Ze względu na wynik jest to instrukcja zupełnie równoważna poprzedniej, ale tym razem następuje tylko jedno odwołanie do zmiennej n, a poza tym zamiast dwóch operacji (+ i =) wykonywana jest tylko jedna. Poza wspomnianym wyżej operatorem += mamy do dys- pozycji także analogiczne operatory *=, /=, = i –=. Ich priorytet równy jest 15. Rozdział 3. ¨ Typy zmiennych i instrukcje sterujące 53 Jeżeli chcielibyśmy zwiększyć wartość zmiennej tylko o jeden — taka sytuacja ma często miejsce w przypadku indeksów pętli — moglibyśmy użyć jeszcze innego ope- ratora, a mianowicie ++. Jest to operator inkrementacji i może być umieszczony zarówno przed, jak i za zmienną. I ma to zasadnicze znaczenie w przypadku, gdy występuje on wspólnie z operatorem przypisania. //przEpadek a) int a1=2; int a2=++a1; ShowMessage(a2); //przEpadek b) int b1=2; int b2=b1++; ShowMessage(b2); Jeżeli operator inkrementacji umieszczony zostanie przed zmienną, jak w przypadku a), to wartość zmiennej a1 zostanie najpierw zwiększona o jeden, a dopiero wtedy jej wartość zostanie użyta do zainicjowania zmiennej a2. W przypadku b) kolejność ope- racji jest odwrotna. Wpierw wartość zmiennej b1 zostanie przypisana do b2, a dopiero wówczas wartość b1 zostanie zwiększona. Typ logiczny i operatory logiczne Poza operatorami arytmetycznymi zdefiniowane są jeszcze operatory logiczne, ope- ratory porównania, operatory związane ze wskaźnikami (omówimy je w następnym rozdziale), operatory działające na bitach liczb (te omówimy w rozdziale 10.), opera- tory dotyczące zbiorów oraz np. operator pozwalający na łączenie łańcuchów. Ope- ratory porównania to ==, != (różne), , , = i =. Myślę, że ich działania nie trzeba omawiać, bo działają w sposób jak najbardziej intuicyjny. Natomiast operatory lo- giczne to !, i ||. Wszystkie dotyczą zmiennej typu bool, która może przyjmować wartość true lub false. Działanie operatorów logicznych omówione zostało w tabeli 3.3. Zasadniczym zastosowaniem tych operatorów będzie konstruowanie warunków in- strukcji warunkowej, którą zaraz poznamy, i warunków przerywania pętli, którymi zaj- miemy się trochę później. Tabela 3.3. Operatory logiczne (t = true, f = false) Operator Opis Przykłady Priorytet ! || negacja koniukcja alternatywa !t = f, !f daje t t t = t, t f = f, f f = f t || t = t, t || f = t, f || f = f 2 12 13 Instrukcja warunkowa if Wróćmy do naszego równania kwadratowego. Na razie mamy obliczoną wartość delty. Sprawdźmy, czy nie jest ona mniejsza od zera. Jak pamiętamy, równanie nie ma wów- czas rozwiązań. Do tego typu zadań służy instrukcja warunkowa if (ang. jeżeli): if (warunek) polecenie; 54 Część I ¨ Zintegrowane środowisko programistyczne i język programowania C++ Polecenie zostanie wykonane jedynie wtedy, gdy warunek zostanie spełniony, a więc jeżeli wyrażenie pełniące rolę warunku ma wartość true. Jeżeli od warunku chcemy uzależnić wykonanie większej ilości poleceń, to musimy je umieścić w bloku otoczonym nawiasami klamrowymi { i }: if (warunek) { polecenia } Szkielet instrukcji warunkowej w takiej postaci widoczny jest na listingu 3.6. Dopiszmy go do edytowanej przez nas metody. Listing 3.6. Jeżeli delta jest mniejsza od zera, to… void __fastcall TForm1::Button1Click(TObject *Sender) { double a=StrToFloat(Edit1- Text); double b=StrToFloat(Edit2- Text); double c=StrToFloat(Edit3- Text); double Delta=b*b-4*a*c; if (Delta 0) { } } Co zrobimy, jeżeli Delta jest mniejsza od zera? Oczywiście poinformujemy użytkow- nika, że nie ma co liczyć na rozwiązania. Równanie, którego współczynniki podał, nie ma rozwiązań wśród liczb rzeczywistych. Informację o braku rozwiązań najprościej będzie umieścić w przeznaczonym do tego czwartym polu edycyjnym (komponent Edit4). Do jego własności Text przypiszmy łańcuch z odpowiednim komunikatem (li- sting 3.7). Listing 3.7. Własność Text pól edycyjnych służy nie tylko do odczytania zawartości pola, ale również do jego zmiany void __fastcall TForm1::Button1Click(TObject *Sender) { double a=StrToFloat(Edit1- Text); double b=StrToFloat(Edit2- Text); double c=StrToFloat(Edit3- Text); double Delta=b*b-4*a*c; if (Delta 0) { Edit4- Text= Brak rozwiązań (delta mniejsza od zera) ; } } W przypadku, gdy w razie spełnienia warunku wykonywane jest tylko jedno polecenie, klamry { i } nie są oczywiście konieczne, ale nawet wówczas warto je umieścić w kodzie, bo podnoszą jego czytelność, nie zmieniając jego sensu i nie wpływając na wielkość skompilowanego pliku .exe. Poza tym unikniemy w ten sposób błędu, jeżeli wbrew wcześniejszym intencjom zdecydujemy się jednak dopisać jakieś nowe polecenia. Rozdział 3. ¨ Typy zmiennych i instrukcje sterujące 55 Proszę zwrócić uwagę, że w C++ operator porównania dwóch zmiennych to ==, a nie =. Zatem w warunku instrukcji if może znaleźć się ==, ale raczej nie powinno =. Jak wyłączyć podpowiadanie szablonów instrukcji w edytorze? Po napisaniu instrukcji if i wstawieniu spacji edytor dopisze za nas część kodu i wy- znaczy miejsca, gdzie możemy wstawić warunek i instrukcję. Mnie to doprowadza do szewskiej pasji, bo nie mogę spokojnie pisać dalej kodu, który mam w głowie. Wydaje mi się, że dla Czytelnika, który uczy się C++, takie wyręczenie pamięci na tym etapie też nie jest dobre. Proponuję zatem to cudo wyłączyć. W tym celu z menu Tools wy- bieramy pozycję Options…. W oknie Options (rysunek 3.2) przechodzimy na zakładkę Editor Options/Code Insight i usuwamy zaznaczenie przy opcji Code Template Comple- tion. Następnie naciskam
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C++Builder i Turbo C++. Podstawy
Autor:
Sklep
Format
Cena
Helion.pl Helion.pl
książka
37,00 zł
Idź do sklepu »

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ą: