TDIU20 - Objektorienterad programmering i c++ - föreläsning 3

Transkript

1 TDIU20 - Objektorienterad programmering i c++ - föreläsning 3 Pontus Haglund Department of Computer and information science

2 1 Vad har vi gjort hittills 2 Felhantering 3 Operatorer 4 binära operatorer 5 unära operatorer 6 user-defined literal 7 Typomvandling

3 2 / 57 Dagens föreläsning 1. Vad har vi gått igenom hittills? 2. Kort upprepning av koncept 3. Felhantering: throw, try, catch 4. Typkonvertering 5. Operatorer för complex

5 4 / 57 Vad har vi gått igenom hittills? Klass vs Objekt Struktur av en klass Inkapsling Datamedlemmar Konstruktorer TDD

6 5 / 57 Klass vs Objekt Skillnaden mellan ritning och hus Klassen beskriver hur objektet ska se ut Ett objekt är en instans av klassen (minnet)

7 6 / 57 Aggregate class //main.cpp int main() Card h22, "hearts"; cout << h2.suit << endl; //card.h class Card public: string suit; int value; ; hearts

8 7 / 57 Private Varför? //main.cpp int main() Card h22, "hearts"; cout << h2.suit << endl; //card.h class Card private: string suit; int value; ; Vad går sönder?

9 8 / 57 Konstruktor Varför? //main.cpp int main() Card h22, "hearts"; cout << h2.suit << endl; //card.h class Card public: Card(int v, string s): suits, valuev private: string suit; int value; ; Vad är fortfarande trasigt?

10 9 / 57 Getters Varför? //main.cpp int main() Card h22, "hearts"; cout << h2.get_suit() << endl; //card.h class Card public: Card(int v, string s): suits, valuev get_suit() const return suit; get_value() const return value; private: string suit; int value; ; Har vi nu fått tillbaka all funktionalitet?

11 10 / 57 Setters Nästan... //main.cpp int main() Card h22, "hearts"; cout << h2.get_suit() << endl; //card.h class Card public: Card(int v, string s): suits, valuev get_suit() const return suit; set_suit(string s) suit = s; get_value() const return value; set_value(int v) value = v; private: string suit; int value; ; Har vi nu fått tillbaka all funktionalitet?

12 11 / 57 Inkapsling Det handlar inte att vi inte får ändra på datamedlemmar som är private. Det kan vi använda const för. Ofta är det lämpligt att kunna ändra på datan. Varför håller vi på med detta då?

14 13 / 57 Felhantering i c++ Testar att göra övre blocket Vid fel (en throw) hoppa till ett av catch-blocken Fel kastas upp en nivå i programmet try //Försök göra //Fånga exception catch(logic_error& e) catch(...)

15 14 / 57 Anropa underprogram Vanlig ordning... int main() try fun1(); catchexception& e cerr << e.what(); void fun1() fun2(); return; void fun2 return;

16 15 / 57 Anropa underprogram #include <stderr> Vad händer om vi kastar ett fel? int main() try fun1(); catchexception& e cerr << e.what(); void fun1() fun2(); return; void fun2 throw logic_error"error message";

17 16 / 57 Felhantering och klasser Objekt skall alltid vara i valid states Objekt finns i c++ efter konstruktorn körts utan fel

18 17 / 57 Ok... Jaha... Det var väll gulligt, men vad har det att göra med klasser?

19 18 / 57 Avbryt konstruktor Enda sättet att avbryta en konstruktor class Cls Cls(int a)a if (is_invalid()) throw logic_error("message"); ;

20 19 / 57 Att tänka på try är i princip lika snabbt som vilken annan kod som helst Exceptions är VÄLDIGT långsamma när du kastar dem Använd endast i exceptionella situationer Använd INTE exceptions som en styrstruktur Mycket långsammare Dåligt praxis

21 20 / 57 noexcept noexcept är ett löfte till kompilatorn Vid fel dör programmet Tänk efter noggrant Får inte läcka fel men kan fånga class Card int get_value() const noexcept return value;

