funkcje i procedury

Deklaracja funkcji :
typ nazwa(lista parametrów formalnych);
zawiera wyłącznie nagłówek funkcji, czyli pierwszy wiersz jej definicji.
Definicja funkcji ma składnię:
typ nazwa (lista parametrów formalnych)
{
//polecenia zawarte w funkcji
}
Typ określa jakiego typu wartość przyjmuje funkcja nazwa. Jeżeli tu podamy określenie void,
funkcji nie jest przypisywana wartość. Gdy wpiszemy nazwę konkretnego typu, wówczas funkcji
nadawana jest wartość. Przypisanie wartości funkcji wykonuje się poleceniem return wewnątrz
funkcji.
PRZYKŁAD 1:
int funkcja(void)
{
int a=2, b=5;
funkcja oblicza sumę zmiennych a i b, ponadto
wartością funkcji jest wyznaczona suma a+b
return a+b;
}
PRZYKŁAD 2:
void funkcja (void)
{
int a=2, b=5;
cout<<a+b<<endl;
Tu nie pojawia się polecenie nadania jej wartości
return. Typ funkcji to void.
Wynika stąd ze:
- funkcji nie jest nadawana wartość
- Wyznaczona suma a i b wypisywana jest
bezpośrednio na ekran
}
Uruchomienie funkcji w programie wykonujemy następująco:
nazwa (lista parametrów aktualnych);
Jeżeli funkcja jest typu void, wywołujemy ją samodzielnie, nie wiążąc z żadnym wyrażeniem.
Jeśli funkcji przypisano wartość, to przeważnie obliczoną wartość przekazujemy do wyrażenia
(przypisać konkretnej zmiennej lub wykorzystać w wyrażeniu).
Parametry formalne to argumenty, które wprowadzamy do funkcji z zewnątrz. Lista parametrów
zawiera określenie ich typów i liczby. Z parametrami formalnymi mamy do czynienia w
momencie deklarowania (definiowania) funkcji. Gdy już przechodzimy do jej uruchomienia, w
miejsce parametrów formalnych wstawiane są parametry aktualne, czyli konkretne zmienne lub
wartości wpisywane w miejsce parametrów formalnych.
Należy zachować zgodność typów i liczby parametrów. Jeśli w miejsce parametrów formalnych
wpiszemy słowo void, wówczas funkcja nie posiada parametrów i jest uruchamiana z pustym
nawiasem.
PRZYKŁAD:
#include <iostream>
using namespace std;
void funkcja1(void)
{
cout<”uruchomienie funkcji1”<<endl;
}
void funkcja2 (int a, int b)
{
cout<<”uruchomienie funkcji2:”<<endl;
cout<<a+b<<endl;
}
int funkcja3(int a, int b)
{
return a+b;
}
main()
{
int x=2, int y=8, z;
funkcja1();
funkcja2(x,y);
cout<<”uruchomienie funkcji3”<<endl;
z=funkcja3(x,y);
cout<<”suma= „<<z<<endl;
}
----------------------------------------------------------------------------------------------------------------------------
Zmienne lokalne i globalne
Zakresem działania zmiennej jest blok w którym została dana zmienna zadeklarowana.
Jeśli zmienna zostanie zadeklarowana we wnętrzu funkcji lub instrukcji, to nazywamy ją
zmienną lokalną.
Zmienna zadeklarowana w funkcji dostępna jest od momentu jej zadeklarowania do
zakończenia działania funkcji.
Zmienna zadeklarowana w instrukcji jest lokalna względem tej instrukcji.
Zmienna globalna deklarowana jest w części deklaracyjnej programu i można się do niej
odwoływać w dowolnym miejscu programu. Jest o niebezpieczne ponieważ wartość takiej
zmiennej może być zmienina przez jedną z funkcji w sposób niewidoczny dla innej funkcji.
PRZYKŁAD:
# include <iostream>
Rusing namespace std;
int a=5;
int oblicz(void)
{ int b=4;
return a*b;
}
Zmienna b jest lokalna – dostępna tylko w ………..
Zmienna c jest lokalna dostępna tylko w ………….
zmienna a jest ……………. dostępna
………………………………………………..
main()
{
int c;;
c=oblicz();
cout<<c<<endl;
return 0;
}
Przekazywanie parametrów w funkcjach
1. Przez wartość
stosowana jest wówczas, gdy nie chcemy, aby wartość parametrów aktualnych była
zmieniana wewnątrz funkcji lub gdy w miejsce parametrów chcemy wpisać wartości liczbowe.
Podczas wywołania funkcji tworzona jest pomocnicza zmienna lokalna o tej samej
nazwie co parametr formalny i o wartości równej parametrowi aktualnemu, z której korzysta
program.
Po zakończeniu funkcji zmienna pomocnicza jest kasowana, działania wykonane na niej
nie są widoczne poza funkcją.
PRZYKŁAD:
funkcja:
void funkcja(int n)
{
n-n+2;
cout<<”wewnątrz funkcji
n=”<<n<<endl;
}
uruchomienie funkcji:
int a=5;
funkcja(a);
cout<<” na zewnątrz funkcji: „<<a<<endl;
Tablica jednowymiarowa
Elementy tablicy numerowane są od 0.
Deklaracja tablicy:
typ identyfikator [rozmiar]
np. t[5];
do elementów odwołujemy się przez indeksy: t[0], t[1], .., t[?];
deklarując tablicę t[rozmiar] nie możemy odwoływac się do elementu t[rozmiar]. Indeksy tej
tablicy zawierają się w zakresie […;… .] .
Nadanie tablicy wartości początkowej umożliwia inicjalizacja tablicy, która ma postać:
typ identyfikator [rozmiar]={lista wartości};
Nazwa tablicy jest adresem elementu tablicy o numerze 0. Wynika stąd , że zapisy *t i t[0] są
równoważne. Nastepne elementy tablicy można wskazywać, dodając numer elementu do
wskaźnika wyrazu początkowego.
np. mamy zadeklarowaną tablicę int t[4], wówcza elementy tablicy mają następujące
identyfikatory:
t[0] lub *t
t[1] lub *(t+1)
t[2] lub *(t+1)
t[3] lub *(t+2)
t[4] lub *(t+3)
Jeżeli chcemy przekazać tablicę jako parametr do funkcji, musimy pamiętać ze do funkcji
przekazywany jest tylko adres początkowy tablicy
np. deklaracja funkcji ma postać:
void funkcja (double t[]);
void funkcja(double *t);
PRZYKŁAD:
#include <iostream>
#include <iomanip>
using namespace std;
const int max=25;
void wczytaj (int *t, int n)
{
cout<<”podaj elementy tablicy: ‘<,endl;
for (int i=0; i<n; i++)
{
cout<,”t[“<<i<<] = “;
cin>.t[i] ;
cout<<endl;
}
}
void wypisz (int t[]. int n)
{
cout<<”wczytana tablica: „<<endl;
for (int i=0; i<n; i++)
cout<<setw(7)<<t[i] ;
//setw(7) – wyznacza szerokość pola równą n znaków
cout<<endl;
}
void wypiszodwrotnie (int t[], int n)
{
cout<<”\nwczytana tablica odwrotnie: “<<endl;
for (int i-n; i>=0; i--) cout<<setw(7)<<t[i];
cout<<endl;
}
main()
{
int t[max];
wczytaj (t,8);
wypisz (t,8);
wypiszodwrotnie (t,8);
return 0;
}