Archiwa tagu: codeblocks

C++ kurs programowania – funkcje, przekazanie argumentów przez referencję (CodeBlocks/C++Builder)

Witam was serdecznie w kolejnym artykule poświęconym przekazywaniu argumentów do funkcji. Dzisiaj opowiem o przekazywaniu argumentów do funkcji przez referencje.

Na początku jak zwykle tworzymy jakieś zmienne i funkcje do której będziemy przekazywali argumenty przez referencje.

Na początek utworzymy sobie trzy zmienne: dlugosc, szerokosc i wysokosc i przypiszemy do nich wartości.

int dlugosc = 10;

int szerokosc = 20;

int wysokosc = 30;

 

Teraz utworzymy funkcje, do której będziemy przekazywać argumenty. Analogicznie jak przy ćwiczeniach z przekazywania argumentów przez wskaźniki utworzymy funkcję o nazwie podwoj_wymiary, która będzie miała za zadanie podwojenie wartości naszych zmiennych. W ciele funkcji od razu utworzymy kod, który ma za zadanie podwojenie wartości naszych zmiennych.

void podwoj_wymiary(int &dl, int &szer, int &wys)

{

     dl = dl * 2;

     szer = szer * 2;

     wys = wys * 2;

}

 

Oczywiście od razu słowo komentarza dotyczącego utworzonej funkcji. Na początku słówko void mówi nam tyle, że nasza funkcja nie zwraca żadnej wartości. Następnie nazwa funkcji podwoj_wymiary i nawiasy w których definiujemy argumenty funkcji. Zwróć uwagę że zdefiniowaliśmy trzy argumenty. Określiliśmy ich typy ale przed każdym z nich znajduje się znak &, który mówi o tym że argumenty te będą przekazywane przez referencje.

Teraz zostało nam wrócić do funkcji głównej, wywołać funkcje i podać jej argumenty.

podwoj_wymiery(dlugosc, szerokosc, wysokosc);

Na koniec w celu obejrzenia efektów działania funkcji dodajmy sobie linie i wyświetlmy wartości wszystkich trzech zmiennych.

cout << "Dlugosc : " << dlugosc << ", szerokosc : " << szerokosc << ", wysokosc : " << wysokosc << endl;

Na samym końcu dodajemy sobie linie instrukcją

getch();

żeby zatrzymać na chwilę program i zobaczyć efekt końcowy uruchomienia. Pamiętaj że aby instrukcja getch() zadziałała na początku musimy dodać bibliotekę conio.h.

W tym momencie nasz cały kod wygląda następująco.

Listing


#include <iostream>

#include <conio.h>

using namespace std;

 

void podwoj_wymiary(int &dl, int &szer, int &wys)

{

    dl = dl * 2;

    szer = szer * 2;

    wys = wys * 2;

}

 

int main()

{

    int dlugosc = 10;

    int szerokosc = 20;

    int wysokosc = 30;

 

    podwoj_wymiary(dlugosc, szerokosc, wysokosc);

cout << "Dlugosc : " << dlugosc << ", szerokosc : " << szerokosc << ", wysokosc : " << wysokosc << endl;

 

    getch();

    return 0;

}


Uruchamiamy program i wynikiem jego działania jest poniższa linia.

Dlugosc : 20, szerokosc : 40, wysokosc : 60

Widzisz więc, że dzięki przekazaniu argumentów przez referencje otrzymaliśmy dostęp do tych zmiennych a w instrukcjami w ciele funkcji zmieniliśmy ich wartości.

Żeby lepiej zobrazować co się stało, przed wywołaniem funkcji podwoj_wymiary wyświetlmy sobie adresy wszystkich zmiennych.

cout << "Adres zm. dlugosc : " << &dlugosc << ", adres zm. szerokosc : " << &szerokosc << ", adres zm. wysokosc : " << &wysokosc << endl;

efektem wykonania tej linii będzie

Adres zm. dlugosc : 0x61fe1c, adres zm. szerokosc : 0x61fe18, adres zm. wysokosc : 0x61fe14

I analogicznie wewnątrz funkcji podwoj_wymiary wyświetlmy sobie adresy zmiennych zdefiniowanych w funkcji.

cout << "Adres dl : " << &dl << ", adres zm. szer : " << &szer << ", adres zm. wys : " << &wys << endl;

efektem wykonania powyższej linii będzie

Adres dl : 0x61fe1c, adres zm. szer : 0x61fe18, adres zm. wys : 0x61fe14