22 21 / 57 Strömmar Dokumenterat i std::basic_ios goodbit - allt funkar badbit - spik i disken failbit - i/o hantering misslyckades eofbit - har nått slutet av filen int main() std::ostringstream stream; if (!stream.fail()) std::cout << "stream is not fail\n"; stream.setstate(std::ios_base::failbit); if (stream.fail()) std::cout << "now stream is fail\n"; if (!stream.good()) std::cout << "and stream is not good\n";

24 23 / 57 Operator? Finns inom matematiken Finns inom programmering Verkar på operander

25 24 / 57 Skriv din egen operator Klasser kan ha sina egna operatorer - + string mfl int main() Complex c11,2; Complex c22,1; cout << c1 + c2 << endl; Varför fungerar/fungerar inte ovantstående?

26 25 / 57 När använder vi operatorer i c++? Complex c11, 3; Complex c22, 1; Complex c3 = c1 + c2;

27 26 / 57 Hur ser c++ på det? Complex c11, 3; Complex c22, 1; c1 + c2; c2 + c1; Complex c11, 3; Complex c22, 1; c1.operator+(c2); c2.operator+(c2);

28 27 / 57 Ett annat exempel Complex c11, 3; cout << c1; Complex c11, 3; cout.operator<<(c1); Ok det var enkelt... eller?

29 28 / 57 Det finns lite olika varianter binära medlemmar icke medlemmar unära user-defined literals (användardefinerade literaler?)

31 30 / 57 Binära operatorer Har 2 operander. //Exempel c1 + c2; c3 = c1; cout << c3; //Hur c++ ser det c1.operator+(c2); c3.operator=(c1); cout.operator<<(c3); //Objektet är vänstersidan //I Complex.h class Complex public: Complex operator+(complex const& rhs); Complex& operator=(complex const& rhs); Ostream& operator<<(complex const& rhs); ; Men om objektet är vänstra operanden... Hur funkar det med operator<<?

32 31 / 57 Inne eller utanför klassen? Vi kan inte ändra i ostream/cout //Exempel c1 + c2; c3 = c1; cout << c3; //Hur c++ ser det c1.operator+(c2); c3.operator=(c1); operator<<(cout, c3); //Objektet är vänstersidan //I Complex.h class Complex public: Complex operator+(complex const& rhs) const; Complex& operator=(complex const& rhs); //friend Ostream& operator<<...? // Friend? ; Ostream& operator<<(ostream & os, Complex const& rhs);

33 32 / 57 Implementation av binär operator + //h-fil class Complex public: Complex operator+(complex const& rhs) const; ; //c1 + c2 //cc-fil Complex Complex::operator+(Complex const& rhs) const int new_realreal + rhs.real; int new_imagimag + rhs.imag; Complex new_complex_numbernew_real, new_imag; return new_complex_number; Complex Complex::operator+(Complex const& rhs) return Complexreal + rhs.real, imag + rhs.imag;

34 33 / 57 Implementation av binär operator = //h-fil class Complex public: Complex& operator=(complex const& rhs); ; //c1 = c2 //cc-fil Complex& Complex::operator=(Complex const& rhs) real = rhs.real; imag = rhs.imag; return *this; //dereference operator

35 34 / 57 Implementation av binär operator << //h-fil class Complex ; ostream& operator<<(ostream & lhs, Complex const& rhs); // cout << c1; //cc-fil ostream& operator<<(ostream & lhs, Complex const& rhs) lhs << rhs.get_real() << " + " << rhs.get_imag() << "i"; return lhs;

36 35 / 57 Vadå ostream? Varför inte cout? ostream en klass cout ostringstream ofilestream... cout objekt av typen ostream globalt skriver till stdout cerr som cout fast till stderr

37 36 / 57 Så varför inte cout? TEST_CASE("Cout test") Complex c11, 2; cout << c1; //???? // Dear user please check // that output is correct // in your shell i

38 37 / 57 Så varför inte cout? TEST_CASE("Cout test") Complex c11, 2; cout << c1; //???? // Dear user please check // that output is 1 + 2i // in your shell i

39 38 / 57 ostream! TEST_CASE("String stream test") Complex c11, 2; stringstream sstream; sstream << c1; CHECK( sstream.str() == "1 + 2i" );

