Procedury i funkcje
Informatyka » zakres rozszerzony » Procedury i funkcje
Modele programowania
Programowanie liniowe - program jest ciągiem instrukcji języka programowania. Nie ma instrukcji warunkowych i nie wyodrębnia się podprogramów.
Programowanie strukturalne - program ma odpowiednią strukturę, można wyodrębnić deklaracje (modułów, zmiennych i stałych), definicję podprogramów oraz bloki instrukcji, w tym sterujące wykonaniem programu (warunkowe, iteracyjne). Każda zmienna ma swój ściśle określony typ.
Programowanie modularne - jest to rozszerzenie podejścia proceduralnego, w którym powtarzające się w programie ciągi instrukcji zapisuje się w postaci procedur i funkcji, nadających się do wielokrotnego wykorzystania. Procedury i funkcje zebrane są w modułach, które zapisane są pod unikatową nazwą i mogą być wykorzystane w wielu programach.
Programowanie obiektowe - program jest definiowany jako zbiór obiektów, które posiadają określone właściwości (związane z obiektem dane) i metody (operacje, jakie można na obiekcie wykonać)
Programowanie zdarzeniowe - podobnie jak w programowaniu obiektowym, program to zbiór obiektów, jednak kolejność wykonywania instrukcji programu zależy od zaistnienia określonych zdarzeń (naciśnięcie przycisku, wprowadzenie danej, upływ czasu.
Metody programowania
Programowanie zstępujące - "z góry do dołu" polegające na zdefiniowaniu problemu ogólnego i podzielenie go na podproblemy, które są dzielone na jeszcze mniejsze podproblemy łatwe do rozwiązania.
Programowania wstępujące - "z dołu do góry" polega na rozwiązaniu elementarnych problemów, które składa się w całość prowadzą do rozwiązania problemu.
Podprogram - jest to wyodrębniony fragment programu, realizujący określone zadania, który może być wielokrotnie wykorzystywany w programie.
Zalety stosowania podprogramów:
- dzielenie zadania na mniejsze części
- zwiększenie czytelności i przejrzystości programu
- skrócenie programu - fragmenty programu które się powtarzają, są wyodrębnione w postaci podprogramów
- łatwiejsze wyszukiwanie błędów
- łatwiejsze poprawianie programu
- możliwość programowania zespołowego
Funkcje w języku C++
W języku C++ wszystkie podprogramy nazywane są funkcjami. Dzielimy je na:
- funkcje niezwracające wartości (odpowiednik procedury w niektórych językach np: Pascal)
- funkcje zwracające wartość (odpowiednik funkcji w niektórych językach np: Pascal)
Aby zastosować w programie własną funkcję, trzeba ją zdefiniować, a następnie wywołać.
Ogólna postać funkcji w języku C++
opis_typu nazwa_funkcji (lista parametrów formalnych)
{
instrukcje;
return zwracana_wartość;
}
Funkcje niezwracające wartości
Są to funkcje typu void. W swojej budowie nie zawierają słowa return.
void nazwa_funkcji (lista parametrów formalnych)
{
instrukcje;
}
Przykład funkcji niezwracającej wartości (typu void)
void powitanie()
{
cout << "Witaj świecie" << endl;
}
Wywołanie funkcji niezwracającej wartości
Aby wywołać taką funkcję, należy wpisać jej nazwę w odpowiednim miejscu w programie (np. funkcji głównej main). W przypadku funkcji z parametrami dodatkowo należy podać parametry aktualne.
nazwa_funkcji
nazwa_funkcji(lista parametrów aktualnych)
Przykładowy program z funkcją nie zwracającą wartości
#include < iostream >
#include < cstdlib >
using namespace std;
//== Funkcja powitanie ==
void powitanie()
{
cout << "Witaj świecie" << endl;
}
//================
int main(int argc, char** argv) {
//== wywołanie funkcji powitanie ==
powitanie();
return 0;
}
Funkcje zwracające wartość
Są to funkcje, które w swojej budowie zawierają słowo return.
opis_typu nazwa_funkcji (lista parametrów formalnych)
{
instrukcje;
return zwracana_wartość;
}
Przykład funkcji zwracającej wartość
int suma(int a, int b)
{
int c;
c = a+b;
return c;
}
Wywołanie funkcji zwracającej wartość
Aby użyć takiej funkcji można:
1) wywołać ją umieszczając jej wynik w zmiennej
zmienna = nazwa_funkcji(lista parametrów)
2) wykorzystać jako element wyrażenia lub instrukcji
cout << nazwa_funkcji(lista parametrów)
Przykład programu z funkcją zwracającą wartość
#include < iostream >
#include < cstdlib >
using namespace std;
//== Funkcja suma ==
int suma(int a, int b)
{
int c;
c = a+b;
return c;
}
//================
int main(int argc, char** argv) {
//== użycie funkcji suma ==
cout << "Suma liczb 2 i 3 wynosi: "<< suma(2,3) << endl;
return 0;
}
Zadanie 1.
Napisz program z funkcją wyliczającą pole prostokąta.
Zadanie 2.
Napisz funkcję, która wyświetli na ekranie monitora prostokąt o bokach 10 na 5, narysowanego za pomocą znaków "*". Wnętrze prostokąta powino być wypełnione znakami "*".Wykorzystaj w programie instrukcje iteracyjne.
**********
**********
**********
**********
**********
Zadanie 3.
Napisz funkcję, która wyprowadzi na ekran monitora prostokąt narysowany za pomocą znaków "*" o wielkości x, y podanej przez użytkownika. Zmienne powinny być przekazane do funkcji w postacji parametrów.
x
**********
**********
********** y
**********
**********
Zadanie 4.
Napisz funkcję, która wyprowadzi na ekran monitora trójkąt narysowany za pomocą znaków "*" według przykładu:
*
***
*****
Zadanie 5.
Napisz program, z użyciem funkcji z zadania 4, który wyprowadzi na ekran monitora figurę według przykładu:
*
***
*****
*
***
*****
*
***
*****
Zadanie 6.
Napisz funkcję, która wyprowadzi na ekran monitora trójkąt który ma n poziomów w pionie. Zmienna n powinna być przekazana do funkcji jako parametr.
*
*** n
*****
Zadanie 7.
Napisz program, z użyciem funkcji z zadania 6, który wyprowadzi na ekran monitora figurę według przykładu:
*
***
*****
*
***
*****
*******
*
***
*****
*******
*********
Zasięg zmiennej
Zasięg zmiennej określa zakres widoczności nazwy zmiennej w obrębie programu.
Ze względu na zasięg zmiennej rozróżniamy:
- zmienne globalne
- zmienne lokalne
Zmienne globalne
Zmienne globalne deklarujemy poza funkcjami i są one widoczne w całym programie
Zmienne lokalne
Zmienne lokalne so to zmienne deklarowane wewnątrz funkcji i widoczne są od miejsca deklaracji do końca funkcji. W języku C++ zmienne lokalne mogą być także widoczne tylko w obrębie jednego bloku instrukcji { }.
Zmienne globalne mogą zostać przesłonięte.
Jeżeli w funkcji zostanie zdeklarowana zmienna o takiej samej nazwie jak zmienna globalna to spowoduje to przesłonięcie zmiennej globalnej, tzn. że używana będzie zmienna lokalna a nie globalna.
Zadanie 8.
Przeanalizuj działanie programu:
#include < iostream >
#include < cstdlib >
using namespace std;
int i = 20;
void powitanie()
{
int i = 10;
cout << "Wartość zmiennej lokalnej i = " << i<< endl;
}
//================
int main(int argc, char** argv) {
powitanie();
cout << "Wartość zmiennej globalnej i = " << i<< endl;
return 0;
}
Zadanie 9.
Napisz program zawierający deklarację zmiennej globalnej i lokalnej.
Zadanie 10.
Napisz program zawierający przesłonięcie zmiennej globalnej.
Sposoby przekazywania parametrów
Parametry w procedurach i funkcjach mogą być przekazywane:
- przez wartość
- przez zmienną (referencję)
Przekazywanie parametrów przez wartość
Parametry przekazywane przez wartość są traktowane jak zmienne lokalne i operacje wykonane na tych parametrach nie powodują zmian wartości parametrów przekazanych do podprogramu.
Deklaracja funkcji z przekazywaniem parametrów przez wartość
opis_typu_funkcji nazwa_funkcji (nazwa_typu parametr)
Przekazywanie parametrów przez zmienną (referencję)
Parametry aktualne przekazane przez zmienną (referencję) w momencie użycia odpowiadających im parametrów formalnych ulegają zmianie.
Deklaracja funkcji z przekazywaniem parametrów przez zmienną (referencję)
W deklaracji funkcji przed nazwa parametru należy użyć znaku &
opis_typu_funkcji nazwa_funkcji (nazwa_typu ¶metr)
Zadanie 11.
Przeanalizuj działanie programu:
#include < iostream >
#include < cstdlib >
using namespace std;
void powitanie( int x )
{
x = 10;
}
//================
int main(int argc, char** argv) {
int y=5;
powitanie(y);
cout << "Wartość zmiennej y = " << y << endl;
return 0;
}
Zadanie 12.
Przeanalizuj działanie programu:
#include < iostream >
#include < cstdlib >
using namespace std;
void powitanie( int &x )
{
x = 10;
}
//================
int main(int argc, char** argv) {
int y=5;
powitanie(y);
cout << "Wartość zmiennej y = " << y << endl;
return 0;
}
Zadanie 13.
Przeanalizuj działanie programu:
#include < iostream >
#include < cstdlib >
using namespace std;
void pole_prostokata( int a, int b, int &p )
{
p = a * b;
}
//================
int main(int argc, char** argv) {
int x = 3;
int y = 5;
int z;
pole_prostokata(x, y, z);
cout << "Pole prostokąta wynosi: " << z << endl;
return 0;
}