Oczywiście u Ciebie adresy które się wyświetlają będą inne, natomiast zwróć uwagę że adres zmiennej dlugosc równa się adresowi zmiennej dl, adres zmiennej szerokosc równa się adresowi zmiennej szer, a adres zmiennej wysokosc równa się adresowi zmiennej wys.  Oznacza to tyle, że dzięki referencji otrzymaliśmy dostęp do oryginalnych zmiennych dlugosc, szerokosc i wysokosc. Zauważ że zmieniając wartości zmiennych dl, szer i wys w funkcji podwoj_wymiary zmieniasz tak naprawdę wartości zmiennych dlugosc, szerokosc i wysokosc.

Mam nadzieję że po tym przykładzie bez problemu będziesz w stanie przekazywać do funkcji argumenty przez referencje. Oczywiście zachęcam do ćwiczeń, bo tylko w taki sposób szybko utrwalisz zdobytą wiedzę. Kolejne artykuły w przygotowaniu także "do zobaczenia".

Poniżej link do kodu z tego odcinka:

CodeBlocks   C++Builder 10.2


c++ kurs programowania obiektowego spis treści  

 

 

 

 

 

C++ kurs programowania – funkcje, przekazanie argumentów przez wskaźnik (CodeBlocks/C++Builder)

Witam was serdecznie w drugim artykule z serii przekazywanie argumentów funkcji. Dzisiaj zapoznamy się z metodą przekazywania argumentów przez wskaźnik.

No to do dzieła.

Na początku za inicjujemy sobie trzy zmienne o nazwach: długosc, szerokosc, wysokosc.

int dlugosc = 10;

int szerokosc = 20;

int wysokosc = 30;

Teraz utworzymy sobie trzy wskaźniki, do każdej zmiennej po jednym. Części o wskaźnikach dowiedzieliśmy się, że wskaźnik możemy utworzyć w jednym kroku, od razu przypisując wartość do wskaźnika, albo w dwóch krokach w pierwszym kroku tworząc sam wskaźnik, a w drugim kroku przypisując temu wskaźnikowi odpowiednią wartość.

Dla pierwszej zmiennej utworzymy wskaźnik pierwszą metodą.

int *wsk_dlugosc = &dlugosc;

Utworzyliśmy wskaźnik o nazwie wsk_dlugosc i przypisaliśmy do wskaźnika adres zmiennej długosc.

Dla zmiennej szerokosc,  dla odmiany, utworzymy wskaźnik w dwóch krokach.

int *wsk_szerokosc;

wsk_szerokosc = &szerokosc;

Efekt końcowy w obu przypadkach będzie identyczny.

I został  nam jeszcze trzeci wskaźnik dla zmiennej wysokosc.

int *wsk_wysokosc = &wysokosc;

W tym momencie utworzymy sobie funkcję o nazwie podwoj_wymiary, która będzie miała za zadanie dwukrotne zwiększenie każdego z wymiarów.

Nasza funkcja będzie wyglądała jak poniżej. Pamiętaj o tym  żeby umieścić funkcję poza główną funkcją main().

void podwoj_wymiary(int *dl, int *szer, int *wys)

{

    *dl = *dl * 2;

    *szer = *szer * 2;

    *wys = *wys * 2;

}

 

Przeanalizujmy pierwszą linijkę. Na początku słówko void oznacza że funkcja nie zwraca żadnych wartości.  Następnie znajduje się nazwa funkcji, czyli u nas podwoj_wymiary.  Po nazwie funkcji  w nawiasie  znajdują się argumenty, które przekazujemy do funkcji. W naszym przypadku znajdują się tutaj definicje trzech wskaźników ze wskazaniem typów zmiennych na które wskazują. W ciele funkcji wykorzystujemy owe wskaźniki do podwojenia wartości na które wskazują te wskaźniki.

Z części o wskaźnikach wiemy, że przy definicji wskaźnika używamy znaku * dla oznaczenia że definiujemy wskaźnik. Natomiast później przy pracy ze wskaźnikiem jeżeli używamy znaku * to odwołujemy się do wartości zmiennej na którą wskazuje wskaźnik. Zerknij jeszcze raz na definicje funkcji podwoj_wymiary. W związku z powyższym co innego będzie oznaczała * w nawiasach w miejscu definicji argumentów funkcji a co innego będzie oznaczała * w ciele funkcji.

W części dotyczącej argumentów funkcji definiujemy zmienne wskaźnikowe (wskaźniki), a w ciele funkcji poprzez znak * będziemy odwoływać się do wartości zmiennej na którą wskazuje wskaźnik.

