plik

1. Opis poglądowy środowiska

C++ Builder jest środowiskiem programistycznym typu RAD, które dzięki znajomości
języka C/C++ umożliwia konstruowanie aplikacji dla platformy Windows i
Net(odpowiednikiem dla systemów GNU/Linux jest Kylix) zarówno w trybie graficznym jak
i tekstowym. RAD (Rapid Application Development) – "szybkie tworzenie aplikacji" - Jest to
ideologia i technologia polegająca na udostępnieniu programiście dużych możliwości
prototypowania oraz dużego zestawu gotowych komponentów. Wygląd aplikacji projektuje
się przesuwając odpowiednie elementy w obszarze okna projektowanego programu metodą
przeciągnij i upuść. Środowisko Borland C++ Builder Personal przeznaczone jest do użytku
niekomercyjnego. Jego komercyjnym odpowiednikiem i zarazem rozszerzeniem jest Borland
C++ Builder 2006, którego można zakupić jako osobny pakiet lub w pakiecie Borland
Developer Studio – środowiska programistycznego obsługującego wiele języków. Edycja
personal jest darmowa i legalna pod warunkiem rejestracji w firmie Borland.

2. Zdobądź C++ Builder 6.0 Personal
C++ Builder’a można ściągnąć za darmo ze strony www.borland.pl. W tym celu należy
kliknąć w „darmowe wersje” w zakładce „do pobrania”. Na nowo otwartej stronie można
ściągnąć Buildera z serwera FTP(BSC Polska) lub z serwera Borland.com. Lepszym
rozwiązaniem jest ściągnięcie z FTP.

Zanim zacznie się pobieranie obowiązkowa jest rejestracja użytkownika.

Czerwone kropki obok fraz oznaczają pola obowiązkowe do wypełnienia.
Pola bardzo ważne w rejestracji:
Login Name: -wpisujemy login potrzebny do logowania się i oprogramowania,
Password: - wpisujemy hasło, musi być dłuższe niż 4 znaki,
Re-Enter: - ponownie wpisujemy hasło,
Email: - należy wpisać autentyczny e-mail, na który zostaną przesłane klucze,
Company: - należy wpisać N/A jeżeli nie pracujemy w firmie.

Na podany w rejestracji e-mail zostaną przesłane: numer seryjny i kod autoryzacji. Numer
seryjny składa się z trzech segmentów i w sumie z 14 znaków, a kod autoryzacji z dwu
segmentów i w sumie z 6 znaków.

3. Instalacja
Proces instalacji rozpoczyna się od uruchomienia pliku instalacyjnego. Zacznie się on
rozpakowywać, a po zakończeniu pokaże się ekran informujący zamiarze zainstalowania
środowiska Borland C++ Builder 6 personal. Należy kliknąć na Next.

Następnym krokiem jest wpisanie numeru seryjnego i kodu autoryzacji otrzymanych po
rejestracji.

Następnie akceptujemy umowę licencyjną.

Następny ekran to informacje o samej instalacji. Po wszystkich czynnościach zatwierdzamy
wybór przyciskiem Next. Następne opcje instalacyjne wymagają nieco więcej uwagi samego
użytkownika. Są to wybór typu instalacji, wybór kontrolek pakietów Office, miejsce
docelowe instalacji, a także dostęp do bazy instalacji. Użytkownik może wybrać jeden z
trzech typów instalacji typowej – typical, lekkiej – compact i niestandartowej – custom.

Zalecana jest instalacja typowa, gdyż zawiera wszystkie składniki potrzebne do pracy w
środowisku Borland C++ Builder. Jest to zarazem pełna instalacja. Tryb niestandartowy
można wykorzystać wtedy, gdy jakieś elementy środowiska nie są potrzebne i można je
pominąć. W następnym kroku określamy jakie kontrolki pakietu Office mają zostać
zarejestrowane. Obie będą dostępne w środowisku, ale tylko jedna będzie zarejestrowana –
sugeruję wybrać nowszy pakiet czyli Office 2000.

Decyzję zatwierdź przyciskiem Next. W dalszej części wybieramy lokalizację, czyli miejsce,
gdzie zainstaluje się C++ Builder wraz z komponentami naprzykład:

Ostatnią decyzją jest ta o zapisaniu bazy danych instalacji. Opcja ta jest użyteczna przy
deinstalacji środowiska Borland C++ Builder. Zajmuje niewiele 5 MB więc zapisanie jej z
pewnością nie nadwyręży pojemności dysku.

Wybór zatwierdź przyciskiem next.
Ostatni ekran służy jako informacja, że zaraz rozpocznie się isntalacja i jeszcze można
dokonać zmian wciskając klawisz Back lub zainstalować środowisko klikając w Install.
Instalacja potrwa w zależności od szybkości procesora i ilości pamięci operacyjnej od kilku
do kilkudziesięciu minut. Po zakończonej instalacji należy kliknąć na Finish i z reguły trzeba
zresetować komputer klikając na Yes.

Instalator Borland C++ Builder zamieścił w menu start swój aktywator(C++ Builder), zawsze
znajduje się on w zakładce „Borland C++ Builder 6”. Podczas pierwszego uruchomienia
środowiska użytkownik proszony jest o zarejestrowanie i aktywację programu. Nie jest to
konieczne, a w dodatku możliwe do pominięcia. Wystarczy w tym celu kliknąć w Cancel , a
w okienku, które pojawi się następnie wybrać przycisk Exit Registration.

4. Opis środowiska
Zaraz po uruchomieniu środowiska w oczy użytkownika rzuca się 5 elementów. Są to:
4.1 Menu główne,
4.2 Drzewo obiektów,
4.3 Nadzorca obiektów,
4.4 Forma 1,
4.5 Edytor kodu źródłowego.

4.1 Menu główne

Menu główne składa się właściwie z 3 części:
1 – gotowe obiekty – zestaw gotowych elementów, które można wykorzystać w programie.
Są to elementy takie jak przyciski, pola wyboru, linie komend, pola tekstowe itp.
2 – skrótowce wyciągnięte z menu sterowania,
3 – menu sterowania(File, Edit, Search, Project, Run, Component, Tools, Window, Help) –
menu sterowania służy jak sama nazwa wskazuje do sterowania pracą środowiska.
Umożliwia tworzenie nowych form, edytowanie ikon, zapisywanie i odczytywanie
projektów, kompilowanie, linkowanie i budowanie aplikacji.

4.2 Drzewo obiektów

Drzewo obiektów wyświetla wszystkie elementy
wchodzące w skład poszczególnych form. Element zwłaszcza
przydatny w dużych projektach liczących dziesiątki a nawet
setki elementów.

4.3 Nadzorca obiektów

Element ten jest odpowiedzialny za umożliwienie łatwej
konfiguracji elementów wchodzących w skład tworzonego
programu. Obszar zaznaczony czerwoną ramką to pole
wyboru poszczególnych elementów widocznych w drzewie
obiektów. Każdy z nich ma opcje, które można dostosować do
potrzeb aktualnie tworzonego programu oraz do własnej
wygody.

Edytor kodu źródłowego to element służący do zapisywania funkcji tworzonego programu
w języku C++.

