6. Metody część 2

W tym rozdziale powiemy sobie więcej o metodach. Zrozumienie tego rodziału jest kluczowe do pisania ładnego i przyjrzystego kodu.

6.1 Przekazywanie argumentów do funkcji

Przeważnie pisaliśmy metody na zasadzie

void Method(){}

W nawiasach () możemy przekazać argumenty do funkcji. Już wyjaśniam, dlaczego jest to przydatne. Funkcje tak samo jak klasy, powinny trzymać się zasady Single Responsibility Principle.
Jeżeli piszemy kalkulator i zrobimy klase CalculatorLogic na takiej zasadzie

CalculatorLogic()
{
public:
    CalculatorLogic(){}
};

Powstaje pytanie jak przekazywać dane do tej klasy? Na przykładzie:

void Add()
{
    int firstNumber, secondNumber;
    cout << "podaj dwie liczby calkowite\n";
    cin >> firstNumber >> secondNumber;
    cout << "Twoj wynik to " << firstNumber + secondNumber << "\n";
}

Zastanów się co jest źle z tym kodem zanim zaczniesz czytać dalej.
- Funkcja nazywa się Add, a pobiera i wyświetla coś użytkownikowi! Jest to złamanie SRP, a co więcej jest to bardzo niepraktyczne. Dlaczego? Powiedzmy, że chcemy zrobić sprawdzenie liczb czy są poprawne (np zakres, czy ktoś nie wprowadził znaku itd.). Funkcja wtedy po prostu zrobi się skomplikowana. A takie funkcje (przeważnie) nie powinny istnieć.

Przychodzą nam z pomocą parametry funkcji. Popatrz na przykładowy kod

void Add(int firstNumber, int secondNumber)
{
    cout << "Twoj wynik to " << firstNumber + secondNumber << "\n";
}

Kod nam się skrócił o rząd wielkości. Zrobił się protszy i czytelniejszy. Nadal wyświetla coś do użytkownika. Tym zajmiemy się w sekcji 6.2.
Jak wywołujemy taką funkcje? Robimy coś na zasadzie:

int main()
{
    int numberOne, numberTwo; // specjalnie zmienilem tutaj nazwy, bo chce Ci pokazac, ze nazwy w funkcji są niezalezne. One mają swoj wlasny proces zycia (swoj wlasny zasieg ktory jest tylko i wylacznie w tej funkcji*)
    cout << "podaj dwie liczby calkowite\n";
    cin >> numberOne >> numberTwo;

    CalculatorLogic calculatorLogic;
    calculatorLogic.Add(numberOne, numberTwo);
}

Jak widać, ilość argumentów przekazanych i zdefiniowanych musi się zgadzać. Spróbuj skompilować kod z jednym przekazanym argumentem (np. tylko numberOne). Kompilator powinien nam podpowiedzieć, że funkcja oczekuje X argumentów a podaliśmy Y argumentów.
Zdefiniowane argumenty mogą być dowolnego typu, ale przekazane obiekty muszą się zgadzać jeżeli chodzi o typy danych. Troche to pogmatwane. Rozbijmy to na części pierwsze

Jeżeli mamy funkcje
void Foo(Wood object) {}

To nie możemy jej wywołać z obiektem typu Metal*. Typy danych muszą się zgadzać inaczej program nam się nie skompiluję. Jeżeli chodzi o liczby, to uważaj by do inta nie przepisywać float'ów. Wszystko co jest po przecinku zostanie **ucięte**!

6.2 Zwracany typ funkcji

W większości wypadków pisaliśmy void NazwaFunkcji(argumenty). Teraz wyjaśnie co robi ten void i jak go zamienić. Popatrz na ten kod

int Add(int firstNumber, int secondNumber)
{
    return firstNumber + secondNumber;
}

Zmieniłem deklaracje z void na int. To mówi, że ta funkcja zwraca jako wynik liczbę całkowitą. Void natomiast mówi, że funkcja nic nie zwraca. Zauważ, że jest teraz coś takiego jak return. Teraz w main możemy napisać

int main()
{
    int numberOne, numberTwo;
    cout << "podaj dwie liczby calkowite\n";
    cin >> numberOne >> numberTwo;

    CalculatorLogic calculatorLogic;
    cout << "Twoj wynik to " << calculatorLogic.Add(numberOne, numberTwo) << "\n";
}

możemy równie dobrze zrobić coś takiego

int main()
{
    int numberOne, numberTwo;
    cout << "podaj dwie liczby calkowite\n";
    cin >> numberOne >> numberTwo;

    CalculatorLogic calculatorLogic;
    int sum = calculatorLogic.Add(numberOne, numberTwo);
    cout << "Twoj wynik to " << sum << "\n";
    // tutaj mozemy dalej korzystac z tej sumy jezeli potrzebujemy
}

spróbuj w funkcji Add napisać sam return bez żadnego wyrażenia i zobacz co kompilator wyświetli.

6.3 Funkcje wywolujace inne funkcje

Funkcje mogą, a w większości to wywołują inne funkcje. Nasze funkcje powinny robić jedną rzecz. Nie było by to przyjemne kombinować z wywoływaniem funkcji tylko dlatego, że funkcja robi "za mało". Kod wtedy stał by sie nieczytelny. Na przykład jak powinno się pisać kod

void HandleInput(){}

Mówi nam, że ta funkcja obsługuje wejście (zapewne od Użytkownika). Zapewne w takiej funkcji zrobimy coś takiego

