Aktualizacja: 23.06.2005  Wersja: 0.4.48
Szukaj ::..
Temat ::..

..:: HOME ::..

  ::..:: INTERNETOWY SERWIS PROGRAMISTYCZNY ::..::

 

 

LEKCJA 7

LEKCJA 7. Z czego składa się program. 
_______________________________________________________________ 
W trakcie tej lekcji: 
* Dowiesz się co robić, jeśli tęsknisz za Pascalem. 
* Zapoznasz się wstępnie z preprocesorem C++. 
* Poznasz dokładniej niektóre elementy języka C++. 
_______________________________________________________________ 

Zanim zagłębimy się w szczegóły działania preprocesora i 
kompilatora, dla zilustrowania mechanizmu działania dyrektyw 
popełnimy żart programistyczny. Nie ma nic gorszego niż spalić 
dobry żart, upewnijmy się więc najpierw, czy nasza 
"czarodziejska kula" jest gotowa do magicznych sztuczek. 
Sprawdź, czy na dyskietce znajdują się pliki 

A:\PASCAL.H 
A:\POLTEKST.H 

Jeśli nie, to przed zabawą w magiczne sztuczki programistyczne 
musisz odtworzyć te pliki z zapasowej kopii dyskietki, którą 
sporządziłeś przed rozpoczęciem LEKCJI 1. 

Jeśli masz już oba pliki, to wykonaj następujące czynności: 

1. Włóż do napędu A: dyskietkę z plikami PASCAL.H i POLTEKST.H. 
2. Uruchom kompilator C++. 

PROGRAMY HOKUS.EXE i POKUS.EXE - czyli sztuczki z Preprpcesorem 
C++ 

1. Zrób porządek na ekranie - pozamykaj zbędne okna. 
2. Naciśnij klawisz [F3]. Pojawi się znajome okienko dialogowe 
"Open". 
3. Wpisz do okienka tekstowego nazwę nowego programu: 
A:\HOKUS.C 
i naciśnij [Enter]. 
4. Wpisz następujący tekst programu: 

[P004.CPP] 

#include <a:\pascal.h> 

Program 
Begin 
Write("Ten program jest podobny"); 
Write(" do Turbo Pascala "); 
Write(" tak tez mozna pisac w BORLAND C++ !"); 
Readln; 
End 


5. Uruchom program [Ctrl]-[F9]. Jeśli wystąpią błędy, skoryguj 
ewentualne niezgodności z oryginałem. Ostrzeżenie "WARNING" 
możesz zignorować. 

UWAGA: MUSI ZOSTAĆ ZACHOWANA IDEALNA ZGODNOŚĆ z tekstem 
oryginału! 

6. Uruchom program rozkazem Run [Alt]-[R], [Enter]. Zwróć uwagę, 

że powtórna kompilacja przebiega szybciej, jeśli w międzyczasie 
nie dokonałeś zmian w programie. 
7. Zamknij okno edytora rozkazem Close (z menu Window). Zapisz 
program HOKUS.CPP w wersji źródłowej na dyskietkę A:. 

A teraz następna sztuczka, na którą pozwala C++. 

Utworzymy następny program POKUS.CPP. 

1. Wykonaj czynności z pp. 1 i 2 z poprzedniego przykładu. 
2. Otwórz okienko nowego programu - File | Open (np. klawiszem 
[F3]) i wpisz nazwę programu. Możesz zastosować również File | 
New. 

A:\POKUS.CPP 

3. Naciśnij [Enter]. 
4. Wpisz tekst programu: 

[P005.CPP] 

# include <a:\poltekst.h> 
program 
poczatek 
czysty_ekran 
drukuj ("Ten program - POKUS.CPP "); 
drukuj ("Jest napisany po polsku "); 
drukuj ("a mimo to Turbo C++ go rozumie!"); 
czekaj; 
koniec 

5. Uruchom program [Alt]-[R], [R]. Jeśli wystąpią błędy, 
skoryguj ewentualne niezgodności z oryginałem. Ostrzeżenie 
"WARNING" możesz zignorować. 
UWAGA: MUSI ZOSTAĆ ZACHOWANA IDEALNA ZGODNOŚĆ! 

