Sposoby przekazywania parametrów

Parametry formalne przekazywane przez wartości  w treści danej procedury lub funkcji są  traktowane jak zmienne lokalne. Ewentualne procesy wykonywane na tych parametrach wewnątrz procedury lub funkcji nie powodują zmian wartości odpowiadających im parametrów aktualnych.


1. PRZEKAZYWANIE PARAMETRÓW PRZEZ WARTOŚĆ 

Najpopularniejszą metodą budowania funkcji jest przekazywanie argumentów przez wartość. Funkcja musi zawierać argumenty wraz z ich typami, oddzielone przecinkami. Kiedy przekazujemy do funkcji jakąś zmienną, zostaje utworzona w pamięci jej kopia. Wszystko co dzieje się wewnątrz funkcji odbywa się tak naprawdę na kopii zmiennej przekazanej w argumencie poprzez wartość.
W takim wypadku konieczne staje się zwrócenie odpowiedniej wartości za pomocą return i przypisanie zwróconej wartości do odpowiednich zmiennych. Jeżeli funkcja nie zwróci żadnej wartości, wtedy jej wywołanie może stać się bezcelowe. Utworzona kopia zmiennej, nawet jeżeli zostanie zmodyfikowana, zostanie usunięta z pamięci po zakończeniu funkcji.

Przykład:
#include <iostream>
using namespace std;
int a,b;
void Wartosci (int x, int y)

{ 

x=x+10;

y=y-10;

cout << "x=" << x << endl;

cout << "y=" << y<< endl;

}

int main()

{

cin >> a >> b;

Wartosci(a,b);

cout << a=" << a << endl;

cout << "b=" << b << endl;

return 0;

}

2. PRZEKAZYWANIE PARAMETRÓW PRZEZ ZMIENNĄ - PRZEZ REFERENCJĘ 

W procedurze lub funkcji, w której parametry przekazywane są przez zmienną (przez referencję), operacje wykonywane w tej treści procedury na parametrach formalnych w momencie wywołania danej procedury powodują wykonanie tych operacji na odpowiednich parametrach aktualnych. 

Przykład: 

#include <iostream>
#include <cstdlib>
using namespace std;
void zwieksz_kilka(int *dl, int *wys, int *waga)
{
*dl = *dl * 2;
*wys = *wys * 2;
*waga = *waga * 2;
}
int main()
{

int dlugosc = 125;
int wysokosc = 300;
int waga = 20;

int *wsk_dlugosc = &dlugosc;
int *wsk_wysokosc = &wysokosc;
int *wsk_waga = &waga;
zwieksz_kilka(wsk_dlugosc, wsk_wysokosc, wsk_waga);
cout << dlugosc << endl;
cout << wysokosc << endl;
cout << waga << endl;
system("pause >nul");
return 0;
}

Zasięg zmiennej

1. Ze względu na zasięg zmiennej  rozróżniamy zmienne globalne i lokalne. Jeżeli zmienna zadeklarowana jest w ciele klasy, na przykład formatki, to podział ten przechodzi na prywatny i publiczny.
Zmienna lokalna dostępna jest w czasie wykonywania tego fragmentu kodu, do którego jest przypisana. W naszym przypadku będzie, to występować w ciele funkcji zdarzeń używanych komponentów. Zmienna globalna, ma zasięg w całym kodzie programu.

2. ZMIENNA GLOBALNA  I JEJ STOSOWANIE

Zaletą zmiennych globalnych jest to, że są one widoczne w całym programie. Nie miało to dużego znaczenia w przypadku naszych dotychczasowych programach, jednak nabierze bardzo dużego znaczenia, kiedy przedstawię Ci pojęcie funkcji w C++.

Zmienne globalne deklaruje się (i ewentualnie inicjalizuje) pomiędzy blokiem dołączonych plików nagłówkowych a funkcją main. Ponieważ są to zwykłe zmienne (mają tylko dodatkowe właściwości), to deklaracja, inicjalizacja oraz posługiwanie się tymi zmiennymi wygląda dokładnie tak samo, jak to robiliśmy w dotychczasowych programach.

Ponieważ zmienne globalne są widoczne w całym programie, zatem są również widoczne wewnątrz funkcji main. Oznacza to, że wewnątrz funkcji main (oraz wszystkich innych funkcji), możemy dokonywać wszystkich operacji jakie są tylko możliwe dla zmiennej danego typu.

Przykład programu: 

 #include <iostream> 

using namespace std;

int i;

void Usmiechy()

{

int i;

for (i=0; n i++) cout << ":-)";

}

int main()

{

i=10;

Usmiechy();

cout << i;

return 0;

}