Teraz pozostaje nam tylko powrót do funkcji głównej i wywołanie funkcji podwoj_wymiary.

podwoj_wymiary(wsk_dlugosc, wsk_szerokosc, wsk_wysokosc);

Przy wywołaniu funkcji korzystamy z nazw wskaźników, więc do funkcji przekażemy adresy komórek pamięci RAM które znajdują się we wskaźnikach.

Na samym końcu pozostaje nam tylko wyświetlanie wartości zmiennych długosc, szerokosc, wysokosc.

cout << "Dlugosc : " << dlugosc << endl;

cout << "Szerokosc : " << szerokosc << endl;

cout << "Wysokosc : " << wysokosc << endl;

 

Całość naszego programu będzie wyglądał jak poniżej.

Listing


#include <iostream>

#include <conio.h>

using namespace std;

void podwoj_wymiary(int *dl, int *szer, int *wys)

{

    *dl = *dl * 2;

    *szer = *szer * 2;

    *wys = *wys * 2;

}

 

int main()

{

    // inicjalizacja zmiennych

    int dlugosc = 10;

    int szerokosc = 20;

    int wysokosc = 30;

 

    // wskazniki

    int *wsk_dlugosc = &dlugosc;

    int *wsk_szerokosc = &szerokosc;

    int *wsk_wysokosc = &wysokosc;

 

    // wywolanie funkcji

    podwoj_wymiary(wsk_dlugosc, wsk_szerokosc, wsk_wysokosc);

 

    // wyswietlenie nowych wartosci

    cout << "Dlugosc : " << dlugosc << endl;

    cout << "Szerokosc : " << szerokosc << endl;

    cout << "Wysokosc : " << wysokosc << endl;

 

    getch();

    return 0;

}


Po uruchomieniu programu na ekranie powinniśmy otrzymać następujący wynik.

Dlugosc : 20

Szerokosc : 40

Wysokosc : 60

 

Przeanalizujmy co się stało? Dlaczego wartości zmiennych długosc, szerokosc i wysokosc są dwukrotnie większe niż zdefiniowane na początku mimo, że nasza funkcja podwoj_wymiary nic nie zwraca bo jest typu void?

Odpowiedź jest prosta. Do funkcji podwoj_wymiary przekazaliśmy wskaźniki wszystkich trzech zmiennych, ale wewnątrz funkcji odwoływaliśmy się do wartości tych zmiennych, czyli pracowaliśmy na oryginalnych wartościach. Dlatego mimo że funkcja podwoj_wymiary nic nie zwraca, zmieniła wartości na które wskazują nasze wskaźniki.

Zwróć jeszcze uwagę na jedną rzecz. Przy przekazywaniu do funkcji argumentów przez wartość funkcja zwracała tylko jedną wartość. Natomiast tutaj przy przekazaniu do funkcji argumentów przez wskaźnik naraz mogliśmy zmodyfikować wartości trzech zmiennych. To także duża zaleta tej metody.

Myślę że przekazywanie argumentów przez wskaźnik nie stanowi już dla ciebie żadnego problemu. Zapraszam cię serdecznie do kolejnych artykułów.

 

Poniżej link do kodu z tego odcinka:

 

CodeBlocks   C++Builder 10.2


c++ kurs programowania obiektowego spis treści  

 

 

 

 

 

C++ kurs programowania – funkcje, przekazanie argumentów przez wartość (CodeBlocks/C++Builder)

Witam was serdecznie w kolejnym artykule. Dzisiaj pokażę Ci jak przekazać argument(-y) do funkcji przez wartość.

Otwieramy nowy projekt konsolowy w naszym Code Blocks. I przechodzimy do funkcji main(). Widok pustego projektu konsolowego w Code Blocks poniżej.

Listing


#include <iostream>

using namespace std;

int main()

{

    cout << "Hello world!" << endl;

    return 0;

}


Ustawiamy się na początku funkcji main()  i inicjujemy zmienną liczba oraz przypisujemy od razu do niej wartość 99.

int liczba = 99;

Teraz w zależności od tego co sobie wymyślimy, będziemy chcieli stworzyć funkcje i przekazać wartość zmiennej liczba do funkcji. Ta nowa funkcja powinna wykonać na tej wartości jakieś działania/ operacje a następnie powinna zwrócić nam nową wartość.

Stwórzmy więc szkielet nowej funkcji.

int zwieksz_wartosc(int liczba_kopia)

