Podstawy programowania Borland c++ builder

Strona w budowie

Kolejne części typowego programu:

biblioteki – definicje funkcji użytych w programie,
dodatkowe polecenia,
dane globalne – zmienne i stałe dostępne w całym programie,
funkcje – definicje funkcji napisanych i użytych w programie,
funkcja główna main.

Dopuszczalna jest równieże kolejność:

biblioteki,
dodatkowe polecenia,
dane globalne,
nagłówki funkcji – „pierwsze linie” definicji funkcji napisanych i użytych w programie,
funkcja główna main.
funkcje – definicje funkcji napisanych i użytych w programie.

Komentarz do kodu

Komentarz to fragment programu, który nie jest kodem – jest pomijany przez kompilatora. Między znakami /* i */ umieszcza się komentarz, który może zajmować dowolną liczbę linii programu. Po znakach // umieszcza się komentarz, który kończy się z końcem tej samej linii programu.

Biblioteka

Biblioteka to zbiór funkcji, z których korzysta się w programie, ale nie napisanych w nim.

Każdą potrzebną bibliotekę dołącza się poleceniem #include, np.:

#include<iostream> // dołączenie biblioteki iostream

Dodatkowe polecenia

Polecenie using namespace sdt ustawia klawiaturę jako domyślne źródło pobierania danych, a ekran jako domyślne źródło zwracania danych, jeśli używa się operatorów cin i cout z biblioteki iostream:

using namespace std;

Przykład użycia cin i cout:

#include <iostream> 
int main() { 
int a; float b; std::cout << "Podaj liczbe calkowita: "; std::cin >> a; std::cout << "Podaj liczbe rzeczywista: "; std::cin >> b; std::cout << "Liczba a = " << a << std::endl; std::cout << "Liczba b = " << b << std::endl; return 0; }

Przykłąd użycia scanf:

int a; float b; double c; char d; scanf("%d", &a); // pobranie liczby całkowitej do a scanf("%f %lf %c", &b, &c, &d); // pobranie liczb // rzeczywistych do b i c oraz znaku do d // (wprowadzane dane są oddzielane spacjami) scanf("%f,%lf,%c", &b, &c, &d); // pobranie jak wyżej // (wprowadzane dane są oddzielane przecinkami)

gdzie:

%d – liczba całkowita (do zmiennej typu int),
%f – liczba rzeczywista (do zmiennej typu float),
%lf – liczba rzeczywista (do zmiennej typu double),
%c – znak (do zmiennej typu char),
%s – łańcuch znaków (do zmiennej typu string lub tablicy typu char).

Argumenty funkcji scanf to formatowanie wprowadzanych danych (w cudzysłowie) i adresy zmiennych, do których są wprowadzane. Adres zmiennej to jej nazwa poprzedzona znakiem &. Argumenty oddzielane są przecinkami.

Format danej wprowadzanej do zmiennej opisuje znak % i identyfikator typu zmiennej, opcjonalnie poprzedzony rozmiarem danej.

Przykłąd użycia scanf:

Przy pomocy funkcji printf (z biblioteki stdio.h) można wyświetlić dane bezpośrednio lub do jednej lub więcej zmiennych, np.:

int a = 15; float b = 7.45; char c = 'k'; printf("qwerty"); // wyświetlenie napisu qwerty printf("%d", a); // wyświetlenie zawartości a printf("b=%f", a); // wyświetlenie napisu b= i zawartości b printf("%.1f", a); // wyświetlenie zawartości b // z 1 cyfrą części ułamkowej printf("%c %d", c, c); // wyświetlenie zawartości c jako znaku, // spacji i zawartości z jako kodu ASCII

gdzie:

%d – liczba całkowita (ze zmiennej typu int),
%f – liczba rzeczywista (ze zmiennej typu float lub typu double),
%c – znak (ze zmiennej typu char),
%s – łańcuch znaków (ze zmiennej typu string lub tablicy typu char).

Wybrane biblioteki i ich funkcje

- alloc.h – operacje na pamięci programu:
  - calloc – przydzielenie pamięci na dynamiczną tablicę,
  - free – zwolnienie pamięci przydzielonej wcześniej na dynamiczną tablicę,
- cstdlib – operacje systemowe, w tym na terminalu”
  - system – funkcja wykonująca polecenie systemowe.
