C++Builder i Turbo C++. Podstawy

Autor: Jacek Matulewski

Szczegóły książki w Helionie
ISBN: 83-246-0642-4
Cena: 37 zł
Oprawa: miękka
Format: B5
Data wydania: 2006.12.13
Liczba stron: 280
Przykładowy rozdział: ftp://ftp.helion.pl/online/cbuipo/cbuipo-3.pdf
Kategoria: C++

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.

  • Instalacja środowiska programistycznego
  • Pierwszy projekt
  • Zmienne i instrukcje w C++
  • Programowanie zorientowane obiektowo
  • Wyszukiwanie i usuwanie błędów w kodzie
  • Komponenty VCL oferowane przez C++Buildera
  • Tworzenie interfejsu użytkownika dla aplikacji
  • Drukowanie
  • Operacje na plikach
  • Przechowywanie informacji w rejestrze systemowym
  • Tworzenie własnych komponentów VCL

Poznaj nowoczesne narzędzia programistyczne.

C++Builder i Turbo C++. Podstawy -- spis treści

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)

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)
  • Ł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)

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)

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)
    • 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)

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)

©2007 Włodzimierz Gajda | prace magisterskie | Dubai | Korekta prac magisterskich , Ebooki programowanie androida, Pozycjonowanie stron Poznań