5. Tekst, kompilacja, linkowanie, program
Aby zapisać jakąkolwiek instrukcję, która ma sterować działaniem programu należy
poznać składnię(gramatykę) wybranego języka programowania lub jego dialektu. Oczywiste
jest, że kod źródłowy w postaci znaków alfabetu jest niezrozumiały dla komputera. W tym
celu musi nastąpić „tłumaczenie tekstu” na język, którym posługuje się komputer. Za to
zadanie odpowiedzialny jest kompilator. Przed samą kompilacją tekst napisanego programu
przechodzi przez preprocesing(tekst jest przeglądany przez preprocesor). Preprocesor –
dokonuje konwersji tekstu programu w ten sposób, że: wszystkie wystąpienia znaków \ i
bezpośrednio po nim nowej linii są usuwane, następuje zamiana sekwencji specjalnych w
stałych tekstowych i znakowych ich odpowiednikami(np. zamiana znaku „\n” na znak o
kodzie ASCII 13), usuwane są wszelkie komentarze, łączone są sąsiadujące stałe tekstowe w
jedną stałą tekstową. Preprocesorem możemy sterować( i w praktyce sterujemy) za pomocą
dyrektyw. Dyrektywy to wiersze rozpoczynające się znakiem # i mogą znajdować się w
dowolnym miejscu programu. Najważniejsze dyrektywy to: #include w ramach którego
określa się pliki nagłówkowe, oraz #define, który służy do deklarowania stałych. Po przejściu
preprocesora i kompilacji dysponujemy wersją skompilowaną, która jest jeszcze niepełna.
Musi nastąpić połączenie jej z odpowiednimi bibliotekami. Za proces łączenia
odpowiedzialny jest program zwany linkerem. Przyłączanie funkcji bibliotecznych odbywa
się dopiero na etapie linkowania. Dyrektywa #include zaznajomiła kompilator tylko z samym
nagłówkiem biblioteki. Stało się tak, aby kompilator mógł sprawdzić poprawność odniesienia
do biblioteki. Sama treść funkcji znajdujących się w bibliotekach dołączana jest dopiero w
procesie linkowania.. Po przeprowadzeniu w/w czynności otrzymujemy program w wersjji
wykonywalnej.
Program – to stwierdzenie znane jest w czasach obecnych każdemu dziecku od
przedszkola. Użytkownicy komputerów potrafią wymienić cały szereg różnego rodzaju
programów od prostego notatnika do samego Quake’a. Programem nazywamy ciąg instrukcji
(w ilości skończonej) prowadzących do rozwiązania konkretnego zadania. Richard Stellman
powiedział kiedyś, że program można porównać do przepisu kulinarnego. Przepis tak jak
program to spis pozycji, które mówią co, gdzie i kiedy wstawić, żeby uzyskać określony
rezultat. Takimi składnikami są w programie instrukcje, dyrektywy, wyrażenia, pętle,
zmienne, stałe itp. Ich odpowiednie użycie prowadzi do wyśmienitego, ładnie napisanego
kodu i działającej aplikacji, albo do całkowitej porażki.

6. Podstawy języka C++
Większość kursów i książek poświęconych językom programowania rozpoczyna się od
programu wyświetlającego na ekranie napis HelloWorld. Nie będę łamał tej tradycji i na
samym początku postaram się omówić taki program. Od czegoś trzeba przecież zacząć.
Jednak pamiętać należy, że pisanie programów dla trybu teksowego(dla konsolety
GNU/Linux’a czy dla DOS’u) różni się od pisania programów dla trybu graficznego(czyli
tego co jest przedmiotem zainteresowania tej instrukcji). Na początku napiszę kod źródłowy
HelloWorld dla trybu tekstowego, opiszę jak skompilować ten program i jak otworzyć.
Otwieramy Borland C++ Builder. Zamykamy formę 1 i edytor kodu nie zapisując zmian.
Z menu file wybieramy kolejno New -> Other. W nowym oknie wybieramy ikonkę Cpp file
i klikamy na OK. Na ekranie pojawi się nowe okno edytora kodu źródłowego, gdzie należy
przepisać poniższy listing.

#include<iostream.h>
#include<conio.h>
int main()
{
cout<<”Hello World!!”<<endl;
cout<<”nacisnij dowolny klawisz”<<endl;
getch();
return 0;
}

Teraz należy tylko zapisać projekt i skompilować program. W tym celu należy klinkąć na
File->Save, teraz wystarczy już tylko wybrać lokalizację dla pliku z kodem. Aby
skompilować projekt należy kliknąć na Project->Build Project1. Jeżeli nie ma błędów
kompilacji to wykonywalna wersja programu znajduje się w tym samym katalogu, w którym
zapisywany był plik z kodem źródłowym. Uruchomiony program to tylko okienko wiersza
poleceń z napisami. W linii pierwszej i drugiej widzimy dyrektywy określające pliki
nagłówkowe iostream.h, oraz conio.h. Nawiasy ostre wokół nazw plików informują
preprocesor szuka plików nagłówkowych w katalogu zawierającym wszystkie pliki
nagłówkowe dostarczone wraz z kompilatorem. Plik iostream.h(input-output stream) jest
używany przez obiekt cout służący do wyświetlania tekstu na ekranie, natomiast conio.h jest
używany przez getch(), który w systemach windows służy do podtrzymywania ekranu
konsoli. W skrócie efektem działania linii 1 i 2 jest wstawienie zawartości plików iostream.h
i conio.h do kodu źródłowego programu. Linijka 3 to deklaracja i otwarcie głównej funkcji w
każdym programie w języku C++ czyli main(). Funkcje są blokami kodu wykonującymi
jedną bądź więcej operacji. Zwykle funkcje są wywoływane przez inne funkcje, ale funkcja
main() wywoływana jest automatycznie po uruchomieniu programu. Funkcja main() zwraca
do systemu operacyjnego wartość całkowitą(integer - int). Ponieważ niektóre systemy
operacyjne umożliwiają sprawdzanie jaka wartość została zwrócona przez program, przyjęło
się, że zwrócenie wartości 0 oznacza, że program zakończył działanie normalnie. Element
zwracający określoną wartość znajduje się w linijce 8 (return), po którym należy umieścić
zwracaną wartość(w tym przypadku cyfrę 0). Linie 4 i 9 to klamry otwierające i zamykające
ciało funkcji main(). Między nimi znajduje się cała zawartość funkcji. Linie 5 i 6 wyświetlają
ciąg znaków na ekranie monitora. Elementy cout – wskazują standardowe wyjście, << -
oznaczają przekierowanie do wyjścia, endl – oznacza przeniesienie do następnej linii na
ekranie. Większość instrukcji w języku C++ kończy się znakiem średnika. Program pisany w
języku C++ ma następującą strukturę:

#include<nagłówek1.h>
#include<nagłówek2.h>
int main()
{

ciało funkcji głównej;

}

Program HelloWorld pozostawia wiele do życzenia w kwestii funkcjonalności. Dobry
program to taki, który swoim działaniem: ułatwia pracę z komputerem, oszczędza czas
potrzebny do wykonania określonej/określonych czynności. Zanim powstanie program należy
najpierw określić specyfikację problemu, czyli co konkretnie ma robić ta aplikacja, przy czym
nie istotne jest jak określony zostanie problem. Ważne, aby założenia były zrozumiałe dla
programisty, bądź grupy programistów. Najczęściej w celu zwizualizowania problemu i
schematu działania aplikacji tworzone są schematy blokowe bądź lista kroków. Oba
rozwiązania pozwalają na szczegółowe dopracowanie projektu i ewentualne rozbicie
zasadniczego problemu na mniejsze części. Tyle celem ukierunkowania projektowego.