- iostream – operacje wejścia/wyjścia, w tym pobieranie danych z klawiatury i wyświetlanie ich na ekranie:
  - cin – operator pobrania danych,
  - cout – operator zwrócenia danych.
- math.h – operacje matematyczne:
  - pow – potęga liczby o zadanym wykładniku,
  - sqrt – kwadratowy pierwiastek z liczby.
- stdio.h – operacje wejścia/wyjścia, w tym pobieranie danych z klawiatury i wyświetlanie ich na ekranie:
  - fgets – funkcja pobierająca ciąg znaków do tablicy znaków,
  - printf – funkcja zwrócenia danych,
  - scanf – funkcja pobrania danych.
- string.h – operacje na łańcuchach znaków:
  - strlen – funkcja zwracająca długość łańcucha.

Funkcja główna -> main

Funkcja main to główna funkcja programu, której ciało definiuje to, co program ma wykonać.

Standardowo funkcja main zwraca liczbę całkowitą (0, jeśli wykonała się poprawnie), więc jej nagłówek zawiera typ int, np.:

int main() { std::cout << "Hello World!\n"; }

Typy danych

Wybrane typy danych:

bool – wartość logiczna: true lub 1 (prawda), false lub 0 (fałsz),
char – znak: litera, cyfra itp.,
int – liczba całkowita (-2147483648 .. 2147483647),
float – liczba rzeczywista (8 cyfrowa),
double – liczba rzeczywista (15-cyfrowa),
string – łańcuch znaków (wymaga biblioteki string.h).

Zapisywanie danych w kodzie:

liczbie rzeczywistej - część ułamkową oddziela się od całkowitej kropką, np. 2.25,
znak umieszcza się w apostrofach, np 'a',
łańcuch znaków umieszcza się w cudzysłowie, np. "qwerty", "a" (łańcuch jednoznakowy), "" (łańcuch pusty).

Zmienną tworzy (deklaruje) się, podając jej typ, nazwę i ewentualnie początkową wartość, np:

bool czy_tak = true; // zmienna czy_tak typu bool zawierająca true float liczba; // zmienna liczba typu float double liczba_1,liczba_2; // zmienne liczba_1 i liczba_ typu double

Stałą tworzy się, podając słowo const, jej typ, nazwę i wartość, np:

const int stala = 12; // stała stala typu int zawierająca 12

Instrukcja warunku „if”.

Instrukcja warunku if służy do wyboru operacji do wykonania, zależnie od prawdziwości podanego warunku. Warunek podaje się w nawiasach; musi mieć wartość logiczną, np.:

if( wyrazenieLogiczne == true )... //powyższy zapis jest równoważny poniższemu: if( wyrazenieLogiczne )... ////lub if( wiek > 100 || wiek < 2 )...

Przykład użycie bloku instrukcji:

#include <iostream> int main() { int wiek; std::cin >> wiek; if( wiek >= 18 ) { std::cout << "Czy jesteś osobą pełnoletnią?." << std::endl; std::cout << "Tak, możesz głosować :)" << std::endl; } std::cout << "Koniec" << std::endl; return 0; }

Zagnieżdżanie warunków przykład:

#include <iostream> int main() { int liczba; std::cin >> liczba; if( liczba >= 10 ) { std::cout << "Liczba jest >= 10" << std::endl; if( liczba >= 50 ) { std::cout << "Liczba jest >= 50" << std::endl; if( liczba <= 100 ) std::cout << "Liczba jest <= 100" << std::endl; } } std::cout << "Koniec" << std::endl; return 0; }

Słowo kluczowe else:

Słowo kluczowe else oznacza "w przeciwnym wypadku", czyli jeśli warunek nie zostanie spełniony, wykonaj inny kod.

#include <iostream> int main() { int wiek; std::cin >> wiek; if( wiek >= 18 ) std::cout << "Jestes pelnoletni." << std::endl; else std::cout << "Nie jestes pelnoletni." << std::endl; std::cout << "Koniec" << std::endl; return 0; }

Instrukcja wyboru „switch”

Instrukcja warunku switch służy do wyboru operacji do wykonania, zależnie od wartości podanej zmiennej kontrolnej. Dla każdej wartości definiuje się osobny przypadek wyrażeniem case, np.:

