Struktura programu
Kurs ten przeznaczony jest dla tych, którzy chcą poznać podstawy C/C++ oraz Buildera C++ W pierwszej części kursu zajmiemy się ogólną strukturą programów pisanych we wspomnianych językach. Do jej omówienia posłużymy się prostym przykładem. Oto on:
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
int main()
{
cout << "Witaj";
cout << endl << "świecie";
getch();
return 0;
}
//------------------------------------------------
Podstawą całego programu jest funkcja main() Po uruchomieniu programu to właśnie ona wykonywana jest jako pierwsza. W niej następują wywołania kolejnych funkcji lub wykonywane są jakieś polecenia (tak jak w naszym przypadku). Cała wspomniana funkcja zamykana jest poleceniem return 0 która wysyła do systemu informację o zakończeniu działania programu. Wartość 0 jest równoważna z wartością boolowską false i w przypadku tego polecenia oznacza, że program został zakończony poprawnie. Wszystkie inne wartości oznaczałyby, że nastąpił błąd przy zamykaniu programu.
Na samym początku pisanego programu, dołączyliśmy za pomocą dyrektywy #include dwa pliki nagłówkowe. To właśnie w nich znajdują się deklaracje poleceń użytych wewnątrz funkcji main() Słowa cout oraz endl zawarte są w pliku nagłówkowym iostream.h Pierwsza z nich w połączeniu z operatorem << służy do wypisania tekstu na ekran, zaś druga - zrzuca pisany tekst do kolejnej lini. W powyższym przykładzie została użyta także funkcja getch() która powoduje oczekiwanie na wciśnięcie jakiegoś klawisza. Aby ją użyć musieliśmy najpierw dołączyć plik nagłówkowy: conio.h Oprócz nich istnieje także plik nagłówkowy: stdio.h która zawiera deklaracje standardowych funkcji wejścia i wyjścia.
Po definicji plików nagłówkowych następuję dołączenie dyrektywy #pragma hdrstop która informuje kompilator o końcu listy, dołączanych plików zewnętrznych.
Zmienne i stałe
Zmienne i stałe są jednymi z podstawowych pojęć każdego języka programowania. Są to jakby pojedyncze fragmenty pamięci w których przechowywane są jakieś dane. Dzięki wykorzystaniu wcześniej zadeklarowanych zmiennych lub stałych mamy bardzo prosty dostęp do ich wartości. Możemy w każdej chwili zmienić wartość zmiennej.
W C++ przed użyciem każdej zmiennej trzeba ją najpierw zadeklarować, tzn. określić nazwę zmiennej oraz jej typ. Podstawowymi typami danych są:
int - liczby całkowite
float - liczby zmiennoprzecinkowe
double - liczby zmiennoprzecinkowe o podwójnej długości
char - znaki
void - typ pusty
Przykładowa deklaracja zmiennej może wyglądać następująco:
int liczba1;
Aby zadeklarować stałą wystarczy na początku deklaracji dodać słówko const. Dodatkowo deklarując stałą należy przypisać jej wartość:
const int liczba1 = 7;
Czym jednak różnią się zmienne od stałych ? Po prostu wartość zmiennej podczas działania programu można zmieniać wielokrotnie, zaś wartość stałej jest ustalana tylko raz, przy jej deklaracji. Wartość zmiennej można przypisać na pomocą operatora " = ":
int liczba1;
liczba1 = 7;
Napiszmy teraz prosty programik, który pobierze od użytkownika jakąś liczbę i podniesie ją do kwadratu:
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
int x, y; //deklaracja zmiennych
int main()
{
cout << "Podaj jakąs liczbę: ";
cin >> x;
y = x * x;
cout << "Kwadrat tej liczby wynosi: " << y;
cout << endl << "Naciśnij jakiś klawisz...";
getch();
return 0;
}
//--------------------------------------------------
Myślę, że powyższy kod nie jest trudny do zrozumienia. Doszło tylko jedno słówko, którego masz prawo nie znać - cin Przypisuje ono zmiennej poprzedzonej operatorem >> wartość wprowadzoną przez użytkownika.
Operatory
Operacje na zmiennych można przeprowadzać za pomocą operatorów. Podstawą grupą operatorów są operatory przypisania, najważniejsze z nich zamieściłem w poniższej tabeli.
Operator |
Zastosowanie |
= |
operator przypisania |
+= |
dodaje wartość i przypisuje ją |
-+ |
odejmuje wartość i przypisuje ją |
/= |
dzieli wartość i przypisuje ją |
*= |
mnoży wartość i przypisuje ją |
Wśród operatorów wyróżniamy także operatory arytmetyczne. Dzięki nim możemy przeprowadzić operacje matematyczne na zmiennych lub liczbach.
+ |
dodaj |
- |
odejmij |
/ |
podziel |
* |
pomnóż |
% |
zwróć resztę z dzielenia |
Operatory porównania oraz operatory logiczne są wykorzystywane najczęściej w instrukcjach warunkowych, lecz także w pętlach. Oto one:
== |
równe |
!= |
różne |
> |
większe |
< |
mniejsze |
>= |
większe lub równe |
<= |
mniejsze lub równe |
&& |
koniunkcja |
|| |
alternatywa |
! |
zaprzeczenie |
Pisząc programy w C++ równie często wykorzystuje się wskaźniki oraz klasy. Przy ich użyciu wykorzystuje się również operatory:
typ * |
wskaźnik |
*wskaźnik |
adresowanie |
&zmienna |
adres zmiennej |
class |
deklaracja klasy |
struct |
deklaracja struktury |
:: |
kwalifikator zakresu |
-> |
odwołanie kwalifikacyjne |
Tablice
Tablice można nazwać jakby pewnym rodzajem zmiennych. Są to ich zbiory pod jedną nazwą. Korzystanie z tablic ma wiele zalet, po pierwsze zamiast tworzyć po kolei wszystkie zmienne element1, element2... możemy utworzyć tablicę, po drugie możemy je przeszukać lub wyświetlić ich wartości za jednym razem przy pomocy pętli. Tablice podobnie jak zmienne przed ich użyciem należy zadeklarować, np. tak:
int Tablica[5];
Taki zapis oznacza, że została utworzona tablica, która składa się jakby z pięciu zmiennych, w których można zapisać liczby całkowite. Przypisując poszczególnym elementom wartości należy pamiętać, że nazwy poszczególnych elementów tablicy numerowane są od zera do n-1. Przykładowe przypisanie poszczególnym wartościom tablicy możne wyglądać następująco:
Tablica[0] = 100;
Tablica[1] = 200;
Tablica[2] = 300;
Tablica[3] = 400;
Tablica[4] = 500;
Talice typu znakowego:
char Tablica[3];
umożliwiają przypisanie jej poszczególnym elementom wartości w sposób prostszy:
char Tablica[3] = "CPW"
co oznacza, że elementowi [0] został przypisany znak "C", [1] - "P", zaś [2] - "W" Możliwe jest także tworzenie tablic dwuwymiarowych:
int Tablica [2][3];
oznacza to, że tablica posiada cześć elementów, których indexy wyglądają następująco:
Tablica[0][0]
Tablica[0][1]
Tablica[0][2]
Tablica[1][0]
Tablica[1][1]
Tablica[1][2]
Wartości poszczególnym elementom przypisuję się bardzo prosto:
Tablica[0][1] = 300;
Jeżeli chcielibyśmy wyświetlić wartość jakiejś tablicy, można to zrobić w sposób następujący:
cout << Tablica[3]
lub dla tablic wielowymiarowych:
cout << Tablica[0][3]
Instrukcje warunkowe
Instrukcje warunkowe są kolejną rzeczą, wykorzystywaną bardzo często we wszystkich językach programowania. Dzięki nim tworzone programy nie będą tak bardzo statyczne. Sposób wykonywania programu może dzieki nim zależeć od woli użytkownika. Instrukcje warunkowe w C++ / Builderze C++ mają podobną postać do instrukcji wykorzystywanych w JavaScript lub w PHP. Poniżej zamieściłem schemat najprostszej instrukcji warunkowej:
if(warunek1)
{
ten kod jest wykonany, gdy jest spełniony warunek1
}
else
{
ten kod jest wykonany, gdy nie został spełniony warunek1
}
Stwórzmy teraz prosty program, który pobierze od użytkownika jakąś liczbę z przedziału od 1-5 i wyśiwtli ją w postaci słownej:
#include
#include
#pragma hdrstop
int x; //deklaracja zmiennych
int main()
{
cout << "Podaj liczbę z zakresu od 0 do 5: ";
cin >> x;
cout << "Oto ta liczba zapisana słownie: ";
if(x == 0)
{ cout << "zero"; }
if(x == 1)
{ cout << "jeden"; }
if(x == 2)
{ cout << "dwa"; }
if(x == 3)
{ cout << "trzy"; }
if(x == 4)
{ cout << "cztery"; }
if(x == 5)
{ cout << "pięc"; }
cout << endl << "Aby zkończyć program naciśnij enter";
getch();
return 0;
}
//-----------------------------------------------------
Pętle
Może zacznijmy od tego do czego służą pętle. Programy, które tworzyliśmy to tej pory można było wykonać tylko raz. Dzięki pętlom możemy stworzyć takie programy, które będą kończyć swoją pracę dopiero np. po wciśnięciu klawisza "Esc" lub będą mogły wykonać jakiś kod kilka razy bez jego powtarzania. Istnieje kilka rodzajów tego rodzaju instrukcji. Każda ma inną zasadę działania o nich przeczytasz już za chwilę.
Pierwszą pętlą, którą omówię jest pętla for. Poniżej zamieszczam jej schemat
for(inicjalizacja; warunek; inkrementacja)
{
polecenia;
}
Przedstawiona powyżej instrukcja ma zastosowanie tylko wtedy, kiedy jakiś fragment chcemy wykonać dokładnie określoną liczbę razy. Jako pierwszą operację przypisujemy dowolnej zmiennej wartość początkową (inicjalizacja), później określamy warunek po którym pętla zostanie zakończona. Na samym końcu dokonujemy zwiększenia (zazwyczaj o jeden) zmiennej zadeklarowanej w inicjalizacji. Stwórzmy teraz program, który będzie numerował kolejne linie od 0 do 25:
#include
#include
#pragma hdrstop
int x; //deklaracja zmiennych
int main()
{
for(x = 1; x <= 25; x++)
{
cout << endl << x;
}
getch();
return 0;
}
//------------------------------------------------------
Kolejną pętlą udostępnioną w C++ jest pętla while. Jej ogólna struktura wygląda następująco:
while(warunek)
{
polecenia;
}
Warunek sprawdzany jest przed pierwszym wykonaniem pętli, dlatego znajdujące się wewnątrz funkcji polecenia mogą zostać nie wykonane ani razu. Pętla działa do momentu kiedy warunek zawraca wartość True. Jeżeli zwrócony warunek będzie negatywny program wykona instrukcje znajdujące się zaraz po pętli. Dokonajmy teraz przeróbki programu stworzonego przy omówieniu poprzedniej instrukcji (for):
#include
#include
#pragma hdrstop
int x; //deklaracja zmiennych
int main()
{
x = 0;
while(x < 25)
{
x = x + 1;
cout << endl << x;
}
getch();
return 0;
}
//------------------------------------------------------
Na zakończenie, omówię ostatnią z pętli dostępnych w C++. Instrukcja do...while jest w znacznym stopniu podobna do pętli omawianej przed chwilą. Różnica pomiędzy nimi występuje tylko taka, że warunek jest sprawdzany dopiero na jej końcu. Dlatego pętla musi zostać wykonana przynajmniej raz:
do {
polecenia;
} while(warunek);
Stwórzmy teraz program który będzie pobierał o użytkownika dwie liczby i sumował je. Ten scenariusz będzie się dział aż do momentu, kiedy użytkownik wciśnie znak "S":
#include
#include
#pragma hdrstop
int x, y; //deklaracja zmiennych
char stop;
int main()
{
do {
cout << endl << "Podaj pierwszą liczbę: ";
cin >> x;
cout << "Podaj drugą liczbę: ";
cin >> y;
cout << "Ich suma wynosi: " << x + y;
cout << endl << "Aby zakończyć program wciśnij znak: S";
cout << endl << "w przeciwnym wypadku dowolną inną literę: ";
cin >> stop;
} while (stop != 's' && stop != 's');
return 0;
}
//------------------------------------------------------
Funkcje
Funkcje są jednym z ważniejszych elementów każdego języka programowania. Umożliwiają pogrupowanie instrukcji w poszczególne grupy dzięki czemu nie musimy powtarzać tego samego fragmentu kodu wielokrotnie. Dodatkową zaletą funkcji jest to, że możemy przesłać do jej wnętrza jakieś wartości dzięki czemu każde wykonanie funkcji może zwrócić inną wartość. Podstawowa struktura każdej funkcji wygląda następująco:
int Nazwa_funkcji(int x, int y)
{
int z = x + y;
return z;
}
Na samym początku określamy typ danych, który ma zostać zwrócony za pomocą wyrażenia return. W naszym przypadku jest to int co oznacza, że funkcja zwróci całkowitą wartość liczbową. Parametr ten może przyjmować także wartość void co oznacza, że funkcja nie zwróci żadnego parametru. Dalej następuje określenie nazwy funkcji pod którą będzie występować. W nawiasie podajemy parametry, które mają być przekazane do funkcji. Wewnątrz nawiasów {} znajduje się całe ciało funkcji, w którym mogą znajdować się różne polecenia. Wnętrze funkcji jest zakończone słówkiem return, o którym mówiliśmy przy pierwszych częściach tego kursy, jednak jeszcze raz przypomnę, służy ono do zwrócenia wartości do programu. Może zauważyłeś już uwagę, że cały czas używałeś funkcji, choć może nie zdawałeś sobie zbytnio z tego sprawy. Była to funkcja main().
Uwaga !!!
Aby można było odróżnić nazwy funkcji od zmiennych
ich nawy zakończone są nawiasami ()
Stwórzmy teraz prosty programik wykorzystujący funkcje, jego działanie omówię później.
#include
#include
#pragma hdrstop
int suma(int x, int y);
int main()
{
cout << endl << suma(31,1489);
cout << endl << suma(4123,123);
cout << endl << suma(32,12);
getch();
return 0;
}
int suma(int x, int y)
{
int z = x + y;
return z;
}
//-----------------------------------------------------
Całe ciało funkcji znajduje się dopiero po głównej funkcji programu, czyli main() Należało jednak zadeklarować naszą funkcję zaraz przed nią:
int suma(int x, int y);
Co prawda można było także całą funkcję umieścić w miejscu jej deklaracji, jednak sposób, który wykorzystałem w powyższym przykładzie jest częściej stosowany.