41 40 / 57 Unära operatorer Har 1 operand. //Exempel c1++; //post ++c1; //pre --c1; //pre c1--; //post -c1; //??? //Hur c++ ser det c1.operator++(int); //? c1.operator++(); c1.operator--(); c1.operator--(int); //? c1.operator-(); //Objektet är vänstersidan //I Complex.h class Complex public: Complex& operator++(); Complex operator++(int); Complex& operator--(); Complex operator--(int); Complex& operator-(); ; postinkrement är lite av ett fulhack...

42 41 / 57 Implementera preinkrement //h-filen class Complex public: Complex& operator++(); // ++c1 < Complex operator++(int); // c1++ Complex& operator--(); // --c1 Complex operator--(int); // c1-- Complex& operator-(); // -c1 ; Complex& Complex::operator++() real += 1; imag += 1; return *this;

43 42 / 57 Implementera postinkrement //h-filen class Complex public: Complex& operator++(); // ++c1 Complex operator++(int); // c1++ < Complex& operator--(); // --c1 Complex operator--(int); // c1-- Complex& operator-(); // -c1 ; Complex Complex::operator++(int) Complex tmp*this; real += 1; imag += 1; return tmp;

44 43 / 57 Implementera unärt minus //h-filen class Complex public: Complex& operator++(); // ++c1 Complex operator++(int); // c1++ Complex operator--(); // --c1 Complex operator--(int); // c1-- Complex operator-(); // -c1 < ; Complex& Complex::operator-() real *= -1; imag *= -1; return *this;

46 45 / 57 user-defined literals Allows integer, floating-point, character, and string literals to produce objects of user-defined type by defining a user-defined suffix Ett ganska avancerat koncept men kan vara användbart ibland.

47 46 / 57 Usecase Säg att vi vill skriva ett program där följande syntax fungerar för att skapa komplexatal. int main() Complex c1 = 1 + 2_i cout << c1 << endl; cout << 1 + 3_i << endl;

48 47 / 57 2_i För att delen med 2_i ska fungera beghöver vi ha en user-defined literal. Det är en operator på formatet: Complex operator "" _i(unsigned long long int i); Den returnerar ett objekt av typen Complex för att detta ska fungera: Complex operator "" _i(unsigned long long int i) return Complex0, static_cast<int>(i);

49 48 / 57 Hur sätter vi ihop dem? //I klassen Complex Complex::operator "" _i(unsigned long long int i) return Complex0, static_cast<int>(i); //Utanför klassen Complex operator+(int lhs, Complex const& rhs) return Complexlhs, rhs.i; Complex c1+2_i; Complex c2 = 1+2_i. cout << 1+2_i;

51 50 / 57 Typomvandling Att omvandla en typ till en annan Exempelvis göra om en int till en double Varför! Hur?

52 51 / 57 static cast Kontrolleras compile time Krävs att objektet vet hur det konverteras till typen string cs1 = static_cast<string>( Complex1, 3 ); Complex c1, 3; string cs2 = static_cast<string>( c ); Hur kan vi se till att Complex vet hur den skall konverteras till string?

53 52 / 57 dynamic cast Kontrolleras run time Krävs att objektet vet hur det konverteras till typen Är bara användbart när man castar en superklass-pekare till en subklass-pekare string cs1 = dynamic_cast<string>( Complex1, 3 );//Funkar inte Complex c1, 3; string cs2 = dynamic_cast<string>( c );//Funkar inte Hur kan vi se till att Complex vet hur den skall konverteras till string?

54 53 / 57 Hur vet klassen? Genom att lägga till den operatorn i klassen //Unary operator //Medlemsfunktion Complex::operator string() return to_string(); class Complex operator string(); Observera: Ingen returtyp Fungerar för andra typer

55 54 / 57 Typkonverterande konstruktorer operatorn sköter konvertering från din typ till en annan konstruktorn sköter konvertering från en annan typ till din typ //h-fil class Complex Complex(std::string const& str);

56 55 / 57 C-style tldr: Använd inte string complex_string = (string) Complex1, 2; // VS string complex_string = static_cast<string>(complex1, 2); //...

57 56 / 57 Strömmar och konvertering Strömmar är ett utmärkt sätt att konvertera till rätt från början: int a; char b; int c; char d; double e; // 1 : 2 : 4.0 cin >> a >> b >> c >> d >> e;

58 57 / 57 fler sätt stoi to_string string()

59