switch( zmienna ) { case wartosc_1: //jakiś kod break; case wartosc_2: //jakiś kod break; //... case wartosc_n: //jakiś kod break; default: //jakiś kod break; }

Polecenie break kończy/przerywa wykonywanie wyrażenia switch.

Wyrażenie default jest opcjonalne; odpowiada wszystkim innym przypadkom, niż te zdefiniowane wyrażeniami case.

Pętle: for, while, do..while

Pętla for:

Instrukcja pętli for służy do wielokrotnego wykonania jej kodu, zwykle zależnie od wartości zmiennej sterującej pętlą i/lub spełnienia danego warunku.

Budowa pętli for jak łatwo można zauważyć jest podzielona na cztery części:

nadawanie początkowych wartości zmiennym (instrukcja_1);
warunek kończący pętlę for (instrukcja_2); z
większenie (zmniejszenie) licznika pętli (instrukcja_3).

for( instrukcja_1; instrukcja_2; instrukcja_3 ) { //blok instrukcji }

Przykłąd:

for( int i = 1; i <= 10; i++ ) { //Powtarzany blok instrukcji }

Pętla while:

Instrukcja pętli while służy do wielokrotnego wykonania jej kodu, zależnie od spełnienia podanego warunku. Wykonanie pętli następuje po sprawdzeniu, że warunek jest prawdziwy; w przeciwnym razie pętla się kończy. Czyli pętla wykonywana jest dopóki warunek jest prawdziwy.:

while (warunekKoncowy){ lista_instrukcji }

Przykłąd:

#include <iostream> int main() { int ile=3; while (ile<10) { std::cout <<"Pierwsza instrukcja"<<std::endl; std::cout <<"Druga instrukcja"<<std::endl; ++ile; } std::cout <<std::endl<<"Nacisnij ENTER aby zakonczyc"<<std::endl; getchar(); return 0; }

Pętla do .. while:

Instrukcja pętli do .. while służy do wielokrotnego wykonania jej kodu, zależnie od spełnienia podanego warunku. Drugie i każde kolejne wykonanie pętli następuje po sprawdzeniu, że warunek jest prawdziwy; w przeciwnym razie pętla się kończy. Czyli pętla taka wykona się zawsze przynajmniej raz.

do { lista_instrukcji } while (warunekKoncowy);

Przykłąd:

#include <iostream> int main() { int liczba; do { std::cout << "Podaj liczbe 123 aby zakonczyc petle" << std::endl; std::cin >> liczba; std::cout << "Podales liczbe " << liczba << std::endl; } while( liczba != 123 ); std::cout << "Koniec" << std::endl; return 0; }

Tablica statyczna

Tablica jest uporządkowaną strukturą danych tego samego typu.

Statyczna tablica ma stały rozmiar i tworzona jest podobnie do zmiennej – lokalnie lub globalnie; z zawartością lub bez. Rozmiar tablicy (liczbę jej komórek) podaje się w nawiasach [], np.:

Przykład tworzenia tablicy jednowymiarowej:

char znaki[4]; // utworzenie tablice znaki jako tablicę 4 znaków char znaki[4] = {'x','y','z','r'}; // utworzenie tablice znaki i wypełnij elementami char c[] = {'x','y','z'}; // bez podania rozmiaru tablicy int tablica[4] // utworzenie tablicy int int tablica[4] = {1,2,3,4}; int tablica[] = {1,2,3,4};

Przykład tworzenia tablicy dwuwymiarowej:

int tab[3][4]; // utworzenie tablicy 3×4 liczb całkowitych int tab[3][4] = { // utworzenie takie samej tablicy z liczbami {1,2,3,4}, // wiersz 1 {5,6,7,8}, // wiersz 2 {9,10,11,12}}; // wiersz 3

Zapis i odczyt z tablicy:

//zapis do tablicy int tablica[7]; int tab[10] tablica[3] = 5; // wstawienie liczby 5 do komórki nr 3 // wstawienie do każdej komórki jej numeru: for (int i = 0; i < 10; i++) // zmienna kontrolna zaczyna się od 0 { tab[i] = i; //dla każdego elementu tablicy } //odczyt z tablicy int element = tab[4]; // skopiowanie tab[4] do zmiennej element // wyświetlenie każdej komórki: for(i=0; i<7; i++) // zmienna kontrolna zaczyna się od 0 { cout << a[i]; }

Wskaźnik

Wskaźnik (ang. pointer) – typ zmiennej odpowiedzialnej za przechowywanie adresu do innej zmiennej (innego miejsca w pamięci) w obrębie naszej aplikacji.

Wskaźnik może wskazywać na jakąś zmienną, strukturę, tablicę a nawet funkcję. Podstawowe operatory niezbędne do operowania wskaźnikami:

* – operator wyłuskania wartości zmiennej, na którą wskazuje wskaźnik (wyciąga wartość ze wskaźnika)
& – operator pobrania adresu danej zmiennej, tablicy, struktury itp (pobiera adres zmiennej)

Przykład:

int telefon = 12345; //zmienna liczbowa int *wsk = &telefon; //przypisanie wskaźnikowi adresu zmiennej telefon cout << *wsk << endl; //wyświetlenie wyłuskanej wartości wskaźnika (12345) cout << wsk << endl; //wyświetlenie adresu zmiennej telefon cout << &wsk << endl; //wyświetlenie adresu wskaźnika cout << &telefon << endl; //wyświetlenie adresu zmiennej telefon

Wskaźnik jako argumentem funkcji:

#include <iostream> using namespace std; // funkcja przyjmuje jako argument wskaźnik void zwieksz_liczbe (int *liczba) { *liczba+= 5; } int main() { int numerek = 5; int *wsk = &numerek; // operatora pobrania adresu (&) a nie samą wartość zwieksz_liczbe(wsk); //przekazujemy wskaźnik (bez operatorów) cout << numerek << endl; zwieksz_liczbe(&numerek); //przekazujemy bezpośrednio adres zmiennej (operator &) cout << numerek << endl; return 0; }

Funkcje

Budowa funkcji:

typ_zwracanej_wartosci nazwa( typ_1 nazwa_1 ,typ_2 nazwa_2, ..., typ_n _n ) { return zwracana_wartosc; }

Funkcja bezargumentowa nie otrzymuje żadnych danych wejściowych jako argumentów, czyli nawiasy () umieszczone po jej nazwie są puste. PRzykład:

// definicja funkcji zwroc_liczbe: int zwroc_liczbe() { int a = 5; return a; // ta funkcja zwraca liczbę 5 } // wykonanie funkcji zwroc_liczbe w funkcji main: int main() { cout << zwroc_liczbe(); // wyświetlenie liczby 5 return 0; }

Funkcja z argumentami przekazywanymi przez wartość otrzymuje wartości (liczby, znaki itp.) jako dane wejściowe, które wpisuje do zmiennych podanych w nawiasach () w nagłówku definicji funkcji jako argumenty; te zmienne są lokalnymi zmiennymi tej funkcji. Przykłąd:

// definicja funkcji suma int suma(int a, int b) { return a + b; // funkcja zwraca sumę argumentów a i b } // wykonanie funkcji suma w funkcji main: // przekazanie przez zmienne int main() { int c = 2; int d = 3; cout << suma(d, c); // wyświetlenie sumy liczb 2 i 3 return 0; } //lub int main() { cout << suma(2, 3); // wyświetlenie sumy liczb 2 i 3 return 0; }

Tablica dynamiczna jedno i dwuwymiarowa

Operatory new i delete:

int * tablica = new int[3]; //wskaźnik tego samego typu co elementy tablicy tablica[0] = 11; tablica[1] = 12; tablica[2] = 13; delete [] tablica; // zawsze usuwamy

Generowanie tablicy dwuwymiarowej dynamicznej odbywa podobnie jak jednowymiarowej. Zamiast tworzyć wskaźnik do jednego wymiaru, tworzymy tablicę wskaźników wskazujących na wymiary. W uproszczeniu tworzymy tablicę z tablic. Przykład

int ** tablica = new int * [3]; tablica[0] = new int [3]; // wskaźnik tablica[0] wskazuje na nową tablicę tablica[1] = new int [3]; // wskaźnik tablica[1] wskazuje na nową tablicę tablica[2] = new int [3]; // wskaźnik tablica[2] wskazuje na nową tablicę tablica[2][2] = 123; cout << tablica[2][2]; // zwalniamy pamiec delete [] tablica[0]; delete [] tablica[1]; delete [] tablica[2]; delete [] tablica;