6.1 Zmienne i stałe
Zmienne i stałe służą najogólniej mówiąc do przechowywania danych, którymi posługuje
się program. Dzięki zmiennym i stałym możliwe są wszelakie operacje na tych danych. Aby
skutecznie prowadzić operacje na zmiennych należy je odpowiednio zdefiniować ponieważ
inaczej traktowane są(inne rozmiary pamięci operacyjnej są im przydzielane) liczby
całkowite, inaczej pojedyncze znaki, łańcuchy znaków, liczby zmiennoprzecinkowe.
Poniższa tabelka ilustruje nazwy zmiennych, ich rozmiary w pamięci oraz zakresy
wartości(dla maszyn 32 bitowych).

Nazwa

Rozmiar w bajtach

Zakres

char

-128 do 127

unsigned char

0 do 255

short int

-32 768 do 32 767

unsigned short int

0 do 65 535

long int

-2 147 483 648 do 2 147 483 647

unsigned long int

0 do 4 294 967 295

int

jak long

unsigned int

jak unsigned long

float

1,2*10

-38

do 3,4*10

double

2,2*10

-308

do 1,8*10

308

bool

true(prawda) lub false(fałsz)

Jeżeli jesteś zainteresowany sprawdzeniem tych wartości istnieje bardzo prosta metoda.
Wystarczy napisać program testujący rozmiar poszczególnych typów zmiennych. Oto jego
kod.

#include<iostream.h>
#include<conio.h>
int main(){
cout<<”rozmiar zmiennych typu char to: ”<<sizeof(char)<<” bajtow”<<endl;
cout<<”rozmiar zmiennych typu short to: ”<<sizeof(short)<<” bajtow”<<endl;
cout<<”rozmiar zmiennych typu long to: ”<<sizeof(long)<<” bajtow”<<endl;
cout<<”rozmiar zmiennych typu int to: ”<<sizeof(int)<<” bajtow”<<endl;
cout<<”rozmiar zmiennych typu float to: ”<<sizeof(float)<<” bajtow”<<endl;
cout<<”rozmiar zmiennych typu bool to: ”<<sizeof(bool)<<” bajtow”<<endl;
cout<<”rozmiar zmiennych typu double to: ”<<sizeof(double)<<”
bajtow”<<endl;
getch();
return 0;
}

Zajmiemy się teraz definiowaniem zmiennych, przypisywaniem im określonych wartości,
a także poddamy je prostym operacjom arytmetycznym. Aby użyć określonego typu zmiennej
należy ją zdeklarować, nazwać i ewentualnie określić początkową jej wartość. Deklaracją
zmiennej jest po prostu podanie jej typu np. int. Nazwą zmiennej może być dowolny ciąg
znaków nie zawierający: białych spacji, narodowych znaków diakrytycznych, nie zaczynający
się cyfrą. Przykład zdefiniowanych zmiennych:

int a;
int b=5;
char litera=’a’;
float UlamekDziesietny=0.68;

Zmienne definiujące wartości całkowite mogą występować w dwu typach: ze
znakiem(signed [występuje domyślnie]) i bez znaku(unsigned). Zmienne typu całkowitego
bez słowa kluczowego unsigned traktowane są jako liczby ze znakiem. Efektem podania
słowa kluczowego jest uzyskanie liczb ujemnych. W liczbach ze znakiem najstarszy bit
oznacza znak – jeżeli przyjmuje 0 to pozostałe bity określają liczbę dodatnią, jeżeli 1 to
ujemną. W razie problemów ze zrozumieniem odsyłam do uważnego przestudiowania
systemów pozycyjnych – ze szczególnym uwzględnieniem systemu binarnego. Odpowiednią
dawkę informacji można znaleźć w książce „Układy Cyfrowe” Wojciecha Głockiego.
Gdyby z jakiegoś powodu do zmiennej przypisać wartość większą niż może ona pomieścić
np. do zmiennej typu char bez znaku próbować przypisać wartość 256 to wynikiem takiego
przypisania będzie cyfra 0. Dowodem na to niech będzie poniższy program.

#include<iostream.h>
#include<conio.h>
int main(){
unsigned char a=255;
cout<<”zawartosc zmiennej a: ”<<a<<endl;

/* a++ - operacja zwana inkrementacją – zwiększenie wartości o 1 */

a++;
cout<<”zawartosc zmiennej a: ”<<a<<endl;
getch();
return 0;
}

Dwa znaki // - oznaczają komentarz. Wszystko co następuje po tych znakach, aż do końca
linii wiersza jest pomijane przez kompilator. Komentarze służą umieszczaniu wyjaśnień w
samym kodzie źródłowym. Innym stylem komentarzy jest /* */ . Wszystko co znajduje się
pomiędzy /* i */ jest komentarzem.
Zmienne mogą być poddawane różnorakim operacjom matematycznym. Poniższa tabela
przedstawia ważniejsze operatory stosowane w C/C++.

Operator

Znaczenie

Przykład

Operatory arytmetyczne

dodawanie

a=b+c;

odejmowanie

a=b-c;

mnożenie

a=b*c;

dzielenie

a=b/c;

Modulo(reszta z dzielenia
całkowitego)

a=b%c;

Operatory przypisania

przypisanie

a=10;

dodanie i przypisanie

a+=10; (równoznaczne z

a=a+10)

odjęcie i przypisanie

a-=10;

Operatory relacyjne

równy

if(a==10){...}

nie równy(różny od)

if(a!=10){...}

mniejszy niż

if(a<10){...}

większy niż

if(a>10){...}

mniejszy lub równy

if(a<=10){...}

większy lub równy

if(a>=10){...}

Operatory logiczne

iloczyn logiczny(koniunkcja)

If((a==10) && (b==5)){…}

suma logiczna(alternatywa)

If((a==10) || (b==5)){...}

Operatory
jednoargumentowe
++

Inkrementacja(zwiększenie o
1)

A++;

++A

Dekrementacja(zmniejszenie o
1)

a--;
--a;

Operatory arytmetyczne, przypisania i relacyjne nie powinny stanowić problemu. Operator
iloczynu logicznego opisuje jakich n warunków musi zostać spełnionych, aby zostały
wykonane polecenia w klamrach. Muszą zostać spełnione wszystkie warunki. Załóżmy, że do
wykonania jakiegoś skoku warunkowego muszą zostać spełnione 3 zależności. Jeżeli
pierwsza zostanie spełniona sprawdzana jest druga. Jeżeli ta druga też jest spełniona
sprawdzana jest trzecia. Gdyby druga zależność nie została spełniona sprawdzanie zostałoby
przerwane, gdyż muszą zostać spełnione wszystkie warunki. Operacja sumy logicznej polega
na sprawdzeniu czy choć jedna spośród n zależności jest spełniona.
Operatory jednoargumentowe inkrementacja i dekrementacja określają zwiększenie i
zmniejszenie wartości o 1. Zapis:

a++;

jest równoważny z zapisem:

a=a+1;

co oznacza: do a dodaj 1 i przypisz do a. Operacja ta jest poprawna z programistycznego
punktu widzenia. Niby dlaczego nie możnaby dodać sobie jakieś wartości do zmiennej, a
następnie przypisać tą wartość do tej samej zmiennej? Można podzielić inkrementację i
dekrementację na przedrostkową i przyrostkową, w zależności od umiejscowienia operatora
względem zmiennej.