3. ZMIENNA  LOKALNA I JEJ ZASTOSOWANIE
Nazwy zmiennych globalnych muszą być między sobą różne. Nie jest możliwe utworzenie zmiennych globalnych o tej samej nazwie. Sprawia to, że w przypadku dużej liczby zmiennych, należy tworzyć coraz dłuższe nazwy zmiennych, których zapamiętanie staje się coraz bardziej uciążliwe.
Poza tym, ponieważ zmienne globalne są dostępne wszędzie, można je zatem w dowolnym miejscu zmienić. Oczywiście może to stanowić zaletę, jednak w większych programach jest tak naprawdę wadą. Nasza zmienna może bowiem zostać zmieniona w dowolnym miejscu programu, często przez przypadek.
Nawet jeśli program piszemy sami, możemy się łatwo zapomnieć lub pomylić, a co dopiero gdy program pisze kilku programistów. Wówczas prawdopodobieństwo przypadkowej i niechcianej zmiany wartości zmiennej globalnej jest bardzo duże, a znalezienie takiego błędu w programie, który liczy kilka lub kilkanaście tysięcy linii, może zająć zbyt dużo cennego czasu.
Ostatnią ważną kwestią jest to, że ponieważ zmienne globalne istnieją przez cały czas działania programu, to przez cały czas zajmują miejsce w pamięci operacyjnej. W przypadku dużej liczby zmiennych lub bardzo rozbudowanych programów, nie można oczywiście dopuszczać do przechowywania wszystkich zmiennych przez cały czas działania programu w pamięci, dlatego też należy szukać innych rozwiązań.
W tym momencie dobrze by było, gdyby udało Ci się zapamiętać - zmienne globalne mają zaletę, bo są wszędzie dostępne, ale przez to ich używanie jest bardzo ryzykowne, gdyż wszędzie może nastąpić zmiana ich wartości. Mamy zatem połączenie teoretycznej wygody z dużym niebezpieczeństwem.
Wierzę, że w ten oto sposób zachęciłem Cię do przeczytania dalszej części lekcji i zapoznania się ze zmiennymi lokalnymi, które są znacznie wygodniejsze w użyciu.

Nawiasy klamrowe wyznaczają zasięg lokalny.

  Przykłąd programu:
#include <iostream> 

using namespace std;

int k, i;

void Usmiechy()
{
int k;
cin >> k;
if (k>0) for (i=0; i<20; i++) cout << ":-)";
else for (i=0; i<20; i++) cout << ":-(";
}

int main()

{

i=10;

Usmiechy();

cout << i;

return 0;

}

Funkcje niezwracające wartości w języku C++

1. Aby w jezyku C++ wywołać funkcję niezwracającą wartości (typu void) , należy wpisać jej nazwę w odpowiednim miejscu funkcji głównej - main - a w przypadku funkcji a parametrami - dodatkowo podać parametry aktualne.


2. Wywoływanie funkcji ma postać:
nazwa_funkcji (lista parametrów aktualnych);

3. Przykład takiego programu:
#include <iostream>
using nameapace std;
int i;
void Usmiechy()
{
for (i=0; i<20; i++)
cout << ":-)";
}
int main ()
{
cout << "usmiechnij sie: " << endl;
Usmiechy();
return 0;
}


4. Stosowanie takiej funkcji z parametrem:
#include <iostream>
using nameapace std;
int i;
void Usmiechy(int n)
{
for (i=0; i<n; i++)
cout << ":-)";
}
int main ()
{
cout << "podaj liczbe usmiechow: ";
cin >> m;
cout << "usmiechnij sie: " << endl;
Usmiechy(m);
return 0;
}

Funkcje zwracające wartość w języku C++

1. Każda funkcja posiada trzy własności:

- zwraca dane (lub nie jeśli tego nie chcemy);
 - posiada swoją nazwę;
- może posiadać dowolną liczbę argumentów wejściowych (lub może nie mieć żadnego, jeśli tego nie chcemy).

2. Funkcja zwracająca wartość - wylicza wartość i odsyła tę wartość do funkcji wywołującej. Mówimy, że funkcja zwraca 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ść;
}

3. 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)

4. Przykłady programu: 

#include <iostream>

using namespace std;

int x, y;

int SumaKwadratow (int a, int b)

{ 

return a*a+b*b;

}

int main()

{ 

cout << "wprowadz skladniki" << endl;

cin >> x >> y;

cout << SumaKwadratow(x,y);

return 0;

}

____________________________________

#include <iostream> 

using namespacd std;

int x,y;

int SumaKwadrat ()

{

return x*x+y*y 

} 

int main ()

{ 

cin >> x>> y;

cout << SumaKwadrat();

return 0;

}

Stosowanie procedur i funkcji w językach

1. Programowanie zstępujące i wstępujące.
Programowanie zstępujące (projektowanie zstępujące, ang. top-down design) – rozwiązanie programistyczne polegające na zdefiniowaniu problemu ogólnego poprzez podzielenie na podproblemy, które są dzielone na jeszcze mniejsze podproblemy aż do rozwiązań oczywistych, łatwych do zapisania. Następnie złożenie z rozwiązań podproblemów niższego rzędu rozwiązań problemów wyższego rzędu aż do całkowitego rozwiązania problemu

