Miesięczne archiwum: Luty 2018

C++ kurs podstawy programowania. Praca z plikami tekstowymi, zapis.

Dzisiaj poznamy bardzo przydatną rzecz a mianowicie nauczymy się odczytywać dane (tekst) z plików. To bardzo przydatna umiejętność. Pliki tekstowe mogą nawet służyć jako takie mini bazy danych więc sam widzisz, że umiejętność pracy z plikami tekstowymi jest naprawdę ważna i przydatna. Zaczynamy!

Startujemy oczywiście z poziomu pustego projektu Hello world! (listing poniżej).

#include <iostream>

using namespace std;

int main()
{
    cout << "Hello world!" << endl;
    return 0;
}

Stworzymy plik, który kiedyś wykorzystamy do stworzenia programu do nauki języka angielskiego. Będzie on przechowywał w kolejnych liniach najpierw słówko angielskie a w następnej linii jego polskie tłumaczenie. Nazwa pliku będzie odwoływała się do kategorii słówek, które będą się znajdowały wewnątrz pliku. Na początek stworzymy plik, który będzie przechowywał słówka do nauki zwierząt.

Żeby w ogóle pracować z plikami tekstowymi musimy dodać do naszego projektu bibliotekę poleceniem include.

#include <fstream>

Tą linię dodajemy poniżej dodanej biblioteki iostream (poniżej pierwszej linii).

Teraz możemy utworzyć zmienna plikową typu fstream, która będzie nam służyła do odwoływania się do naszego pliku. Tak jak do zapisywania ciągów znaków wykorzystujemy zmienną o typie string tak dla plików tworzymy zmienną plikową o dowolnej nazwie typu fstream.

fstream moj_plik;

Następnie musimy podać komputerowi lokalizację naszego pliku i w jakim trybie chcemy do otworzyć, bo możemy otworzyć plik albo do zapisu albo do odczytu, w sumie logiczne jeżeli chcemy coś do pliku zapisać/lub dopisać albo chcemy coś z niego odczytać. Poniżej kod.

moj_plik.open("zwierzeta.txt",ios::out);

Funkcja open() służy do otwierania pliku. Pierwszy argument w nawiasach, u nas zwierzeta.txt, mówi o ścieżce dostępu do pliku, czyli o lokalizacji pliku na dysku. Tutaj jest tylko sama nazwa pliku więc code::blocks będzie szukał naszego pliku w katalogu z projektem. Co oznacza parametr ios::out. Słówko  ios znaczy input output stream czyli zaznaczamy, że chodzi nam o strumień danych, out oznacza, że ten strumień danych chcemy wyprowadzić z programu do pliku. Znak :: to operator zasięgu mówi tylko tyle, że funkcja out jest częścią składową klasy ios.

Funkcja open() przy próbie otwarcia pliku działa jeszcze w jeden sposób. Sprawdza ona czy w podanej lokalizacji (pierwszy parametr) znajduje się plik o wskazanej przez nas nazwie. Jeżeli tak to otworzy ten plik do zapisu, a jeżeli nie to najpierw utworzy taki plik i otworzy go do zapisu. Fajnie, nawet nie musimy się za bardzo martwić, co w sytuacji kiedy naszego pliku nie ma we wskazanej lokalizacji, funkcja open() załatwi to za nas.

Żeby „wrzucić” jakieś dane do pliku utworzymy sobie dwie zmienne pomocnicze które będą nam przechowywały słówko w języku angielskim i jego tłumaczenie po polsku podane przez użytkownika.

string slowkoen, slowkopl;

Zmienne tworzymy pomiędzy using namespace std; a funkcją main().

Teraz poprosimy użytkownika o wprowadzenie z klawiatury słówka angielskiego i jego polskiego tłumaczenia.

    cout << "Slowko angielskie: ";
    cin >> slowkoen;
    cout << "Polskie tlumaczenie: ";
    cin >> slowkopl;

Czyli w zmiennych slowkoen i slowkopl mamy już słówka które chcemy zapisać w pliku. No to zapisujemy. Sprawa jest bardzo prosta.

    moj_plik << slowkoen << endl;
    moj_plik << slowkopl << endl;

Na początku odwołujesz się do Twojego pliku poprzez zmienną plikową mój_plik a później „wyprowadzasz” z programu dane z tych zmiennych do pliku. Zwróć uwagę, że na końcu każdej linii wywołujemy funkcję endl() („end line”, czyli koniec linii). Gdybyśmy tego nie zrobili to wszystkie dane, angielskie i polskie słówko, zapisałoby się do pliku w jednej linii.

Dodatkowo możemy wyświetlić użytkownikowi komunikat o tym, że słówka zostały zapisane do pliku.

cout << "Slowka zapisane" << endl;

W momencie kiedy już nie będziemy korzystać z pliku należy zamknąć plik.

moj_plik.close();

Cały nasz kod będzie wyglądał jak poniżej.

 

#include <iostream>
#include <fstream>

using namespace std;

string slowkoen, slowkopl;

int main()
{
    fstream moj_plik;
    moj_plik.open("zwierzeta.txt",ios::out);

    cout << "Slowko angielskie: ";
    cin >> slowkoen;
    cout << "Polskie tlumaczenie: ";
    cin >> slowkopl;

    moj_plik << slowkoen << endl;
    moj_plik << slowkopl << endl;
    cout << "Slowka zapisane" << endl;

    moj_plik.close();

    return 0;
}

Po uruchomieniu program pyta użytkownika o podanie słówka angielskiego

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Po jego podaniu i potwierdzeniu enterem program pyta nas o polskie tłumaczenie podanego słówka.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

 

Po podaniu polskiego słówka, program wyświetla komunikat do użytkownika, że słówko jest dodane i kończy pracę. Oczywiście code::blocks wyświetla jeszcze swoje powiadomienie o czasie wykonania programu i czeka na wciśnięcie jakiegoś klawisza z klawiatury.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Widzimy, że w konsoli wszystko poszło zgodnie z planem, ale czy utworzyliśmy pliki i czy znajdują się w nim dane które wprowadziliśmy. Zobaczmy w katalogu z projektem czy istnieje plik o nazwie zwierzęta.txt.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Widzimy, że w katalogu naszego projektu znajduje się plik zwierzęta.txt czyli wszystko wygląda dobrze. Teraz zostało nam do sprawdzenia czy po otwarciu pliku dane które wysłaliśmy do pliku się zapisały.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Wszystko zadziałało prawidłowo, w pliku znajdują się dwie linie z zapisanymi słówkami. Ktoś jednak przytomnie spyta co się stanie w przypadku ponownego uruchomienia programu. Czy program dopisze dane do pliku czy je nadpisze. No to uruchamiamy program jeszcze raz.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Sprawdzamy co się dzieje w pliku.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Widzimy więc, że każde uruchomienie programu powoduje nadpisanie wcześniej wprowadzonych danych. Czy możemy coś z tym zrobić? Oczywiście, że tak. W miejscu gdzie określamy w jakim trybie otwieramy nasz plik musimy dodać parametr mówiący o tym, że chcemy dopisywać dane a nie zastępować. Wystarczy do linii

