Witam.
Chciałbym poprowadzić poradnik, jak wystartować z projektowaniem aplikacji w środowisku C++ Builder 6 firmy Borland. Językiem, którym posługujemy się w tym środowisku jest (jak sama nazwa wskazuje - C++). Z racji tego, że sam często borykam się z jakimś problemem w tym środowisku, liczę na uwagi z Waszej strony - w końcu jak to p.Mirek mówi - pisząc tu, na forum, sami się uczymy Z resztą sam często pytam na czacie czy forum, kiedy czegoś nie rozumiem.

Troszkę o środowisku.
Sam C++ Builder (w wersji 6) jest już dzisiaj przez wielu uważany, jako dość przestarzałe narzędzie. Faktycznie coś w tym musi być, gdyż Borland już jej oficjalnie nie wspiera Nie zrażajmy się tym, gdyż nawet na dzień dzisiejszy można skomponować tu programy, które pozwolą nam wygodnie połączyć np. naszą płytkę ATB z komputerem (np. przez UART). Z resztą to, czego się tu nauczymy, na pewno przyda się w innych środowiskach:)

Firma Borland wypuściła również równolegle środowisko Delphi, które do złudzenia przypomina C++ Builder. Dodatkową zaletą jest fakt, że wiele komponentów napisanych w Delphi (w języku Pascal), można również użyć w C++ Builderze. Często wyszukując w internecie przykłady rozwiązań jakiś problemów, błędów czy innych rzeczy, znajdujemy je w języku Pascal, dlatego też warto "liznąć" chociaż podstawy tego języka, żeby je chociaż zrozumieć i przepisać do C++.