Przedrostkowe zwiększają wartość i przypisują ją do zmiennej, a przyrostkowe przypisują do
zmiennej, a następnie zwiększają wartość. Różnica jest widoczna przy wykonywaniu kilku
operacji pod rząd.
W programach trybu tekstowego dane do programu wprowadza się najczęściej za pomocą
klawiatury(wprowadzania danych z plików nie będę opisywał z racji ograniczenia czasowego
na napisanie tej pracy). Aby pobrać jakąś daną z klawiatury należy zastosować obiekt typu
cin. Przykład zastosowania obiektu cin i operatorów znajduje się poniżej.

#include<iostream.h>
#include<conio.h>
int main(){

/* - deklaracja zmiennej typu int o nazwie x */

int x;

/* - przypisanie wartości 2 zmiennej y */

int y=2;

/*- deklaracja zmiennej z typu float */

float z;
cout<<”wprowadz wartosc: ”;

/* - zastosowanie cin. Przypominam, że >> oznaczają wprowadzanie, natomiast
<< wyprowadzenie. */

cin>>x;
cout<<”zawartosc zmiennej x: ”<<x<<endl;
cout<<”y+x= ”<<(x+y)<<endl;
cout<<”y*x= ”<<(x*y)<<endl;
z=x/y;
cout<<”x/y= ”<<z<<endl;
getch();
return 0;
}

Jeżeli program został przepisany poprawnie to na ekranie konsoli powinno być widać
następujące wiersze przy założeniu, że przypisano do x wartość 3:

wprowadz wartosc: 3
3
5
6
1

Śledząc uważnie powyższy wydruk i kod źródłowy możnaby przypuszczać, że ostatnia linijka
zawiera błędną wartość 1. 3/2 to przecież 1.5, a nie 1. Rozwiązanie tego problemu jest
dziecinnie proste. Otóż nawet jeżeli zmienna z jest wartością zmiennoprzecinkową to
przypisano jej iloraz wartości całkowitych(jeżeli wszystkie składniki działania są wartościami
całkowitymi to wynik też jest wartością całkowitą), co oznacza, że pominięte zostały
wszystkie wartości po przecinku. Rozwiązaniem tego problemu jest zmiana typów zmiennych
x i y na typ float.
Zmienne podzielić możemy ze względu na umiejscowienie w kodzie źródłowym programu
na lokalne i globalne. Lokalne to takie, które deklarowane są w jednej funkcji i działają w
ramach jej ciała, natomiast globalne deklarowane są(mogą być) po dyrektywach preprocesora.

Stałe jak sama nazwa wskazuje służą do przechowywania danych w pamięci bez
możliwości ich zmodyfikowania podczas działania programu. Wszelkie zmiany wartości
stałych zmieniane są tylko i wyłącznie przez modyfikację kodu źródłowego. Stałe można
zdefiniować na dwa sposoby. Pierwszy z nich – starszy i obecnie coraz rzadziej używany –
polega na zapisaniu stałej jako dyrektywy preprocesora.

#define stala 5
#define stala2 „stala2 jest stałą tekstową”
#define stala3 2.12

Należy zwrócić uwagę na brak jakichkolwiek operatorów przypisania i średników na końcu
deklaracji. Późniejsze wywołania w kodzie programu odbywają się identycznie jak w
wypadku zmiennych, czyli:

cout<<”zawartosc stalej: ”<<stal2<<endl;
x=y+stala; // zakładając, że x i y są wcześniej zdeklarowane...

Drugi sposób – nowy i chyba wygodniejszy dla kompilatora – polega na zdefiniowaniu
słowem kluczowym const, po którym trzeba zdeklarować typ stałej(dokładnie tak samo jak
zmiennej czyli np. int, bool, signed char itp.).

const unsigned short int calkowita=15;
const float pi=3.14;

Zasady użycia nie zmieniają się.

Stałe wyliczeniowe – to elementy umożliwiające tworzenie nowych typów i definiowanie ich
zmiennych. Aby zdeklarować stałą wyliczeniową należy użyć słowa kluczowego enum.

enum Kolor(zielony, czerwony, czarny, bialy, zolty);

Powyższe wyliczenie działa następująco: tworzy nowy typ Kolor oraz przyporządkowuje
kolejnym barwom(stałym symbolicznym) wartości(zielony jest stałą o wartości 0, czerwony
jest stałą o wartości 1 itd.). Każde wyliczana stała ma wartość całkowitą – jeżeli nie zostanie
ona zdefiniowana to domyślnie wartości liczone są od zera.

enum Kolor(zielony=4, czerwony, czarny, bialy=100, zolty);

Zapis taki jak wyżej wymieniony powoduje, że zielonemu zostanie przyporządkowana
wartość 4, czerwonemu 5, czarnemu 6, białemu 100 i żółtemu 101. Możliwe jest definiowanie
zmiennych typu Kolor, ale mogą one przyjmować tylko wartości wyliczone tzn. w tym
wypadku: zielony, czerwony, czarny, bialy, zolty lub 4,5,6,100,101. Stałe wyliczeniowe to w
rzeczywistości stałe typu unsigned int i zawsze odpowiadają wartościom całkowitym.
W skrócie można powiedzieć, że stałe wyliczeniowe realizują funkcję nazywania wartości.
Jest to użyteczne zwłaszcza podczas prac z blokami takimi jak kolory, dni tygodnia itp.
W C/C++ rozróżniane są wielkie i małe litery – w związku z czym trzeba bardzo uważać
podczas deklarowania i używania nie tylko zmiennych, ale i wszystkich obiektów, którym
można przypisać nazwę. Zmienna o nazwie las różni się więc od zmiennej o nazwie Las, a
obie z kolei różnią się od zmiennej o nazwie LAS.

6.2 Wyrażenia i instrukcje
W poprzednim podrozdziale przedstawiłem tabelkę z najczęściej używanymi operatorami
matematycznymi i logicznymi. W tym miejscu postaram się pokrótce wskazać jak używać
tych operatorów w wyrażeniach, jak zagnieżdżać nawiasy i opiszę podstawowe instrukcje
sterujące działaniem programu. Ufam, że każdy czytający zna kolejność wykonywania
działań w matematyce – ponieważ kompilator także „ją zna”.
Instrukcje – kontrolują kolejność działania programu. Wszystkie instrukcje w C/C++
kończą się średnikiem. Przykładowa instrukcja:

a=b+c;

Ta instrukcja nie oznacza wcale, że a jest równe sumie b i c, tylko przypisanie wartości sumy
b i c do zmiennej a. Dobrym pomysłem byłoby przejrzenie poprzednio opisanych kodów
źródłowych i odszukanie instrukcji.
Instrukcje złożone – zwane również blokami – to zbiory instrukcji pojedynczych
zamkniętych w klamrach. Przykład:

{
x=(2+a)*b;
c=x;
cout<<c<<endl;
}

Cały ten blok kodu działa jak pojedyncza instrukcja, choć klamry nie są zakończone
średnikami.

Wyrażenia – Wyrażeniem nazywamy wszystko co zwraca jakąś wartość. Ponieważ
instrukcja

5+7; zwraca wartość 12 jest więc wyrażeniem. Wszystkie wyrażenia są

jednocześnie instrukcjami. Przykłady wyrażeń:

a=b+c;
x=y=z+3*(5-v);
return 0;

Pamiętać należy o tym, że instrukcja przypisania przypisuje operandowi(obiekt po prawej i po
lewej stronie operatora) po lewej stronie wartość operandu po prawej stronie operatora.
Zwracam też uwagę na fakt, że stała mogą być tylko r-wartościami[(r-values) operandami po
prawej stronie], nigdy l-wartościami. L-wartością nie może być również cyfra.
Programik niżej przedstawiony pokazuje działanie operatora odejmowania. Przepisz,
skompiluj i uruchom.

