Archiwum kategorii: C++

Oddaję w Wasze ręce kurs programowania obiektowego w C++. Dzięki temu kursowi wejdziesz na nowy poziom programowania (po podejściu proceduralny).

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  

 

 

 

 

 

C++ kurs podstawy programowania. Pętla DO WHILE.

Pętla do … while to nic innego jak inny wariant pętli while. Różnica jest tylko taka, że pętla do … while sprawdza warunek na końcu pętli przez co musi się wykonać choćby raz mimo, że warunek nie będzie spełniony. Przykład wyświetlenia liczb od 1 do 10 za pomocą pętli do … while poniżej.

    do
    {
        cout << i << endl;
        i++;
    }
    while(i<=10);

Widzisz, że składnia się trochę różni. Na początku jest słówko do, później, pomiędzy nawiasami klamrowymi, mamy ciało pętli a dopiero na końcu słówko while i warunek. Wszystko kończymy znakiem średnika. Efekt uruchomienia powyższej pętli poniżej.
cpp c++ kurs programowania pętla do while

 


c++ kurs programowania obiektowego spis treści 

 

 

C++ kurs podstawy programowania. Pętla WHILE.

Pętla  WHILE
Drugą pętlą którą poznamy jest pętla while. Na początek zaznajomimy się ze składnią tej pętli.

    while(warunek)
    {
        // cialo petli while
        // instrukcja lub blok instrukcji
        // do wykonania gdy warunek spelniony
    }

W pętli while instrukcja (lub blok instrukcji) będzie się wykonywała tyle razy aż warunek nie będzie spełniony.  Należy pamiętać, żeby w ciele pętli należy zaprogramować taki mechanizm, żeby w jakiejś konkretnej sytuacji była możliwość zakończenia pętli w przeciwnym wypadku zapętlimy ją w nieskończoność.
Spróbujmy teraz zapisać z użyciem pętli while przykład, który oprogramowywaliśmy dla pętli for, czyli klasyczne wyświetlenie na ekranie liczb od 1 do 10.

    int i=1;
    while(i<=10)
    {
        cout << i << endl;
        i++;
    }

Na początku deklarujemy sobie zmienną i która w tym przypadku będzie potrzebna do sprawdzania warunku wyjścia z pętli. Następnie po słówku while definiujemy warunek który będzie sprawdzany przed uruchomieniem każdego obiegu pętli, czy jest spełniony. Jeżeli będzie spełniony (wartość TRUE) pętla się wykona, w przeciwnym wypadku (wartość FALSE) pętla w ogóle przestaje się wykonywać. Widzisz, że za każdym razem w pętli while wyświetlamy na ekranie wartość zmiennej i. Za każdym jednak razem jej wartość jest zwiększana o 1 poleceniem i++ . W momencie kiedy zmienna i osiągnie wartość 11 czyli warunek nie będzie już spełniony pętla przestaje się wykonywać. Jeżeli od początku warunek nie będzie spełniony pętla while nie wykona się ani razu. Efekt uruchomienia naszego kodu poniżej.
cpp c++ kurs programowania pętla while

 


c++ kurs programowania obiektowego spis treści 

 

 

C++ kurs podstawy programowania. Pętla FOR.

Pętla FOR
Jak już wspomniałem wcześniej pętle są wykorzystywane do cyklicznego wykonywania zadanego kodu. Jeżeli z góry wiemy ile razy chcemy wykonać dany zestaw instrukcji to pętla for jest idealna do tego zadania. Pętle tego typu nazywamy licznikowymi bądź iteracyjnymi, bo z reguły startujemy od jakiejś wartości początkowej, przy każdym obrocie (obiegu) pętli wartość licznika zwiększamy o jeden, do momentu kiedy pętla osiągnie górną granicę. Ale najlepiej objaśnię to na konkretnym przykładzie. Będzie to znowu klasyka gatunku, czyli wyświetlenie na ekranie liczb od 1 do 10.

    int i = 1;
    for( i; i <= 10 ; i++)
        cout << i << endl;