Do dzieła
1. Pobieramy instalkę C++ Buildera (np. z tąd: http://download.komputerswiat.pl/progra ... 6-personal )
2. Wykonujemy kolejne kroki, kiedy program zapyta nas o kod do instalacji, możemy spokojnie skopiować jakiś z internetu (np. z http://serials.ws ) - sam program jest darmowy do zastosowań niekomercyjnych.
3. Po zakończeniu instalacji i pierwszym uruchomieniu, program prosi nas, abyśmy się zarejestrowali. Można to zrobić, jednak jeśli nie zechcemy się rejestrować, program również się uruchomi.

Po uruchomieniu programu powinniśmy zobaczyć takie okno:



Pierwsze co robimy po uruchomieniu programu, to zapisujemy projekt gdzieś na dysku. w tym celu klikamy



i zapisujemy najpierw nasze okienko, które tworzymy, a później cały projekt. Do testów nie musimy nawet zmieniać nazw plików.

Na początek poszczególne elementy programu:
Na samej górze mamy pasek narzędzi. Tego chyba nie trzeba tłumaczyć - znajdziemy tam różne mniej lub bardziej interesujące funkcje - będę się do niego odnosić, gdy zajdzie potrzeba coś tam nagrzebać.
Poniżej widać różne ikony, na początku najbardziej interesujące dla nas to:
- zapisywanie wszystkich modyfikowanych plików - polecam robić to tak często jak to możliwe, inaczej w przypadku awarii zasilania czy komputera utracimy wszystkie zmiany.
- przełącza nas między okienkiem z kodem naszego programu, a Formatką/Formą z osadzonymi obiektami.
- kompiluje i uruchamia nasz program. (UWAGA, ten przycisk nie zapisuje zmian w kodzie, a jedynie generuje nowy plik *.exe)

Po prawej znajdują się komponenty w formie ikonek (są one posegregowane tematycznie).
Te ikonki też będziemy omawiać w trakcie trwania poradnika. Teraz powiem już, że są one dzielone na widoczne i niewidoczne oraz że przyjęło się używać ich nazewnictwa, ale poprzedając je literką "T". Np. komponent Edit jest klasą o nazwie TEdit - pomaga nam to tyle, że jeśli zechcemy znaleźć w wyszukiwarce jakąś stronę z opisem tego komponentu, znajdziemy tylko wyniki dotyczące środowiska Borlanda. Spróbujcie wpisać w google "Edit" oraz "TEdit"

Osobno mamy cztery okienka:
- Object TreeView - w nim ukażą się nasze obiekty w formie drzewka. Klikając w któryś z nich, możemy zmieniać jego ustawienia w oknie Object Inspector
- Object Inspector - tutaj naszym oczą ukazują się dwie zakładki:
+ Zakładka Properties - pozwala wprowadzać wiele zmian w każdym obiekcie. Mamy tu do ustawienia różne opcje, począwszy od samej nazwy obiektu, jego wielkość, kolor, kształt, położenie itp. Zmiany wprowadzone w tej zakładce obowiązują od uruchomienia programu (tj. możemy je później zmieniać podczas pracy programu - wprowadzając je w jego kodzie źródłowym).
+ Zakładka Events - w niej możemy konfigurować zdarzenia, które mogą nastąpić w trakcie np. kliknięcia w jakiś obiekt. Kiedy wybierzemy sobie np zdarzenie "OnClick" i klikniemy na nie podwójnie - program przejdzie od razu do okienka z kodem programu i utworzy szkielet funkcji, która się wykona jeśli właśnie klikniemy w dany obiekt.
- Nasza formatka (domyślnie Form1) - Tutaj umieszczamy wizualnie nasze obiekty na oknie programu. Tak właśnie będzie wyglądał nasz program po jego skompilowaniu
- Nasz kod programu (domyślnie Unit1.cpp) - Najważniejsze okno, czyli instrukcje, jakie ma wykonać dla nas program (pisane oczywiście w C++ - podstawowa znajomość chociaż C - obowiązkowa ).


Myślę, że czas teraz przejść do napisania pierwszego programu - czyli standardowe "Hello World"

Umieśćmy sobie na naszej formatce trzy komponenty:
Edit (zakładka Standard) - klikamy raz na komponent z listy, następnie na wolny obszar na formatce.
Button,
Label.
- już teraz zauważymy, że w oknie Object TreeView, na obszarze naszej formatki Form1 pojawiły się trzy obiekty: Button1, Edit1 oraz Label1.



1. Kliknijmy teraz na Edit1, później w oknie Object Inspector, w zakładce Properties odszukajmy parametr "Text" i zmieńmy jego wartość na "Hello World!".


2. Kliknijmy na Label1, następnie wartość jego parametru "Caption" usuńmy, tj zostawmy pustą.
3. Wartość parametru Caption naszego przycisku Button1 zmieńmy na "Przepisz!"

Teraz nasze okno powinno prezentować się w ten sposób:



Już teraz możemy uruchomić nasz program klikając zielony trójkącik skierowany w prawo Mamy ładne okienko, w którym..... w zasadzie nic się nie dzieje Możemy sobie klikać w przycisk "Przepisz!", ale nie wywoła nam to żadnego efektu.

Nadajmy więc troszkę życia naszemu programowi:)
Zamknijmy więc nasz program, klikając przycisk dla malkontentów, czyli krzyżyk w jego prawym górnym rogu. Kliknijmy więc w TreeView na nasz Button1, następnie w Object Ispector wybierzmy zakładkę Events, a tam klikamy dwukrotnie na puste pole po prawej stronie od zdarzenia "OnClick". Wygeneruje nam się szkielet funkcji:

Dajmy więc instrukcję programowi, aby przepisał tekst z okna Edit1 do obiektu Label1!
Między klamrami wpisujemy instrukcje:


Chwila wyjaśnienia odnośnie stosowanego operatora "->". Nasze obiekty (np.Label1) to w rzeczywistości wskaźnik do utworzonej zmiennej klasy TLabel, dlatego stosujemy taką przyjemną i przejrzystą strzałeczkę.

UWAGA! Gdyby w trakcie testowania naszego programu wystąpił błąd w postaci wyjątku:



Niestety nie uda nam się po prostu zamknąć okienka z programem. Jest to spowodowane tym, że program automatycznie przełącza naszą aplikację w tryb debugowania. Nie będę tego trybu omawiał, dlatego aby zamknąć naszą wadliwą aplikację, klikamy "OK" a następnie w pasku narzędzi szukamy opcji "Program Reset" w zakładce "Run".



CDN

_________________
Pozdrawiam:
Mikołaj

Częśc 2.
W drugiej części poradnika przejdziemy od razu do ciekawszych rzeczy, tzn. postaramy się napisać prosty notatnik. Nie będzie on co prawda miał jakiś fjuczerów, typu sprawdzanie pisowni, kolorowanie składni itp.; jednakże dzięki niemu nauczymy się obsługi plików oraz kilku ciekawych komponentów.

Na początku tworzymy sobie nową aplikację.
Pierwszą rzeczą, jaką zrobimy, będzie utworzenie MENU - czyli paska narzędzi na górze, w którym umieścimy sobie przyciski odpowiedzialne za otwieranie i zapisywanie pliku tekstowego.
W tym celu szukamy w zakładce Standard komponentu o nazwie MainMenu. Wybieramy go, a następnie umieszczamy w dowolnym miejscu naszej formatki.
Następnym krokiem będzie dodanie opcji w naszym Menu. W tym celu wybieramy sobie nasz obiekt MainMenu1 i w zakładce Properties szukamy parametru Items. Po jego zaznaczeniu pojawi nam się po prawej stronie przycisk z wielokropkiem. Klikamy w niego i naszym oczom ukaże się okienko o nazwie Form1->MainMenu1. Dodajmy teraz kategorię podmenu oraz kilka opcji pozwalających na pracę naszego Notatnika. Tą czynność wykonujemy klikając prawym przyciskiem myszy na niebieski kwadracik i wybierając Insert.




Umówmy się, że ten górny kwardacik to będzie kategoria, a dolne to będą opcje.
Zaznaczamy sobie naszą kategorię i szukamy w Object Inspector > Properties parametru Caption. Wybierzmy go i zmieńmy jego wartość na "Plik".
Teraz wybierzmy pierwszą opcję z kategorii Plik i tym samym sposobem nadajmy jej parametrowi Caption wartość "Nowy". Tym samym sposobem dodajmy jeszcze kolejno opcje "Otwórz...", "Zapisz", "Zapisz jako..." oraz "Zamknij".



Pole tekstowe - Memo
Weźmy teraz do łapki komponent o nazwie Memo i umieśćmy go na formatce. Rozciągnijmy go tak, aby zajmował całe nasze pozostałe pole.
WSKAZÓWKA!
Szerokość naszego obiektu Memo1 powinna być mniejsza niż szerokość formatki - wtedy nie pojawi nam się pasek na dole (suwak do przesuwania lewo-prawo). Chodzi tutaj o to, żeby wziąć pod uwagę szerokość marginesu okna. Wystarczy, że Wybierzemy z TreeView naszą formatkę (Form1) i w zakładce Events klikniemy na zdarzenie OnCreate i w funkcji, która nam się utworzy, wkleimy prostą komendę:


Oczywiście to samo robimy z wysokością - w rezultacie funkcja FormCreate na ten moment przyjmie postać:

Problem powstanie wtedy, gdy zachce nam się zmienić podczas pracy rozmiar okna. Jednakże na to też mamy sposób:) Wybieramy na naszej formatce zdarzenie OnResize i wklejamy tam dokładnie to samo. Ta funkcja dla odmiany wywoła się przy każdym rozsunięciu okna.
void __fastcall TForm1::FormResize(TObject *Sender)