6. Zamknij okno edytora rozkazem Close (z menu Window). Zapisz 
program HOKUS.C w wersji źródłowej na dyskietkę A:. 

WYJAŚNIENIE SZTUCZEK - PREPROCESOR C++ CPP.EXE. 

A teraz wyjaśnienie naszych magicznych sztuczek. Jeśli jesteś 
niecierpliwy, na pewno już sam zajrzałeś do plików PASCAL.H i 
POLTEKST.H, bo jest chyba oczywiste od początku, że to tam 
właśnie musi ukrywać się to wszystko, co pozwala nam robić nasze 

hokus-pokus. Skorzystaliśmy z pewnej nie występującej ani w 
Pascalu, ani w Basicu umiejętności języków C i C++ - a 
mianowicie z PREPROCESORA. 

Najczęściej stosowanymi dyrektywami preprocesora są: 

# include - włącz 

# define - zdefiniuj 

Do rozpoznania dyrektyw preprocesora służy znak (#) - HASH. 

Zwróć uwagę, że zapisy 

#include 
# include 

są całkowicie równoważne. Poza tym dyrektywy preprocesora nie 
kończą się średnikiem. 

Działanie preprocesora (czyli wstępne przetwarzanie tekstu 
programu jeszcze przed przystąpieniem do kompilacji) polega na 
zastąpieniu w tekście programu jednych łańcuchów znaków przez 
inne. Takie pary możemy "zadać" preprocesorowi właśnie dyrektywą 

#define. Nasze nagłówki wyglądają następująco: 

PASCAL.H: 
_______________________________________________________________ 
# include <stdio.h> 
# define Program main() 
# define Begin { 
# define Writeln printf 
# define Readln getch() 
# define End } 
________________________________________________________________ 

POLTEKST.H: 
________________________________________________________________ 
# include <stdio.h> 
# define program main() 
# define poczatek { 
# define koniec } 
# define czysty_ekran clrscr(); 
# define drukuj printf 
# define czekaj getch() 
________________________________________________________________ 

Zwróć uwagę, że warunkiem poprawnego zadziałania preprocesora 
jest zrezygnowanie ze spacji wewnątrz łańcuchów znakowych, 
spacje bowiem w preprocesorze rozdzielają dwa łańcuchy znaków - np.

"drukuj" 

- ten ZA KTÓRY CHCEMY COŚ PODSTAWIĆ oraz np. 

"printf" 

- ten, KTÓRY NALEŻY PODSTAWIAĆ. Często w programach 
zauważysz łańcuchy znaków pisane w dość specjalny sposób: 

napisy_w_których_unika_się_spacji. 

ELEMENTY PROGRAMU W JĘZYKU C++. 

Uogólniając, program w języku C++ składa się z następujących 
elementów: 

1. Dyrektyw preprocesora. Przykład: 

#define drukuj printf 

Działanie: W tekście programu PONIŻEJ niniejszej dyrektywy 
zastąp wszystkie łańcuchy znaków "drukuj" łańcuchami znaków 
"printf". 

#include <D:\KATALOG\nazwa.roz> 

Działanie: W to miejsce pliku wstaw zawartość pliku tekstowego 
NAZWA.ROZ z katalogu KATALOG na dysku D:. 

2. Komentarzy. Przykład: 

// Tu obliczamy sumę lub /*To jest komentarz*/ 

3. Deklaracji. Przykład: 
KAŻDY PROGRAM musi zawierać deklarację funkcji main (ang. main - 
główna). Funkcja ta często jest bezparametrowa, co można 
zaakcentować wpisując w nawiasy słowo kluczowe void: 

main(void) 

lub pisząc puste nawiasy: 

main() 

4. Instrukcji. 

i++; 

Działanie: Dokonaj inkrementacji zmiennej i, tzn. wykonaj 
operację i:=i+1 

[???] Dla dociekliwych - kilka słów o funkcji main() 
________________________________________________________________ 
Funkcja main() występuje najczęściej w następujących 
(równoważnych) postaciach: 

main() int main() int main(void) 

- program w momencie uruchomienia nie pobiera żadnych argumentów 

z wiersza rozkazu --> () lub (void) 
- program zwraca po zakończeniu jedną licznę (int = integer - 
liczba całkowita) do systemu operacyjnego informując go w taki 
sposób, czy wykonał się do końca i bezbłędnie i czy można go 
usunąć z pamięci (bywają także programy rezydujące w pamięci - 
tzw. TSR, o czym system operacyjny powinien "wiedzieć"). 

void main() void main(void) 

- program nie pobiera i nie zwraca żadnych paramatrów. 
Główna funkcja main() może w środowisku okienkowym przeobrazić 
się w główną funkcję okienkową: 

WinMain(.....) 

a w środowisku obiektowym w 

OwlMain(....) 

OWL - biblioteka obiektów dla Windows - Object Windows Library. 

W nawiasach funkcji main(), WinMain() i OwlMain() mogą pojawić 
się parametry (argumenty) pobierane przez program w momencie 
uruchomienia z wiersza rozkazu lub od środowiska operacyjnego 
(szczegóły w dalszej części książki). 
Programy w C++ mogą składać się z wielu plików dyskowych. Typowy 

program zawiera. Nazywa się to zwykle projektami wielomodułowymi 

- a poszczególne pliki - modułami lub elementami składowymi 
projektu: 

* plik nagłówkowy - NAZWA.H 
* moduł główny - NAZWA.CPP (ten i tylko ten zawiera funkcję 
main()) 
* moduły pomocnicze - NAZWA2.CPP, NAZWA3.CPP, itp 
* pliki z zasobami typu menu, okienka dialogowe, itp - NAZWA.RC, 

NAZWA.DLG 
* wreszcie plik instruktażowy - jak z tego wszystkiego zrobić 
końcową aplikację. W zależności od wersji kompilatora pliki 
instruktażowe mogą mieć nazwy: NAZWA.PRJ (Project - BORLAND), 
NAZWA.IDE, a dla programu MAKE - MAKEFILE, NAZWA.MAK, NAZWA.NMK, 

itp. 
W środowisku Windows występuje jeszcze zwykle w składzie 
projektów aplikacji tzw. plik definicji sposobu wykorzystania 
zasobów - NAZWA.DEF. 
________________________________________________________________ 

[S!] void - czyli nijaki. 
________________________________________________________________ 
Słowa kluczowe: 
void - pusty, wolny, nieokreślony, avoid - unikać. 
main - główny, główna. 
return - powrót, zwrot. 
Nazwa funkcji: 
exit() - wyjście. 
________________________________________________________________ 

Po nazwie funkcji main() NIE NALEŻY stawiać średnika (;). 
Przy pomocy tej funkcji program kontaktuje się z systemem 
operacyjnym. Parametry funkcji main, to te same parametry z 
którymi uruchamiamy nasz program w systemie DOS. Np. rozkaz 

FORMAT A: 

oznacza, że do programu przekazujemy parametr A:. 

Ponieważ w każdym programie oprócz nagłówka funkcji: 

main(void) 

podajemy również tzw. ciało funkcji, np.: 


printf("wydrukuj cokolwiek"); 
return 0; 


jest to jednocześnie DEFINICJA FUNKCJI main(). 
Zwróć uwagę, że funkcja printf() nie jest w powyższym 
przykładzie w żaden sposób ani deklarowana ani definiowana. 
Wiersz: 

printf("pisz!"); 

stanowi WYWOŁANIE funkcji printf() z parametrem pisz! - 
łańcuchem znaków, który należy wydrukować. 
W C++ nawet jeśli nawiasy przeznaczone w funkcji na przekazanie 
jej argumentów są puste - muszą być obecne. Poprawne wywołanie 
funkcji w języku C++ może mieć następującą formę: 

nazwa_funkcji(); 

nazwa_funkcji(par1, par2, par3, .....); 

zmienna = nazwa_funkcji(par1, par2, ...); 

Funkcja w momencie jej wywołania uzyskuje przekazane jej 
parametry. Są to tzw. ARGUMENTY FUNKCJI. Aby to wszystko 
bardziej przypominało to, co znasz ze szkoły popatrzmy na 
analogię. W zapisie: 

y = sin(x) lub y = sin(90) 

x - oznacza argument funkcji, który może być zmienną (w szkole 
nazywałeś zmienne "niewiadomymi") 
y - oznacza wartość zwracaną "po zadziałaniu" funkcji 
sin() - oznacza nazwę funkcji. Zastosowanie funkcji będziemy w 
programach nazywać "wywołaniem funkcji". 

Język C++ operuje wyłącznie pojęciem FUNKCJI. W C ani w C++ nie 
ma podziału na FUNKCJE i PROCEDURY. 

Każda funkcja może być w programie wywoływana wielokrotnie. 
Każde wywołanie funkcji może następować z innymi argumentami. 
Funkcja może w wyniku swojego działania zmieniać wartość jakiejś 

zmiennej występującej w programie. Mówimy wtedy, że funkcja 
ZWRACA wartość do programu. Funkcja main() jest funkcją 
szczególną, która "zwraca" wartość do systemu operacyjnego, w 
którym pracuje program. Zapis: 

main() lub int main() 
{ { 
return 5; exit(5); 
} } 

oznacza: 
1. Funkcja main jest bezparametrowa (nie przyjmuje żadnych 
argumentów z zewnątrz). 
2. Funkcja main zwraca jako wynik swojego działania liczbę 
całkowitą typu int (ang. INTeger - całkowita). Zwróć uwagę, że 
jest to domyślny sposób działania funkcji main(). Jeśli nie 
napiszemy przed funkcją main() słowa "int" - kompilator C++ doda 

je sobie automatycznie. Jeśli świadomie nie zamierzamy zwracać 
do systemu operacyjnego żadnych informacji - musimy wyraźnie 
napisać tam "void". 
3. Funkcja zwróci do systemu DOS wartość 5. Zwróć uwagę na 
istotną różnicę formalną, Słowo "return" jest słowem kluczowym 
języka C, natomiast słowo "exit" jest nazwą funkcji exit(). 
Zastosowanie tej funkcji w programie wymaga dołączenia pliku 
nagłówkowego z jej prototypem. 

Ponieważ nasz kurs języka C++ rozpoczęliśmy od programu z 
funkcją printf() i zapewne będzie nam ona towarzyszyć jeszcze 
długo, pora poświęcić jej trochę uwagi. 

FUNKCJA printf(). 

Jest to funkcja FORMATOWANEGO wyjścia na standardowe urządzenie 
wyjścia (ang. stdout - STandarD OUTput). Definicja - ściślej 
tzw. PROTOTYP tej funkcji znajduje się w pliku nagłówkowym 
STDIO.H. Wniosek praktyczny: Każdy program korzystający z 
funkcji printf() powinien zawierać dyrektywę preprocesora: 

#include <stdio.h> 

zanim nastąpi wywołanie funkcji printf(). 

[???] A JEŚLI ZAPOMNIAŁEM O <STDIO.H> ??? 
________________________________________________________________ 
Możesz nadać plikowi z tekstem żródłowym programu rozszerzenie 
.C zamiast .CPP. W kompilatorach Borlanda powoduje to przy 
domyślnych ustawieniach kompilatora wywołanie kompilatora C 
zamiast C++. C jest bardziej tolerancyjny i dokona kompilacji 
(wyświetli jedynie komunikat ostrzegawczy - Warning). Kompilator 

C++ jest mniej tolerancyjny. Jeśli zapomnisz dołączyć odpowiedni 

plik nagłówkowy może pojawić się komunikat: 

Error: Function printf() should have a prototype in function 
main 
(Funkcja printf() powinna mieć prototyp) 

Więcej o zawartości i znaczeniu plików nagłówkowych *.h dowiesz 
się z następnych lekcji. Na razie postaraj się pomiętać o 
dołączeniu wskazanego w przykładzie pliku. 
________________________________________________________________ 

[???] Skąd to wiadomo? 
________________________________________________________________ 
Jeśli masz wątpliwości, jaki plik nagłówkowy należałoby dołączyć 

- najprościej zajrzeć do systemu pomocy - Help. Na pasku 
głównego menu w IDE masz napis Help. Menu Help możesz rozwinąć 
myszką lub naciskając kombinację klawiszy [Alt]+[H]. Jeśli w 
menu wybierzesz rozkaz Index (Spis) przeniesiesz się do okienka 
z alfabetycznym spisem haseł. Są tam słowa kluczowe, nazwy 
funkcji i jeszcze wiele innych interesujących rzeczy. Powinieneś 

teraz wykonać następujące czynności: 

* posługując się klawiszami kursora (ze strzałkami) odszukać w 
spisie nazwę funkcji 
albo 
* rozpocząć pisanie nazwy funkcji na klawiaturze (system Help 
sam wyszuka w spisie wypisaną w ten sposób nazwę) 
* nacisnąć [Enter] 
Przeniesiesz się do okienka opisu danej funkcji. Na samym 
początku w okienku każdej funkcji podana jest nazwa pliku 
nagłówkowego, w którym znajduje się prototyp funkcji. Nawet 
jeśli nie jesteś biegłym anglistą, łatwo rozpoznasz pliki 
nagłówkowe - po charakterystycznych rozszerzeniach .H (rzadziej 
.HPP. Charakterystyczne rozszerzenie *.H pochodzi od "plik 
nagłówkowy" - ang. Header file). 
________________________________________________________________ 

Funkcja printf() zwraca wartość całkowitą typu int: 

* liczbę bajtów przesłanych na standardowe urządzenie wyjścia; 
* w przypadku wystąpienia błędu - kod znaku EOF. 

[S!] 
EOF - End Of File - znak końca pliku. 
EOL - End Of Line - znak końca linii. 
Indicator - znak, wskaźnik (nie mylić z pointerem !) 

[???] SKĄD TO WIADOMO ? 
________________________________________________________________ 
Kody EOF, EOL są tzw. predefiniowanymi stałymi. Ich szyfrowanie 
(przypisywanie tym identyfikatorom określonej stałej wartości 
liczbowej) dokonuje się z zastosowaniem preprocesora C++. 
To, że nie musisz się zastanawiać ile to właściwie jest EOF 
(zero ? czy -1 ?) zawdzięczamy też dołączanym plikom typu *.H, w 

których np. przy użyciu dyrektywy #define zostały PREDEFINIOWANE 

(zdefiniowane wstępnie) niektóre stałe. Jeśli jesteś bardzo 
dociekliwy, zajrzyj do wnętrza pliku STDIO.H (view, edit, type). 

Znajdziesz tam między innymi taki wiersz: 

#define EOF (-1) //End of file indicator 
________________________________________________________________ 

Składnia prototypu (ang. syntax): 

int printf(const char *format [arg1, arg2,.....]); 

lub trochę prościej: 

printf(format, arg1, arg2,.....argn); 

Liczba argumentów może być zmienna. 

C++ oferuje wiele funkcji o podobnym działaniu - np.: 

cprintf(), fprintf(), sprintf(), vprintf(), vsprintf(), itp. 

Ponieważ FORMAT brzmi może trochę obco, nazwijmy go WZORCEM. Jak 

wiesz, wszystkie informacje przechowywane są w pamięci komputera 

jako ciągi zer i jedynek. Jest to forma trochę niewygodna dla 
człowieka, więc zanim informacja trafi na ekran musi zostać 
zamieniona na postać dla nas wygodniejszą - np. na cyfry 
dziesiętne, litery itp.. Taki proces nazywany jest KONWERSJĄ, a 
podany w funkcji printf() FORMAT - WZORZEC to upraszczając, 
rozkaz dokonania takiej właśnie konwersii. Możesz więc zarządać 
przedstawienia liczby na ekranie w postaci np. SZESNASTKOWEJ lub 

DZIESIĘTNEJ - tak, jak Ci wygodniej. Wzorce konwersji w 
najprostszym przypadku mają postać %s, %d, %f, itp.: 
I tak: 

%s - wyprowadź łańcuch znaków (s - String - łańcuch) 
Przykład: 

printf("%s","jakis napis"); 
ale także 
printf("Jakis napis"); 

ponieważ format "%s" jest formatem domyślnym dla funkcji 
printf(). 

Przykład: 

printf("%39s","jakis napis"); 

spowoduje uzupełnienie napisu spacjami do zadanej długości 39 
znaków (Sprawdź!). Funkcja printf() operuje tzw. POLEM 
WYJŚCIOWYM. Długość pola wyjściowego możemy określić przy pomocy 

liczb wpisanych pomiędzy znaki % oraz typ - np. s. Możemy także 
określić ilość cyfr przed i po przecinku. 

%c - wyprowadź pojedynczy znak (c - Character - znak) 
Przykład: 

printf("%c",X); 

(spowoduje wydrukowanie litery X) 

%d - wyprowadź liczbę całkowitą typu int w postaci dziesiętnej 
€€€€€(d - Decimal - dziesiętny). 
Przykład: 

printf("%d", 1994); 

%f - wyprowadź liczbę rzeczywistą typu float w postaci 
dziesiętnej (f - Floating point - zmienny przecinek). 

Przykład: 

printf("%f", 3.1416); 
printf("%f3.2", 3.14159); 

%o - wyprowadź liczbę całkowitą typu int w postaci ósemkowej 
(o - Octal - ósemkowa). 
Przykład: 

printf("%o", 255); 

%x - wyprowadź liczbę całkowitą typu int w postaci szesnastkowej 

€€€€€(x - heXadecimal - szesnastkowa). 
%x lub %X - cyfry szesnastkowe a,b,c,d,e,f lub A,B,C,D,E,F. 

%ld - liczba całkowita "długa" - long int. 

%Lf - liczba rzeczywista poczwórnej precyzji typu long double 
float. 

%e - liczba w formacie wykładniczym typu 1.23e-05 (0.0000123) 

%g - automatyczny wybór formatu %f albo %e. 

Po przytoczeniu przykładów uogólnijmy sposób zastosowania wzorca 

formatu: 

%[przełączniki][szerokość_pola][.precyzja][rozmiar]Typ 

Posługując się różnymi sposobami formatowania liczb możemy 
zażądać wydrukowania liczb w najwygodniejszej dla nas formie. W 
programie przykładowym dokonujemy zamiany liczb dziesiętnych na 
szesnastkowe. 

[P006.CPP] 

// Program przykladowy 10na16.CPP 

#include <stdio.h> 
#include <conio.h> 

int liczba; 

int main() 

clrscr(); 
printf("Podaj liczbe dziesietna calkowita ? \n"); 
scanf("%d", &liczba); 
printf("\nSzesnastkowo to wynosi: "); 
printf("%x",liczba); 
getch(); 
return 0; 


Ten program pozwala zamienić dziesiętne liczby całkowite na 
liczby szesnastkowe. Zakres dostępnych liczb wynika z 
zadeklarowanego typu int. Więcej na ten temat dowiesz się z 
następnych lekcji. Spróbujmy odwrotnie: 

[P007.CPP] 

// Program przykladowy 16na10.CPP 
//UWAGA: Sam dołącz pliki nagłówkowe 

int liczba; 

int main() 

clrscr(); 
printf("Podaj liczbe SZESNASTKOWA-np. AF - DUZE LITERY: \n"); 
scanf("%X", &liczba); 
printf("%s","\nDziesietnie to wynosi: "); 
printf("%d",liczba); 
getch(); 
return 0; 


Myślę, że program 16NA10.CPP można pozostawić bez dodatkowego 
komentarza. Zwróć uwagę, że funkcja scanf() "formatuje" dane 
wejściowe bardzo podobnie do funkcji printf(). Pewnie dziwi Cię 
trochę "dualny" zapis: 

liczba i &liczba. 

Zagadka zostanie niebawem wyjaśniona. W trakcie następnych 
Lekcji zajmiemy się dokładniej zmiennymi, i ich rozmieszczeniem 
w pamięci a na razie wracamy do funkcji printf(). 

Jako się rzekło wcześniej - funkcja printf() może mieć wiele 
argumentów. Pozwala nam to przy pomocy jednego wywołania funkcji 

wyprowadzać złożone napisy. 

Przykład: 

printf("Iloczyn 3 %c 5 %8s %d", *, "wynosi ",15); 

Działanie: 
"Iloczyn_3_ - wyprowadź jako łańcuch znaków. 
%c - tu wyprowadź pojedynczy znak - *. 
_5_ - wyprowadź jako łańcuch znaków. 
%8s - wyprowadź łańcuch "wynosi_" uzupełniając go z przodu 
spacjami do długości 8 znaków. 
%d - wyprowadź 15 jako liczbę dziesiętną. 

UWAGA: Znakiem podkreślenia w tekście książki "_" oznaczyłem 
spację, spacja to też znak. 

Przykład: 

printf("Iloczyn 3 %c 5 %9s %f", x, "wynosi ", 3*5); 

Zwróć uwagę, że tym razem kazaliśmy komputerowi samodzielnie 
policzyć ile wynosi nasz iloczyn, tzn. zastosowaliśmy jako 
argument funkcji printf() nie stałą, a WYRAŻENIE. Działanie 
możesz prześledzić przy pomocy programu przykładowego: 

[P008.CPP] 

// Program WYRAZ.CPP - Dołącz pliki nagłówkowe 

int main() 

clrscr(); 
printf("Skomplikowany napis:\n"); 
printf("Iloczyn 3 %c 5 %8s %d", *, "wyniosi ", 15); 
getch(); 
printf("\nWyrazenie jako argument:\n"); 
printf("Iloczyn 3 %c 5 %9s %d", x, "wynosi ", 3*5); 
printf("\n\n\n"); 
printf("Przyjrzyj sie i nacisnij klawisz..."); 
getch(); 
return 0; 


Wyjaśnijmy jeszcze jedno "dziwactwo" - znaki sterujące 
rozmieszczeniem napisów na ekranie. Oto tabelka z najczęściej 
używanymi znakami specjalnymi: 

________________________________________________________________ 

Znak Nazwa Działanie 
________________________________________________________________ 

\n New Line Przejście na początek nowego wiersza 

\b BackSpace Cofnięcie kursora o jeden znak 
\f Form feed O stronicę w dół 
\r Carriage return Powrót na początek bież. wiersza 
\t Horizontal Tab Tabulacja pozioma 
\v Vertical Tab Tabulacja pionowa 
\a Sound a beep Pisk głośniczka 
\ Displ. backslash Wyświetl znak \ 
\(apostrof) Display (apostrof) Wyświetl znak (apostrof) 
\" Display " Wyświetl znak " (cudzysłów) 
________________________________________________________________ 

UWAGA: Trzy ostatnie "backlash-kody" pozwalają wyprowadzić na 
ekran znaki specjalne \ (apostrof) i ", co czasami się przydaje. 
Szczególnie \ jest często przydatny. 

[Z] 
Spróbuj samodzielnie: 

1. Napisać i uruchomić program wykonujący konwersję liczb 
ósemkowych na dziesiętne i odwrotnie. 
2. Przy pomocy pojedynczego wywołania funkcji printf() 
wydrukować kilka złożonych napisów typu: 
* suma 2+4 to 6 
* działanie 5*7*27+6-873 daje wynik...( właśnie, ile?). 
3. Sprawdź działanie tabulacji pionowej \v. Ile to wierszy? 

[???] DYSKIETKA NIE JEST Z GUMY !!! 
________________________________________________________________ 
Jeśli podczas kompilacji programów w okienku będzie się 
uporczywie, bez widocznego powodu pojawiał napis "Errors" - 
błędy, a w okienku komunikatów "Message" pojawi się napis: 

Fatal A:\PROGRAM.C: Error writing output file 
(Fatalny błąd podczas kompilacji pliku A:\PROGRAM.C: Błąd przy 
zapisie pliku wyjściowego), 

to znak, że na dyskietce zabrakło miejsca. Pora zmienić katalog 
wyjściowy kompilatora C++. Aby to zrobić należy: 
1. Rozwinąć menu Option - [Alt]-[O]. 
2. Wybrać rozkaz Directories... - [D]. 
3. Przejść do okienka "Output Directory" - 2 razy [Tab]. 
4. Wpisać do okienka katalog z dysku stałego, np.: C:\ 
5. Nacisnąć [Enter]. 
6. Powtórzyć kompilację programu, przy której nastąpiło 
przepełnienie dyskietki. 
7. Usunąć z dyskietki A: zbędne pliki *.EXE (TYLKO *.EXE !!!). 

Oczywiście lepiej posługiwać się własnym katalogiem na dysku 
stałym, ale dysk też niestety nie jest z gumy. Złośliwi twierdzą 

nawet, że każdy dysk jest za mały a każdy procesor zbyt wolny 
(to ponoć tylko kwestia czasu...). 
________________________________________________________________ 


[!!!] Dla dociekliwych - Przykłady programów. 
________________________________________________________________ 
Jeśli zajrzysz już do systemu Help, przwiń cierpliwie tekst 
opisu funkcji do końca. W większości funkcji na końcu 
umieszczony jest krótki "firmowy" program przykładowy. 
Nie musisz go przepisywać! 
W menu Edit IDE masz do dyspozycji rozkaz 
Edit | Copy Example (Skopiuj przykład) 
Przykład zostanie skopiowany do Schowka (Clipboard). 
Po wyjściu z systemu pomocy warto rozkazem 
File | New 
otworzyć nowe okno robocze a następnie rozkazem 
Edit | Paste (Wstaw) 
wstawić program przykładowy ze schowka. Możesz go teraz 
uruchamiać, modyfikować a nawet wstawić jako fragment do swojego 

programu. 
Podobnie jak większość edytorów tekstu zintegrowany edytor 
środowiska IDE pozwala manipulować fragmentami blokami tekstu i 
wykonywać typowe operacje edytorskie zarówno w obrębie 
pojedynczego okna, jak i pomiędzy różnymi okienkami. Służą do 
tego celu następujące operacje: 

* Select/Mark text block - zaznaczenie fragmentu tekstu. 
Możesz dokonać tego klawiszami- np.: [Shift]+[-->], bądź 
naciskając i przytrzymując lewy klawisz myszki i "przejeżdżając 
nad odpowiednim fragmentem tekstu". Wybrany fragment tekstu 
zostanie wyróżniony podświetleniem. 
* Edit | Cut - wytnij. 
Zaznaczony wcześniej fragment tekstu zostanie skopiowany do 
Schowka i jednocześnie usunięty z ekranu. 
* Edit | Copy - skopiuj. 
Zaznaczony wcześniej fragment tekstu zostanie skopiowany do 
Schowka i bez usuwania z ekranu. 
* Edit | Paste - wstaw. 
Zaznaczony wcześniej w Schowku fragment tekstu zostanie 
skopiowany na ekran począwszy od miejsca wskazanego w danej 
chwili kursorem. 


 


DZIAŁ C&C++
...

TYP I NAZWA PLIKÓW  DO POBRANIA:
.....
...
... LEKCJA7.txt 26kB
FORMAT ARCHIWUM:
...
...

 

 

Strona poœwięcona jest technologiom programowania C++ z wykorzystaniem pakietu Visual C++, Pascal, DELPHI, C oraz technologiom tworzenia grafiki komputerowej z wykorzystaniem OpenGl i innych technik.
Wszelkie materiały zamieszczone zostały na stronie w celach dydaktycznych. Autor nie ponosi odpowiedzialnoœci za treœci materiałów oraz skutki wywołane ich wykorzystaniem.

(c) P.PARDEL 2001-2005 gg:1991389

Serwis znajduje się na serwerze www.friko.pl ..::..::..