SHARE
TWEET

Untitled

a guest Aug 12th, 2017 47 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. using namespace std;
  3. /***************************************************/
  4. /*
  5. class A {
  6. public:
  7.     A() {cout << "A ctor" << endl;}
  8.     A(A& a) {cout << "A copy ctor" << endl;}
  9.     virtual ~A() {cout << "A dtor" << endl;}
  10.     virtual void f() {cout << "A f" << endl;}
  11. };
  12.  
  13. class B : public A {
  14. public:
  15.     B() {cout << "B ctor" << endl;}
  16.     ~B() {cout << "B dtor" << endl;}
  17.     void f() {cout << "B f" << endl;}
  18. };
  19.  
  20. class C : public B {
  21. public:
  22.     C() {cout << "C ctor" << endl;}
  23.     ~C() {cout << "C dtor" << endl;}
  24.     void f() {cout << "C f" << endl;}
  25. };
  26.  
  27. class X {
  28. public:
  29.     X() {cout << "X ctor" << endl;}
  30.     X(X& x) {cout << "X copy ctor" << endl;}
  31.     ~X() {cout << "X dtor" << endl; }
  32.     void f() {cout << "X f" << endl; }
  33. };
  34.  
  35. X foo(A& a, X x) {
  36.     cout << "*** in foo" << endl;
  37.     A aa;
  38.     aa = a;
  39.     X xx(x);
  40.     cout << "*** leaving foo" << endl;
  41.     return xx; }
  42.  
  43. int main() {
  44.     cout << "*** starting main" << endl;
  45.     A * a_ptr_to_a = new A; //constructor kallas när den skapas A
  46.     B * b_ptr_to_b = new B; //constructor kallas när den skapas A sen B
  47.     C * c_ptr_to_c = new C; //constructor kallas när den skapas A sen B sen C
  48.     X x1; //constructor kallas när den skapas och sen är den på stacken så den kör destruktor också
  49.     X * x_ptr_to_x = &x1; //skapar bara en pekare till x1 så den gör ingenting
  50.     A * a_ptr_to_b = b_ptr_to_b; //skapar bara en pekare till B så den gör ingenting
  51.     A * a_ptr_to_c = c_ptr_to_c; //skapar bara en pekare till C så den gör ingenting
  52.     B * b_ptr_to_c = c_ptr_to_c; //skapar bara en pekare till C så den gör ingenting
  53.    
  54.     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
  55.     a_ptr_to_a -> f(); //funktionen f() i class A kallas. detta slängs in mellan X constructor och destructor
  56.     b_ptr_to_b -> f(); //funktionen f() i class B kallas. detta slängs in mellan X constructor och destructor
  57.     c_ptr_to_c -> f(); //funktionen f() i class C kallas. detta slängs in mellan X constructor och destructor
  58.     x_ptr_to_x -> f(); //funktionen f() i class X kallas. detta slängs in mellan X constructor och destructor
  59.    
  60.     cout << "*** calls of f #2:" << endl; //bygger vidare på samma princip, skrivs ut innan X destructorn
  61.     a_ptr_to_b -> f(); //bygger vidare på samma princip, skrivs ut innan X destructorn. kör funktionen i class B
  62.     a_ptr_to_c -> f(); //bygger vidare på samma princip, skrivs ut innan X destructorn kör funktionen i class C
  63.     b_ptr_to_c -> f(); //bygger vidare på samma princip, skrivs ut innan X destructorn kör funktionen i class C
  64.    
  65.     X x2; //skapar en ny X, constructor och destructor körs. antar att destructor i x1 körs innan x2
  66.    
  67.     cout << "*** calling foo" << endl; //skrivs ut innan BÅDA destructors i x1 och x2
  68.     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.
  69.    
  70.     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"
  71.     cout << "*** delete a_ptr_to_a:" << endl; //skriver ut innan x1 och x2 destructors
  72.     delete a_ptr_to_a; //vid delete kallas destructorn denna körs INNAN x1 och x2
  73.    
  74.     cout << "*** delete b_ptr_to_b:" << endl; //vanlig print
  75.     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???
  76.    
  77.     cout << "*** delete b_ptr_to_c:" << endl; //vanlig print
  78.     delete b_ptr_to_c; //destructor till C kallas, sen B, sen A
  79.    
  80.     cout << "*** leaving main" << endl;
  81.     //x1 och x2 destructor kommer att kallas sist för att de ligger på stacken!!!
  82.     return 0;
  83. }*/
  84.  
  85. /***************************************************/
  86.  
  87. /*
  88.  class Base{
  89.  public:
  90.  virtual int Alpha() = 0;
  91.  virtual int Beta() { return 10; }
  92.  virtual int Gamma() { return 20; }
  93.  virtual int Delta() { return Alpha()*2; }
  94.  virtual int Epsilon() { return 1; }
  95.  };
  96.  
  97.  class Child1 : public Base {
  98.  public:
  99.  virtual int Alpha() { return 0; }
  100.  };
  101.  
  102.  class Child2 : public Child1 {
  103.  public:
  104.  virtual int Alpha() { return Child1::Gamma();}
  105.  virtual int Beta() { return Alpha()-10; }
  106.  virtual int Delta() { return Child2::Gamma(); }
  107.  virtual int Epsilon() { return 2; }
  108.  };
  109.  
  110.  class Child3 : public Child2 {
  111.  public:
  112.  virtual int Gamma() { return 1000; }
  113.  };
  114.  
  115.  int main(void) {
  116.  
  117.  Base *a = new Child2();
  118.  Base *b = new Child3();
  119.  Child2 *c = new Child2();
  120.  Child2 *d = new Child3();
  121.  
  122.  printf("%i\n", a->Alpha());    //
  123.  printf("%i\n", a->Beta());     //
  124.  printf("%i\n", b->Delta());    //
  125.  printf("%i\n", a->Gamma());    //
  126.  printf("%i\n", c->Epsilon());  //
  127.  printf("%i\n", d->Gamma());    //
  128.      
  129.  }
  130. */
  131.  
  132. /***************************************************/
  133.  
  134. //int main(){
  135. //
  136. //    string what = "Tough Exam!";
  137. //    what = "Or maybe not";
  138. //    cout << what;
  139. //    what[1] = 'k';
  140. //    cout << what;
  141. //}
  142.  
  143. /***************************************************/
  144.  
  145. //int& Now(){
  146. //
  147. //    int Result = 1;
  148. //    return Result;
  149. //}
  150. //
  151. //int main(){
  152. //
  153. //    int when;
  154. //    when = Now();
  155. //    cout << when;
  156. //}
  157.  
  158. /***************************************************/
  159.  
  160. /*
  161. class Top{
  162. public:
  163.     int a;
  164.     Top(int x) {a=x;}
  165. };
  166.  
  167. class Bottom : public Top{
  168. public:
  169.     int b;
  170.     Bottom():Top(5) {b=0; a=0;}
  171. };
  172.  
  173. int main(){
  174.     Bottom bot;
  175.     cout << bot.a << endl << bot.b;
  176. }*/
  177.  
  178. /***************************************************/
  179.  
  180. class Container{
  181. public:
  182.     int value;
  183.     Container(int amount) {value=amount; cout << "Value: " << value << endl;}
  184.     ~Container() {cout << "You killed " << value << endl;}
  185. };
  186.  
  187. class ExamQuestion{
  188. public:
  189.     Container data;
  190.     ExamQuestion(int a) : data(a) {cout << "New Object\n";}
  191.     ExamQuestion(ExamQuestion& cp) : data(cp.data.value+10) {cout << "Special\n";}
  192. };
  193.  
  194. void TrickyPart(ExamQuestion why){
  195.     ExamQuestion tricky = why;
  196.     cout << "You cannot trick Me!\n";
  197. }
  198.  
  199. int main(){
  200.     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.
  201.    
  202.     cout << "Call Tricky Part\n";
  203.  
  204.     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.
  205.     cout << "End\n";
  206. }
  207.  
  208. /***************************************************/
RAW Paste Data
Top