Następną rzeczą, jaką wypadałoby zrobić, jest czyszczenie okna Memo1 przy starcie programu. W tym celu dopisujemy do funkcji OnCreate następującą linijkę:

Teraz po uruchomieniu programu możemy już pisać sobie notatki I będą one zapisane... szkoda tylko, że w pamieci RAM - czyli dopóki nie wyłączymy naszego notatnika.

Obsługa plików w Memo.
Aby otworzyć plik tekstowy, najpierw zdefiniujmy sobie, jakie pliki nasz edytor ma otwierać oraz jak ma to w ogóle robić Wybieramy zatem komponent o nazwie OpenDialog (zakładka Dialogs) i umieśćmy go na formatce. Teraz w zakładce Properties utworzonego obiektu wybierzmy sobie parametr Filter i w jego wartości kliknijmy sobie wielokropek. Dla uproszczenia ustawmy, żeby nasz edytor otwierał pliki *.txt oraz dowolne inne, ma to wyglądać tak:



Następną czynnością jest utworzenie okna dialogowego "Otwórz..." przy kliknięciu Plik>Otwórz... Robimy to standardowo, czyli tworzymy funkcję:

Oczywiście nie muszę już chyba dopowiadać, że robimy to poprzez zakładkę Events po wybraniu odpowiedniego obiektu (w naszym przypadku Otwrz1)



Teraz podyktujemy Notatnikowi, co ma zrobić, jeśli wybierzemy jakiś plik do otwarcia. Tworzymy funkcję dla wydarzenia OnCanClose obiektu OpenDialog1:


Możemy teraz uruchomić nasz program i sprawdzić, czy faktycznie nam się coś pokaże przy otwieraniu pliku VOILA:



Analogicznie postępujemy dla opcji Zapisz jako... Wybieramy komponent SaveDialog i postępujemy dokładnie tak jak przy otwieraniu - tworzymy zdarzenia i wklepujemy kod:


Na koniec oprogramujmy jeszcze opcje "Zapisz" oraz "Zamknij"



Oczywiście można by jeszcze dodać opcję "Nowy plik", czy ostrzeganie przed niezapisanym plikiem, ale to już pozostawiam Wam Następna część będzie już nawiązywać do komunikacji TCP. Naprawdę polecam korzystać z pomocy w internecie Warto też samemu sprawdzać różne funkcje, sprawdzając je po kolei z okienka podpowiedzi funkcji.

_________________
Pozdrawiam:
Mikołaj

Bardzo ciekawe i przyjemne wprowadzenie w środowisko
Sam pracuję od czasu do czasu w Borland.

Przydałby się artykuł o wykorzystaniu i tworzeniu własnych wtyczek.

Szukam informacji o wtyczkach do obsługi COM.

Będzie o obsłudze COM, ale to jak się wyrobię z obowiązkami. Własnych komponentów sam jeszcze nie umiem do końca tworzyć, ale postaram się coś o tym napisać:) tymczasem wszelkie dyskusje proszę prowadzić w wyznaczonym do tego, osobnym temacie:)

Wysłane z mojego GT-I9500 przy użyciu Tapatalk 4

_________________
Pozdrawiam:
Mikołaj