moj_plik.open("zwierzeta.txt",ios::out);

dodać parametr

moj_plik.open("zwierzeta.txt",ios::out | ios::app);

Sprawdźmy czy działa. Aktualnie w naszym pliku mamy dodanego psa. No to nie może zabraknąć także kota. Uruchamiamy program i dodajemy słówka cat / kot.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Sprawdźmy co się stało w naszym plik. Otwieramy plik zwierzęta.txt.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Bingo! Pod słówkami dotyczącymi psa dodały się dwie linie dotyczące kota. Oto właśnie nam chodziło. Widzisz więc, że zapisywanie danych do pliku tekstowego to nic trudnego. Finalnie nasz kod przybierze postać.

#include <iostream>
#include <fstream>

using namespace std;

string slowkoen, slowkopl;

int main()
{
    fstream moj_plik;
    moj_plik.open("zwierzeta.txt",ios::out | ios::app);

    cout << "Slowko angielskie: ";
    cin >> slowkoen;
    cout << "Polskie tlumaczenie: ";
    cin >> slowkopl;

    moj_plik << slowkoen << endl;
    moj_plik << slowkopl << endl;
    cout << "Slowka zapisane" << endl;

    moj_plik.close();

    return 0;
}

W kolejnych częściach kursu nauczysz się odczytywać te dane z pliku.


c++ kurs programowania obiektowego spis treści 

 

 

C++ kurs podstawy programowania. Zmienne. Typy danych.

Tworząc programy komputerowe często musimy zapisywać (zapamiętać) różne dane, które w dalszej części będziemy wykorzystywali do różnych celów np. proste równanie matematyczne a+b. Jak stworzylibyśmy program który dodaje dwie liczby do siebie? Na początku poprosilibyśmy użytkownika o podanie pierwszej liczby, później o podanie drugiej i na końcu dodalibyśmy obie wartości do siebie. Do dobrze, ale gdzie i jak komputer zapisze te wartości które poda użytkownik? Otóż komputer zapisuje te wartości w pamięci komputera pod nazwą którą poda mu programista, bo przecież my jako programiści jakoś do tej wartości później musimy się odwołać, jakoś ją zidentyfikować. My jako programiści nie musimy wiedzieć gdzie konkretnie ta wartość się w pamięci znajduje, wystarczy, że wiemy jak się do niej odwołać. To miejsce, o konkretnej nazwie, które będzie przechowywało jakąś wartość nazywamy zmienną. Można to przyrównać do wielkiej komody (pamięć komputera) z wieloma szufladami. Taką jedną pojedynczą szufladę będziemy nazywamy zmienną. Do naszej szuflady możemy „włożyć” jakąś wartość (określonego typu, o typach za chwilę). Szufladę musimy jakoś nazwać żebyśmy wiedzieli, którą szufladę w danym momencie chcemy otworzyć. Poniżej przykład deklaracji zmiennej, która będzie przechowywała liczbę całkowitą. Deklaracja to takie przygotowanie naszej szuflady na wrzucenie konkretnej wartości, ale jeszcze tej wartości do szuflady nie wrzucamy. Przygotowując tą szufladę musimy „powiedzieć” komputerowi dokładnie jakiego typu zmienne będzie tam można przechowywać, czyli określamy typ zmiennej. Jeżeli określimy, że do zmiennej (szuflady) możemy wrzucić liczbę całkowitą (typ int) to będziemy do niej mogli wrzucić tylko wartości tego typu i żadnej innej, nie wrzucimy tam np. jakiegoś tekstu bo ta szuflada przyjmie tylko liczbę całkowitą.

int liczba;

gdzie: int oznacza typ zmiennej, czyli typ przechowywanej wartości, a liczba to nazwa zmiennej.

Zauważ, że w tym momencie mamy już zdefiniowaną zmienną, czyli określiliśmy jakie wartości (jakiego typu) ta zmienna może przyjąć (przechowywać) i określiliśmy jej nazwę ale nie przypisaliśmy do tej zmiennej żadnej wartości. Przypisanie wartości do zmiennej nazywamy inicjalizacją, patrz kod poniżej.

liczba = 1;

Zobaczy, że deklaracja i inicjalizacja zajmują dwie linijki kodu. Czy można to zrobić szybciej? Tak. Poniżej przykład deklaracji i inicjalizacji zmiennej w jednej linijce.

int liczba = 1;

Powyższy zapis oznacza, że w pamięci komputera „siedzi” zmienna o nazwie liczba, która w tym momencie przechowuje wartość 1, czyli liczbę całkowitą. To, że w zmiennej liczba możemy zapisać tylko liczbę całkowita określa nam typ zmiennej przed jej nazwą, czyli int.

Do naszej zmiennej możemy w każdym momencie przypisać nową wartość np.

int liczba = 2;

W tym momencie nasza zmienna o nazwie liczba przechowuje już wartość 2. Czyli wartość 1 została zastąpiona wartością 2. Jeżeli odwołamy się w tym momencie do tej zmiennej np. będziemy ją chcieli wyświetlić na ekranie to wyświetlimy liczbę 2.

cout << liczba << endl;

Czyli cały nasz program przybierze formę.

#include <iostream>
using namespace std;
int main()
{
    int liczba = 1;
    liczba = 2;
    cout << liczba << endl;
    return 0;
}

 

A poniżej efekt uruchomienia naszego programu

cpp c++ kurs programowania podstawy zmienne typy danych

Teraz przejdziemy do tematu typów danych. Już poznałeś typ int, który mówi nam, że możemy do zmiennej zapisać tylko liczbę całkowitą. No ale my, do tworzenia naszego programu, potrzebujemy zapisywać inne wartości np. liczby zmiennoprzecinkowe, ciągu znaków itd. Spokojnie i takie dane możemy zapisywać w zmiennych wykorzystując odpowiedni typ. Wykaz najpopularniejszych typów danych przedstawiam Ci poniżej.

cpp c++ kurs programowania podstawy zmienne typy danych

 

Dla przykładu, jeżeli będziemy chcieli zapisać a później wyświetlić jakiś ciąg znaków nasz kod będzie wyglądał tak.

#include <iostream>

using namespace std;

int main()
{
    string tekst; // deklaracja zmiennej o nazwie tekst i typie string
    tekst = "Ala ma kota"; // przypisanie zmiennej tekst wartości, czyli zdania  „Ala ma kota”.
    cout << tekst << endl; // wyświetlenie zawartości zmiennej tekst na ekranie
    return 0;
}

