#include <iostream>
using namespace std;
/***************************************************/
/*
class A {
public:
    A() {cout << "A ctor" << endl;}
    A(A& a) {cout << "A copy ctor" << endl;}
    virtual ~A() {cout << "A dtor" << endl;}
    virtual void f() {cout << "A f" << endl;}
};

class B : public A {
public:
    B() {cout << "B ctor" << endl;}
    ~B() {cout << "B dtor" << endl;}
    void f() {cout << "B f" << endl;}
};

class C : public B {
public:
    C() {cout << "C ctor" << endl;}
    ~C() {cout << "C dtor" << endl;}
    void f() {cout << "C f" << endl;}
};

class X {
public:
    X() {cout << "X ctor" << endl;}
    X(X& x) {cout << "X copy ctor" << endl;}
    ~X() {cout << "X dtor" << endl; }
    void f() {cout << "X f" << endl; }
};

X foo(A& a, X x) {
    cout << "*** in foo" << endl;
    A aa;
    aa = a;
    X xx(x);
    cout << "*** leaving foo" << endl;
    return xx; }

int main() {
    cout << "*** starting main" << endl;
    A * a_ptr_to_a = new A; //constructor kallas när den skapas A
    B * b_ptr_to_b = new B; //constructor kallas när den skapas A sen B
    C * c_ptr_to_c = new C; //constructor kallas när den skapas A sen B sen C
    X x1; //constructor kallas när den skapas och sen är den på stacken så den kör destruktor också
    X * x_ptr_to_x = &x1; //skapar bara en pekare till x1 så den gör ingenting
    A * a_ptr_to_b = b_ptr_to_b; //skapar bara en pekare till B så den gör ingenting
    A * a_ptr_to_c = c_ptr_to_c; //skapar bara en pekare till C så den gör ingenting
    B * b_ptr_to_c = c_ptr_to_c; //skapar bara en pekare till C så den gör ingenting

    cout << "*** calls of f #1:" << endl; //X constructorn körs och sen skriver ut denna rad. sen avslutas de och då körs X destructor
    a_ptr_to_a -> f(); //funktionen f() i class A kallas. detta slängs in mellan X constructor och destructor
    b_ptr_to_b -> f(); //funktionen f() i class B kallas. detta slängs in mellan X constructor och destructor
    c_ptr_to_c -> f(); //funktionen f() i class C kallas. detta slängs in mellan X constructor och destructor
    x_ptr_to_x -> f(); //funktionen f() i class X kallas. detta slängs in mellan X constructor och destructor

    cout << "*** calls of f #2:" << endl; //bygger vidare på samma princip, skrivs ut innan X destructorn
    a_ptr_to_b -> f(); //bygger vidare på samma princip, skrivs ut innan X destructorn. kör funktionen i class B
    a_ptr_to_c -> f(); //bygger vidare på samma princip, skrivs ut innan X destructorn kör funktionen i class C
    b_ptr_to_c -> f(); //bygger vidare på samma princip, skrivs ut innan X destructorn kör funktionen i class C

    X x2; //skapar en ny X, constructor och destructor körs. antar att destructor i x1 körs innan x2

    cout << "*** calling foo" << endl; //skrivs ut innan BÅDA destructors i x1 och x2
    x2 = foo( *a_ptr_to_a, x1 ); //adressen till a skickas in till foo, objektet x1 skickas in och därför körs copyconstruktorn i X. Texten "***in foo" skrivs ut. Ett objekt a skapas, construkton körs. Sedan skapas ett objekt av X, x1 skickas, därför körs X copyconstruktor. "*** leaving foo" skrivs ut, destrukorn på A körs och de båda X:en körs.

    cout << "*** back in main" << endl; //säger detta INNAN x1 och x2 destructors. destructors ovanför i X foo(...) kallas automatiskt för de "är på stacken"
    cout << "*** delete a_ptr_to_a:" << endl; //skriver ut innan x1 och x2 destructors
    delete a_ptr_to_a; //vid delete kallas destructorn denna körs INNAN x1 och x2

    cout << "*** delete b_ptr_to_b:" << endl; //vanlig print
    delete b_ptr_to_b; //destructor till B kallas, sen efter det till A, varför vet jag inte, är det för den inheritar???

    cout << "*** delete b_ptr_to_c:" << endl; //vanlig print
    delete b_ptr_to_c; //destructor till C kallas, sen B, sen A

    cout << "*** leaving main" << endl;
    //x1 och x2 destructor kommer att kallas sist för att de ligger på stacken!!!
    return 0;
}*/