Przeanalizujmy teraz nasz kod. Na początku zadeklarowałem zmienną i = 1 o typie int. Będzie ona spełniała funkcję licznika dla pętli for. No i teraz sedno sprawy, czyli sama pętla. W Nawiasie po słówku for podajemy trzy argumenty. Pierwszy to warunek początkowy, czyli w naszym przypadku i. Tak jak pisałem wcześniej nasza zmienna i będzie spełniała funkcję licznika, czyli na początku licznik ustawiamy na 1. Drugi parametr to tzw. górna granica, czyli warunek dla którego pętla przestanie się wykonywać. W naszym przypadku pętla ma przestać się wykonywać kiedy wartość licznika i będzie mniejsza lub równa 10 i to mamy właśnie zapisane w drugim argumencie i <=10 . Jeżeli warunek będzie spełniony pętla się wykona, jeżeli nie to pętla stanie. W trzecim argumencie musimy powiedzieć kompilatorowi jak będzie zmieniał się nasz licznik. W naszym przypadku chcemy, żeby licznik zwiększał się o 1 przy każdym obiegu pętli, dlatego zastosowałem inkrementację zmiennej i w postaci składni i++ . To co znajduje się w następnej linii to instrukcja którą chcemy wykonać przy każdym obiegu pętli. Jeżeli tych instrukcji wyłoby więcej to umieszczamy je w nawiasach {}. My chcemy, przy każdym obiegu pętli, wyświetlić wartość licznika i. Możemy uzyskać ten efekt korzystając ze składni cout << i << endl; . Oczywiście endl na końcu oznacza, przy każdym obiegu pętli, przejście do następnej linii tak, żeby każda wartość wyświetliła się w osobnej linii. Wrzućmy nasz kod w startowy program i uruchomimy go.

#include <iostream>

using namespace std;

int main()
{
    int i = 1;
    for( i; i <= 10 ; i++)
        cout << i << endl;

    return 0;
}

Po uruchomieniu na ekranie zobaczymy.
 cpp c++ course kurs programowania pętla for loop for
Właśnie o taki efekt nam chodziło, więc program zaliczamy do działających prawidłowo. Zwróć uwagę, że pętla for sprawdza warunek przed wykonaniem kodu w pętli. Jeżeli wiec nie będzie on spełniony kod się nie wykona. Jeżeli od początku warunek nie będzie spełniony pętla for nie wykona się ani razu.

 


c++ kurs programowania obiektowego spis treści 

 

 

C++ kurs podstawy programowania. Instrukcja warunkowa switch case.

Instrukcja SWITCH…CASE
Innym pomysłem na rozwiązanie problemu obsługi warunków jest instrukcja switch…case (czasami nazywana instrukcją wielokrotnego wyboru). Poniżej definicja i zaraz zabieram się do objaśniania kodu.

switch(zmienna)
{
case wartosc_1:
    // jeżeli zmienna = wartość_1 to wykonaj kod który znajduje się tutaj
    break;
   
case wartosc_2:
    // jeżeli zmienna = wartość_2 to wykonaj kod który znajduje się tutaj
    break;
   
    //...
case wartosc_n:
    // jeżeli zmienna = wartość_n to wykonaj kod który znajduje się tutaj
    break;
   
default:
// kod który wykona się w momencie kiedy wartość zmiennej zmienna
   //     nie będzie oprogramowana w żadnym z powyższych przypadków
    break;
}

Na początku widzisz słówko switch i parametr w nawiasie. Tym parametrem jest wartość zmiennej i w zależności od tej wartości switch zachowa się tak jak to mu oprogramujemy. Po słówku case oprogramowujemy konkretne przypadki, co komputer ma zrobić w zależności od wartości zmiennej zdefiniowanej w parametrze instrukcji switch. Słówko break przerywa działanie instrukcji switch. Wykonamy teraz małe ćwiczenie napiszemy program który zapyta użytkownika o liczbę z przedziału od 1 do 5. Pobierzemy tą liczbę do zmiennej i w zależności od wybranej liczby wyświetlimy komunikat „Wpisales liczbe n, wiec wykonuje kod z czesci case:n”, gdzie pod n będziemy podstawiali liczbę podaną przez użytkownika. No to do dzieła.