#include<iostream.h>
#include<conio.h>
int mian(){
unsigned int roznica, WiekszaLiczba=200, MniejszaLiczba=150;
roznica=WiekszaLiczba-MniejszaLiczba;
cout<<”roznica to: ”<<roznica<<endl;
roznica=MniejszaLiczba-WiekszaLiczba;
cout<<”a teraz roznica to: ”<<roznica<<endl;
return 0;
}

Spokojnie – wartość 4294967246 to nie żaden błąd kompilatora, czy przypadkowa
wartość. W poprzednim podrozdziale opisałem co się dzieje kiedy przekroczona zostanie
minimalna lub maksymalna wartość zmiennej. Tak stało się w tym przypadku – zdeklarowane
zostały trzy zmienne typu całkowitego bez znaku. Nie można więc do liczby bez znaku
przypisać wartości ujemnej, a po drugie przekroczona została minimalna wartość zmiennej,
więc odejmowane były wartości „od góry”. Porównaj wynik z tabelką wartości zmiennych.
Instrukcja if(jeżeli) – bardzo ważna w języku C/C++ - umożliwia sprawdzenie spełnienia
warunku. Jeżeli wyrażenie ma wartość true(prawda) to instrukcja jest wykonywana, w
przeciwnym wypadku jest pomijana.

if(wyrażenie)
instrukcja;

Przykład:

if((a>b) || (c=d))
cout<<z<<endl;

Ponieważ blok instrukcji stanowi odpowiednik instrukcji pojedynczej instrukcja warunkowa
może być dość rozbudowana:

if(wyrażenie)
  {
   instrukcja1;
   instrukcja2;
   instrukcja3;
   }

Instrukcja warunkowa if może zostać rozbudowana o element else(w przeciwnym wypadku) –
służący do wykonania instrukcji jeżeli wyrażenie będzie miało wartość false(fałsz). Przykład
użycia instrukcji if else:

#include<iostream.h>
#include<conio.h>
int main(){
short int Pierwsza, Druga;
cout<<”wprowadz pierwsza cyfre/liczbe: ”;
cin>>Pierwsza;
cout<<”wprowadz druga cyfre/liczbe: ”;
cin>>Druga;
   if(Pierwsza>=Druga){
   cout<<”Pierwsza jest wieksza lub rowna drugiej”<<endl;
   cout<<Pierwsza<<” >= ”<<Druga<<endl;
   }
   else{
   cout<<”Druga jest wieksza od pierwszej”<<endl;
   cout<<Druga<<” > ”<<Pierwsza<<endl;
   }
return 0;
}

Pętle – elementy umożliwiające powtarzanie określonej instrukcji lub bloku. Instrukcja
goto(idź do) – jest protoplastą pętli – umożliwia przeskok do dowolnego miejsca w kodzie
źródłowym. Aby umożliwić przeskok trzeba określić miejsce w kodzie, do którego będzie
odnosił się skok, miejsce to nazywa się etykietą, może mieć dowolną nazwę i kończy się
dwukropkiem. Miejsce, z którego skok będzie wykonywany składa się z instrukcji goto,
nazwy etykiety i kończy się średnikiem.

instrukcja1;
instrukcja2;
etykieta:
if(instrukcja3)
goto etykieta;

Przykład działania:

#include<iostream.h>
#include<conio.h>
int main(){
short int licznik=0;
petla:
licznik++;
if(licznik<10)
goto petla;
cout<<”gotowe – osiagnieta wartosc to 10: ”<<licznik<<endl;
getch();
return 0;
}

Program wykonuje się dopóki licznik nie osiągnie wartości 10, która zostanie wyświetlona na
ekranie po zakończeniu pętli. Instrukcja goto jest obecnie bardzo rzadko używana.
Pętla while(dopóki) – powoduje powtarzanie się instrukcji tak długo jak zaczynające pętlę
wyrażenie warunkowe ma wartość true. Działanie pętli while:

while(wyrażenie warunkowe)
instrukcja_wykonywana;

Demonstracja działania pętli while:

#include<iostream.h>
#include<conio.h>
int main(){
short int licznik=0;
while(licznik<10){
  licznik++;
  cout<<licznik<<endl;
  }
cout<<”start!!”<<endl;
getch();
return 0;
}
Program ten wywołuje pętlę, która wykonuje się do momentu, aż wartość licznika nie
osiągnie 10 – wtedy pętla przerywa swoje działanie i wyświetlony zostaje napis „start”.

Instrukcje break;(przerwij) i continue;(kontynuuj) – zmieniają kierunek działania programu.
Break – przerywa wykonywanie instrukcji zawartych w pętli, a continue powoduje powrót do
początku pętli. Obie instrukcje mogą okazać się przydatne zwłaszcza w bardziej
rozbudowanych pętalch.

while(warunek){
instrukcja1;
  if(warunek2){
  instrukcja2;
  break;
  }
  else{
  instrukcja3;
  continue;
  }
}

Tak można blokowo opisać działanie continue i break. Pętla sprawdza, czy wartość warunku
to true, następnie wykonuje instrukcję1, sprawdza warunek2, jeżeli jego wartość to true
przerywa działanie pętli while, w przeciwnym wypadku wykonywana jest instrukcja3 i pętla
rozpoczyna się od początku.

Pętla do...while(wykonuj... dopóki) – pętla ta w odróżnieniu od pętli while najpierw
wykonuje instrukcje, a potem sprawdza warunek wykonania. Idea pętli do...while przedstawia
się następująco:

do{
instrukcja1;
instrukcja2;
} while(warunek);

Przykład:

#include<iostream.h>
#include<conio.h>
int main(){
short int licznik;
cout<<”podaj ilosc wyswietlen: ”;
cin>>licznik;

do
cout<<++licznik<<” raz”<<endl;
while(licznik<10);

getch();
return 0;
}

Powyższy program pobiera od użytkownika liczbę całkowitą, która następnie jest
inkrementowana przedrostkowo i wyświetlana, do momentu, w którym licznik nie będzie
mniejszy od 10. Zastanów się co by się zmieniło i dlaczego gdyby program wykonywał
inkrementację przyrostkową.

Pętla for(dla) – składa się z następujących elementów:

for(inicjalizacja; test; akcja)
instrukcja;

Przykład:

#include<iostream.h>
#include<conio.h>
int main(){
short int licznik;

for(licznik=0; licznik<10; ++licznik)
cout<<licznik<<endl;

getch();
return 0;
}

Instrukcja for w linii 6 przypisuje wartość początkową zmiennej licznik, sprawdza czy
wartość zmiennej licznik jest mniejsza od 10, następnie inkrementuje przyrostkowo. W
skrócie można powiedzieć, że pętla for działa w następujący sposób:
dla(for) każdego testu, o wartości początkowej(inicjalizacja) wykonaj akcję. W tym wypadku
dla każdej wartości licznika mniejszej od 10, przy wartości początkowej 0, zwiększ wartość
licznika o 1. Jeżeli test zwróci wartość true to wykonywane jest ciało pętli for, w tym
wypadku wyświetlenie wartości licznika na ekranie, w następnej kolejności wykonywana jest
akcja. Inicjalizacja i akcja mogą być dowolnymi instrukcjami C++, natomiast test musi być
wyrażeniem – czyli musi zwrócić jakąś wartość.