Efekt uruchomienia programu poniżej.

cpp c++ kurs programowania podstawy zmienne typy danych

 

Myślę, że jesteś już gotowy na samodzielne napisanie swojego pierwszego programu. Poniżej opis.

Zadanie.

Firma wypracowała w danym roku zysk, którym chce się podzielić z wszystkimi pracownikami. 80% zysku zostanie przeznaczona na premie dla wszystkich pracowników (po równo dla każdego), kolejne 15 % przeznaczone będzie wyłącznie dla kadry kierowniczej a dodatkowe 5% dla prezesa. Jaką premię otrzyma każdy z pracowników firmy (pracownik produkcji, kierownik, prezes)? Zakładamy, że prezes jest jeden a liczbę pracowników produkcji i kadry kierowniczej podaje użytkownik.

Przy założeniu, że kwota zysku to 10000 zł, liczba pracowników produkcji to 10 osób, liczba kierowników to 3 osoby i prezesie, premie rozkładają się następująco:

  • Premia dla pracownika produkcji: 571,429 zł
  • Premia dla członka kadry kierowniczej: 946,429 zł
  • Premia dla Prezesa: 2017,86 zł

Poniżej kod programu.

#include <iostream>

using namespace std;

int liczbaPracownikow, liczbaKierownikow;
float zysk, zyskPracownicy, zyskKierownicy, zyskPrezes;
float premiaPracownik, premiaKierownik, premiaPrezes;

int main()
{
    cout << "Jaki zysk wypracowala firma: ";
    cin >> zysk;

    cout << "Podaj liczbe pracownikow dzialu produkcji: ";
    cin >> liczbaPracownikow;

    cout << "Podaj liczbe czlonkow kadry kierowniczej: ";
    cin >> liczbaKierownikow;

    premiaPracownik = zysk*0.8/(liczbaPracownikow+liczbaKierownikow+1);
    premiaKierownik = zysk*0.15/ (liczbaKierownikow + 1) + premiaPracownik;
    premiaPrezes = zysk*0.05 + premiaPracownik + premiaKierownik;

    cout << "Premia dla pracownika produkcji: " << premiaPracownik << endl;
    cout << "Premia dla czlonka kadry kierowniczej: " << premiaKierownik << endl;
    cout << "Premia dla Prezesa: " << premiaPrezes << endl;

    return 0;
}

Zwróć uwagę na kilka haczyków. Pierwszy haczyk jest taki, że to 80% musimy rozdzielić pomiędzy wszystkich pracowników firmy, czyli pomiędzy pracowników produkcji ale także między kierowników i prezesa, bo oni także są pracownikami firmy. Drugi haczyk jest taki, że prezes to także członek kadry kierowniczej, czyli 15% zysku przeznaczone dla kadry kierowniczej musimy podzielić przez liczbę kierowników + prezes. I stąd te wyniki.

 


 

c++ kurs programowania obiektowego spis treści 

 

 