#include <iostream>

using namespace std;

int main()
{
    int liczba;
    cout << "Podaj liczbe 1-5 : ";
    cin >> liczba;
    switch(liczba)
    {
    case 1: 
        cout << "Wpisales liczbe 1, wiec wykonuje kod z czesci case:1"; 
        break;
    case 2: 
        cout << "wpisales liczbe 2, wiec wykonuje kod z czesci case:2"; 
        break;
    case 3: 
        cout << "wpisales liczbe 3, wiec wykonuje kod z czesci case:3"; 
        break;
    case 4: 
        cout << "wpisales liczbe 4, wiec wykonuje kod z czesci case:4"; 
        break;
    case 5: 
        cout << "wpisales liczbe 5, wiec wykonuje kod z czesci case:5"; 
        break;
    
    }

    return 0;
}

Przetestujmy nasz program podając liczbę 2 (zrzut poniżej).

 cpp c++ loops switch
Widzimy, że wszystko poszło zgodnie z planem i wykonała się instrukcja dla wartości zmiennej liczba = 2.
A co się stanie jeżeli użytkownik podałby liczbę spoza zakresu np. 6 ? Przetestujmy.
 cpp c++ loops switch
Widzimy, że nic tragicznego się nie stało. Program „poszedł” dalej i nie wyświetlił żadnej instrukcji bo wartość 6 dla zmiennej liczba nie była oprogramowana w switch-u, więc kompilator nie wiedział co ma zrobić. Czasami jednak potrzebujemy oprogramować taką sytuację kiedy chcemy wykonać jakiś kod lub wyświetlić jakiś komunikat dla przypadku który jest inny niż oprogramowaliśmy w switch-u, jak np. u nas kiedy użytkownik podał liczbę 6. Do tego celu służy instrukcja default. Definiujemy ją identycznie jak w przypadku instrukcji case.

default:
   cout << "liczba nie z przedzialu 1-5, wiec nie wykonam zadnego kodu";
   break;

 Stosując instrukcję default mówimy kompilatorowi, że jeżeli nie znajdzie wartości z warunku oprogramowanej w instrukcji case to ma wykonać kod z części default. Dopiszmy tą część kodu do naszego programu i przetestujmy go.

#include <iostream>

using namespace std;

int main()
{
    int liczba;
    cout << "Podaj liczbe 1-5 : ";
    cin >> liczba;
    switch(liczba)
    {
    case 1:
        cout << "Wpisales liczbe 1, wiec wykonuje kod z czesci case:1";
        break;
    case 2:
        cout << "wpisales liczbe 2, wiec wykonuje kod z czesci case:2";
        break;
    case 3:
        cout << "wpisales liczbe 3, wiec wykonuje kod z czesci case:3";
        break;
    case 4:
        cout << "wpisales liczbe 4, wiec wykonuje kod z czesci case:4";
        break;
    case 5:
        cout << "wpisales liczbe 5, wiec wykonuje kod z czesci case:5";
        break;
    default:
        cout << "liczba nie z przedzialu 1-5, wiec nie wykonam zadnego kodu";
        break;
    }
    cout << endl;



    return 0;
}

Uruchamiamy program i wprowadzamy wartość 6.
 cpp c++ loops switch
Widzimy na ekranie komunikat który oprogramowaliśmy dla  warunku default, więc wszystko działa jak należy.

 


c++ kurs programowania obiektowego spis treści 

 

 

C++ kurs podstawy programowania. Instrukcja warunkowa if else.

Instrukcja IF ELSE
Pierwszą z instrukcji warunkowych jaką poznamy jest instrukcja if … else. Definicja if-a poniżej.

if(warunek)
   {    
      // jeżeli warunek jest spełniony, czyli przyjmuje wartość TRUE (prawdy)
      // to wykona się kod pomiędzy tymi klamrami
   }
else
   {
      // w przeciwnym wypadku wykona się ten kod tutaj
      // czyli warunek przyjmuje wartość FALSE (fałsz)
   }