6.3 Funkcje – w telegraficznym skrócie
Funkcja – jest podprogramem operującym na danych i zwracającym jakąś wartość. Każdy
program w C/C++ posiada co najmniej jedną funkcję, main(). Funkcja ta wywoływana jest
gdy tylko program rozpoczyna działanie. Inne funkcje są w praktyce wywoływane przez
funkcję main() i same również mogą wywoływać inne funkcje. Każda funkcja ma określoną
nazwę, określony typ zwracanej wartości i parametry. Parametrem nazywamy typ wartości
jaka zostaje przekazana funkcji podczas jej wywołania. Zapis:

int MojaFunkcja();

oznacza, że funkcja zwraca wartość całkowitą. Jest możliwe zdefiniowanie parametrów, które
będą przekazane do funkcji:

int MojaFunkcja(int a, float b);

Zapis ten oznacza, że funkcja zwraca wartość całkowitą, a jej parametrami jest jakaś wartość
całkowita i zmiennoprzecinkowa.
Aby użyć funkcji trzeba najpierw ją zdeklarować (deklaracja funkcji nazywa się
prototypem), czyli poinformować kompilator o jej nazwie, typie zwracanej wartości , oraz o
jej parametrach, a następnie zdefiniować. Definicja informuje kompilator jak działa funkcja.
Prototyp funkcji umieszcza się zaraz po dyrektywach preprocesora.

Elementy prototypu:

short int Obszar (int Dlugosc, int Szerokosc);

short int – określa zwracany typ,
Obszar – nazwa funkcji,
Dlugosc, Szerokosc – Nazwy parametrów,
int, int(oba w nawiasie) – typy parametrów.

Definicja funkcji składa się z nagłówka funkcji oraz jej ciała. Nagłówek funkcji składa się z
typu zwracanej wartości, nazwy funkcji, nazw i typów parametrów. Nagłówek funkcji nie
kończy się średnikiem. Ciało ograniczone jest dwoma nawiasami klamrowymi, między
którymi znajdują się instrukcje. Przykładowa definicja:

short int Obszar(int Dlugosc, int Szerokosc){

// instrukcje

return (Dlugosc*Szerokosc);

// - zwracana wartość

}

Wywołanie funkcji odbywa się w ciele innej dowolnej funkcji. Kiedy funkcja zostaje
wywołana sterowanie programem przenosi się do jej ciała, a następnie powraca do miejsca, z
którego została wywołana. Wywołanie składa się z nazwy funkcji oraz z nazw parametrów,
kończy się średnikiem.

Obszr(Dlugosc,Szerokosc);

Przykład programu wykorzystującego funkcję:

#include<iostream.h>
#include<conio.h>

/* prototyp funkcji /

short int Obszar(int Dlugosc, int Szerokosc);

int main(){
int Dlugosc, Szerokosc;
cout<<”wprowadz dlugosc: ”;
cin>>Dlugosc;
cout<<”wprowadz szerokosc: ”;
cin>>Szerokosc;
int x;

/* wywolanie funkcji i przypisanie zwracanej wartości do zmiennej x */

x=Obszar(Dlugosc, Szerokosc);
cout<<”Pole wynosi: ”<<x<<” metrow kwadratowych”<<endl;
getch();
return 0;
}

