Programowanie w C/C++
Temat: Przegląd operacji zaawansowanych
Funkcje
Funkcja
Funkcja  nazwana część programu (podprogram), która może być
wywołana z innej części dowolną ilość razy.
Składnia funkcji: zwracany_typ nazwa([parametry]) {
instrukcje;
...
[return [obiekt_zwracany]];
}
l Przed odwołaniem się do nazwy funkcji wymagana jest jej deklaracja (nie-
koniecznie definicja).
l Sama funkcja może być zdefiniowana póz
niej.
float pole(float); float pole(float r) {
return 3.14159f * r * r;
void main() {
}
...
cout << pole(7.3) << endl; void main() {
} ...
cout << pole(7.3) << endl;
float pole(float r) {
}
return 3.14159f * r * r;
}
Funkcje - przykłady
l Funkcja wypisująca na ekranie komunikat:
void napis() { // można też napisać: void napis(void) {
cout <<  Komunikat\n ;
}
l Funkcja wypisująca na ekranie znak zadaną ilość razy:
void echo(char znak, unsigned int ile) {
while(ile--)
cout << znak;
}
l Funkcja obliczająca objętość walca:
double objWalca(double r, double h) {
double pole_podst = 3.1415 * r * r;
return h * pole_podst;
}
Deklaracja funkcji
Składnia funkcji: zwracany_typ nazwa([parametry]) {
instrukcje;
...
nagłówek funkcji
[return [obiekt_zwracany]];
}
Przykłady
double objWalca (double r, double h);
lub double objKuli(double, double);
void echo(char znak, unsigned int ile);
lub void echo(char, unsigned int);
void napis();
Uwaga: na końcu każdej deklaracji znajduje się średnik!!!
Zwracanie wyniku przez funkcję
Funkcja zwraca wartość przez instrukcję return wyrażenie.
Wyrażenie musi być typu zadeklarowanego jako typ zwracany przez funkcję
lub dającego się skonwertować do typu zwracanego.
double objWalca(double r, double h) {
double pole_podst = 3.1415 * r * r;
return h * pole_podst;
}
wyrażenie
Jeśli funkcja zwraca typ void, czyli nie zwraca niczego, to wewnątrz funkcji nie
wolno użyć instrukcji return.
Ponieważ funkcja zwraca wartość wyrażenia, sama może być użyta w wyrażeniu:
a + objWalca(5,6) *0.1
Parametry formalne funkcji
i aktualne wywołania funkcji
parametry (argumenty) formalne
Definicja funkcji:
double objWalca(double r , double h ) {
double pole_podst = 3.1415 * r * r;
return h * pole_podst;
}
Wywołanie funkcji w programie:
#include
//.................
double promien, wysokosc;
//.................
parametry (argumenty) aktualne
promien=3.4; wysokosc=5.8;
wywołania funkcji
cout<cout<Argumenty funkcji  przesyłanie przez wartość
Do funkcji przesyłana jest wartość liczbowa argumentu aktualnego wywołania
funkcji. Wartość ta służy do inicjalizacji parametru formalnego. Funkcja pracuje
na kopii argumentu aktualnego. Po opuszczeniu funkcji kopia znika, wobec tego
znika też to, co zostało zrobione w funkcji.
Argumenty funkcji  przesyłanie przez wartość, cd.
Przykład
#include
void dodaj5(int a);
void main(){
int b=2;
cout<<"Przed wywolaniem funkcji dodaj5 parametr aktualny = "
<dodaj5(b);
cout<<"\nPo wywolaniu funkcji dodaj5 parametr aktualny = "
<}
void dodaj5(int a){
a+=5;
cout<<"\nW funkcji dodano do parametru formalnego 5"<cout<<"arg formalny = "<}
Argumenty funkcji  przesyłanie przez wartość, cd.
Przykład
Wynik działania programu:
Przed wywolaniem funkcji dodaj5 parametr aktualny = 2
W funkcji dodano do parametru formalnego 5
arg formalny = 7
Po wywolaniu funkcji dodaj5 parametr aktualny = 2
Argumenty funkcji  przesyłanie przez referencję
Przesyłanie argumentów funkcji przez referencję pozwala funkcji na
modyfikowanie zmiennych znajdujących się pozą tą funkcją. Przy przekazywaniu
argumentu przez referencję przesyłany jest adres argumentu wywołania funkcji.
Argumenty funkcji  przesyłanie przez referencję, cd.
Przykład
#include
void dodaj5(int a, int &aa);
void main(){
int b=2, bb=10;
cout<<"Przed wywolaniem f. dodaj5 p. akt. 1 = "<cout<<"Przed wywolaniem f. dodaj5 p. akt. 2 = "<dodaj5(b,bb);
cout<<"\nPo wywolaniu f. dodaj5 p. akt. 1 = "<cout<<"Po wywolaniu f. dodaj5 p. akt. 2 = "<}
void dodaj5(int a, int &aa){
a+=5; aa+=5;
cout<<"\nW funkcji dodano do p. form. liczbe 5"<cout<<"arg formalny 1 = "<cout<<"arg formalny 2 = "<}
Argumenty funkcji  przesyłanie przez referencję, cd.
Przykład
Wynik działania programu:
Przed wywolaniem f. dodaj5 p. akt. 1 = 2
Przed wywolaniem f. dodaj5 p. akt. 2 = 10
W funkcji dodano do p. form. liczbe 5
arg formalny 1 = 7
arg formalny 2 = 15
Po wywolaniu f. dodaj5 p. akt. 1 = 2
Po wywolaniu f. dodaj5 p. akt. 2 = 15
Przekazywanie parametrów przez wskaz
niki
Funkcja otrzymuje kopie wskaz
nika, który może określać adres zmiennej
należącej do innej funkcji. Zmiana zawartości obszaru wskazywanego przez
parametry wskaz
nikowe prowadzi do zmiany wartości zmiennych
utworzonych w innych funkcjach programu.
Wskaz
nik  zmienna przeznaczona do przechowywania
adresu innej zmiennej
Przekazywanie parametrów przez wskaz
niki jest stosowane:
l do przekazywania struktur danych o dużych rozmiarach (np. tablic);
l w celu umożliwienia zwrócenia więcej niż jednej wartości.
typ_wartości nazwa_funkcji (typ_1 *par1, typ_2 *par2, ... )
Podczas wywołania funkcji należy przekazać adresy argumentów:
zmienna = nazwa_funkcji(&arg1, &arg2, ....);
np. scanf( %d , &x);
Przekazywanie parametrów przez wskaz
niki c.d.
Przykład
#include
#include
void sum(int *x, int y);
void main(void)
{int a, b;
clrscr();
a = 5; b = 10;
cout << "\nWartosc przed wywolaniem funkcji a = " << a; // a = 5
sum(&a,b); // funkcja nie zwraca wyniku a = 15
cout << "\nWartosc po wywolaniu funkcji a = " << a; // a = 15
getch();
}
void sum(int *x, int y)
{
*x = *x + y;
cout << "\nLiczba wewnatrz funkcji x = " << *x;
}
Czy deklaracja funkcji jest zawsze konieczna?
deklaracja
float pole(float); float pole(float r) {
return 3.14159f * r * r;
void main() {
}
...
cout << pole(7.3) << endl; void main() {
} ...
cout << pole(7.3) << endl;
float pole(float r) {
}
return 3.14159f * r * r;
}
definicja
Z deklaracją. Bez deklaracji.
Definicja funkcji poniżej jej wywołania Definicja funkcji przed jej wywołaniem
Argumenty domniemane
argument domniemany
#include
int przelicz(int a,int b, int p=1 );
void main(){
int x=2, y=10, s=2;
cout<< przelicz(x,y) <cout<< przelicz(x,y,s) <}
int przelicz(int a,int b,int p){ wywołanie funkcji
int result;
z domniemanym argumentem
result=(a+b)*p;
return result;
}
Wynik działania programu: Uwaga: Kompilator jest informowany, że
12
argument jest domniemany tylko raz, przy
24
deklaracji funkcji. Jeśli definicja funkcji podana
jest póz
niej, to informacja nie jest powtarzana.
Zmienne lokalne statyczne
Słowo kluczowe static przed zmienną wewnątrz funkcji pozwala na
zdefiniowanie zmiennej, która po zakończeniu działania funkcji nie jest  usuwana
z pamięci ale zachowuje swoje wartości do następnego wywołania funkcji.
Zmienne globalne  są wstępnie inicjalizowane zerami.
Zmienne lokalne  nie są wstępnie inicjalizowane, zawierają  śmieci .
Zmienne lokalne statyczne  są wstępnie inicjalizowane zerami i zajmują
w pamięci ten sam obszar, co zmienne globalne.
Definiowanie zmiennych statycznych:
static typ_zmiennej nazwa_zmiennej;
void f1(){
static int ile_razy=0; //lub static int ile_razy;
ile_razy++;
cout<<"Wywolanie funkcji f1: "<}
void f2(){
int ile=0;
ile++;
cout<<"Wywolanie funkcji f2: "<}
Funkcje i zmienne w programie składającym
się z kilku plików
Funkcje i zmienne programu mogą być umieszczone w kilku plikach.
Aby funkcje z pliku B miały dostęp do funkcji i zmiennych globalnych z pliku A,
trzeba w pliku B zamieścić deklaracje tych zmiennych i funkcji.
//plik A - definicje //plik B - deklaracje
int n; extern int n;
double x; extern double x;
void f1(){ void f1();
static int ile_razy=0;
ile_razy++;
}
Najczęściej wszystkie deklaracje umieszczane są w pliku nagłówkowym, który
bezpośrednio przed kompilacją jest włączany do pliku przez dyrektywę #include.
//plik nagl.h //plik B
extern int n; #include "nagl.h"
extern double x;
Nazwa ujęta w cudzysłów informuje kompilator,
void f1();
że plik nagłówkowy znajduje się w bieżącym katalogu
Globalne nazwy statyczne
Postawienie przed zmienną globalną słowa kluczowego static jest informacją
dla kompilatora, że nazwa tej zmiennej ma być niewidoczna w innych plikach,
z których składa się dany program.
Funkcje z atrybutem inline
Jeżeli chcemy, aby kod funkcji był umieszczany w miejscu jej wywołania, to
należy poprzedzić definicję funkcji atrybutem inline.
Wystąpienie w funkcji jednego z następujących słów kluczowych: do, while,
for, goto, switch, case, break, continue spowoduje, że kompilator potraktuje
funkcję jako zwykłą funkcję statyczną.
Przykład
inline double pot(double x)
{ return x*x*x; }
inline int max(int a, int b)
{ return (a > b ? a : b); }
void main(void)
{ int a = 2; int b = 7;
clrscr();
cout << "\na^3 = " << pot(a); // a^3 = 8
cout << "\nMax = " << max(9, max(a,b)); // max = 9
getch();
}
W przypadku wywołania max(9, max(a,b)) funkcja max zostanie
dwukrotnie włączona do kodu wynikowego.
Funkcje przeciążone
Przeciążanie funkcji pozwala zdefiniować w programie rodzinę funkcji
o tej samej nazwie, lecz różniących się parametrami (liczbą i /lub typem
parametrów).
Funkcje przeciążone nie muszą zwracać wartości tego samego typu,
ale dwie funkcje nie mogą się różnić jedynie typem zwracanego wyniku.
Wybór funkcji z rodziny funkcji przeciążonych jest dokonywany na podstawie
analizy parametrów wywołania. Poszukiwana jest funkcja przeciążona o typach
i liczbie parametrów zgodnych z wywołaniem. Jeżeli funkcja taka nie zostanie
znaleziona, to dokonywane są standardowe konwersje typów i poszukiwanie
jest kontynuowane.
Funkcje przeciążone c.d.
Przykład
void pisz(int a, int b)
{ printf("\n%5d %5d", a, b); }
void pisz(float a, float b)
{ printf("\n%5.2f %5.2f", a, b); }
void pisz(char a)
{ printf("\n%c", a); }
double potega(double podst, double wyk)
{ return (podst > 0) ? exp(wyk*log(podst)) : -1E+20; }
long potega (int podst, int wyk)
{ long w=1;
if (podst>0 && wyk>0) for (int i = 1; i <= wyk; i++) w = w * podst;
else w = -1;
return w;
}
void main(void)
{ int a = 5; int b = 10;
float x = 1.2f; float y = 20.0f;
char z = 'A';
pisz(a,b); pisz(x,y); pisz(z);
cout << potega(2.0,0.5) << endl; // 1.414214
cout << potega(2,3) << endl; // 8
}
Funkcje o zmiennej liczbie parametrów
Składnia:
nazwa_funkcji (parametry_ustalone, ... );
Dostęp do parametrów nieustalonych jest realizowany następująco:
1. deklaracja zmiennej, np. pocz typu va_list (va_list pocz);
zmienna wspomnianego typu zawierać będzie adres początku listy zmiennych
parametrów;
2. wywołanie makrorozkazu va_start(pocz, c), gdzie c oznacza nazwę
ostatniego ustalonego parametru;
3. pobranie argumentu za pomocą makrorozkazu va_arg,
np. zmienna = va_arg(pocz, typ_arg); przyjmuje się, że argument jest typu
typ_arg; kolejne wywołania makrorozkazu będą powodowały pobieranie
kolejnych parametrów funkcji;
4. wywołanie makrorozkazu va_end(pocz); rozkaz powinien być wywoływany
tylko po przeczytaniu wszystkich argumentów;
jego wywołanie pozwoli na normalne zakończenie funkcji.
Uwaga! Korzystanie z makrorozkazów va_start, va_arg i innych wymaga
dołączenia pliku nagłówkowego stdarg.h.
Funkcje o zmiennej liczbie parametrów c.d.
Przykład 1.
double obl_wiel(double x, int n, ...)
// obliczanie wartosci wielomianu stopnia n
{ double sum = 0.0; double wsp;
va_list pocz; // początek obszaru zmiennych argumentów
va_start(pocz,n); // adres ostatniego ustalonego argumentu
while (n)
{ wsp = va_arg(pocz, double);
sum += wsp * pow(x,n); // a * x^n
n--;
}
sum += va_arg(pocz, double); // sum = sum + a0
va_end(pocz);
return sum;
}
Funkcje o zmiennej liczbie parametrów c.d.
Przykład 2.
float srednia(int n, ...)
{
int k = n;
float sum = 0.0f;
va_list pocz; // początek obszaru zmiennych argumentów
va_start(pocz,n); // adres ostatniego ustalonego argumentu
while (k--) sum += va_arg(pocz, int);
va_end(pocz);
return sum;
}
Parametry funkcji main
W języku C istnieje możliwość przekazywania argumentów do uruchamianego
programu za pomocą wiersza poleceń.
Przekazywane argumenty są kojarzone z parametrami wywołania funkcji main:
void main(int argc, char *argv[])
- argc  liczba argumentów wywołania funkcji zwiększona o 1
(argumenty + argument uwzględniający nazwę programu);
-argv[ ]  tablica wskaz
ników do tekstów opisujących argumenty;
przyjmuje się, że argv[0] jest wskaz
nikiem (adresem) do tekstu opisującego
pełną nazwę programu (uwzględniającą ścieżkę dostępu); natomiast argv[1],
..., argv[argc-1] są wskaz
nikami do tekstów odpowiadających
argumentom wywołania funkcji;
Np. wywołanie programu lista.exe 1 2 3, znajdującego się na dysku C:,
spowoduje następujące skojarzenia argumentów z parametrami funkcji main:
argc = 4,
argv[0]  wskaz
nik na  C:\\lista.exe ,
argv[1]  wskaz
nik na  1 ,
argv[2]  wskaz
nik na  2 ,
argv[3]  wskaz
nik na  3 .
Parametry funkcji main - przykład
int main(int argc, char *argv[])
{
double pom = 0, suma = 0; int i = 0;
clrscr();
if (argc < 2) {
printf("Wywołanie programu: %s argumenty oddzielone spacja\n", argv[0]);
exit(0); // argv[0]  nazwa programu
}
if (argc > 1)
{ printf("Ścieżka programu: %s\n", argv[0]);
printf("Nazwa właściwa programu: %s\n", strrchr(argv[0],'\\')+1 );
printf("Liczba argumentów programu: %d\n", argc-1);
for (i=1; i < argc; i++) {
printf("Arg. %d = %9s Liczba zn. %d\n", i, argv[i],strlen(argv[i]));
pom = atof(argv[i]); // konwersja łańcucha do liczby double
if (pom != HUGE_VAL) suma+=pom; // spraw. czy konwersja jest
// prawidłowa?
else exit(1); }
}
printf("Suma argumentów = %lg\n", suma);
getch(); return 0;
}
Rekurencja
Rekurencja  wywoływanie funkcji przez samą siebie.
Przykłady:
unsigned int silnia(unsigned int n){
Obliczanie silni:
unsigned int wynik;
Def. silni
if(n) wynik=n*silnia(n-1);
jeśli n=0 to silnia=1
else wynik=1;
jeśli n>0 silnia=n*silnia(n-1)
return wynik;
}
unsigned int Fibb(unsigned int n){
Obliczanie wyrazów ciągu
unsigned int wynik;
Fibbonaciego:
if(n==0) wynik=0;
Def.
else if(n==1) wynik=1;
F0=0
else wynik=Fibb(n-2)+Fibb(n-1);
return wynik;
F1=1
}
Fn=Fn-2+Fn-1
Przekazywanie tablicy do funkcji
Przekazywanie tablicy do funkcji  przesyłany jest tylko adres początku tablicy.
void funkcja(int tab[]);
.....
//fragment programu
int t[]={1,4,-2};
funkcja(t); //wywołanie funkcji
Uwaga!!!
Nazwa tablicy jest jednocześnie adresem zerowego elementu tej tablicy.
t+2 jest w pamięci adresem elementu o indeksie 2, czyli jest równoważne
zapisowi
&t[2]
Znak & (ampersand)  to jednoargumentowy operator do uzyskania adresu
obiektu.
Wartość elementu o adresie &t[2] to t[2]
" Wskaz
niki  przypomnienie i ważne:
Wskaz
niki do funkcji !!! Ułatwiają życie &
Wskaz
niki w argumentach funkcji
float pole(float r);
Przesyłanie argumentów przez wartość
void main() {
...
cout << pole(7.3) << endl;
}
float pole(float r) {
return 3.14159 * r * r;
}
float pole(float *r);
Przesyłanie argumentów
void main(){
przez wskaz
nik.
float rr=1;
Zmiana wewnątrz funkcji
cout<wartości przesyłanego
cout<argumentu.
}
float pole(float *r) {
float wynik;
wynik= 3.14159f * *r * *r;
*r=0.5f* *r;
return wynik;
}
#include
void f1(int *pi, int rozm); Przesyłanie tablic
void f2(int *pi, int rozm);
do funkcji
void f3(int t[], int rozm);
void main(){
int tab[5]={1,2,3,4,5};
f1(tab,5);
Funkcje są wywoływane przez podanie
f2(tab,5);
nazwy tablicy
f3(tab,5);
}
void f1(int *pi, int rozm){ Przesłany adres tablicy inicjalizuje
cout<<"\nfunkcja f1\t";
lokalny wskaz
nik pi. Wewnątrz funkcji
for(int i=0;i- zapis wskaz
nikowy
cout<<*(pi++)<<'\t';
}
void f2(int *pi, int rozm){
Przesłany adres tablicy inicjalizuje
cout<<"\nfunkcja f2\t";
lokalny wskaz
nik pi. Wewnątrz funkcji
for(int i=0;i- zapis tablicowy
cout<}
void f3(int t[], int rozm){ Przesłany adres tablicy odebrany
cout<<"\nfunkcja f3\t";
jako tablica
for(int i=0;icout<}
Przesyłanie tablic do funkcji  cd
" Odebranie tablicy jako tablicy  czytelność funkcji
" Odebranie tablicy jako adresu inicjującego wskaz
nik  funkcja działa szybciej
" Odebranie tablicy jako adresu  łatwiejsze przekazywanie tablic
wielowymiarowych (rozmiary tablicy nie muszą być znane w momencie
wywołania funkcji)
Segment i offset wskaz
nika
Odczytanie wartości segmentu i offsetu wskaz
nika umożliwiają makra:
unsigned FP_SEG(void far *wsk); // segment wskaz
nika
unsigned FP_OFF(void far *wsk); // offset wskaz
nika
Utworzenie wskaz
nika o określonym segmencie i offsecie umożliwia makro:
void far *MK_FP(unsigned segment, unsigned offset).
Np.
void far *d = MK_FP(0xB800, 0x0000);
unsigned s = FP_SEG(d); // s = 0xB800;
unsigned o = FP_OFF(d); // o = 0x0000;
Uwaga! Aby użyć powyższych makr trzeba dołączyć plik nagłówkowy dos.h.
Wskaz
niki do stałych
Wskaz
niki do stałych mogą zawierać adresy dowolnych zmiennych i mogą być
modyfikowane w programie, ale nie można za ich pomocą modyfikować
zmiennych wskazywanych.
const int stala = 10; // definicja stałej typu int
const int *wsk_st; // wskaz
nik do stałej typu int
void main() {
int i = 5;
const int *w = &i; // wskaz
nik zainicjowany
wsk_st = &i; // inicjacja adresem zmiennej automatycznej i
cout << *wsk_st << endl; // 5
cout << *w << endl; // 5
// *w = *w + 5; // błąd kompilatora !
// *wsk_st+= 7; // nie można modyfikować stałej
wsk_st = &stala; // wskaz
nik inicjowany adresem stałej
w = &stala; // wskaz
nik inicjowany adresem stałej
cout << *wsk_st << endl; // 10
cout << *w << endl; // 10
}
Stałe wskaz
niki
Stały wskaz
nik to wskaz
nik, który zawsze pokazuje na to samo. Wskaz
nik tego
typu musi być zainicjowany w miejscu definicji - tak jak każda stała.
W programie nie można już modyfikować jego wartości.
Za pomocą wskaz
nika stałego można jednak modyfikować zawartość zmiennej
wskazywanej, ale tylko tej, której adresem wskaz
nik został zainicjowany.
const int st = 4; // stała
int zm = 10; // definicja zmiennej
int * const w = &zm; // stały wskaz
nik do zmiennej zm
// int * const x = &st; // błąd  wskaz
nik musi wskazywać na stałą
const * const x = &st; // dobrze - stały wskaz
nik do stałej
int i = 7;
int * const wi = &i; // stały wskaz
nik do zmiennej lokalnej i
int * const pz = &zm; // stały wskaz
nik do zmiennej zm
cout << *wi << endl; // i=7 = i
cout << *pz << *w << endl; // 10 i 10; zm=10
*wi +=8; // i = 7 + 8 = 15
cout << i << endl; // i =15
// wi = &zm; // błąd  nie wolno zmieniać stałej wi
*pz += 2; // zm = 10 + 2
cout << zm << endl; // zm = 12
Tablice wskaz
ników
typ_wskazywany *tablica[rozmiar];
//typ_wskazywany *(tablica[rozmiar]); zapis równoważny
double *tablica[10];
Jak przydzielić pamięć dla tablicy dwuwymiarowej?
Wskaz
niki do funkcji
typ_zwracany (*wsk_do_funkcji)([argumenty_funkcji]);
#include
void f1();
void f2();
void blad();
void main(){
void (*pf)()=blad;
int i;
cin>>i;
if(i==1) pf=f1;
else if(i==2) pf=f2;
(*pf)();
}
void f1(){
cout<<"funkcja f1\n";
}
void f2(){
cout<<"funkcja f2\n";
}
void blad(){
cout<<"blad\n";
}
Wskaz
niki do funkcji  cd
Nazwa funkcji jest adresem jej początku (adresem miejsca w pamięci, gdzie
zaczyna się kod tej funkcji).
Zastosowanie wskaz
ników do funkcji:
" Przesyłanie argumentów do funkcji. Adres funkcji można wysłać jako
argument.
" Tworzenie tablic ze wskaz
ników do funkcji.
#include
void f1();
void f2();
void blad();
void funkcja(int i, void (*pf)());
Przesyłanie argumentów do funkcji
void main(){
void (*pf)()=NULL;
int i;
cin>>i;
funkcja(i,pf);
}
void funkcja(int i, void (*pf)()){
pf=blad;
if(i==1) pf=f1;
else if(i==2) pf=f2;
(*pf)();
}
void f1(){
cout<<"funkcja f1\n";
}
void f2(){
cout<<"funkcja f2\n";
}
void blad(){
cout<<"blad\n";
}
#include
void f1();
void f2();
void blad();
void main(){
void (*pt[3])()={f1,f2,blad};
Tablica wskaz
ników do funkcji
for(int i=0;i<3;i++)
(*pt[i])();
}
void f1(){
cout<<"funkcja f1\n";
}
void f2(){
cout<<"funkcja f2\n";
}
void blad(){
cout<<"blad\n";
}