Programowanie wstępujące - oznacza rozpoczęcie pracy z interfejsem, zaimportowanie go do modułu, a następnie, jeśli to konieczne, zmodyfikowanie go w edytorze interfejsów.
Poniższa ilustracja przedstawia to programowanie:

2. Zalety stosowania podprogramów - procedur i funkcji

Stosowanie procedur i funkcji umożliwia: 

- dzielenie zadania na mniejsze części 

- każda może być realizowana w oddzielnej procedurze lub funkcji. 

-wprowadzenie porządku do programu

- zwiększenie jego czytelności i przejrzystości. 

-łatwiejsze wyszukiwanie błędów i dokonywanie poprawek 

- w procedurze lub w funkcji można zlokalizować błędy szybciej niż na długiej liście instrukcji programu głównego. 

-programowanie zespołowe 

- po uzgodnieniu postaci procedur lub funkcji każdy z członków zespołu może zająć się pracą się nad "swoimi" procedurami lub funkcjami. Zaletami programowania strukturalnego są szczególnie widoczne przy pisaniu dużych programów,rozwiązujących złożone problemy

3. Modele programowania:
- liniowe,



- strukturalne -  paradygmat programowania opierający się na podziale kodu źródłowego programu na procedury i hierarchicznie ułożone bloki z wykorzystaniem struktur kontrolnych w postaci instrukcji wyboru i pętli.
- modularne - 

- obiektowe - 

- zdarzeniowe - 

Algorytm z pętlą zagnieżdżoną

Algorytm z pętlą zagnieżdżoną

1. Specyfikacja

Zadanie: Napisz listę kroków algorytmu,który umożliwi wyprowadzenie na ekran monitora prostokąta o bokach n, m narysowanego za pomocą znaku *

(m - liczba znaków * w poziomie, n - liczba znaków w pionie) *.

Wnętrze prostokąta powinno być wypełnione znakami *.

Dane: Liczby naturalne dodatnie,określające ilość znaków * w prostokącie o bokach m,n.

Wynik: Prostokąt o wymiarach m, x, n zbudowany ze znaków*.

Lista kroków:

1.Zacznij algorytm

2.Zmiennej i przypisz wartość jeden: i:=1.

3.Jeśli i jest większe od n, przejdź do kroku 4;

w przeciwnym wypadku

3.1. Zmiennej j przypisz wartość jeden: j:=1;

3.2. Jeśli j jest większe od m,

przejdź do nowego wiersza;

zwiększ licznik i o jeden (i:= i+1)

wróć do kroku 3;

w przeciwnym wypadku 

wprowadź ('*');

zwiększ licznik j o jeden(j := j+1)

wróć do kroku 3.2;

4. Zakończ algorytm. 

Listing do wyżej wymienionego algorytmu:
#include <iostream>

using namespace std;

int main () 

{ int i,j,m,n; 

cout << "Podaj wartosc m: "; 

cin >> m; 

cout << "Podaj wartosc n: "; 

cin >> n; 

for (i=0; i<n; i++)
}
for(j=0; j<m; j++) 

cout << "*"; 

cout << endl; 

} 

return:0
}

Algorytm iteracyjny iloczynu n liczb

Iteracja - polega na wielokrotnym powtarzaniu tej samej operacji (ciągu operacji).
Iterację implementujemy, stosując tzw. PĘTLĘ.

Specyfikacja zadania lub problemu - opis zadania, w którym wymienia się dane wejściowe oraz wyniki, związek między danymi a wynikami.

Algorytm iteracyjny iloczynu n liczb 

Specyfikacja:

Zadanie: Oblicz iloczyn n liczb całkowitych.

Dane: n dowolnych liczb całkowitych, kolejno zapamiętywanych w zmiennej a.

Wynik: wartość iloczynu zatytułuj: iloczyn.

Co zrobić? - lista kroków.

1. Rozpocznij algorytm.
2. Zmiennej iloczyn oraz zmiennej i przypisz wartość jeden: iloczyn:=1; i:=1.
3. Wprowadź liczbę całkowitą i zapamiętaj ją w zmiennej a.
4. Pomnóż iloczyn poprzez wprowadzoną liczbę a: iloczyn := iloczyn * a.
5. Jeżeli i nie równa się n, zwiększ licznik o jeden (i:= i+1) i wróć do kroku nr. 3.
6. Wprowadź wynik: iloczyn.
7. Zakończ algorytm.

Prowizoryczny system blokowy powyższego algorytmu:

Listing to wydruk kodu źródłowego programu.

Listing powyższego programu:



#include <iostream> 

using namespace std; 

int main()

 { 

int i, a, iloczyn, n; 

cout << "podaj ilosc liczb :\n";

cin >> n; 

iloczyn=1; 

for (i=1; i<=n; i++)

 { 

cout << "podaj liczbe nr : " << i+1 <<" ";

 cin >> a;

 iloczyn*=a; 

} 

cout << iloczyn;

 return 0;

}