/* definicja funkcji /

short int Obszar(int Dlugosc, int Szerokosc){
cout<<”w ciele funkcji Obszar”<<endl;
return(Dlugosc*Szerokosc);
}

6.4 Programowanie w środowisku Borland C++ Builder
W podrozdziale tym spróbuję opisać podstawowe działania w celu utworzenia prostych
programów pracujących w trybie graficznym w systemach z rodziny windows. Fundamentem
C++ Builder’a dla trybu graficznego jest biblioteka VCL. W najprostszych słowach jest to
obiekt komunikujący się z innymi elementami aplikacji za pomocą właściwości, metod i
zdarzeń. VCL wywodzi się z języka Object Pascal. Projektowanie aplikacji za pomocą
obiektów VCL sprowadza się z właściwie do ich umieszczania na formach. Aby sprawdzić
działanie programu bez konieczności budowania pliku wykonywalnego wystarczy nacisnąć
klawisz F9. Program skompiluje się w pamięci i uruchomi. Aby zapisać program do postaci
pliku wykonywalnego(z rozszerzeniem exe) należy w menu głównym środowiska wybrać
zakładkę Project, a następnie kliknąć na BuildProject. Plik wykonywalny znajdzie się w
miejscu, w którym zapisywane były pliki projektu programu.

6.4.1 – właściwości, metody, zdarzenia
Właściwości(properties) – komponentu kontrolują jego wygląd i/lub zachowanie. Niektóre
właściwości są wspólne dla grup komponentów i pełnią w nich identyczne funkcje. Dla
wszystkich komponentów widzialnych dla użytkownika wspólne są właściwości

Top i Left.

Określają one położenie górnego, lewego wierzchołka komponentu na formularzu(Formie)-
zarówno podczas projektowania jak i podczas działania aplikacji.

Top określa położenie w

pionie, a

Left w poziomie. Wszystkie właściwości znajdują się na nadzorcy obiektów.

Wstaw na formę przycisk(Button) – w nadzorcy obiektów wyszukaj właściwości

Left i

Top. Zmodyfikuj je kilkoma wartościami z przedziału 0 – 600. Natychmiast po zatwierdzeniu
parametru położenie przycisku powinno się zmienić. Właściwość

Caption(nagłówek) służy

do wyświetlania tekstu „na zewnątrz” obiektu. Zaznacz przycisk i w nadzorcy obiektów
poszukaj właściwości Caption. Zmień znajdujący się tam wpis. Zmienił się napis na
przycisku.
Możliwa jest zmiana właściwości obiektów w czasie działania programu. Wstaw na formę
obiekt

Label. Służy on jedynie do wyświetlania danych. Zaznacz go i wymaż zawartość

właściwości Caption. Rozciągnij trochę

Label na formie. Teraz dwa razy kliknij na

przycisku, dodanym ostatnio. Otworzy się edytor kodu źródłowego z funkcją opisującą
przycisk. Między klamrami wpisz:

Label1->Caption=”Efekt naciśnięcia przycisku”;

Teraz zapisz projekt klikając na File, następnie na SaveProjectAs..., zapamiętaj miejsce,
gdzie zapisujesz. Naciśnij F9 w celu szybkiego sprawdzenia działania programu. Jak się
okaże naciśnięcie przycisku wyświetli na obiekcie

Label informację tekstową.

Metody – są to procedury i funkcje wywoływane w celu uzyskania pożądanego
zachowania komponentu. Dla każdego komponentu widzialnego zdefiniowana jest metoda
Show(), która go wyświetla i metoda Hide(), powodująca jego ukrycie. Metody są
funkcjami więc mogą posiadać atrybuty wejścia i zwracają jakąś wartość – wniosek – wartość
tą można zawsze gdzieś przypisać. Książkowym przykładem działania metod jest pokazanie
zasady działania

Show() i Hide(). W tym przykładzie posłużę się dwoma przyciskami i

jednym elementem label. Wstaw na pustą formę dwa przyciski. Pierwszemu z nich zmień
nagłówek(caption) na „pokaz/ukryj”, a drugiemu na „pisz...”. Label1 może pozostać bez
zmian. Niżej przedstawiony program wypisuje tekst w polu Label1 wtedy, kiedy jest możliwe
naciśnięcie przycisku2, jeżeli jest on niewidoczny zawartość Label1 będzie czyszczona.
Przycisk1 będzie służył do pokazywania i ukrywania przycisku2. Kliknij dwa razy na
przycisku2, kiedy pokaże się edytor, przepisz do funkcji przycisku2 następujący ciąg:

Label1->Caption="Piszę więc żyję... ";

Powróć do widoku formy i dwukrotnie kliknij na przycisku1. W funkcji przycisku1 wpisz to:

if(Button2->Visible){
Button2->Hide();
Label1->Caption="";
}
else
Button2->Show();

Działanie instrukcji if wyjaśniłem w poprzednim rozdziale. Właściwość

Visible sprawdza

czy obiekt jest widoczny, jeżeli tak to ukrywa przycisk2 i kasuje tekst w Label1, w
przeciwnym wypadku pokazuje przycisk2. Przykładowy wygląd formy z dodanymi
elementami:

Mam nadzieję, że ten opis
wystarczał do zrozumienia tego
jak się tym(C++ Builder’em)
posługiwać, przynajmniej jeżeli
chodzi o bardzo proste sprawy.
Generalnie to aby odwołać się
do właściwości obiektów i
wykonywać na nich działania(bo
do tego sprowadza się
programowanie w C++
Builderze) wystarczy określić
ten obiekt, wskazać na jego
właściwość i przypisać tej
właściwości odpowiednią
wartość.

W skrócie wygląda to następująco:

NazwaObiektu->Właściwość=wartość;

Do funkcji poszczególnych obiektów odwołujemy się podobnie:

NazwaObiektu->NazwaFunkcji(paramentry);

Ponieważ każda funkcja zwraca wartość – tą wartość można przypisać do jakieś zmiennej:

x=NazwaObiektu->NazwaFunkcji(parametry);

Niektóre właściwości są rozgałęzione, na przykład

Font(Czcionka) – występuje w każdym

widzialnym obiekcie. Na nadzorcy obiektów przy tej właściwości widnieje plus(+). Oznacza
to, że właściwość nie jest obiektem prostym, lecz składa się z innych właściwości, które mogą
być oddzielnie modyfikowane(np. krój czcionki, rozmiar, kolor itp.). Można rozszerzyć
działanie tego programu na przykład o to by czcionka była koloru czerwonego. Wystarczy
przed:

Label1->Caption="Piszę więc żyję... ";

wstawić:

Label1->Font->Color=clRed;

//- wszystkie kolory poprzedzane są literami cl

Label1 – to obiekt,
Font – to pierwsza właśćiwość,
Color – druga właściwość,
clRed – wartość przypisana właściwości Color.

Zdarzenia(events) – pojęcie to oznacza, że przyczyną działań podejmowanych przez
program są zdarzenia generowane przez użytkownika np. klinięcie myszą, wpisanie
określonej frazy, przesunięcie kursora myszy itp. W bibliotece VCL – zdarzeniem jest
wszystko co dotyczy komponentu i może mieć znaczenie dla użytkownika. Lista wszystkich
zdarzeń, na które reaguje obiekt znajduje się na karcie

Events nadzorcy obiektów.

Naciśnięcie klawisza w przykładzie poprzednim oznaczało tyle co wykonanie instrukcji
zdarzenia

OnClick. Można zmodyfikować ten program tak, by ukrywał przycisk2 w

momencie, kiedy kursor myszy znajduje się bezpośrednio nad przyciskiem1. W tym celu
należy zaznaczyć przycisk1, w zakładce Events znaleźć zdarzenie

OnMouseMove i

dwukrotnie kliknąć na polu obok.
Czerwone pole obrazuje miejsce, w którym należy kliknąć.
Otworzy się edytor kodu. Tam w funkcji przycisku1 należy
wkleić ten sam kawałek kodu, który wcześniej posłużył do
ukrywania i pokazywania przycisku2. Oczywiście trzeba jeszcze
usunąć fragment kodu z funkcji, która obsługiwała zdarzenie
klinięcia na przycisku. Na wszelki wypadek umieszczę fragment

kodu z edytora, żeby pokazać o co chodzi.

//ten kawałek jest odpowiedzialny za zdarzenie OnMouseOver

void __fastcall TForm1::Button1MouseMove(TObject *Sender,
TShiftState Shift, int X, int Y)
{
if(Button2->Visible){
Button2->Hide();
Label1->Caption="";
}
else{
Button2->Show();
}
}

// a ten za zdarzenie OnClick

void __fastcall TForm1::Button1Click(TObject *Sender)
{
}

W tym momencie wystarczy tylko zapisać projekt i wcisnąć F9 lub zapisać program do
postaci wykonywalnej i uruchomić ręcznie.

7. Przykładowe programy w C++
Bez owijania w bawełnę – tutaj zawarłem projekty troszkę bardziej złożonych programów.
jeden dla trybu tekstowego i jeden dla graficznego.

7.1 Prosty program liczący wartości liczb podniesionych do potęgi n.

#include<iostream.h>
#include<conio.h>

int main(){
float a,wynik;
unsigned int n;
cout<<"wprowadz podstawe potegi: ";
cin>>a;
cout<<"wprowadz wykladnik potegi: ";
cin>>n;

wynik=1;
   while(n!=0){
    if(n!=0){
      n=n-1;
      wynik=a*wynik;
      }
   }

cout<<"wynik: "<<wynik<<endl;
getch();
return 0;
}

Przy używaniu tego programu należy zwrócić uwagę na ograniczoną wartość zmiennej
wynik. Gdyby wyniki przekroczyły maksymalną wartość trzeba zmienić typ zmiennej wynik
na double. Oczywiście wtedy skrócona zostanie dokładność po przecinku – ale coś za coś.

7.2 Banalny edytor tekstu z możliwością zapisu w formacie txt i html.

Potrzebne komponenty:
Z karty Standard:
- Memo
- MainMenu

Z karty Dialogs:
- OpenDialog
- SaveDialog
- FontDialog

Zaczniemy od zmiany nagłówka(Caption) formy1 na Mój Notatnik – albo coś w tym stylu.
Wrzuć komponent Memo na formę, zaznacz go. W nadzorcy obiektów poszukaj właściwości
Lines. Kliknij w trzykropek po prawej stronie tej właściwości.

Czerwony obszar wskazuje konkretnie o jaki trzykropek chodzi.
Otworzy się String List Edytor(Edytor linii). Wymaż napis Memo1 i
kliknij na OK. Teraz poszukaj właściwości Align dla obiektu
Memo1. Align określa ułożenie elementu na formie. Przestaw
wartość z alNone na alClient. Pole Memo1 powinno się rozciągnąć

na cały obszar formy. Teraz obiekt Memo będzie zmieniał swój rozmiar w zależności od
rozmiaru formy. Teraz wstaw na formę obiekt MainMenu z zakładki Standard. Na projekcie
pokaże się mały kwadracik. Kliknij na nim dwukrotnie. Ukaże się okno takie jak to:

Zaznaczony na niebiesko prostokąt oznacza pole, które właśnie poddawane jest edycji.
Zmodyfikuj jego nagłówek tak, aby zawierał on napis

&Plik. Okno powinno się zmienić w

ten sposób:

Teraz wiesz już jak edytować pola MainMenu. W zakładce plik
zmodyfikuj kolejne pola tak, aby zawierały napisy: Nowy, Otwórz,
Zapisz, Zakończ. Efekt ma być taki jak na obrazku poniżej. Skróty
klawiszowe dobiera się we właściwości ShortCut – wystarczy wybrać z
listy odpowiednią kombinację. Należy dodać teraz zakładkę Edycja, a w

niej: Wytnij(ze skrótem Ctrl+x), Kopiuj(Ctrl+c), Wklej(Ctrl+v),
Czcionka(dowolny skrót). Zamknij okno edycji. Forma1 powinna
wyglądać teraz tak jak na rysunku na następnej stronie lub podobnie.
Obiekt MainMenu nie będzie widoczny podczas działania samego
programu. Jeżeli jesteś ciekawy/ciekawa działania tego co dotychczas
udało się wykonać naciśnij po prostu F9. Programik ten nie robi w
chwili obecnej nic, można co prawda wprowadzić znaki w obiekt
Memo, ale nic poza tym.

Zanim dołożymy możliwość zapisu, czy otwarcia pliku umożliwimy programowi kopiowanie,
wycinanie i wklejanie tekstu. W tym celu należy w drzewie obiektów wybrać obiekt
MainMenu1, rozwinąć pole edycji i dwukrotnie kliknąć na Wytnij{Wytnij1}. W edytorze
kodu wprowadzimy metodę(funkcję), która wycina tekst do schowka.

Memo1->CutToClipboard();

Dla przycisku kopiuj użyj następującej metody:

Memo1->CopyToClipboard();

,a dla wklej:

Memo1->PasteFromClipboard();

Fragment kodu odpowiedzialny za te trzy funkcje będzie więc wyglądał tak:

void __fastcall TForm1::Wytnij1Click(TObject *Sender)
{
Memo1->CutToClipboard();
}
void __fastcall TForm1::Kopiuj1Click(TObject *Sender)
{
Memo1->CopyToClipboard();
}
void __fastcall TForm1::Wklej1Click(TObject *Sender)
{
Memo1->PasteFromClipboard();
}

Teraz zaprogramujemy funkcję Nowy, oraz Zamknij z zakładki Plik. Klinięcie na Nowy ma
spowodować, że zawartość obiektu Memo1 zostanie wyczyszczona. Wybierz z drzewa
obiektów Nowy{Nowy1} i kliknij na nim dwukrotnie. W edytorze kodu zapisz następującą
funkcję:

Memo1->Lines->Clear();

Memo1 – to nazwa obiektu,
Lines – to właśćiwość,
Clear() – to funkcja, która kasuje zawartość określonej właściwości.

Natomiast dla przycisku zamknij wpisz następującą metodę:

Application->Terminate();

Chyba nie wymaga komentarza :-).

Nadszedł czas, by dodać możliwość zapisywania i odczytywania plików. Założeniem jest
to, że edytor ten może otworzyć i zapisać pliki w formacie txt i html. Dołóż z zakładki
Dialogs w menu głównym obiekty: SaveDialog i OpenDialog. Zaznacz OpenDialog i obejrzyj
dokładnie właściwości w nadzorcy obiektów.

DefaultExt określa domyśle rozszerzenie

otwieranego pliku(w SaveDialog ta właściwość dopisuje domyślne rozszerzenie do nazwy
pliku jeżeli plik nie zawiera zarejestrowanego rozszerzenia).

FileName – to nazwa pliku,

który ma być otwarty. Proponuję obie te właściwości pozostawić bez zmian.
Filter – pozwala określić z jakimi rozszerzeniami będą otwierane/zapisywane pliki. Pierwsza
kolumna zawiera nazwę filtru(widoczną w oknie dialogowym), druga zadaje filtr
wykorzystywany podczas wyświetlania plików.

InitialDir –katalog domyślny - określa

katalog, który będzie otwierany jako pierwszy przy próbie odczytu/zapisu pliku.
Teraz skoro wiesz już co do czego służy – ustaw katalog domyślny na C:\, zarówno dla
obiektu OpenDialog jak i SaveDialog. Następnie kliknij na trzykropek przy właściwości
Filter, otworzy się okno Edytor Filtrów:

W pierwszym wierszu kolumny
Filter Name wprowadź
następujący tekst:
Dokument tekstowy(*.txt).

W kolumnie Filter w pierwszym
wierszu wprowadź:
*.txt

W wierszu drugim kolumny Filter
Name wprowadź:
Dokument HTML(*.html)
natomiast w wierszu drugim
kolumny Filter wpisz: *.html.

Oczywiście bez kropek po rozszerzeniach. Identycznie operację powtórz dla obiektu
SaveDialog.

Teraz – wyszukaj w drzewie obiektów obiektu otwórz i kliknij na niego dwa razy. Wpisz
następujące instrukcje:

OpenDialog1->Execute();
Memo1->Lines->LoadFromFile(OpenDialog1->FileName);

Linijka pierwsza wywołuje obiekt OpenDialog1, a w drugiej wywoływana jest metoda
LoadFromFile(ładuj z pliku) należąca do właśćiwości Lines obiektu Memo. Parametrem dla
metody LoadFromFile jest właściwość FileName(nazwa pliku) należąca do obiektu
OpenDialog1.

Bardzo podobnie ma się sprawa z funkcją zapisu do pliku. Wpisz te instrukcje dla obiektu
zapisz:

SaveDialog1->Execute();
Memo1->Lines->SaveToFile(SaveDialog1->FileName);

Pozostało więc jedynie wprowadzić funkcję ustawień czcionki. Dołóż element FontDialog na
formie. Znów wyszukaj przycisku Czcionka{Czcionka1} w drzewie obiektów. W funkcji tego
przycisku dołóż następujące linijki:

FontDialog1->Execute();
Memo1->Font=FontDialog1->Font;

Projekt ukończony – pozostało go zapisać i skompilować. Przypominam, że plik
wykonywalny znajduje się w tym samym katalogu co zapisany projekt. Jeżeli Ci się
spodobało możesz spróbować rozszerzyć jego możliwości choćby o możliwość wydruku.

8. I co dalej?
To co starałem się opisać w tej krótkiej instrukcji nie jest nawet wstępem do
programowania w języku C/C++. Starałem się wybrać to co jest najistotniejsze jeżeli chodzi o
podstawy programowania w trybie tekstowym. Wielu funkcji tego trybu, nie mówiąc już o
trybie graficznym, nie omówiłem. Temat programowania w jakimkolwiek języku jest zbyt
skomplikowany, by dobrze opisać go w tak krótkim czasie jakim dysponowałem. Jeżeli to co
przygotowałem(kosztem zarwanych nocy) o język C++ zachęcam do poszukiwania
informacji w internecie. Podstawową stroną, którą powinieneś odwiedzić jest
www.cplusplus.com. Pamiętaj jednak, że język ten ewoluuje, kolejnym tworem z rodziny C
jest C#. Jeżeli czasem jakiś program – poprawnie się skompiluje – a później nie chce działać,
nie denerwuj się – różne cuda dzieją się czasem na systemach z rodziny windows. Jeżeli
chciałbyś/chciałabyś spróbować swoich sił w systemach z rodziny GNU/Linux – użyj
środowiska Kylix.
Najlepszą drogą nauki programowania jest praktyka. Przeglądaj kody źródłowe napisane
przez innych, staraj się je zrozumieć. Jeżeli jakiś fragment jest dla Ciebie niezrozumiały –
pytaj. Staraj się w swoich źródłach stosować wcięcia przy zagnieżdżaniu nawet kilku pętli
jedna w drugiej. Pisz, kompiluj i ucz się na własnych błędach, i jak ktoś kiedyś powiedział
„C++ oferuje wiele sposobów rozwiązania danego zadania. Prawdziwa sztuka polega na
wybraniu odpowiedniego narzędzia dla odpowiedniego zadania” .