Wróćmy do przykładu z kontrolowaniem prędkości. Jak mogłoby to wyglądać. Postarajmy się to oprogramować. Przyjmijmy, że co chwilę odczytujemy wartość z czujnika prędkości auta. Wartość z czujnika wrzucamy do zmiennej o nazwie aktualna_predkosc. Mamy też oprogramowane dwie funkcje. Pierwsza odcina dopływ paliwa i będzie miała nazwę zamknij_doplyw_paliwa(), a druga otwierająca z powrotem  dopływ paliwa o nazwie otworz_doplyw_paliwa(). Będzie nam potrzebna jeszcze jedna zmienna, nazwiemy ją dopływ_paliwa, zaraz wyjaśnię dlaczego. Nasz kod mógłby wyglądać jak poniżej.

if(aktualna_predkosc >= 200)
   {
      zamknij_doplyw_paliwa();
      doplyw_paliwa = "Z";
   }
else
   {
      // sprawdz czy doplyw zamkniety
      if(doplyw_paliwa == "Z")
         {
            otworz_doplyw_paliwa();
            doplyw_paliwa = "O";
         }
   }

Powyższy kod można przetłumaczyć tak. Jeżeli aktualna_predkosc jest większa lub równa 200, czyli moment kiedy przekroczyliśmy prędkość graniczną 200 km/h, to uruchom funkcję zamknij_doplyw_paliwa() i ustaw zmienną dopływ_paliwa na "Z" (zamknięty). W przeciwnym przypadku, czyli kiedy prędkość jest mniejsza niż 200 km/h, wykonaj kod z części else{}. Ale tutaj mamy drugiego if-a, bo jeszcze musimy sprawdzić czy aktualnie dopływ_paliwa jest zamknięty czy otwarty. Drugiego if-a możemy przetłumaczyć tak. Jeżeli dopływ_paliwa jest zamknięty (czyli nasz poprzednia prędkość była większa niż 200km/h) uruchamiamy funkcję otworz_doplyw_paliwa() i ustawiamy dopływ_paliwa na "O" (otwarty). Jeżeli dopływ_paliwa jest otwarty ("O") to nie robimy nic no bo aktualnie dopływ paliwa jest otwarty więc nie ma potrzeby uruchamiania funkcji otworz_doplyw_paliwa(). Myślę, że już rozumiesz dokładnie działanie instrukcji if… else i po co w ogóle była nam potrzebna zmienna dopływ_paliwa.
Zwróć uwagę, że używając instrukcji if nie musisz za każdym razem korzystać także z konstrukcji if…else możesz skorzystać tylko z if-a.
Jak już zauważyłeś if-y możemy zagnieżdżać, czyli definiować jednego if-a wewnątrz drugiego.
Cały kod programu mógłby wyglądać tak.

#include <iostream>

using namespace std;

void zamknij_doplyw_paliwa()
{
    cout << "Jedziesz jak wariat, zwolnij!" << endl;
    cout << "Zamykam doplyw paliwa!" << endl << endl;
}

void otworz_doplyw_paliwa()
{
    cout << "Widze, ze zwolniles!" << endl;
    cout << "Otwieram doplyw paliwa!" << endl << endl;
}
    int aktualna_predkosc;
    int i; // licznik dla for-a
    string doplyw_paliwa;

int main()
{



    for(i=0;i<=5;i++)
    {
        cout << "Z jaka predkoscia aktualnie jedziesz? : ";
        cin >> aktualna_predkosc;

        if(aktualna_predkosc >= 200)
           {
              zamknij_doplyw_paliwa();
              doplyw_paliwa = "Z";
           }
        else
           {
              // sprawdz czy doplyw zamkniety
              if(doplyw_paliwa == "Z")
                 {
                    otworz_doplyw_paliwa();
                    doplyw_paliwa = "O";
                 }
                 else
                 {
                     cout << "Jedziesz przepisowo, jedz tak dalej!" << endl << endl;
                 }

           }

    }

    cout << "Dziekujemy za skorzystanie z naszej nawigacji";

    return 0;
}


c++ kurs programowania obiektowego spis treści