{

      // ciało funkcji, czyli działania i operacje które ma wykonać funkcja

}

Mamy już szkielet funkcji teraz omówmy sobie jej elementy. Int na początku określa jakiego typu wartości zwróci nasza funkcja. Następnie mamy nazwę funkcji, w naszym przypadku jest to zwieksz_wartosc  i od razu wiadomo co będzie robiła nasza funkcja a mianowicie zwiększała wartość zmiennej która zostanie do niej przekazana. Następnie występują nawiacy otwarte w których definiujemy argumenty funkcji.  Argumenty funkcji to wszystko to, co przekazujemy do funkcji przy jej wywołaniu. W naszym przypadku jest tylko jeden argument liczba_kopia o typie int.  Argument ten musi mieć typ int  bo do funkcji będziemy przekazywać zmienną liczba, która jest typu int.

Teraz zajmijmy się chciałem funkcji, czyli określeniem co ta funkcja będzie robiła z wartością która zostanie do niej przekazana.

liczba_kopia = liczba_kopia++;

return liczba_kopia;

Pierwsza linijka oznacza że weźmiemy wartość argumentu liczba_kopia, zwiększymy tą wartość o jeden, poprzez wykonanie inkrementacji na tej wartości przy użyciu znaków ++,  a następnie wgranie tej nowej wartość z powrotem do zmiennej liczba_kopia.

W drugiej linii słówko return oznacza, że funkcja zwróci to co znajduje się po prawej stronie od tego słówka, czyli wartość zmiennej liczba_kopia.

Reasumując.  Określiliśmy, że funkcja zwieksz_wartosc przyjmuje jeden argument typu int, następnie wartość która zostanie przekazana do funkcji będzie zwiększona o 1 i w efekcie funkcja zwróci nową  zwiększoną wartość. Zwracana wartość też ma być typu int bo tak określiliśmy na początku definicji funkcji.

Wróćmy teraz do naszego programu głównego i wywołajmy sobie naszą funkcję zwieksz_wartosc.

zwieksz_wartosc(liczba);

Wywołaliśmy funkcje z argumentem ale musimy określić gdzie chcemy "wrzucić" wynik który zwróci funkcja.

Możemy wrzucić ten wynik z powrotem do zmienne liczba i wtedy nasza linia będzie wyglądała następująco.

liczba =  zwieksz_wartosc(liczba);

ale możemy też utworzyć nową zmienną do której wrzucimy wartość z funkcji

int nowa_liczba =  zwieksz_wartosc(liczba);

lub od razu przesłać wartość zwróconą przez funkcję na ekran.

cout << zwieksz_wartosc(liczba) << endl;

Ja w naszym programie wybiorę trzecią opcję. W tym momencie ostateczny kod naszego programu wygląda jak poniżej.

Listing


#include <iostream>

using namespace std;

int zwieksz_wartosc(int liczba_kopia)

{

      liczba_kopia = liczba_kopia++;

    return liczba_kopia;

}

int main()

{

    int liczba = 99;

    cout << zwieksz_wartosc(liczba) << endl;

    return 0;

}


Po uruchomieniu naszego programu otrzymamy nową (zmienioną) wartość zmiennej liczba. Początkowo ma ona wartość 99. Następnie wywołujemy funkcję zwieksz_wartosc i jako argument funkcji podajemy zmienną liczba. Funkcja zwieksz_wartosc zwiększa wartość otrzymanej wartości o 1 i zwraca nową wartość. W efekcie funkcja zwraca nam wartość 100 którą przesyłamy na ekran.

I teraz może słówko wyjaśnienia na temat przekazania wartości zmiennej liczba do funkcji zwieksz_wartosc. Zwróć uwagę że w argumencie funkcji zwieksz_wartosc jest zdefiniowana zmienna o nazwie liczba_kopia.  Nazwa ta nie jest przypadkowa, ponieważ w momencie przekazywania wartości jakiejś zmiennej do funkcji następuje utworzenie jej kopii w pamięci i wewnątrz funkcji jest wykorzystywana kopia tej wartości a nie oryginał. Z tego też powodu funkcja musi zwracać jakąś wartość dzięki poleceniu return. Pamiętaj że utworzona kopia zmiennej w pamięci po zamknięciu funkcji, zostaje usunięta. I jeszcze jedna ważna uwaga. Jeżeli przekazujemy do funkcji artumenty przez wartość, funkcja może zwrócić tylko jedną wartość, jak w naszym przypadku return liczba_kopia.