C++ kurs programowania obiektowego (#6) Jak stworzyć dobry projekt (podział kodu na pliki).

Wiemy już co nieco o programowaniu obiektowym. Nie popadajmy jednak w samouwielbienie J na razie jest to niewiele ale już potrafimy coś zrobić. Przyszedł czas żeby Cię zapoznać z możliwościami dobrego rozplanowania projektu. Jak w prosty sposób poukładać sobie kod żeby był przejrzysty i żeby szybko można było dotrzeć do miejsca które chcemy odnaleźć.

Przy małych projektach nie mamy większego problemu jeżeli wszystkie klasy, metody i funkcje umieścimy w jednym pliku, głównym pliku main.cpp. Jeżeli tak podchodzimy do tematu to klasy lub funkcje umieścilibyśmy pomiędzy deklaracją przestrzeni nazw (using namespace) a główną funkcja main(). Poniżej taki właśnie przykład, program główny z dodaną klasą Smartfon (jej cechami i metodami).

Listing 6

#include <iostream>

using namespace std;

class Smartfon
{
    int waga;        // mierzona w g
    int szerokosc;   // mierzona w mm
    int wysokosc;    // mierzona w mm
    int grubosc;     // mierzona w mm
    float ile_cali;  // mierzona w calach
    int bateria;     // pojemnosc baterii mierzona w mAh

    void odbierz();
    void zadzwon();
};

int main()
{
    Smartfon smartfon1;
    smartfon1.waga = 1000;
    cout<< smartfon1.waga<<endl;
    return 0;
}

Ktoś powie, na razie na nasze potrzeby to wystarcza. Podejrzewam, że jak byśmy dopisali jeszcze kilka klas dalej nasz projekt byłby dla nas czytelny i umielibyśmy się w nim poruszać. Ale co w momencie kiedy nasz projekt rozrósł by się do większych rozmiarów np. 100 klas i każda klasa miałaby pomiędzy 50-100 linii kodu. Albo pójdźmy o krok dalej i dodajmy, że nasz program piszemy z przyjaciółmi i każdy ma określone zadania do oprogramowania i każdy pisze swoją część kodu u siebie w doku a my później musimy to połączyć w jedną działającą całość. No, przyznacie że nie jest to łatwe. Dobrze by było podzielić nasz kod na jakieś logiczne części i powiązać je ze sobą. Praca na jednym pliku nie jest podejściem dobrym. I dlatego wymyślono możliwość podziału kodu na kilka plików.

 

Żeby osiągnąć nasz zamierzony cel przeniesiemy wszystkie definicje klas do innego pliku np. klasy.cpp. Czy coś na tym zyskamy? Tak, bo już mamy oddzielony „kod główny” programu od klas. Więc tworzymy sobie nasz program w pliku main.cpp, tworząc kod wewnątrz funkcji main(), a klasy mamy w zupełnie osobnym pliku i to w nim dokonujemy potrzebnych zmian w klasach. Ale w pliku klasy.cpp dalej ciężko jest się nam poruszać. Przy niewielkich projektach, powiedzmy do kilku lub kilkudziesięciu klas, będziemy w stanie nad tym zapanować, ale my mamy nie być krótkowzroczni i myśleć przyszłościowo, jak szachiści przewidywać kolejne ruchy przeciwnika na kilka ruchów do przodu. Prędzej czy później nasz projekt się rozrośnie i jeżeli dalej wszystko będziemy mieli w jednym worku możemy w końcu przestać nad tym panować. Mam do Ciebie pytanie. Co robisz jeżeli chcesz wyszukać szybko jakąś treść w książce? Sięgasz do spisu treści! I tutaj zastosujemy podobny mechanizm. Utworzymy sobie taki dodatkowy pliczek z takim spisem treści o rozszerzeniu ‘h’ (od słówka headers, czyli nagłówki) np. klasy.h. Co nam to da? Uzyskamy dzięki temu mechanizm do szybkiego wyszukiwania metod i funkcji. W tym spisie treści szybko uzyskamy informację o wszystkich klasach ich atrybutach i metodach. Bez wchodzenia w kod danej metody będziemy wiedzieli  To tam umieszczamy komentarze po co jest ta funkcja, jak ona działa, jakie parametry przyjmuje itd.   

Jak byśmy rozbili nasz kod z listingu 6 na pliki które przed chwilą opisałem.

Plik main.cpp wyglądałby tak

Listing 7 – plik main.cpp

#include <iostream>
#include "klasy.h"

using namespace std;

int main()
{
    Smartfon smartfon1;
    smartfon1.waga = 1000;
    cout<< smartfon1.waga<<endl;
    return 0;
}

Plik klasy.h wyglądałby tak

Listing 8 – plik klasy.h

#include <iostream>

using namespace std;

class Smartfon
{
public:
    int waga;        // mierzona w g
    int szerokosc;   // mierzona w mm
    int wysokosc;    // mierzona w mm
    int grubosc;     // mierzona w mm
    float ile_cali;  // mierzona w calach
    int bateria;     // pojemnosc baterii mierzona w mAh

    void odbierz();
    void zadzwon();
};

a plik klasy.cpp wyglądałby tak

Listing 9 – Plik klasy.cpp

#include <iostream>
#include "klasy.h"

using namespace std;

    void Smartfon::odbierz()
      {
         // ciało metody odbierz 100 linii kodu
      }
    void Smartfon::zadzwon()
      {
         // ciało metody zadzwon 100 linii kodu
      }
/*
itd.  // ciała reszty metod klasy Smartfon
*/

Pewnie zauważyłeś, że w kodzie znalazły się nowe elementy.

  • w pliku main.cpp znalazł się nowy zapis #include "klasy.h"
  • w pliku klasy.cpp także znalazł się ten wpis #include "klasy.h" ale dodatkowo też Smartfon::odbierz() i Smartfon::zadzwon().

Co więc oznaczają owe tajemnicze wpisy.

  • #include "klasy.h"  – za pomocą słówka include mamy możliwość dodania nowych bibliotek ale dlaczego klasy.h jest w podwójnych cudzysłowach " ". My znamy już składnię z dwoma ostrymi nawiasami <> np. wiemy co znaczy #include <iostream>. Różnica między " " a <> jest taka, że ostre nawiasy mówią kompilatorowi, żeby szukał danej biblioteki w standardowych bibliotekach Code::Blocks’a a używając cudzysłowów " " sugerujemy kompilatorowi, że dodajemy plik z naszymi klasami który znajduje się w naszym katalogu z projektem.
    Ogólnie rzecz biorą chodzi o to, żeby plik main.cpp wiedział o istnieniu klas (cech i metod) lub funkcji zdefiniowanych w pliku klasy.h . Wyjaśnienie tego zapisu w pliku klasy.cpp jest dokładnie takie samo.
  • Smartfon::odbierz() – ponieważ może zdarzyć się sytuacja kiedy w kilku klasach będziemy mieli metodę o takiej samej nazwie napisanie np. tylko void odbierz(); nic kompilatorowi nie powie. Kompilator nie będzie wiedział o którą metodę, z której klasy, nam chodzi. Rozwiązaniem tego problemu jest wpisanie przed nazwą metody nazwę klasy z której ta metoda pochodzi a pomiędzy nimi wstawiamy operator zasięgu :: który, w naszym przypadku, oznacza, że metoda odbierz() pochodzi z klasy Smartfon.

Nie znamy jeszcze wszystkich zagadnień związanych z obiektowością więc na tym etapie kursu wystarczy, że będziemy wiedzieć musisz wiedzieć, że żeby metody i atrybuty (cechy) klasy były widoczne w programie głównym muszą być one publiczne dlatego na początku klasy Smartfon (przed definicją atrybutów) wrzuciliśmy słówko public:

 


c++ kurs programowania obiektowego spis treści  c++ kurs programowania obiektowego spis treści

 

 

 

 

 

C++ kurs programowania obiektowego (#5) klasy

Klasy

Już w części o obiektach krótko nadmieniłem co to jest klasa. Przypomnijmy, klasa to taka definicja obiektu, przepis wg którego komputer stworzy później konkretny obiekt (reprezentanta) danej klasy. Poniżej definicja klasy dla smartfona.

Listing 2

class Smartfon
{

int waga;
int szerokosc;
int wysokosc;
int grubosc;
float ile_cali;
int bateria;

};

Widzisz, ze definicję klasy rozpoczynamy od słówka class. Następnie podajemy jej nazwę, a w kolejnych liniach pomiędzy nawiasami { } które określają rozpoczęcie ciała klasy { i zakończenie ciała klasy } umieszczamy treść naszej klasy. W naszym przypadku umieściłem tutaj cechy które określiliśmy wcześniej. Zwróć uwagę, że po każdej linii definiującej daną cechę dajemy znak średnika „ ; ”, Średnik dajemy także po nawiasie zamykającym ciało klasy „ }; ” .

W ciele klasy, oprócz cech, umieszczamy także metody (czyli funkcje opisujące zachowanie naszego obiektu), o czym wspominałem już wcześniej. Cała definicja Twojej klasy mogłaby więc wyglądać np. tak.

Listing 3

class Smartfon

{

int waga;
int szerokosc;
int wysokosc;
int grubosc;
float ile_cali;
int bateria;

void odbierz();
void zadzwon();

};

Oczywiście metody odbierz() i  zadzwon() nic nie robią. Chcę abyś na razie opatrzył się z kodem, tworzyć kod będziemy „za chwilę”. Słówka void jeszcze nie znasz więc wyjaśnię, że słówko to znaczy tyle, że nasza metoda niczego nie będzie zwracała. Widzisz więc, że metoda niczego nie musi zwracać. Może wykonać pewne polecenia zapisane przez programistę ale efektem działania naszej metody nie zawsze musi być zwrócenie jakiejś konkretnej wartości.

Wiemy już co to jest obiekt i co to jest klasa. Przyszedł więc czas na stworzenie obiektu wg opisu zawartego w klasie. Obiekt będziemy tworzyli wewnątrz funkcji main(), czyli wewnątrz „programu głównego”. Deklaracja obiektu jest identyczna z deklaracją zmiennej. Przy zmiennej z lewej strony jej nazwy określamy jakiego typu będzie wartość w tej zmiennej, czyli np.

int liczba;

Czyli zadeklarowaliśmy zmienną o nazwie liczba i o typie int. Czyli tak naprawę nasz int opisuje co będzie w środku zmiennej. A co opisuje co będzie w środku w obiekcie? No oczywiście klasa. Czyli analogicznie do deklaracji zmiennej możemy powiedzieć, że obiekt jest typu klasy która ten obiekt opisuje. Może trochę to dla Ciebie na pierwszy rzut oka zagmatwane ale spójrz na przykład poniżej. Postaram się to wyjaśnić za pomocą klasy którą przed chwilą napisaliśmy , czyli klasy Smartfon.

Smartfon smartfon1;

Co oznacza powyższy zapis. Mówi tyle, że zdefiniowaliśmy obiekt (już konkretnego reprezentanta) o nazwie smarfon1, który jest typu no właśnie dochodzimy do sedna, typu Smartfon, czyli klasy o nazwie Smartfon. Widzisz już analogię między definicją zmiennych i definicją obiektów? Tutaj idealnie widać, że klasa jest Twoim własnym typem, który później możesz wykorzystać przy obiektach.

Jak już  stworzyliśmy konkretny obiekt o nazwie smartfon1 to teraz możemy przypisać każdej z jego cech jakąś wartość zgodną z typem przypisanym do tej cechy np.

smartfon1.waga = 1000;  // pamiętaj waga miała być wyrażana w g.

Nasz kod w tym momencie wygląda jak poniżej.

Lising 4

#include <iostream>

using namespace std;

class Smartfon

{

    int waga;        // mierzona w g

    int szerokosc;   // mierzona w mm

    int wysokosc;    // mierzona w mm

    int grubosc;     // mierzona w mm

    float ile_cali;  // mierzona w calach

    int bateria;     // pojemnosc baterii mierzona w mAh

 

    void odbierz();

    void zadzwon();

};

 

int main()

{

    Smartfon smartfon1;

    smartfon1.waga = 1000;

    cout<< smartfon1.waga<<endl;

    return 0;

}

Gdybyśmy chcieli uruchomić kod powyżej to otrzymamy błąd „error : ‘int Smartfon::waga’ is private”. Co to oznacza? Oznacza to tyle, że cecha waga klasy Smartfon jest prywatna, czyli inne funkcje w „głównym programie” main() nie maja do niej dostępu i nie możemy przypisać jej żadnej wartości przy nowo tworzonych obiektach tej klasy. O modyfikatorach dostępu będzie mowa później w naszym kursie. Na razie musisz wiedzieć, że abyś mógł przypisać wartość do cechy obiektu wewnątrz funkcji main() to musisz „ustawić” jego cechy jako publiczne za pomocą modyfikatora public. Później dowiesz się, że jest jeszcze inne wyjście ale o tym w odcinku o modyfikatorach dostępu. Żeby ustawić cechy klasy jako publiczne wstaw słówko public: przed wszystkimi cechami w ciele klasy.

Listing 5

class Smartfon

{

  public:

    int waga;       

    int szerokosc;  

    int wysokosc;   

    int grubosc;    

    float ile_cali; 

    int bateria;    

 

    void odbierz();

    void zadzwon();

};

To tyle na razie odnośnie klas. Ale ten temat będzie się przewijał jeszcze nie raz.


c++ kurs programowania obiektowego spis treści  c++ kurs programowania obiektowego spis treścic++ kurs programowania obiektowego spis treści

C++ kurs programowania obiektowego (#4) zacznij myśleć obiektowo, obiekty

Zacznij myśleć obiektowo

Co to w ogóle jest programowanie obiektowe? To taki wzorzec (sposób) tworzenia kodu (programu), który polega na definiowaniu przez programistę obiektów i zarządzaniu komunikacją tych obiektów w celu wykonania jakiegoś konkretnego zadania (osiągnięcia założonego celu).

Po co nam w ogóle ta obiektowość? Kiedy zaczynamy swoją przygodę z programowaniem, najczęściej zaczynamy od podejścia proceduralnego i często przy małych projektach na początku nie widzimy potrzeby korzystania z programowania obiektowego. W miarę upływu czasu kiedy nasze potrzeby rosną ale rośnie także nasza świadomość programisty, zaczynamy zauważać pewne ograniczenia i szukamy innych rozwiązań. Nie będę w tym miejscu w punktach wymieniał zalet jakie zyskujesz dzięki programowaniu obiektowemu, będziemy je odkrywać z każdą kolejną częścią tego kursu i sam zauważysz zalety takiego podejścia.

Najfajniejsze w tym wszystkim jest to, że zasady dotyczące „obiektowości” przedstawione w tym kursie będą miały zastosowanie wszędzie nie tylko w C++.

Jeżeli nie zrozumiesz „obiektowości” od razu, nie zrażaj się tylko przeczytaj daną część nawet kilkukrotnie do pełnego zrozumienia danego tematu a uwierz mi Twoja cierpliwość będzie nagrodzona J Może nawet uznasz, że wiedza którą próbujesz przyswoić zupełnie nie jest do niczego potrzebna a poszczególne jej fragmenty nie łączą się ze sobą, to nie zniechęć się, bo w trakcie pracy z tym kursem dojdziesz do wniosku, że to jednak ma sens, że nagle poszczególne kawałki zaczynają się łączyć w większą całość jak układanie puzzli. Tego Ci życzę 🙂

Obiekty

Pierwszym pojęciem jakie poznamy to obiekt. Kiedy mówimy obiekt od razu staje nam przed oczami jakiś realny przedmiot np. smartfon, telewizor, auto itd. Jest to jak najbardziej poprawne skojarzenie bo to są dobre przykłady obiektów. Każdy z tych obiektów ma jakieś właściwości które go cechują (opisują). Te właściwości nazywamy cechami, rzadziej atrybutami lub po prostu właściwościami. Poniżej przykład cech  opisujących obiekt smartfon.

Obiekt: smartfon

Cechy:

  • waga
  • szerokosc
  • wysokosc
  • grubosc
  • ile_cali
  • bateria

Poprzestańmy na tylu cechach, oczywiście moglibyśmy pewnie znaleźć jeszcze kilka ale myślę, że na nasze potrzeby to wystarczy.

Taki opis wystarczy nam ludziom bo my wiemy jakie dane (typy danych) można by było przypisać  tym cechom, ale dla komputera nie jest to wystarczające i musimy mu określić jakie typy danych mogą się znaleźć w poszczególnych cechach np.

  • int waga; // wyrażona w g
  • szerokosc;  // wyrażona w mm
  • wysokosc;  // wyrażona w mm
  • grubosc;  // wyrażona w mm
  • ile_cali;  // wyrażone w calach
  • bateria;  // pojemnosc baterii mierzona w mAh

gdzie int oznacza liczbę całkowitę a float liczbę zmiennoprzecinkową. PAMIĘTAJ w C++ po określeniu cechy dajemy znak średnika ‘;’.

Ktoś powie,  że niektóre z ww. wymiarów powinny być typu float np. szerokość, przecież szerokośc smartfona może być liczbą zmiennoprzecinkową. Tak to prawda jeżeli chcemy aby szerokość była wyrażona w centymetrach, ale jeżeli chcemy ją już wyrazić w milimetrach to już możemy korzystać z typu int. Widzisz więc, że typ danych dla poszczególnej cechy będzie uzależniony od jednostek w jakich będziemy wyrażać jej wartość.

Do tej pory zajmowaliśmy się obiektami rzeczywistymi, czyli realnymi przedmiotami. Może się zdziwisz ale obiekty mogą być także abstrakcyjne, czyli nienamacalne. Przykładem takiego obiektu może być np. sen. Czy jest to coś namacalnego? Nie. A czy może być obiektem który posiada  cechy? Tak. Cechami snu mogą być np. właściciel snu, treść snu, częstotliwość powtarzania się snu, ładunek emocjonalny snu itd. Pewnie dużo częściej będziesz spotykał się z tymi realnymi obiektami ale chcę żebyś wiedział, że te abstrakcyjne także istnieją.

Na razie poznaliśmy cechy obiektów czyli określenie ich stanu. Oprócz tego możemy określić jego zachowanie, czyli wykonywanie przez ten obiekt jakichś czynności, zadań np. smartfon: dzwonienie, odbieranie SMS-ów, budzenie (funkcja budzika); np. pralka: pranie, wirowanie, suszenie itd. Określenie takich zadań nazywamy metodami. Metoda to nic innego jak funkcja wewnątrz klasy, która służy do zdefiniowania zadania wykonywanego przez nasz obiekt z wykorzystaniem cech, które ma ten obiekt.

Przykład metody dla obiektu Smartfon

int CzasPracy(parametry)

{

   // obliczenia na parametrach

   return czas;

}

Spójrz na powyższy przykład. Zdefiniowaliśmy metodę CzasPracy, która ma za zadanie, na podstawie pobranych parametrów, obliczyć (oczywiście szacunkowo) jak długo będzie działał nasz smartfon. Na razie w miejsce parametrów i obliczeń nic nie podstawiam. Chcę żebyś zrozumiał najpierw zasadę technikaliami zajmiemy się w dalszej części kursu.

Teraz trzeba to ubrać w jaką bardziej formalną postać (definicję). Taką definicją jest klasa, to taki opis (schemat) za pomocą którego komputer wie później jak utworzyć dany obiekt.

W kolejnej części dowiesz się jak się tworzy klasę i jak później za pomocą tej klasy tworzymy konkretny egzemplarz danego obiektu.


c++ kurs programowania obiektowego spis treści  c++ kurs programowania obiektowego spis treścic++ kurs programowania obiektowego spis treści

C++ kurs programowania obiektowego (#3) pierwszy program, omówienie kodu

Co w trawie piszczy, czyli objaśnienie kodu programu "Hello world!".

No tak, wszystko fajnie ale skąd w zasadzie wzięły się te wszystkie linie kodu w pliku main.cpp w naszym pierwszym projekcie i co one oznaczają?

cpp c++ hello world code

Przy tworzeniu projektu Code::Blocks wyręcza nas i tworzy główny plik projektu z domyślną (default-ową) treścią, żeby programista sam nie musiał już „klepać” tego kodu od początku. A co oznaczają te poszczególne linie? Prześledźmy kod linia po linii. Wyjaśnienia do poszczególnych linii będę umieszczał w komentarzach, czyli za znakami „//” które w C++ oznaczają komentarz jednoliniowy. Znaczy to tyle, że wszystko co znajdzie się po prawej stronie tych znaków będzie komentarzem i do końca linii będzie pomijane przez kompilator, komputer to po prostu zignoruje np.

// treść komentarza

Code::Blocks oznacza komentarze na szaro. Z reguły komentarze w innych środowiskach są oznaczane na zielono, więc jeżeli spotkasz się z takim kolorem w innych IDE to nie będziesz już zdziwiony. Skoro jesteśmy już przy komentarzach i opisałem komentarz jednoliniowy to zapewne się domyślasz, że istnieje również komentarz wieloliniowy, do zdefiniowania którego używamy znaków /* treść komentarza */. Przykład komentarza wieloliniowego poniżej.

/* treść komentarza wiersz 1

treść komentarza wiersz 2

treść komentarza wiersz 3

treść komentarza wiersz 4

treść komentarza wiersz 5 */

 

Zgodnie z tym co napisałem powyżej wszystko co znajdzie się pomiędzy znakami  /**/ zostanie pominięte (zignorowane) przez kompilator. Tylko nadmienię, że ogólnie przyjęła się niepisana zasada, że komentarze umieszczamy nad kodem który komentujemy.

 

OK, przejdźmy do analizy kodu naszego pliku main.cpp.

// dodanie biblioteki iostream która jest odpowiedzialna za operacje wejścia/wyjścia
#include <iostream>              

Ale co to jest ta biblioteka i co to są operacje wejścia/wyjścia. Biblioteka w programowaniu to taki zbiór gotowych funkcji, takich podprogramów, które w każdym momencie możemy wykorzystać do własnych celów. To tak jak w bibliotece z książkami. Jeżeli potrzebujemy przeczytać jakąś książkę to idziemy do biblioteki wypożyczamy odpowiednią książkę, korzystamy z niej (czytamy) i odnosimy do z powrotem do biblioteki. Przy bibliotece programistycznej nie ma tylko „fizycznych” elementów wypożyczenia i oddania książki do biblioteki ale cała reszta jest identyczna. Jeżeli potrzebujemy, odwołujemy się do konkretnego podprogramu (funkcji) w bibliotece, korzystamy z niej i tyle. Nie musimy nawet wiedzieć jak jest skonstruowany środek tego podprogramu. Musimy tylko wiedzieć do czego służy i jak z niego skorzystać.

Żeby dodać bibliotekę do naszego programu używamy słówka include po którym umieszczamy nazwę dodawanej biblioteki pomiędzy znakami <> co oznacza, że kompilator będzie szukał tej biblioteki w standardowych bibliotekach Code::Blocks’a.

Operacje wejścia/wyjścia to nic innego jak mechanizm porozumiewania się z naszego komputera z urządzeniami wejścia, czyli np. klawiaturą i z urządzeniami wyjścia, czyli np. z monitorem. No przecież w jakiś sposób musimy powiedzieć naszemu komputerowi, że w danym momencie oczekujemy, że użytkownik napisze coś na klawiaturze (wprowadzi jakieś dane) i czekamy na to co on wpisze a w innym przypadku chcemy coś wyświetlić naszemu komputerowi. Ot cała filozofia.

 

// zdefiniowanie przestrzeni nazw
using namespace std;

O co chodzi z tymi przestrzeniami nazw. Wyobraźmy sobie, że mamy duży projekt i dołączyłeś do niego już kilka bibliotek z różnych źródeł. W pewnym momencie dochodzisz do sytuacji dublowania się nazw jakichś obiektów np. funkcji. Rozwiązaniem takiej sytuacji jest stworzenie przestrzeni nazw i umieszczenie wszystkich potrzebnych nam obiektów w tej przestrzeni. Następnie poprzez jej nazwę, możemy odwołać się do danego obiektu (np. funkcji) umieszczonego w tej przestrzeni i dzięki temu kompilator wie, że chcemy skorzystać właśnie z tej konkretnej funkcji (jeżeli jest kilka funkcji o tej samej nazwie w programie). Linia using namespace std;  oznacza, że w naszym programie będziemy korzystali z przestrzeni nazw o nazwie std. Ta przestrzeń zawiera wiele przydatnych elementów m.in. różne funkcje do sortowania, wyszukiwania lub definicje klas takich jak string, vector itd.

// główna funkcja programu
int main()
{

// ciało funkcji

return 0;

}

W końcu doszliśmy do pierwszej funkcji w naszym programie. Składnia powyżej to główna funkcja o nazwie main, która zawsze jest uruchamiana podczas startu programu, no bo przecież program musi wiedzieć z którego miejsca w kodzie ma wystartować. Na początku określamy co ma zwracać funkcja, czyli słówko int. Nie poznaliśmy jeszcze typów danych ale na razie wystarczy żebyś wiedział, że int oznacza liczbę całkowitą, czyli nasza funkcja powinna zwrócić jakąś liczbę całkowitą. Do określenie co zwraca funkcja, używamy słówka return. W tym momencie mówimy naszemu kompilatorowi, że zwracamy określoną wartość (w naszym przypadku wartość 0 bo u nas jest zapis return 0) i program się kończy. Dzięki nawiasom {} kompilator wie gdzie zaczyna się nasza funkcja, nawias { , i gdzie się kończy }. Wszystko co się znajduje wewnątrz naszych nawiasów tworzy ciało naszej funkcji, czyli polecenia do wykonania przez komputer. To tutaj będziemy pisali „główny” kod programu który będzie wykonywany przez komputer.

// funkcja cout służy do wyświetlania ciągów znaków na ekranie
cout << ”Hello world!” << endl ;

To funkcja z obiektowej biblioteki iostream pozwalająca nam na przesłanie na ekran dowolnego ciągu znaków, w naszym przypadku Hello world!. Zobacz jakie to proste, używasz jej nie widząc nawet jej środka. Słówka cout  i endl to odwołanie się do funkcji które znajdują się w bibliotece iostream i żebyśmy mogli odwołać się do nich musieliśmy na początku dodać tą bibliotekę poleceniem #include <iostream>. Ale żeby kompilator wiedział dokładnie o którą dokładnie funkcję chodzi musimy mu także wskazać że chodzi nam o przestrzeń nazw  std i zrobiliśmy to już wcześniej poleceniem using namespace std; Teraz już nie ma możliwości żeby kompilator pomylił funkcje. Gdybyśmy na początku nie zdefiniowali, że chcemy używać właśnie tej przestrzeni nazw (std), musielibyśmy przy każdym użyciu funkcji cout i endl (i każdej innej która należy do tej przestrzeni) określać o jaką przestrzeń nazw nam chodzi w ten sposób std::cout.

No to chyba już wszystko jasne i możemy przejść do kolejnego zagadnienia jakim będzie obiekt a później klasa.


c++ kurs programowania obiektowego spis treści  c++ kurs programowania obiektowego spis treścic++ kurs programowania obiektowego spis treści

C++ kurs programowania obiektowego (#2) pierwszy program „Hello World!”

Tworzymy nasz pierwszy projekt „Hello World!”.

Przyszedł czas na stworzenie Twojego pierwszego projektu i tutaj chyba nie będzie niespodzianki, będzie to projekt wyświetlający napis „Hello World!” w konsoli. To klasyka gatunku. Chyba każdy programista zaczynał od takiego projektu i ja nie zamierzam zmieniać tej tradycji. No to zaczynamy!

Uruchamiamy naszego Code::Blocks’a i klikamy na ikonę Create a new project. Ten sam efekt uzyskamy klikając w menu File -> New -> Project… ale sposób z ikonką jest po prostu szybszy.

cpp c++ course kurs create new project

Rysunek 4. Ikona „Create a new project”.

W kolejnym oknie o nazwie New from template mamy możliwość wybrać szablon projektu. Na początku będziesz pracował w konsoli, dlatego wybierz opcję Console application, czyli będziemy tworzyć aplikację konsolową. Zaznacz więc tą opcję i potwierdź swój wybór przyciskiem Go.

cpp c++ course kurs create new project

Rysunek 5. Wybór szablonu projektu.

Kolejne okno to wybór języka w którym chcesz pisać kod. Ty będziesz programował w C++ więc wybierasz tą opcję z dostępnych języków programowania i przechodzisz dalej klikając w przycisk Next.

cpp c++ course kurs create new project

Rysunek 6. Wybór języka programowania.

Teraz przyszedł czas żebyś nazwał swój projekt i określił gdzie będziesz przechowywał pliki swojego projektu. Zacznijmy od pola Folder to create project in gdzie wpisujemy ścieżkę dostępu do katalogu w którym chcemy przechowywać pliki naszego projektu. Klikając w przycisk […] otworzysz okno dialogowe gdzie na drzewie katalogów możesz wskazać interesujący Cię katalog. Po wskazaniu i potwierdzeniu Twojego wyboru przyciskiem OK wrócisz do poprzedniego okna z wpisaną automatycznie ścieżką dostępu w polu Folder to create project in. Pamiętaj, że finalnie w katalogu który wskazałeś powstanie jeszcze dodatkowy katalog o nazwie takiej samej jaką wpiszesz w polu Project title i tam dopiero znajdą się pliki Twojego projektu. Jak przed chwilą napisałem nazwę Twojego projektu wprowadzasz w pole Project title. Zwróć uwagę, że nazwa ta pojawi się automatycznie w polu Project filename z rozszerzeniem .cbp (o plikach składowych projektu za chwilę).

cpp c++ course kurs create new project

Rysunek 7. Wybór nazwy projektu i jego lokalizacji.

I ostatnie okno gdzie możesz wybrać kompilator dla twojego projektu. W tym oknie wszystko zostaje tak jak na poniższym rysunku. Potwierdzasz tylko Twój wybór przyciskiem Finish.

cpp c++ course kurs create new project

Rysunek 8. Wybór kompilatora.

Jeszcze tylko słówko wyjaśnienia co to jest ten kompilator. Otóż jest to program służący do przetłumaczenia tego do napisałeś, w naszym przypadku w C++, na język zrozumiały przez komputer, żeby komputer zrozumiał czego my tak w ogóle od niego chcemy J i co on ma zrobić.

Po zatwierdzeniu wszystkiego Code::Blocks wróci do okna głównego aplikacji. Zobaczymy dwie nowe rzeczy. Po lewej stronie w zakładce Projects zobaczymy drzewko przedstawiające strukturę naszego projektu. Zwróć uwagę, że po rozwinięciu gałęzi Sources znajduje się plik main.cpp. To główny plik naszego projektu. Dwukrotne kliknięcie go na drzewku spowoduje wyedytowanie tego pliku w głównym oknie po prawej stronie od drzewka projektu (patrz rysunek). Treść którą widzisz poniżej na rysunku powstaje automatycznie przy tworzeniu projektu i pliku main.cpp (listing 1).

cpp c++ course kurs create new project

Rysunek 9. Drzewo projektu i edycja pojedynczego pliku projektu.

Teraz uwagę, że zakładka w której edytujesz plik main.cpp ma taką samą nazwę jak ten plik. W ten sposób będziesz się poruszał pomiędzy poszczególnymi plikami, jeżeli w danym momencie będziesz miał ich otwartych więcej niż jeden a uwierz mi będziesz miał J

Teraz o oknie głównym możesz dowolnie modyfikować treść tego pliku. Już w tym momencie program powinien zadziałać i na ekranie konsoli powinien pojawić się napis Hello world! Żeby uruchomić projekt (program) wciśnij przycisk F9.

cpp c++ course kurs create new project

Rysunek 10. Uruchomienie projektu "Hello world!".

Z powyższego rysunku wynika, że nasz program działa prawidłowo. Na ekranie został wyświetlony napis „Hello world!”. Zwróć uwagę, że poniżej napisu zostały wyświetlone jeszcze dwie dodatkowe linie z informacją o czasie wykonania programu i prośba o wciśnięcie jakiegoś przycisku na klawiaturze. Code:Blocks jest na tyle pomocny, że na samym końcu wstrzymuje nasz program i wyświetla te dodatkowe informację (my sami nie musimy o tym pamiętać) i dopiero po przyciśnięciu jakiegoś przycisku na klawiaturze zamknie okno konsoli. Widzisz jeszcze nie napisałeś nawet kawałka kodu a już uruchomiłeś pierwszy program 🙂


c++ kurs programowania obiektowego spis treści  c++ kurs programowania obiektowego spis treścic++ kurs programowania obiektowego spis treści

C++ kurs programowania obiektowego (#1) Środowisko programistyczne IDE

Oddaję dzisiaj w Twoje ręce pierwszy odcinek serii (mam nadzieję) o obiektowym programowaniu w C++. W dzisiejszym odcinku dowiemy się jak zacząć. Dowiesz się co Ci jest potrzebne do programowania w C++? Skąd masz ściągnąć narzędzia potrzebne do programowania? itd.

Nie tracąc Twojego i mojego cennego czasu zaczynamy!

Czego potrzebuję żeby zacząć programować i co to jest IDE?

Aby rozpocząć swoją przygodę z programowaniem w C++ musisz gdzieś pisać swoje programy. Do tego celu musisz mieć środowisko programistyczne, w skrócie nazywane IDE od angielkich słówek Integrated Development Environment. IDE to aplikacja (lub zbiór aplikacji) w której będziesz pisał kod i dzięki której będzie mógł go uruchomić w celu przetestowania poprawności zaprogramowanych funkcjonalności. Do celów naszego kursu wykorzystamy IDE o nazwie Code::Blocks.

Skąd moge pobrać IDE Code::Blocks?

Środowisko Code::Blocks możemy pobrać ze strony www.codeblocks.org gdzie menu głównym strony klikamy w opcję download. Dzięki temu przejdziemy na stronę skąd możemy pobrać naszego Code::Blocks'a. Aby to zrobić po lewej stronie widzimy menu main w którym klikamy na opcję download a później na binaries.

c++ kurs programowania obiektowego środowisko programistyczne codeblocks

Rysunek 1. Strona codeblocks.org i wybór wersji środowiska programistycznego IDE CodeBlocks

c++ kurs programowania obiektowego środowisko programistyczne codeblocks

Rysunek 2. Wybór źródła pliku instalatora.

W zależności od potrzeb wybieramy odpowiednią opcję. Ja polecam wybranie opcji codeblocks-17.12mingw-nosetup.zip (w nazwie pliku jest zaszyta także wersja IDE więc widać, że w trakcie tworzenia tego kursu aktualną wersją tego IDE jest wersja 17.12). Jest to wersja bez instalacyjna, która zawiera już w sobie kompilator i debuger.

Po kliknięciu w link sourceforge.net przy odpowiedniej wersji CodeBlocks'a uruchomimy ściąganie pliku instalatora w postaci archiwum. Po ściągnięciu i rozpakowaniu archiwum uruchamiamy plik o nazwie codeblocks.exe i już możemy cieszyć się tworzeniem kodu. Acha, nie napisałem chyba chyba najważniejszego plusa tego środowiska, JEST ONO DARMOWE 🙂 więc bez obaw możesz zacząć bawić się w programistę.

c++ kurs programowania obiektowego środowisko programistyczne codeblocks

Rysunek 3. Widok ogólny środowiska programistycznego (IDE) CodeBlocks.


c++ kurs programowania obiektowego spis treści  c++ kurs programowania obiektowego spis treści

C++ kurs programowania obiektowego (#0)

Wszystkie wpisy dotyczące C++ już przeniesione na nasz nowy portal TUTORIALSPOINT.PL

Wszystkie nowe wpisy dot. programowania w C++ , C# , SQL (SQL Server, PostgreSQL i MySQL) będą umieszczane już na nowym portalu TUTORIALSPOINT.PL

 

C++ kurs podstawy programowania

Zmienne. Typy danych.
Instrukcja warunkowa if else.
Instrukcja warunkowa switch case.
Pętla for.
Pętla while.
Pętla do while.
Praca z plikami tekstowymi, zapis.
Praca z plikami tekstowymi, odczyt.

C++ kurs programowania obiektowego

(#1) Środowisko programistyczne IDE (skąd pobrać? jak rozpocząć programować?)
(#2) Pierwszy program "Hello world!".
(#3) Pierwszy program omówienie kodu.
(dodawanie bibliotek, wskazywanie przestrzeni nazw, funkcja main)
(#4) Obiekty (zacznij myśleć obiektowo)
(#5) Klasy
(#6) Jak stworzyć dobry projekt (podział kodu na pliki)
(plik nagłówkowy, plik z ciałami metod)