/***************************************************/

/*
 class Base{
 public:
 virtual int Alpha() = 0;
 virtual int Beta() { return 10; }
 virtual int Gamma() { return 20; }
 virtual int Delta() { return Alpha()*2; }
 virtual int Epsilon() { return 1; }
 };

 class Child1 : public Base {
 public:
 virtual int Alpha() { return 0; }
 };

 class Child2 : public Child1 {
 public:
 virtual int Alpha() { return Child1::Gamma();}
 virtual int Beta() { return Alpha()-10; }
 virtual int Delta() { return Child2::Gamma(); }
 virtual int Epsilon() { return 2; }
 };

 class Child3 : public Child2 {
 public:
 virtual int Gamma() { return 1000; }
 };

 int main(void) {

 Base *a = new Child2();
 Base *b = new Child3();
 Child2 *c = new Child2();
 Child2 *d = new Child3();

 printf("%i\n", a->Alpha());    //
 printf("%i\n", a->Beta());     //
 printf("%i\n", b->Delta());    //
 printf("%i\n", a->Gamma());    //
 printf("%i\n", c->Epsilon());  //
 printf("%i\n", d->Gamma());    //

 }
*/

/***************************************************/

//int main(){
//
//    string what = "Tough Exam!";
//    what = "Or maybe not";
//    cout << what;
//    what[1] = 'k';
//    cout << what;
//}

/***************************************************/

//int& Now(){
//
//    int Result = 1;
//    return Result;
//}
//
//int main(){
//
//    int when;
//    when = Now();
//    cout << when;
//}

/***************************************************/

/*
class Top{
public:
    int a;
    Top(int x) {a=x;}
};

class Bottom : public Top{
public:
    int b;
    Bottom():Top(5) {b=0; a=0;}
};

int main(){
    Bottom bot;
    cout << bot.a << endl << bot.b;
}*/

/***************************************************/

class Container{
public:
    int value;
    Container(int amount) {value=amount; cout << "Value: " << value << endl;}
    ~Container() {cout << "You killed " << value << endl;}
};

class ExamQuestion{
public:
    Container data;
    ExamQuestion(int a) : data(a) {cout << "New Object\n";}
    ExamQuestion(ExamQuestion& cp) : data(cp.data.value+10) {cout << "Special\n";}
};

void TrickyPart(ExamQuestion why){
    ExamQuestion tricky = why;
    cout << "You cannot trick Me!\n";
}

int main(){
    ExamQuestion Muhaha(1); //ett objekt av ExamQuestion skapas, i den klassen skapas ett objekt av Container så ettan som skickas in går till Containers konstruktor där den skriver ut Value: 1. Sedan körs konstruktorn i ExamQuestion, där skrivs New Object ut. Sist körs destruktorn på data så You killed: 1 skrivs ut.

    cout << "Call Tricky Part\n";

    TrickyPart(Muhaha); //ExamQuestion objektet skickas till funktionen TrickyPart, den tar emot "en kopia" som inparameter, därför körs konstruktorn, där den skickar upp "data" som skapas med parameter value+10 vilket är 11. Första printen är alltså "Value: 11 Special". I funktionen skapas sedan ett objekt "tricky" av ExamQuestion och sätts till "why". När "tricky" skapas händer exakt samma sak, fast nu är value 11 och inte 1 som förut, printen kommer alltså bli "Value: 21". Sedan skrivs "You cannot trick Me". Sist körs alla destruktorer.
    cout << "End\n";
}

/***************************************************/