void HandleInput()
{
    GetInput();
    if(!IsInputValid) // czyli jezeli input nie jest poprawny. ! jest negacja warunku. Z true robi false, z false robi true
    {
        NotifyUser()
    }
}

Jako, że jest to bardzo ogólna funkcja, możemy tutaj posiadać funkcje które pobierają i ewentualnie komunikują się z użytkownikiem jeżeli poszło coś nie tak. Mamy pewne warstwy w tych funkcjach. Zaczynając od ogólników a kończąc na szczegółach. Pamiętaj, kod powinien być pisany tak, że osoba nietechniczna powinna być w stanie powiedzieć +- co się w nim dzieje (bez szczegółów, samymi ogólnikami)

6.4 Referencja

Nie wyjaśnie dokładnie czym jest referencja. Temat jest dość skomplikowany i trzebaby było cytować dokumentacje języka oraz interpretacje popularnych kompilatorów. Taki rozdział powstanie, ale nie w najbliższym czasie.
Co musisz wiedziec o referencji, że jest to tak jakby link do stworzonego obiektu. Coś na zasadzie jak masz strone internetową i żeby do niej się dostać to klikasz w link. Nie musisz miec fizycznie tej strony u siebie na komputerze.

Zasada od dzis: Jeżeli coś nie jest typem prostym i nie chcesz tego obiektu skopiować przekaż to przez referencje (chodzi tutaj o funkcje).

Parę przykładów

mamy taką funkcje

int Foo(int number){}

jeżeli wywołamy funkcje Foo(someRandomNumber); to tak na prawdę funkcja Foo stworzy **kopie** liczby someRandomNumber (bedą istnieć dwie zmienne o tej samej wartości). Tworzenie kopii nie jest czymś złym. Czasami chcemy stworzyć kopie. Najczęściej nie potrzebujemy tworzyć kopii, ale do typów prostych w większości nie ma sensu przekazywać referencji. Pokaże kiedy "jest" sens to robić (przeważnie można to zrobić lepiej)

class App
{
public:
    App(){}
    void Foo(int& number) // zauwaz ze jest & za typem danych. Jest to informacja ze number jest referencja
    {
        number = 5;
    }
    void Bar(int number) // tutaj nie ma referencji, zostanie stworzona kopia
    {
        number = 5;
    }
};

int main()
{
    int number = 10;
    App app;
    cout << "liczba oryginalna to " << number;
    app.Bar(number)
    cout << "liczba po wykonaniu funkcji Bar " << number;
    app.Foo(number);
    cout << "liczba po wykonaniu funkcji Foo " << number; // Liczba zostala zmieniona na liczbe 5! bo została przekazana jako "link" i funkcja pracowała na oryginale a nie na kopii!
}

To jest przykład jak działa referencja. Dlaczego warto jej używać? Ze względu na prędkość wykonywania się programu. Wyobraż sobie, że masz obiekt który zajmuję w pamięci 1mb i musisz go przekazać 100 razy w funkcji. Gdy bedziesz tworzyć za każdym razem kopie to raz, ze będzie to powolne (bo program musi przekopiować wszystkie wartości) to jeszcze zajmie 100mb więcej miejsca. Gdy przekażemy referencje oba problemy znikają (referencja jest tania. **Przeważnie** zajmuję 4 bajty)

Tak więc gdy chcemy przekazać klasę to robi to w ten sposób

class App
{
public:
    App(){}
    void Foo(SomeClass& sc)
    {
        // tutaj operacje
    }
};


6.5 Deklaracja i definicja w obrębie klasy

Jeszcze taka drobna rzecz która się przyda do robienia porządku w projekcie

Gdy mamy klase, nie musimy od razu definiować jej funkcji w środku klasy! Praktyka w C++ jest taka, ze deklaracje piszemy w plikach .h (albo hpp), a definicje w plikach .cpp

Najpierw pokaże jak rozdzielić deklaracje i definicje w obrębie jednego pliku

class Foo
{
public:
    Foo(); // zauwaz, ze jest ; i nie ma {} to jest deklaracja
    void Bar(); //tutaj tak samo
};

Foo::Foo() // to jest definicja
{
}

void Foo::Bar() // to jest definicja
{
}

Zasada definicji jest następująca.
TYPZWRACANY NAZWAKLASY::NAZWAMETODY(PARAMETRY)
{
}

A jak to rozdzielić na dwa pliki? Bardzo prosto. Definicje przerzuć do pliku cpp i na samym początku dołącz plik .h w którym sa deklaracje np

Foo.h

#pragma once
Foo()
{
public:
    Foo();
    void Bar();
}

Foo.cpp
#include "Foo.h"
Foo::Foo()
{
}

void Foo::Bar()
{
}

main.cpp

#include "Foo.h"

int main()
{
    Foo foo;
    foo.Bar();
}

6.6 Zadania
- Dopisz CalculatorView do projektu.
- Dopisz pozostałe funkcje kalkulatora takie jak: Subtract, Multiply, Divide, Power* (chodzi o potęgowanie), SquareRoot(pierwiastkowanie), Log*, Cosinus*, Sinus* itd. Pamiętaj by korzystać z gotowych funkcji! Nie wymyślaj koła na nowo.
-* Zmień kalkulator tak by przyjmował N liczb (np dopóki użytkownik nie przerwie wpisywania danych). Zastanów się nad architekturą
- popraw poprzednie programy, tak by przekazywały referencje tam gdzie są potrzebne.
- rodziel dotychczasowe programy tak by definicja była po za klasą