Myślę, że przekazywanie argumentów przez wartość jest już jasne. Zapraszam Cię do kolejnych artykułów gdzie wyjaśnię przekazywanie argumentów do funkcji przez wskaźnik i referencję.

Poniżej link do kodu z tego odcinka:

CodeBlocks   C++Builder 10.2


c++ kurs programowania obiektowego spis treści  

 

 

 

 

 

C++ kurs programowania – wskaźniki (CodeBlocks)

Witam wszystkich serdecznie w kolejnym artykule. Dzisiaj zajmiemy się tematyką wskaźników.

Co to w ogóle są wskaźniki?

Wskaźniki to po prostu zmienne, nazywane zmiennymi wskaźnikowymi, które przechowują adresy innych zmiennych. Ten adres to adres w pamięci RAM zmiennej, na którą wskazuje dany wskaźnik.

No to bez zbędnych wstępów, napiszmy coś praktycznego.

Utwórz nowy projekt  konsolowy.  Standardowy kod konsolowego projektu Code Blocks wygląda jak poniżej.

 

Listing


#include <iostream>

using namespace std;

int main()

{

    cout << "Hello world!" << endl;

    return 0;

}


Zainicjujmy nową zmienną o nazwie liczba i przypiszmy jej wartośc 100.

int  liczba = 100;

Teraz utworzymy zmienną wskaźnikową (wskaźnik) o nazwie wsk_liczba, która będzie przechowywała adres w pamięci RAM zmiennej liczba.

int *wsk_liczba;

Skoro zmienna liczba jest typu int to zmienna wskaźnikowa też musi być typu int. Znak * mówi kompilatorowi, że nazwa za tym znakiem jest nazwa zmiennej wskaźnikowej.

Teraz przepiszmy adres zmiennej liczba do zmiennej wskaźnikowej wsk_liczba.

wsk_liczba = &liczba;

Przy  przy pisaniu adresu zmiennej do wskaźnika używamy znaków &.  Znak ten " wyciąga"  adres pamięci RAM tego co znajduje się po prawej stronie od znaku,  czyli w naszym przypadku adres zmiennej liczba.

Jak korzystać ze wskaźnika?

Do wskaźnika możemy odwołać się na dwa sposoby. Albo odwołać się do wartości którą przechowuje wskaźnik, czyli adres innej zmiennej w pamięci RAM. Albo odwołać się do wartości zmiennej na którą wskazuje wskaźnik.

No to zacznijmy od pracy na wskaźniku, czyli adresie który przechowuje wskaźnik. Naszą linię z „Hello world” zmodyfikuj na taką jak jest poniżej.

cout << wsk_liczba << endl;

W efekcie powinniśmy otrzymać kod jak poniżej.

 

Listing


#include <iostream>

using namespace std;

int main()

{

    int liczba = 100;

    int *wsk_liczba;

    wsk_liczba = &liczba;

    cout << wsk_liczba << endl;

    return 0;

}


PAMIĘTAJ. Jeżeli używasz innego środowiska niż Code Blocks musisz dołączyć do swojego projektu bibliotekę iostream i  ustawić odpowiednią przestrzeń nazw na std.  Code Blocks standardowo dodaje obie te linie do swojego kodu przy projektach konsolowych, więc my w tym momencie nie musimy tego robić.

Teraz możemy uruchomić nasz projekt.

Efektem uruchomienia naszego programu powinien być adres komórki na którą wskazuje wskaźnik.

0x61fe14

Oczywiście adres jest w postaci szesnastkowej.

No to teraz odwołajmy się do wartości zmiennej na którą wskazuje wskaźnik. Do naszego programu dodajmy więcej linię.

cout << *wsk_liczba << endl;

Jak widzisz Różnica polega tylko na tym że przed nazwą wskaźnika stoi znak *. W takim przypadku odwołujemy się do wartości zmiennej na którą wskazuje wskaźnik.

Uruchamiamy nasz program. W wyniku uruchomienia powinniśmy otrzymać dwie linie. Pierwsza to adres zmiennej którą przechowuje wskaźnik. A druga linia to wartość zmiennej na którą wskazuje wskaźnik.

0x61fe14

100

 

Jak widzisz wskaźniki to nie taka trudna sprawa. Zachęcam cię do samodzielnych ćwiczeń ze wskaźnikami. Zapraszam Cię również na kolejne artykuły.

Poniżej link do kodu z tego odcinka:

CodeBlocks


c++ kurs programowania obiektowego spis treści