├── lesson01
    ├── CPP1.askisi1.cpp
    ├── CPP1.askisi2.cpp
    ├── CPP1.askisi3.cpp
    ├── CPP1.bool.cpp
    ├── CPP1.cin.cpp
    ├── CPP1.endl.cpp
    ├── CPP1.helloworld.cpp
    ├── CPP1.helloworld2.cpp
    ├── CPP1.helloworld3.cpp
    ├── CPP1.overloading.cpp
    ├── CPP1.strings.cpp
    ├── askisi1(arxiko).c
    ├── cpp1(4sl).pdf
    └── cpp1.pdf
├── lesson02
    ├── CPP2.accessors.cpp
    ├── CPP2.askisi1.cpp
    ├── CPP2.askisi2.cpp
    ├── CPP2.askisi3.cpp
    ├── CPP2.class.cpp
    ├── CPP2.class_functions.cpp
    ├── CPP2.class_methods.cpp
    ├── CPP2.constructor.cpp
    ├── CPP2.destructor.cpp
    ├── CPP2.private.cpp
    ├── CPP2.private_public.cpp
    ├── CPP2.public.cpp
    ├── cpp2(4sl).pdf
    └── cpp2.pdf
├── lesson03
    ├── CPP3.1d_dynamic_array.cpp
    ├── CPP3.2d_dynamic_array.cpp
    ├── CPP3.askisi1.cpp
    ├── CPP3.askisi2.cpp
    ├── CPP3.assignment_problem.cpp
    ├── CPP3.class_with_pointer.cpp
    ├── CPP3.constructor_destructor.cpp
    ├── CPP3.dereferencing.cpp
    ├── CPP3.dynamic_object.cpp
    ├── CPP3.dynamic_variable.cpp
    ├── CPP3.local_variables.cpp
    ├── CPP3.new_int.cpp
    ├── CPP3.pointers.cpp
    ├── CPP3.pointers_and_objects.cpp
    ├── CPP3.sizeof.cpp
    ├── cpp3(4sl).pdf
    └── cpp3.pdf
├── lesson04
    ├── cpp4(4sl).pdf
    ├── cpp4.askisi1.cpp
    ├── cpp4.askisi2.cpp
    ├── cpp4.askisi3.cpp
    ├── cpp4.bypointer.cpp
    ├── cpp4.byreference.cpp
    ├── cpp4.byvalue.cpp
    ├── cpp4.copy_arg_by_value.cpp
    ├── cpp4.copy_constructor_arg_by_value.cpp
    ├── cpp4.copy_constructor_object_declaration.cpp
    ├── cpp4.copy_constructor_return_ob.cpp
    ├── cpp4.pdf
    ├── cpp4.reference.cpp
    └── cpp4.reference_mistake.cpp
├── lesson05
    ├── CPP5.array_of_objects.cpp
    ├── CPP5.array_of_objects_noinit.cpp
    ├── CPP5.array_of_pointers_to_objects.cpp
    ├── CPP5.class_with_array.cpp
    ├── CPP5.class_with_objects.cpp
    ├── CPP5.construction_with_initialization_syntax.cpp
    ├── CPP5.default_parameters.cpp
    ├── CPP5.dynamic_array_of_objects.cpp
    ├── CPP5.inline_function.cpp
    ├── CPP5.name_collisions.cpp
    ├── CPP5.this.cpp
    ├── CPP5.this_constructor.cpp
    ├── cpp5(4sl).pdf
    ├── cpp5.askisi1.cpp
    ├── cpp5.askisi2.cpp
    ├── cpp5.askisi3.cpp
    ├── cpp5.const_object.cpp
    ├── cpp5.pdf
    ├── cpp5.pointer_to_const_object.cpp
    └── cpp5.reference_to_const_object.cpp
├── lesson06
    ├── cpp6(4sl).pdf
    ├── cpp6.array_with_index_overloading.cpp
    ├── cpp6.askisi1.1.cpp
    ├── cpp6.askisi1.2.cpp
    ├── cpp6.askisi1.3.cpp
    ├── cpp6.askisi2.cpp
    ├── cpp6.askisi3.cpp
    ├── cpp6.operator_equal.cpp
    ├── cpp6.operator_minus.cpp
    ├── cpp6.operator_plus.cpp
    ├── cpp6.operator_plus_int.cpp
    ├── cpp6.operator_plusplus_post.cpp
    ├── cpp6.operator_plusplus_pre.cpp
    └── cpp6.pdf
├── lesson07
    ├── Cpp7(4sl).pdf
    ├── Cpp7.pdf
    ├── STRING.cpp
    ├── STRING.h
    ├── cpp7.askisi1.cpp
    ├── cpp7.askisi2.1.cpp
    ├── cpp7.askisi2.2.cpp
    ├── cpp7.askisi3.cpp
    ├── cpp7.askisi4.1.cpp
    ├── cpp7.askisi4.2.cpp
    ├── cpp7.askisi4.3.cpp
    ├── cpp7.friend_class_ex1.cpp
    ├── cpp7.friend_class_linked_list.cpp
    ├── cpp7.friend_function.cpp
    ├── cpp7.friend_method.cpp
    ├── cpp7.friend_operator_plus.cpp
    └── cpp7.friend_operator_print.cpp
├── lesson08
    ├── cpp8(4sl).pdf
    ├── cpp8.askisi1.cpp
    ├── cpp8.askisi2.cpp
    ├── cpp8.lifespan.cpp
    ├── cpp8.pdf
    ├── cpp8.static_local_variables.cpp
    ├── cpp8.static_members.cpp
    └── cpp8.static_methods.cpp
├── lesson09
    ├── cpp9(4sl).pdf
    ├── cpp9.askisi1.cpp
    ├── cpp9.askisi2.cpp
    ├── cpp9.pdf
    ├── cpp9.string.cpp
    ├── cpp9.string_add_rem_upd.cpp
    ├── cpp9.string_capacity.cpp
    ├── cpp9.string_find.cpp
    └── cpp9.string_operators.cpp
├── lesson10
    ├── cpp10(4sl).pdf
    ├── cpp10.askisi1.1-1.2.cpp
    ├── cpp10.askisi1.3-1.4.cpp
    ├── cpp10.askisi2.1-2.2.cpp
    ├── cpp10.askisi2.3-2.4.cpp
    ├── cpp10.inheritance_constructors.cpp
    ├── cpp10.inheritance_destructors.cpp
    ├── cpp10.pdf
    ├── cpp10.protected_members.cpp
    └── cpp10.public_inheritance.cpp
├── lesson11
    ├── cpp11(4sl).pdf
    ├── cpp11.abstract_class.cpp
    ├── cpp11.askisi1.1.cpp
    ├── cpp11.askisi1.2.cpp
    ├── cpp11.askisi2.1.cpp
    ├── cpp11.destructor_base_pointer.cpp
    ├── cpp11.destructor_derived_pointer.cpp
    ├── cpp11.method_overriding.cpp
    ├── cpp11.pdf
    ├── cpp11.pointer_to_base_class1.cpp
    ├── cpp11.pointer_to_base_class2.cpp
    ├── cpp11.virtual_destructor_derived_pointer.cpp
    ├── cpp11.virtual_method.cpp
    ├── cpp11.virtual_method_object.cpp
    └── cpp11.virtual_method_reference.cpp
├── lesson12
    ├── cpp12(4sl).pdf
    ├── cpp12.askisi1.1.cpp
    ├── cpp12.askisi1.2.cpp
    ├── cpp12.askisi2.1.cpp
    ├── cpp12.askisi2.2.cpp
    ├── cpp12.diamond_problem.cpp
    ├── cpp12.mi_constructors.cpp
    ├── cpp12.multiple_inheritance.cpp
    ├── cpp12.pdf
    ├── cpp12.use_of_resolution_scope_operator.cpp
    └── cpp12.virtual_class.cpp
└── lesson13
    ├── cpp13(4sl).pdf
    ├── cpp13.askisi1.cpp
    ├── cpp13.askisi2.cpp
    ├── cpp13.pdf
    ├── cpp13.swap.cpp
    ├── cpp13.template.cpp
    ├── cpp13.template_non_type_param.cpp
    ├── cpp13.template_with_friend.cpp
    └── cpp13.template_with_static.cpp


/lesson01/CPP1.askisi1.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main() 
 5 | {
 6 |     char name[80];
 7 |     char surname[80];
 8 |     int age;
 9 |     
10 |     cout<<"Dwse to onoma: ";
11 |     cin>>name;
12 |     cout<<"Dwse to epwnimo: ";
13 |     cin>>surname;
14 |     cout<<"Dwse ilikia: ";
15 |     cin>>age;
16 |     
17 |     cout<<name<<" "<<surname<<" ("<<age<<")";
18 |     
19 |     return 0;
20 | }
21 | 
22 | 


--------------------------------------------------------------------------------
/lesson01/CPP1.askisi2.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | double average (int a, int b);
 5 | double average (double a, double b);
 6 | 
 7 | int main()
 8 | {
 9 |     int int_a, int_b;
10 |     double double_a, double_b;
11 |     int in;
12 |     
13 |     cout<<"1-akeraioi, 2-pragmatikoi: ";
14 |     cin>>in;
15 |     
16 |     if (in==1)
17 |     {
18 |         cout<<"Dwse 1o akeraio: ";
19 |         cin>>int_a;
20 |         cout<<"Dwse 2o akeraio: ";
21 |         cin>>int_b;
22 |         cout<<"Mesos oros: "<<average(int_a, int_b);
23 |     }
24 |     else if (in==2)
25 |     {
26 |         cout<<"Dwse 1o pragmatiko: ";
27 |         cin>>double_a;
28 |         cout<<"Dwse 2o pragmatiko: ";
29 |         cin>>double_b;
30 |         cout<<"Mesos oros: "<<average(double_a, double_b);
31 |         
32 |     }
33 |     else
34 |     {
35 |         cout<<"Kopane!";
36 |     }
37 |     
38 |     return 0;
39 | }
40 | 
41 | 
42 | double average (int a, int b)
43 | {
44 |     return (a+b)/2.0;
45 | }
46 | 
47 | 
48 | double average (double a, double b)
49 | {
50 |     return (a+b)/2;
51 | }
52 | 
53 | 


--------------------------------------------------------------------------------
/lesson01/CPP1.askisi3.cpp:
--------------------------------------------------------------------------------
 1 | /* break.cpp: Deixnei tin xrisi tis break */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | #define N 5
 7 | 
 8 | int main()
 9 | {
10 |     int i;
11 |     int A[N]= {5, 3, 2, 4, 8 }; // Pinakas dedomenwn
12 |     int x=7; // Pros anazitisi stoixeio
13 |     bool found;
14 | 
15 |     /* Psaxnoume gia to stoixeio x ston pinaka A */    
16 |     found = false;
17 |     for (i=0; i<N; i++)
18 |     {
19 |         if (A[i]==x)
20 |         {
21 |             found=true;
22 |             break;
23 |         }
24 |            
25 |     }
26 |     
27 |     if (found) 
28 |       cout<<endl<<"Vrethike to stoixeio "<<x<<" sti thesi "<<i;
29 |     else 
30 |       cout<<endl<<"Den vrethike to stoixeio";
31 | 
32 |     return 0;
33 | }
34 | 
35 | 


--------------------------------------------------------------------------------
/lesson01/CPP1.bool.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson01/CPP1.bool.cpp


--------------------------------------------------------------------------------
/lesson01/CPP1.cin.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP1.cin.cpp  Χρήση της cin */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {    
 8 |    int x;
 9 |    
10 |    cout<<"Dwse x: ";
11 |    cin>>x;
12 |    cout<<"To x einai: "<<x;
13 |    
14 |    return 0;
15 | }
16 | 
17 | 
18 | 


--------------------------------------------------------------------------------
/lesson01/CPP1.endl.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP1.endl.cpp  Χρήση του endl */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {    
 8 |    int x = 5;
 9 |    double y = 5.01;
10 |    
11 |    cout<<"To x einai "<<x<<endl<<"kai to y einai "<<y<<"\n";
12 |    
13 |    return 0;
14 | }
15 | 
16 | 


--------------------------------------------------------------------------------
/lesson01/CPP1.helloworld.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP1.helloworld.cpp */
 2 | 
 3 | #include <iostream>
 4 | 
 5 | int main()
 6 | {    
 7 |    std::cout<<"Hello World!";    
 8 |    return 0;
 9 | }
10 | 
11 | 


--------------------------------------------------------------------------------
/lesson01/CPP1.helloworld2.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP1.helloworld2.cpp  using std::cout */
 2 | #include <iostream>
 3 | using std::cout;
 4 | 
 5 | int main()
 6 | {
 7 |    cout<<"Hello World!";    
 8 |    return 0;
 9 | }
10 | 
11 | 


--------------------------------------------------------------------------------
/lesson01/CPP1.helloworld3.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP1.helloworld3.cpp  Ενσωμάτωση όλης της std*/
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {    
 8 |    cout<<"Hello World!";    
 9 |    return 0;
10 | }
11 | 
12 | 


--------------------------------------------------------------------------------
/lesson01/CPP1.overloading.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP1.overloading.cpp  Υπερφόρτωση Συναρτήσεων */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int sum(int x, int y);
 7 | double sum(double x, double y);
 8 | 
 9 | int main()
10 | {    
11 |     cout<<sum(5,3);    
12 |     cout<<" ";    
13 |     cout<<sum(1.1,2.2); 
14 |     return 0;
15 | }
16 | 
17 | int sum(int x, int y)
18 | {    
19 |     return x+y;
20 | }
21 | 
22 | double sum(double x, double y)
23 | {    
24 |      return x+y;
25 | }
26 | 
27 | 
28 | 
29 | 


--------------------------------------------------------------------------------
/lesson01/CPP1.strings.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP1.strings.cpp  */
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {    
 9 |    char str1[80];
10 |    char str2[80];
11 |    
12 |    cout<<"Dwse string: ";
13 |    cin>>str1;
14 |    strcpy(str2,str1);
15 |    cout<<str2;
16 |    
17 |    return 0;
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/lesson01/askisi1(arxiko).c:
--------------------------------------------------------------------------------
 1 | /* break.c: Deixnei tin xrisi tis break */
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | #define N 5
 6 | 
 7 | main()
 8 | {
 9 |     int i;
10 |     int A[N]= {5, 3, 2, 4, 8 }; // Pinakas dedomenwn
11 |     int x=2; // Pros anazitisi stoixeio
12 | 
13 |     /* Psaxnoume gia to stoixeio x ston pinaka A */    
14 |     for (i=0; i<N; i++)
15 |     {
16 |         if (A[i]==x)
17 |            break;
18 |     }
19 |     if (i<N) 
20 | 	printf("\nVrethike to stoixeio %d sti thesi %d",x,i);
21 |     else 
22 | 	printf("\nDen Vrethike to stoixeio");
23 | }
24 | 


--------------------------------------------------------------------------------
/lesson01/cpp1(4sl).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson01/cpp1(4sl).pdf


--------------------------------------------------------------------------------
/lesson01/cpp1.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson01/cpp1.pdf


--------------------------------------------------------------------------------
/lesson02/CPP2.accessors.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP2.accessors.cpp */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class dog 
 7 | {  
 8 |   public:
 9 |     dog(int in_mood);
10 |     ~dog();
11 |     void set_mood(int in_mood);
12 |     int get_mood() const;
13 |     void bark();
14 |     void report_mood();
15 |   private:    
16 |     int mood;
17 | };
18 | 
19 | 
20 | int main() 
21 | {
22 |     dog piko(6);   
23 | 
24 |     cout<<"Piko, how are you today?"<<endl;    
25 |     piko.report_mood();    
26 |     cout<<endl;    
27 | 
28 |     cout<<"Piko, please bark twice for me"<<endl;    
29 |     piko.bark(); 
30 |     piko.bark();   
31 |     return 0; 
32 | }
33 | 
34 | dog::dog(int in_mood)    
35 | {      
36 |     mood=in_mood;    
37 | }    
38 | dog::~dog()    
39 | {      
40 |     cout<<"I will be waiting…!";
41 | }    
42 | void dog::set_mood(int in_mood)
43 | {
44 |     mood = in_mood;
45 | }
46 | int dog::get_mood() const
47 | {
48 |     return mood;
49 | }
50 | void dog::bark()    
51 | {      
52 |     cout<<"woof!"<<endl;    
53 | }
54 | void dog::report_mood()    
55 | {      
56 |     if (mood>10)        
57 |         cout<<"I am cool";      
58 |     else        
59 |         cout<<"I am furious";    
60 | } 
61 | 


--------------------------------------------------------------------------------
/lesson02/CPP2.askisi1.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class dummy {
 5 |   public: 
 6 |     dummy();
 7 |     dummy(int in_x);
 8 |     ~dummy();
 9 |     void set_x(int in_x);
10 |     int get_x() const; 
11 |   private: 
12 |     int x; 
13 | };
14 | 
15 | 
16 | int main()
17 | {
18 |     dummy ob1(10);
19 |     dummy ob2;
20 |     
21 |     return 0; 
22 | }
23 | 
24 | dummy::dummy() 
25 | {
26 |     x = 0; 
27 | }
28 | 
29 | dummy::dummy(int in_x)
30 | {
31 |     x = in_x; 
32 | }
33 | 
34 | dummy::~dummy()
35 | {
36 |     cout<<"Destructing with x= "<<x<<endl; 
37 | }
38 | 
39 | void dummy::set_x(int in_x)
40 | {
41 |     x = in_x; 
42 | }
43 | 
44 | int dummy::get_x() const
45 | {
46 |     return x; 
47 | }
48 | 


--------------------------------------------------------------------------------
/lesson02/CPP2.askisi2.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class point {
 5 |     public:
 6 |         point();
 7 |         point(double in_x, double in_y);
 8 |         void set_x(double in_x);
 9 |         void set_y(double in_y);
10 |         double get_x() const;
11 |         double get_y() const;
12 |         void print();
13 |     private:
14 |         double x;
15 |         double y;
16 | };
17 | 
18 | 
19 | int main()
20 | {
21 |     point ob1(1.1, 2.2);
22 |     point ob2(1.0, 2.0); 
23 |     point ob3;
24 |     
25 |     cout<<"1o simeio: ";
26 |     ob1.print();
27 |     cout<<endl<<"2o simeio: ";
28 |     ob2.print();
29 |     cout<<endl<<"3o simeio: ";
30 |     ob3.print();
31 |     
32 |     return 0;
33 | }
34 | 
35 | point::point() 
36 | {
37 |     x = 0.0;
38 |     y = 0.0;
39 | }
40 | 
41 | point::point(double in_x, double in_y)
42 | {
43 |     x = in_x; 
44 |     y = in_y; 
45 | }
46 | 
47 | void point::set_x(double in_x)
48 | {
49 |     x = in_x;
50 | }
51 | 
52 | void point::set_y(double in_y)
53 | {
54 |     y = in_y;
55 | }
56 | 
57 | double point::get_x() const
58 | {
59 |     return x;
60 | }
61 | 
62 | double point::get_y() const
63 | {
64 |     return y;
65 | }
66 | 
67 | void point::print()
68 | {
69 |     cout<<"("<<x<<","<<y<<")";
70 | }


--------------------------------------------------------------------------------
/lesson02/CPP2.askisi3.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstring>
 3 | using namespace std;
 4 | 
 5 | class wizard {
 6 |     public:
 7 |         wizard(int in_age, char *in_beard, int in_mana);
 8 |         void fireball();
 9 |         void lightning();
10 |         void wait();
11 |     private:
12 |         int age;
13 |         char beard[80];
14 |         int mana;
15 | };
16 | 
17 | 
18 | 
19 | 
20 | int main()
21 | {
22 |     char str[80]="grey";
23 |     wizard gandalf(2019, str, 100);
24 |     
25 |     gandalf.fireball();
26 |     gandalf.wait();
27 |     gandalf.lightning();
28 |     gandalf.wait();
29 |     gandalf.wait();
30 |     gandalf.fireball();
31 |     
32 | }
33 | 
34 | 
35 | 
36 | 
37 | wizard::wizard(int in_age, char *in_beard, int in_mana)
38 | {
39 |     age = in_age;
40 |     strcpy(beard, in_beard);
41 |     mana = in_mana;
42 | }
43 | 
44 | void wizard::fireball()
45 | {
46 |     if (mana >= 30)
47 |     {
48 |         mana-=30; 
49 |         cout<<endl<<"Fireball! (mana:"<<mana<<")";
50 |     }
51 |     else
52 |         cout<<endl<<"Fireball effort (not enough mana)";
53 | }
54 | 
55 | void wizard::lightning()
56 | {
57 |     if (mana>=90)
58 |     {
59 |         mana-=90; 
60 |         cout<<endl<<"Lighting! (mana:"<<mana<<")";
61 |     }
62 |     else
63 |         cout<<endl<<"Lightning effort (not enough mana)";
64 |         
65 | }
66 | 
67 | void wizard::wait()
68 | {
69 |     if (mana<=90)
70 |         mana+=10; 
71 |     cout<<endl<<"wait... (mana:"<<mana<<")";
72 | }


--------------------------------------------------------------------------------
/lesson02/CPP2.class.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP2.class.cpp Σχεδιασμός μιας κλάσης ανάλογα με τις προδιαγραφές */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class dog 
 7 | {  
 8 |   public:
 9 |     void init(int in_mood)    
10 |     {      
11 |       mood=in_mood;    
12 |     }    
13 |     void bark()    
14 |     {      
15 |       cout<<"woof!"<<endl;    
16 |     }
17 |     void report_mood()    
18 |     {      
19 |       if (mood>10)        
20 |         cout<<"I am cool";      
21 |       else        
22 |         cout<<"I am furious";    
23 |     }  
24 |   private:    
25 |     int mood;
26 | };
27 | 
28 | 
29 | int main() 
30 | {
31 |     dog piko;
32 |     
33 |     piko.init(6);
34 |     
35 |     cout<<"Piko, how are you today?"<<endl;
36 |     piko.report_mood();
37 |     cout<<endl;
38 |     cout<<"Piko, please bark twice for me"<<endl;
39 |     piko.bark();
40 |     piko.bark();
41 | }
42 | 


--------------------------------------------------------------------------------
/lesson02/CPP2.class_functions.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP2.class_functions.cpp Ορισμός των μεθόδων έξω από τις κλάσεις */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class dog 
 7 | {  
 8 |   public:
 9 |     void init(int in_mood);    
10 |     void bark();
11 |     void report_mood();    
12 |   private:    
13 |     int mood;
14 | };
15 | 
16 | 
17 | int main() 
18 | {
19 |   dog piko;
20 |     
21 |   piko.init(6);
22 |     
23 |   cout<<"Piko, how are you today?"<<endl;
24 |   piko.report_mood();
25 |   cout<<endl;
26 |   cout<<"Piko, please bark twice for me"<<endl;
27 |   piko.bark();
28 |   piko.bark();
29 | }
30 | 
31 | void dog::init(int in_mood)    
32 | {      
33 |   mood=in_mood;    
34 | }    
35 | void dog::bark()    
36 | {      
37 |   cout<<"woof!"<<endl;    
38 | }
39 | void dog::report_mood()    
40 | {      
41 |   if (mood>10)        
42 |     cout<<"I am cool";      
43 |   else        
44 |     cout<<"I am furious!";    
45 | }  
46 | 


--------------------------------------------------------------------------------
/lesson02/CPP2.class_methods.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP2.class_methods.cpp Ορισμός των μεθόδων έξω από τις κλάσεις */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class dog 
 7 | {  
 8 |   public:
 9 |     void init(int in_mood);    
10 |     void bark();
11 |     void report_mood();    
12 |   private:    
13 |     int mood;
14 | };
15 | 
16 | 
17 | int main() 
18 | {
19 |   dog piko;
20 |     
21 |   piko.init(6);
22 |     
23 |   cout<<"Piko, how are you today?"<<endl;
24 |   piko.report_mood();
25 |   cout<<endl;
26 |   cout<<"Piko, please bark twice for me"<<endl;
27 |   piko.bark();
28 |   piko.bark();
29 | }
30 | 
31 | void dog::init(int in_mood)    
32 | {      
33 |   mood=in_mood;    
34 | }    
35 | void dog::bark()    
36 | {      
37 |   cout<<"woof!"<<endl;    
38 | }
39 | void dog::report_mood()    
40 | {      
41 |   if (mood>10)        
42 |     cout<<"I am cool";      
43 |   else        
44 |     cout<<"I am furious!";    
45 | }  
46 | 


--------------------------------------------------------------------------------
/lesson02/CPP2.constructor.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP2.constructor.cpp */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dog 
 6 | {  
 7 |   public:
 8 |      dog(int in_mood);
 9 |      void bark();
10 |      void report_mood();
11 |   private:    
12 |       int mood;
13 | };
14 | 
15 | int main() 
16 | {
17 |     dog piko(6);   
18 | 
19 |     cout<<"Piko, how are you today?"<<endl;    
20 |     piko.report_mood();    
21 |     cout<<endl;    
22 | 
23 |     cout<<"Piko, please bark twice for me"<<endl;    
24 |     piko.bark(); 
25 |     piko.bark();   
26 |     return 0; 
27 | }
28 | 
29 | dog::dog(int in_mood)    
30 | {      
31 |     mood=in_mood;    
32 | }    
33 | void dog::bark()    
34 | {      
35 |     cout<<"woof!"<<endl;    
36 | }
37 | void dog::report_mood()    
38 | {      
39 |     if (mood>10)        
40 |         cout<<"I am cool";      
41 |     else        
42 |         cout<<"I am furious";    
43 | } 
44 | 


--------------------------------------------------------------------------------
/lesson02/CPP2.destructor.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP2.destructor.cpp */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dog 
 6 | {  
 7 |   public:
 8 |     dog(int in_mood);
 9 |     ~dog();
10 |     void bark();
11 |     void report_mood();
12 |   private:    
13 |     int mood;
14 | };
15 | 
16 | 
17 | int main() 
18 | {
19 |     dog piko(6);   
20 | 
21 |     cout<<"Piko, how are you today?"<<endl;    
22 |     piko.report_mood();    
23 |     cout<<endl;    
24 | 
25 |     cout<<"Piko, please bark twice for me"<<endl;    
26 |     piko.bark(); 
27 |     piko.bark();   
28 |     return 0; 
29 | }
30 | 
31 | dog::dog(int in_mood)    
32 | {      
33 |     mood=in_mood;    
34 | }    
35 | dog::~dog()    
36 | {      
37 |     cout<<"I will be waiting…!";
38 | }    
39 | void dog::bark()    
40 | {      
41 |     cout<<"woof!"<<endl;    
42 | }
43 | void dog::report_mood()    
44 | {      
45 |     if (mood>10)        
46 |         cout<<"I am cool";      
47 |     else        
48 |         cout<<"I am furious";    
49 | } 
50 | 


--------------------------------------------------------------------------------
/lesson02/CPP2.private.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP2.private.cpp Ιδιωτικά Μέλη της κλάσης */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class cow 
 7 | {  
 8 |   public:
 9 |     int weight;
10 |     void express () 
11 |     {
12 |       if (hunger>10)
13 |         cout<<"MmmmmmmmMMMmmM";
14 |     }
15 |     int set_hunger (int h)
16 |     {
17 |       hunger = h; 
18 |     }
19 |   private:    
20 |     int hunger;
21 | };
22 | 
23 | 
24 | int main() 
25 | {
26 |   cow Molly;
27 |   Molly.weight = 500;
28 |   Molly.set_hunger(49);
29 |   Molly.express();
30 | }
31 | 


--------------------------------------------------------------------------------
/lesson02/CPP2.private_public.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP2.class_functions.cpp Ορισμός των μεθόδων έξω από τις κλάσεις */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class cow 
 7 | {  
 8 |   public:
 9 |     int weight;
10 |   private:    
11 |     int hunger;
12 | };
13 | 
14 | 
15 | int main() 
16 | {
17 |   dog piko;
18 |     
19 |   piko.init(6);
20 |     
21 |   cout<<"Piko, how are you today?"<<endl;
22 |   piko.report_mood();
23 |   cout<<endl;
24 |   cout<<"Piko, please bark twice for me"<<endl;
25 |   piko.bark();
26 |   piko.bark();
27 | }
28 | 
29 | void dog::init(int in_mood)    
30 | {      
31 |   mood=in_mood;    
32 | }    
33 | void dog::bark()    
34 | {      
35 |   cout<<"woof!"<<endl;    
36 | }
37 | void dog::report_mood()    
38 | {      
39 |   if (mood>10)        
40 |     cout<<"I am cool";      
41 |   else        
42 |     cout<<"I have my nerves";    
43 | }  
44 | 


--------------------------------------------------------------------------------
/lesson02/CPP2.public.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP2.public.cpp Δημόσια Μέλη της κλάσης */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class cow 
 7 | {  
 8 |   public:
 9 |     int weight;
10 |   private:    
11 |     int hunger;
12 | };
13 | 
14 | 
15 | int main() 
16 | {
17 |   cow molly;
18 |   molly.weight = 500;
19 |   // Molly.hunger = 10; // Δεν επιτρέπεται. Είναι ιδιωτική μεταβλητή
20 | }
21 | 


--------------------------------------------------------------------------------
/lesson02/cpp2(4sl).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson02/cpp2(4sl).pdf


--------------------------------------------------------------------------------
/lesson02/cpp2.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson02/cpp2.pdf


--------------------------------------------------------------------------------
/lesson03/CPP3.1d_dynamic_array.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.1d_dynamic_array.cpp Μονοδιάστατος πίνακας με δυναμική δέσμευση μνήμης */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | int main()
 6 | { 
 7 |     int *arr; 
 8 |     int n=4; 
 9 |     
10 |     /* Δέσμευση Μνήμης */
11 |     arr = new int [n];
12 |     if (!arr) cout<<"Error allocating memory!";
13 |     
14 |     /* Κάποια δουλειά στον πίνακα */
15 |     for (int i=0; i<n; i++)
16 |         arr[i]=i*i;
17 | 
18 |     for (int i=0; i<n; i++)
19 |         cout<<arr[i]<<" ";
20 |         
21 |     /* Αποδέσμευση Μνήμης */
22 |     delete [] arr; 
23 |     
24 |     return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.2d_dynamic_array.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.2d_dynamic_array.cpp Διδιάστατος πίνακας με δυναμική δέσμευση μνήμης */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | int main()
 6 | { 
 7 |     int **arr; 
 8 |     int i,j, n=4, m=4; 
 9 |     
10 |     /* Δέσμευση Μνήμης */
11 |     arr = new int * [n];
12 |     if (!arr) cout<<"Error allocating memory!";
13 |     for (i=0; i<n; i++)
14 |     {
15 |         arr[i] = new int [m];
16 |         if (!arr[i]) cout<<"Error allocating memory!";
17 |     }
18 | 
19 |     /* Κάποια δουλειά στον πίνακα */
20 | 
21 |     for (i=0; i<n; i++)
22 |         for (j=0; j<m; j++)
23 |             arr[i][j]=i*j; 
24 |         
25 |     for (i=0; i<n; i++)
26 |     {
27 |         for (j=0; j<m; j++)
28 |             cout<<arr[i][j]; 
29 |         cout<<endl;
30 |     }
31 |         
32 |     /* Αποδέσμευση Μνήμης */
33 |     for (i=0; i<n; i++)
34 |         delete [] arr[i];
35 |     delete [] arr; 
36 |     
37 |     return 0;
38 | }
39 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.askisi1.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.askisi1.cpp */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | 
 7 | int main()
 8 | {
 9 |     int x = 5;
10 |     int *p;
11 |     int **pp;
12 |     
13 |     p=&x;
14 |     pp=&p;
15 |     
16 |     cout<<"x="<<x<<" (address: "<<&x<<")"<<endl;
17 |     cout<<"p="<<p<<" (address: "<<&p<<")"<<endl;
18 |     cout<<"x=(*p)="<<*p<<endl;
19 |     cout<<"pp="<<pp<<" (address: "<<&pp<<")"<<endl;
20 |     cout<<"x=(**pp)="<<**pp<<endl;
21 |     cout<<"p=(*p)="<<*pp<<endl;
22 |     
23 |     return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.askisi2.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.askisi2.cpp */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class ARRAY {
 7 |   public:
 8 |     ARRAY(int in_n);
 9 |     ~ARRAY();
10 |     void set_i(int i, int val);
11 |     int get_i(int i);
12 |     void print();
13 |   private:
14 |     int *p;
15 |     int n;
16 | };
17 | 
18 | 
19 | int main()
20 | {
21 |     int n=10;
22 |     ARRAY pin(n);
23 |     ARRAY pin2(10);
24 |     
25 |     for (int i=0; i<n; i++)
26 |         pin.set_i(i,i*i);
27 |     
28 |     for (int i=0; i<n; i++)
29 |         pin2.set_i(i,i*i*i);
30 | 
31 |     pin=pin2;
32 | 
33 |     pin.print();
34 |     pin2.print();
35 |     
36 |     return 0;
37 | }
38 | 
39 | ARRAY::ARRAY(int in_n)
40 | {
41 |     n = in_n; 
42 |     
43 |     p = new int [n];
44 |     if (!p)
45 |         cout<<"Error allocating memory!";
46 | }
47 | 
48 | ARRAY::~ARRAY()
49 | {
50 |     delete [] p;
51 | }
52 | 
53 | void ARRAY::set_i(int i, int val)
54 | {
55 |     if (i>=0 && i<n)
56 |         p[i]=val;
57 |     else
58 |         cout<<"Error: Out of bounds!";
59 | }
60 | 
61 | int ARRAY::get_i(int i)
62 | {
63 |     if (i>=0 && i<n)
64 |         return p[i];
65 |     else
66 |         cout<<"Error: Out of bounds!";
67 | }
68 | 
69 | void ARRAY::print()
70 | {
71 |     int i;
72 |     
73 |     for (i=0; i<n; i++)
74 |         cout<<p[i]<<" ";
75 | }
76 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.assignment_problem.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.assignment_problem Δυναμική Δέσμευση και Τελεστής Ανάθεσης */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 |   public:
 7 |     dummy();
 8 |     ~dummy();
 9 |     void set_val(int in_val);
10 |     int get_val();
11 |   private:
12 |     int *p_val;
13 | };
14 | 
15 | int main()
16 | { 
17 |     dummy ob1;
18 |     ob1.set_val(3);
19 |     dummy ob2; 
20 |     ob2 = ob1;     
21 | 
22 |     cout<<ob1.get_val()<<endl;
23 |     cout<<ob2.get_val()<<endl;
24 | 
25 |     return 0;
26 | }
27 | 
28 | dummy::dummy()
29 | {
30 |     p_val = new int;
31 |     if (!p_val)  cout<<"Error allocating memory";
32 |     
33 |     cout<<"Constructing..."<<endl;
34 | }
35 | dummy::~dummy()
36 | {
37 |     delete p_val; 
38 |     cout<<"Destructing..."<<endl;
39 | }
40 | 
41 | void dummy::set_val(int in_val)
42 | {
43 |     *p_val = in_val; 
44 | }
45 | 
46 | int dummy::get_val()
47 | {
48 |     return *p_val; 
49 | }
50 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.class_with_pointer.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.class_with_pointer.cpp Κλάση που περιέχει δείκτη */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 |   public:
 7 |     dummy();
 8 |     ~dummy();
 9 |     void set_val(int in_val);
10 |     int get_val();
11 |   private:
12 |     int *p_val;
13 | };
14 | 
15 | int main()
16 | { 
17 |     dummy ob;
18 |     
19 |     ob.set_val(3);
20 |     
21 |     cout<<endl<<ob.get_val()<<endl;
22 | 
23 |     return 0;
24 | }
25 | 
26 | dummy::dummy()
27 | {
28 |     p_val = new int;
29 |     if (!p_val) {
30 |         cout<<"Error allocating memory";
31 |     }
32 |     cout<<"Constructing...";
33 | }
34 | 
35 | dummy::~dummy()
36 | {
37 |     delete p_val; 
38 |     cout<<"Destructing...";
39 | }
40 | 
41 | void dummy::set_val(int in_val)
42 | {
43 |     *p_val = in_val; 
44 | }
45 | 
46 | int dummy::get_val()
47 | {
48 |     return *p_val; 
49 | }
50 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.constructor_destructor.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.constructor_destructor.cpp */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 |   public:
 7 |     dummy(int in_x);
 8 |     ~dummy();
 9 |   private:
10 |     int x;
11 | };
12 | 
13 | int main()
14 | { 
15 |     dummy *p = NULL;
16 |     
17 |     p = new dummy(5); //constructing
18 |     if (!p) cout<<"Error allocating memory";
19 |     
20 |     cout<<endl;
21 | 
22 |     delete p; //destructing
23 |     return 0;
24 | }
25 | 
26 | dummy::dummy(int in_x)
27 | {
28 |     x = in_x;
29 |     cout<<"Constructing...";
30 | }
31 | 
32 | dummy::~dummy()
33 | {
34 |     cout<<"Destructing...";
35 | }
36 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.dereferencing.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.dereferencing.cpp */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 |     public:
 7 |         int x; 
 8 | };
 9 | 
10 | int main()
11 | {    
12 |     dummy *p = NULL; //Θα δείξει σε αντικείμενο 
13 |     p = new dummy; // Δέσμευση χώρου        
14 |    
15 |     /* Αναθέσεις τιμών */    
16 |     (*p).x = 5;
17 |     
18 |     /* Εκτυπώσεις */    
19 |     cout<<"(*p).x = "<<(*p).x<<endl;      
20 | 
21 |     delete p; // Αποδέσμευση μνήμης    
22 | 
23 |     return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.dynamic_object.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.dynamic_object.cpp Δυναμική Δέσμευση μνήμης για αντικείμενο */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 |     public:
 7 |         int x; 
 8 | };
 9 | 
10 | int main()
11 | {    
12 |     dummy *p = NULL; //Θα δείξει σε αντικείμενο 
13 |     p = new dummy; // Δέσμευση χώρου        
14 |     if (!p) cout<<"Error allocating memory";
15 | 
16 |     /* Αναθέσεις τιμών */   
17 |     p->x = 5;
18 |     
19 |     /* Εκτυπώσεις */    
20 |     cout<<"p->x = "<<p->x<<endl;      
21 | 
22 |     delete p; // Αποδέσμευση μνήμης    
23 | 
24 |     return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.dynamic_variable.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream> // CPP3.dynamic_variable.cpp 
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {    
 6 |     int x; // Μεταβλητή που δεσμέυει στατικό χώρο    
 7 |     int *p; // Δείκτης σε ακέραιο        
 8 |    
 9 |     p = new int; // Δυναμική δέσμευση μνήμης        
10 |     if (!p) cout<<“Error allocating memory”;
11 | 
12 |     /* Αναθέσεις τιμών */    
13 |     x = 1;    
14 |     *p = 5;        
15 |     /* Εκτυπώσεις */    
16 |     cout<<"x = "<<x<<" (address: "<<&x<<")"<<endl;      
17 |     cout<<"*p = "<<*p<<" (address: "<<p<<")"<<endl;    
18 | 
19 |     delete p; // Αποδέσμευση μνήμης    
20 | 
21 |     return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.local_variables.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.local_variables.cpp */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | void f()
 7 | {
 8 |     int y;
 9 |     cout<<"inside f";
10 | }
11 | 
12 | int main()
13 | {
14 |     int x; 
15 | 
16 |     cout<<"inside main";
17 |     f();
18 |     
19 |     return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.new_int.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.new_int.cpp Δεσμευση μνήμης για ακέραιο */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int x; // Μεταβλητή που δεσμέυει στατικό χώρο
 9 |     int *p; // Δείκτης σε ακέραιο
10 |     
11 |     p = new int; // Δυναμική δέσμευση μνήμης
12 |     
13 |     /* Αναθέσεις τιμών */
14 |     x = 5;
15 |     *p = 1;
16 |     
17 |     /* Εκτυπώσεις */
18 |     cout<<"x = "<<x<<" (address: "<<&x<<")"<<endl;
19 |     cout<<"*p = "<<*p<<" (address: "<<p<<")"<<endl;
20 | 
21 |     delete p; // Αποδέσμευση μνήμης
22 | 
23 |     return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.pointers.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.pointers.cpp */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int x=5; 
 9 |     int *p = NULL;
10 | 
11 |     p = &x;  
12 | 
13 |     cout<<"x = "<<x<<" (address: "<<&x<<")"<<endl;      
14 |     cout<<"*p = "<<*p<<" (address: "<<p<<")"<<endl;        
15 |     return 0;
16 | }
17 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.pointers_and_objects.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.pointers_and_objects.cpp Δείκτης σε αντικείμενο */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 |   public:
 7 |     int x;
 8 | };
 9 | 
10 | int main()
11 | { 
12 |     dummy ob;   
13 |     dummy *p = &ob; 
14 |     if (!p) cout<<"Error allocating memory";
15 | 
16 |     /* Αναθέσεις τιμών */    
17 |     ob.x = 6; 
18 |     
19 |     /* Εκτυπώσεις */    
20 |     cout<<ob.x<<" "<<p->x<<" "<<(*p).x<<endl;      
21 | 
22 |     return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/lesson03/CPP3.sizeof.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP3.sizeof.cpp Μέγεθος αντικειμένου */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 |   public:
 7 |     int x;
 8 |     int y;
 9 | };
10 | 
11 | int main()
12 | { 
13 |     dummy ob;   
14 | 
15 |     cout<<sizeof ob<<endl;      
16 | 
17 |     return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/lesson03/cpp3(4sl).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson03/cpp3(4sl).pdf


--------------------------------------------------------------------------------
/lesson03/cpp3.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson03/cpp3.pdf


--------------------------------------------------------------------------------
/lesson04/cpp4(4sl).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson04/cpp4(4sl).pdf


--------------------------------------------------------------------------------
/lesson04/cpp4.askisi1.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp4.askisi1.cpp */
  2 | 
  3 | #include <iostream>
  4 | using namespace std;
  5 | 
  6 | class point {
  7 |     public:
  8 |         point();
  9 |         point(double in_x, double in_y);
 10 |         void set_x(double in_x);
 11 |         void set_y(double in_y);
 12 |         double get_x() const;
 13 |         double get_y() const;
 14 |         void print();
 15 |     private:
 16 |         double x;
 17 |         double y;
 18 | };
 19 | 
 20 | void swap(int &x, int &y);
 21 | void swap(double &x, double &y);
 22 | void swap(point &x, point &y);
 23 | 
 24 | int main()
 25 | {
 26 |     point a(1.1,2.2), b(1.5,2.0);
 27 |     
 28 |     swap(a,b);
 29 |     
 30 |     a.print();
 31 |     b.print();
 32 |     
 33 |     return 0; 
 34 | }
 35 | 
 36 | 
 37 | void swap(int &x, int &y)
 38 | {
 39 |     int temp;
 40 |     
 41 |     temp=x;
 42 |     x=y;
 43 |     y=temp;
 44 | }
 45 | 
 46 | void swap(point &x, point &y)
 47 | {
 48 |     point temp;
 49 |     
 50 |     temp=x;
 51 |     x=y;
 52 |     y=temp;
 53 | }
 54 | 
 55 | void swap(double &x, double &y)
 56 | {
 57 |     double temp;
 58 |     
 59 |     temp=x;
 60 |     x=y;
 61 |     y=temp;
 62 | }
 63 | 
 64 | 
 65 | point::point() 
 66 | {
 67 |     x = 0.0;
 68 |     y = 0.0;
 69 | }
 70 | 
 71 | point::point(double in_x, double in_y)
 72 | {
 73 |     x = in_x; 
 74 |     y = in_y; 
 75 | }
 76 | 
 77 | void point::set_x(double in_x)
 78 | {
 79 |     x = in_x;
 80 | }
 81 | 
 82 | void point::set_y(double in_y)
 83 | {
 84 |     y = in_y;
 85 | }
 86 | 
 87 | double point::get_x() const
 88 | {
 89 |     return x;
 90 | }
 91 | 
 92 | double point::get_y() const
 93 | {
 94 |     return y;
 95 | }
 96 | 
 97 | void point::print()
 98 | {
 99 |     cout<<"("<<x<<","<<y<<")";
100 | }
101 | 


--------------------------------------------------------------------------------
/lesson04/cpp4.askisi2.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP4.askisi2.cpp */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class ARRAY {
 7 |   public:
 8 |     ARRAY(int in_n);
 9 |     ARRAY(const ARRAY &ob);
10 |     ~ARRAY();
11 |     void set_i(int i, int val);
12 |     int get_i(int i);
13 |     int get_n() const; 
14 |     void print();
15 |   private:
16 |     int *p;
17 |     int n;
18 | };
19 | 
20 | 
21 | int main()
22 | {
23 |     int n=10;
24 |     ARRAY pin(n);
25 |     ARRAY pin2 = pin; 
26 |     
27 |     for (int i=0; i<n; i++)
28 |         pin.set_i(i,i*i);
29 |     
30 |     pin.print();
31 | 
32 |     cout<<"\n";
33 | 
34 |     for (int i=0; i<n; i++)
35 |         pin2.set_i(i,i*i*i);
36 |     
37 |     pin2.print();
38 | 
39 |     
40 |     return 0;
41 | }
42 | 
43 | ARRAY::ARRAY(int in_n)
44 | {
45 |     n = in_n; 
46 |     
47 |     p = new int [n];
48 |     if (!p)
49 |         cout<<"Error allocating memory!";
50 | }
51 | 
52 | ARRAY::ARRAY(const ARRAY &ob)
53 | {
54 |     n = ob.get_n(); 
55 |     
56 |     p = new int [n];
57 |     if (!p) cout<<"Memory Allocation Error!";
58 | }
59 | 
60 | ARRAY::~ARRAY()
61 | {
62 |     delete [] p;
63 | }
64 | 
65 | void ARRAY::set_i(int i, int val)
66 | {
67 |     if (i>=0 && i<n)
68 |         p[i]=val;
69 |     else
70 |         cout<<"Error: Out of bounds!";
71 | }
72 | 
73 | int ARRAY::get_i(int i)
74 | {
75 |     if (i>=0 && i<n)
76 |         return p[i];
77 |     else
78 |         cout<<"Error: Out of bounds!";
79 | }
80 | 
81 | int ARRAY::get_n() const
82 | {
83 |     return n;
84 | }
85 | 
86 | void ARRAY::print()
87 | {
88 |     int i;
89 |     
90 |     for (i=0; i<n; i++)
91 |         cout<<p[i]<<" ";
92 | }


--------------------------------------------------------------------------------
/lesson04/cpp4.askisi3.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp4.askisi3.cpp */
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | class STRING {
 8 |     public:
 9 |         STRING();
10 |         STRING(char *in_str);
11 |         STRING(const STRING &ob);
12 |         ~STRING();
13 |         int get_length() const; 
14 |         char *get_str() const; 
15 |         void set_str(char *in_str);
16 |         void print(); 
17 |     private:
18 |        int length;
19 |        char *str; 
20 | };
21 | 
22 | 
23 | int main()
24 | {
25 |     char s[80]="This is a string";
26 |     STRING s1(s);
27 |     STRING s2 = s1; 
28 |     
29 |     strcpy(s, "This is a new string");
30 |     s2.set_str(s);
31 |     
32 |     s1.print(); 
33 |     cout<<endl; 
34 |     s2.print();
35 |     
36 |     return 0; 
37 | }
38 | 
39 | STRING::STRING()
40 | {
41 |     length = 0;
42 |     str = NULL; 
43 | }
44 | 
45 | STRING::STRING(char *in_str)
46 | {
47 |     length = strlen(in_str);
48 |     
49 |     str = new char [length];
50 |     if (!str) cout<<"Error Allocating Memory";
51 |     
52 |     strcpy(str, in_str);
53 | }
54 | 
55 | STRING::STRING(const STRING &ob)
56 | {
57 |     length = ob.get_length(); 
58 |     
59 |     str = new char [length];
60 |     if (!str) cout<<"Error Allocating Memory";
61 |     
62 |     strcpy(str, ob.get_str());    
63 | }
64 | 
65 | STRING::~STRING()
66 | {
67 |     delete [] str; 
68 | }
69 | 
70 | int STRING::get_length() const
71 | {
72 |     return length; 
73 | }
74 | 
75 | char *STRING::get_str() const
76 | {
77 |     return str; 
78 | }
79 | 
80 | void STRING::set_str(char *in_str)
81 | {
82 |     if (str!=NULL)
83 |         delete str; 
84 |     
85 |     length = strlen(in_str);
86 |     
87 |     str = new char [length];
88 |     if (!str) cout<<"Error Allocating Memory";
89 |     
90 |     strcpy(str, in_str);    
91 | }
92 | 
93 | void STRING::print()
94 | {
95 |     cout<<str; 
96 | }
97 | 


--------------------------------------------------------------------------------
/lesson04/cpp4.bypointer.cpp:
--------------------------------------------------------------------------------
 1 | /*cpp4.bypointer.cpp: Πέρασμα ορίσματος μέσω δείκτη */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | void change(int *pA);
 6 | 
 7 | int main()
 8 | {
 9 |     int a=1;
10 |     
11 |     cout<<"main: a="<<a<<endl;
12 |     change(&a);
13 |     cout<<"main: a="<<a<<endl;
14 |     
15 |     return 0;
16 | }
17 | 
18 | void change(int *pA)
19 | {
20 |     *pA=2;
21 |     cout<<"change: *pA="<<*pA<<endl;
22 | }
23 | 


--------------------------------------------------------------------------------
/lesson04/cpp4.byreference.cpp:
--------------------------------------------------------------------------------
 1 | /*cpp4.byreference.cpp: Πέρασμα ορίσματος μέσω αναφοράς */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | void change(int &rA);
 6 | 
 7 | int main()
 8 | {
 9 |     int a=1;
10 |     
11 |     cout<<"main: a="<<a<<endl;
12 |     change(a);
13 |     cout<<"main: a="<<a<<endl;
14 |     
15 |     return 0;
16 | }
17 | 
18 | void change(int &rA)
19 | {
20 |     rA=2;
21 |     cout<<"change: rA="<<rA<<endl;
22 | }
23 | 


--------------------------------------------------------------------------------
/lesson04/cpp4.byvalue.cpp:
--------------------------------------------------------------------------------
 1 | /*cpp4.byvalue.cpp: Πέρασμα ορίσματος μέσω τιμής */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | void change(int vA);
 6 | 
 7 | int main()
 8 | {
 9 |     int a=1;
10 |     
11 |     cout<<"main: a="<<a<<endl;
12 |     change(a);
13 |     cout<<"main: a="<<a<<endl;
14 |     
15 |     return 0;
16 | }
17 | 
18 | void change(int vA)
19 | {
20 |     vA=2;
21 |     cout<<"change: vA="<<vA<<endl;
22 | }
23 | 


--------------------------------------------------------------------------------
/lesson04/cpp4.copy_arg_by_value.cpp:
--------------------------------------------------------------------------------
 1 | /*cpp4.copy_arg_by_value.cpp: Δημιουργία αντιγράφου όταν αντικείμενο διοχετεύεται ως όρισμα */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 |    public:
 7 |       dummy();
 8 |       ~dummy();
 9 |       int x; 
10 | };
11 | 
12 | void f(dummy ob);
13 | 
14 | int main()
15 | {
16 |     dummy d; // καλείται ο constructor
17 |     
18 |     f(d); 
19 |     
20 |     return 0;
21 | }
22 | 
23 | dummy::dummy()
24 | {
25 |     cout<<"Constructing..."<<endl;
26 | }
27 | 
28 | dummy::~dummy()
29 | {
30 |     cout<<"Destructing..."<<endl;
31 | }
32 | 
33 | void f(dummy ob)
34 | {
35 |     // το όρισμα είναι αντίγραφο
36 |     
37 |     // καταστρέφεται το αντίγραφο
38 | }


--------------------------------------------------------------------------------
/lesson04/cpp4.copy_constructor_arg_by_value.cpp:
--------------------------------------------------------------------------------
 1 | /*cpp4.copy_constructor_arg_by_value.cpp: Copy Constructor: Όρισμα μέσω τιμής */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 |    public:
 7 |       dummy();
 8 |       dummy(const dummy &ob);
 9 |       ~dummy();
10 |       int x;
11 | };
12 | 
13 | void f(dummy arg);
14 | 
15 | int main()
16 | {
17 |     dummy d;
18 |     
19 |     cout<<"Main: Before calling f"<<endl;
20 |     f(d); 
21 |     cout<<"Main: After calling f"<<endl;
22 |     
23 |     return 0; 
24 | }
25 | 
26 | dummy::dummy()
27 | {
28 |     cout<<"Constructing..."<<endl;
29 |     x=0; 
30 | }
31 | 
32 | dummy::dummy(const dummy &ob)
33 | {
34 |     cout<<"Copy constructor..."<<endl;
35 |     x=ob.x+1;
36 | }
37 | 
38 | dummy::~dummy()
39 | {
40 |     cout<<"Destructing..."<<endl;
41 | }
42 | 
43 | void f(dummy arg)
44 | {
45 |     cout<<"In function..."<<endl;
46 | }


--------------------------------------------------------------------------------
/lesson04/cpp4.copy_constructor_object_declaration.cpp:
--------------------------------------------------------------------------------
 1 | /*cpp4.copy_constructor_object_declaration.cpp: Δήλωση αντικειμένου μέσω άλλου αντικειμένου */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 |    public:
 7 |       dummy();
 8 |       dummy(const dummy &ob);
 9 |       ~dummy();
10 |       int x;
11 | };
12 | 
13 | void f(dummy ob);
14 | 
15 | int main()
16 | {
17 |     dummy ob1;
18 |     dummy ob2 = ob1; // dummy ob2(ob1);
19 | 
20 |     return 0; 
21 | }
22 | 
23 | dummy::dummy()
24 | {
25 |     cout<<"Constructing..."<<endl;
26 |     x=0; 
27 | }
28 | 
29 | dummy::dummy(const dummy &ob)
30 | {
31 |     cout<<"Copy constructor..."<<endl;
32 |     x=10;
33 | }
34 | 
35 | dummy::~dummy()
36 | {
37 |     cout<<"Destructing..."<<endl;
38 | }
39 | 


--------------------------------------------------------------------------------
/lesson04/cpp4.copy_constructor_return_ob.cpp:
--------------------------------------------------------------------------------
 1 | /*cpp4.copy_constructor_return_ob.cpp: Copy Constructor: Επιστροφή αντικειμένου */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 |    public:
 7 |       dummy();
 8 |       dummy(const dummy &ob);
 9 |       ~dummy();
10 |       int x;
11 | };
12 | 
13 | dummy f();
14 | 
15 | int main()
16 | {
17 |     cout<<"Main: Before calling f"<<endl;
18 |     f(); 
19 |     cout<<"Main: After calling f"<<endl;
20 |     
21 |     return 0; 
22 | }
23 | 
24 | dummy::dummy()
25 | {
26 |     cout<<"Constructing..."<<endl;
27 |     x=0; 
28 | }
29 | 
30 | dummy::dummy(const dummy &ob)
31 | {
32 |     cout<<"Copy constructor..."<<endl;
33 |     x=10;
34 | }
35 | 
36 | dummy::~dummy()
37 | {
38 |     cout<<"Destructing ..."<<endl;
39 | }
40 | 
41 | dummy f()
42 | {
43 |     dummy ob;
44 |     cout<<"In function..."<<endl;
45 |     return ob;
46 | }


--------------------------------------------------------------------------------
/lesson04/cpp4.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson04/cpp4.pdf


--------------------------------------------------------------------------------
/lesson04/cpp4.reference.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp4.reference.cpp Χρήση αναφοράς */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | int main()
 6 | {
 7 |     int x = 3;
 8 |     int &r = x;
 9 |     
10 |     cout<<"x="<<x<<" r="<<r<<endl;
11 |     
12 |     x=4;
13 |     cout<<"x="<<x<<" r="<<r<<endl;
14 | 
15 |     r=5;
16 |     cout<<"x="<<x<<" r="<<r<<endl;
17 |     
18 |     return 0;
19 | }


--------------------------------------------------------------------------------
/lesson04/cpp4.reference_mistake.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp4.reference_mistake.cpp Συνηθισμένο λάθος στις αναφορές */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | int main()
 6 | {
 7 |     int x = 3, y=4;
 8 |     int &r = x;
 9 |     
10 |     cout<<"r="<<r<<endl;
11 |     
12 |     r=y; // Προσπαθεί να αλλάξει την αναφορά
13 | 
14 |     cout<<"x="<<x<<endl; // Άλλαξε όμως το x
15 | 
16 |     return 0;
17 | }


--------------------------------------------------------------------------------
/lesson05/CPP5.array_of_objects.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP5.array_of_objects.cpp : Πίνακας που περιέχει αντικείμενα */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | #define N 3
 7 | 
 8 | class dummy {
 9 |    public:
10 |      dummy();
11 |      dummy(int in_x);
12 |      int get_x() const; 
13 |    private:
14 |      int x; 
15 | };
16 | 
17 | int main()
18 | {
19 |     dummy array[N] = {dummy(), dummy(3), dummy(5)};
20 |     
21 |     for (int i=0; i<N; i++)
22 |         cout<<array[i].get_x()<<" ";
23 | 
24 |     return 0;
25 | }
26 | 
27 | dummy::dummy() 
28 | {
29 |     x=0; 
30 | }
31 | 
32 | dummy::dummy(int in_x) 
33 | {
34 |     x=in_x; 
35 | }
36 | 
37 | int dummy::get_x() const
38 | {
39 |     return x; 
40 | }


--------------------------------------------------------------------------------
/lesson05/CPP5.array_of_objects_noinit.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP5.array_of_objects_noinit.cpp : Πίνακας που περιέχει αντικείμενα χωρίς αρχικοποίηση */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | #define N 3
 7 | 
 8 | class dummy {
 9 |    public:
10 |      dummy();
11 |      void set_x(int in_x);
12 |      int get_x() const; 
13 |    private:
14 |      int x; 
15 | };
16 | 
17 | int main()
18 | {
19 |     dummy array[N];
20 |     
21 |     for (int i=0; i<N; i++)
22 |         array[i].set_x(i*i);    
23 |     
24 |     for (int i=0; i<N; i++)
25 |         cout<<array[i].get_x()<<" ";
26 | 
27 |     return 0;
28 | }
29 | 
30 | dummy::dummy() 
31 | {
32 |     x=0; 
33 | }
34 | 
35 | void dummy::set_x(int in_x)
36 | {
37 |     x=in_x; 
38 | }
39 | 
40 | int dummy::get_x() const
41 | {
42 |     return x; 
43 | }


--------------------------------------------------------------------------------
/lesson05/CPP5.array_of_pointers_to_objects.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP5.array_of_pointers_to_objects.cpp : Πίνακας που περιέχει δείκτες σε αντικείμενα */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | #define N 3
 7 | 
 8 | class dummy {
 9 |    public:
10 |      dummy();
11 |      void set_x(int in_x);
12 |      int get_x() const; 
13 |    private:
14 |      int x; 
15 | };
16 | 
17 | int main()
18 | {
19 |     dummy *array[N];
20 |     
21 |     for (int i=0; i<N; i++)
22 |         array[i] = new dummy;    
23 | 
24 |     for (int i=0; i<N; i++)
25 |         array[i]->set_x(i*i);    
26 |     
27 |     for (int i=0; i<N; i++)
28 |         cout<<array[i]->get_x()<<" ";
29 | 
30 |     for (int i=0; i<N; i++)
31 |         delete array[i];    
32 | 
33 |     return 0;
34 | }
35 | 
36 | dummy::dummy() 
37 | {
38 |     x=0; 
39 | }
40 | 
41 | void dummy::set_x(int in_x)
42 | {
43 |     x=in_x; 
44 | }
45 | 
46 | int dummy::get_x() const
47 | {
48 |     return x; 
49 | }


--------------------------------------------------------------------------------
/lesson05/CPP5.class_with_array.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP5.class_with_array.cpp Κλάση που περιέχει πίνακα */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | #define N 3
 6 | 
 7 | class grades
 8 | {  
 9 |   public:
10 |     grades();
11 |     int set_i(int pos, int val);
12 |     int get_i(int pos) const;
13 |   private:    
14 |     int array[N];
15 | };
16 | 
17 | int main() 
18 | {
19 |     grades my_grades;
20 | 
21 |     /* Εισαγωγή Δεδομένων */
22 |     my_grades.set_i(0,5);
23 |     my_grades.set_i(1,8);
24 |     my_grades.set_i(2,7);
25 | 
26 |    /* Εκτύπωση δεδομένων */
27 |    for (int i=0; i<N; i++)
28 |        cout<<my_grades.get_i(i)<<endl;
29 | 
30 |     return 0; 
31 | }
32 | 
33 | grades::grades()    
34 | {      
35 |      for (int i=0; i<N; i++)
36 |           array[i]=0;
37 | }    
38 | int grades::set_i(int pos, int val)
39 | {
40 |     if (pos>=0 && pos<N)
41 |           array[pos]=val;
42 |     else cout<<"out of bounds";
43 | }
44 | int grades::get_i(int pos) const
45 | {
46 |     if (pos>=0 && pos<N)
47 |         return array[pos];
48 |     cout<<"out of bounds";
49 |     return 0; 
50 | }
51 | 


--------------------------------------------------------------------------------
/lesson05/CPP5.class_with_objects.cpp:
--------------------------------------------------------------------------------
  1 | /* CPP5.class_with_objects.cpp Κλάση που περιέχει αντικείμενα */ 
  2 | #include <iostream>
  3 | using namespace std; 
  4 | 
  5 | class flat {
  6 |   public:
  7 |     flat();
  8 |     ~flat();
  9 |     void set_people(int in_people);
 10 |     int get_people() const;
 11 |   private:
 12 |     int people; 
 13 | };
 14 | 
 15 | class storey {
 16 |   public:
 17 |     storey();
 18 |     ~storey(); 
 19 |     void set_people(int in_flat, int in_people);
 20 |     int get_people() const;
 21 |   private:
 22 |     flat flats[2];
 23 | };
 24 | 
 25 | 
 26 | class building {
 27 |   public:
 28 |     building();
 29 |     ~building(); 
 30 |     void set_people(int in_floor, int in_flat, int in_people);
 31 |     int get_people() const;
 32 |   private:
 33 |     storey storeys[2];
 34 | };
 35 | 
 36 | int main()
 37 | {
 38 |     building b; 
 39 |     
 40 |     b.set_people(0,0,3);
 41 |     b.set_people(0,1,2);
 42 |     b.set_people(1,0,2);
 43 |     b.set_people(1,1,1);
 44 |     
 45 |     cout<<endl;
 46 |     cout<<"People in building: "<<b.get_people(); 
 47 |     cout<<endl<<endl; 
 48 |     
 49 |     return 0; 
 50 | }
 51 | 
 52 | flat::flat()
 53 | {
 54 |     people=0; 
 55 |     cout<<"Constructing flat..."<<endl;
 56 | }
 57 | flat::~flat()
 58 | {
 59 |     cout<<"Destructing flat..."<<endl;
 60 | }
 61 | void flat::set_people(int in_people)
 62 | {
 63 |     people = in_people;
 64 | }
 65 | int flat::get_people() const
 66 | {
 67 |     return people; 
 68 | }
 69 | 
 70 | 
 71 | 
 72 | storey::storey()
 73 | {
 74 |     cout<<"Constructing storey..."<<endl;
 75 | }
 76 | storey::~storey()
 77 | {
 78 |     cout<<"Destructing storey..."<<endl; 
 79 | }
 80 | void storey::set_people(int in_flat, int in_people)
 81 | {
 82 |     flats[in_flat].set_people(in_people);
 83 | }
 84 | int storey::get_people() const
 85 | {
 86 |     return flats[0].get_people()+flats[1].get_people(); 
 87 | }
 88 | 
 89 | 
 90 | building::building()
 91 | {
 92 |     cout<<"Constructing building..."<<endl;
 93 | }
 94 | building::~building()
 95 | {
 96 |     cout<<"Destructing building..."<<endl; 
 97 | }
 98 | void building::set_people(int in_storey, int in_flat, int in_people)
 99 | {
100 |     storeys[in_storey].set_people(in_flat, in_people);
101 | }
102 | int building::get_people() const
103 | {
104 |     return storeys[0].get_people()+storeys[1].get_people(); 
105 | }
106 | 


--------------------------------------------------------------------------------
/lesson05/CPP5.construction_with_initialization_syntax.cpp:
--------------------------------------------------------------------------------
 1 | /*cpp5.construction_with_initialization_syntax.cpp: Εναλλακτικός τρόπος αρχικοποίησης μελών κλάσης από το constructor */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 |    public:
 7 |       dummy(int in_x, int in_y);
 8 |       void print();
 9 |    private:
10 |       int x,y;
11 | };
12 | 
13 | int main()
14 | {
15 |     dummy ob (3,4);
16 |     
17 |     ob.print(); 
18 |     
19 |     return 0; 
20 | }
21 | 
22 | dummy::dummy(int in_x, int in_y): 
23 | x(in_x), y(in_y)
24 | {
25 |     cout<<"Constructing..."<<endl;
26 | }
27 | 
28 | void dummy::print()
29 | {
30 |     cout<<x<<" "<<y; 
31 | }


--------------------------------------------------------------------------------
/lesson05/CPP5.default_parameters.cpp:
--------------------------------------------------------------------------------
 1 | /*cpp5.default_parameters.cpp: Προκαθορισμένα ορίσματα συναρτήσεων */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | int sum(int x1, int x2=0, int x3=0, int x4=0);
 6 | 
 7 | int main()
 8 | {
 9 |     cout<<sum(1,2,3,4)<<endl; 
10 |     cout<<sum(1,2,3)<<endl; 
11 |     cout<<sum(1,2)<<endl; 
12 |     
13 |     return 0; 
14 | }
15 | 
16 | int sum(int x1, int x2, int x3, int x4)
17 | {
18 |     return x1+x2+x3+x4; 
19 | }


--------------------------------------------------------------------------------
/lesson05/CPP5.dynamic_array_of_objects.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP5.dynamic_array_of_objects.cpp : Δυναμικός Πίνακας Αντικειμένων  */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class dummy {
 7 |    public:
 8 |      dummy();
 9 |      void set_x(int in_x);
10 |      int get_x() const; 
11 |    private:
12 |      int x; 
13 | };
14 | 
15 | int main()
16 | {
17 |     dummy *array;
18 |     int n=3; 
19 |     
20 |     array = new dummy [n];
21 |     if (!array) cout<<"Mem error";
22 |     
23 |     for (int i=0; i<n; i++)
24 |         array[i].set_x(i*i);    
25 |     
26 |     for (int i=0; i<n; i++)
27 |         cout<<array[i].get_x()<<" ";
28 | 
29 |     delete [] array;
30 | 
31 |     return 0;
32 | }
33 | 
34 | dummy::dummy() 
35 | {
36 |     x=0; 
37 | }
38 | 
39 | void dummy::set_x(int in_x)
40 | {
41 |     x=in_x; 
42 | }
43 | 
44 | int dummy::get_x() const
45 | {
46 |     return x; 
47 | }


--------------------------------------------------------------------------------
/lesson05/CPP5.inline_function.cpp:
--------------------------------------------------------------------------------
 1 | /*cpp5.inline_function.cpp: Συνάρτηση inline */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | inline int sqr(int x);
 6 | 
 7 | int main()
 8 | {
 9 |     cout<<sqr(4); 
10 |     
11 |     return 0; 
12 | }
13 | 
14 | int sqr(int x)
15 | {
16 |     return x*x; 
17 | }


--------------------------------------------------------------------------------
/lesson05/CPP5.name_collisions.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp5.name_collisions.cpp : Συγκρούσεις ονομάτων */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class dummy {
 7 |    public:
 8 |       dummy() { x = 2; };
 9 |       void print(int x);
10 |    private:
11 |       int x; // class member = 2
12 | };
13 | 
14 | int x=1; // global = 1
15 | 
16 | int main()
17 | {
18 |     dummy ob;
19 |     int x=3; 
20 |     
21 |     ob.print(x);
22 |     
23 |     return 0;
24 | }
25 | 
26 | void dummy::print(int x) // argument = 3
27 | {
28 |     int x = 4; // local = 4
29 |     cout<<x; 
30 | }
31 | 


--------------------------------------------------------------------------------
/lesson05/CPP5.this.cpp:
--------------------------------------------------------------------------------
 1 | /* CPP5.this.cpp : Ο δείκτης this */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class point {
 7 |    public:
 8 |       point(int in_x, int in_y);
 9 |       point *ret_this();
10 |       void print();
11 |    private:
12 |       int x;
13 |       int y;
14 | };
15 | 
16 | int main()
17 | {
18 |     point ob(3,4);
19 |     
20 |     cout<<"Address: "<<&ob<<endl;
21 |     cout<<"Address: "<<ob.ret_this()<<endl;
22 |     
23 |     return 0;
24 | }
25 | 
26 | point::point(int in_x, int in_y)
27 | {
28 |     x=in_x;
29 |     y=in_y;
30 | }
31 | 
32 | point *point::ret_this()
33 | {
34 |     return this;
35 | }
36 | 
37 | void point::print()
38 | {
39 |     cout<<"("<<x<<","<<y<<")";
40 | }


--------------------------------------------------------------------------------
/lesson05/CPP5.this_constructor.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp5.this_constructor.cpp : this και constructor */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class point {
 7 |    public:
 8 |       point(int x, int y);
 9 |       void print();
10 |    private:
11 |       int x;
12 |       int y;
13 | };
14 | 
15 | int main()
16 | {
17 |     point ob(3,4);
18 |     
19 |     ob.print();
20 |     
21 |     return 0;
22 | }
23 | 
24 | point::point(int x, int y)
25 | {
26 |     this->x=x;
27 |     this->y=y;
28 | }
29 | 
30 | void point::print()
31 | {
32 |     cout<<"("<<x<<","<<y<<")";
33 | }


--------------------------------------------------------------------------------
/lesson05/cpp5(4sl).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson05/cpp5(4sl).pdf


--------------------------------------------------------------------------------
/lesson05/cpp5.askisi1.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp5.askisi1.cpp */
  2 | 
  3 | #include <iostream>
  4 | using namespace std; 
  5 | 
  6 | #define N 3
  7 | 
  8 | class tictactoe {
  9 |   public:
 10 |     tictactoe();
 11 |     bool play(int x, int y, char c);
 12 |     char check_winner();
 13 |     void print(); 
 14 |   private:
 15 |     char array[N][N];
 16 | };
 17 | 
 18 | 
 19 | int main()
 20 | {
 21 |     tictactoe t; 
 22 |     char player = 'X';
 23 |     int x,y, step=0;
 24 |     
 25 |     while(true)
 26 |     {
 27 |         cout<<"PLAISIO: "<<endl;
 28 |         t.print();  
 29 |         cout<<"Paizei o "<<player<<endl; 
 30 |         
 31 |         cout<<"Dwse X sintetagmeni: ";
 32 |         cin>>x;
 33 |         cout<<"Dwse Y sintetagmeni: ";
 34 |         cin>>y;
 35 |         
 36 |         if (!t.play(x,y,player))
 37 |         {
 38 |             cout<<"Lathos Kinisi!";
 39 |             continue;
 40 |         }
 41 |         else
 42 |             step++; 
 43 |         
 44 |         if (t.check_winner()!='-')
 45 |         {
 46 |             t.print(); 
 47 |             cout<<"Nikise o "<<t.check_winner();
 48 |             break;
 49 |         }
 50 |         else if (step==9)
 51 |         {
 52 |             t.print(); 
 53 |             cout<<"Isopalia";
 54 |             break;
 55 |         }
 56 |         
 57 | 
 58 |         if (player=='X')
 59 |             player='O';
 60 |         else
 61 |             player='X';
 62 |     }
 63 |     
 64 | 
 65 |     return 0;
 66 | }
 67 | 
 68 | tictactoe::tictactoe()
 69 | {
 70 |     int i,j;
 71 |     
 72 |     for (i=0; i<N; i++)
 73 |         for (j=0; j<N; j++)
 74 |             array[i][j]='-';
 75 | }
 76 | 
 77 | bool tictactoe::play(int x, int y, char c)
 78 | {
 79 |     if (array[x][y]=='-')
 80 |     {
 81 |         if (c=='X'||c=='O')
 82 |         {
 83 |             array[x][y]=c;
 84 |             return true; 
 85 |         }
 86 |         else
 87 |             return false;
 88 |     }
 89 |     else 
 90 |         return false; 
 91 | }
 92 | 
 93 | char tictactoe::check_winner()
 94 | {
 95 |     int i,j; 
 96 |     
 97 |     /* grammes */
 98 |     for (i=0; i<N; i++)
 99 |     {
100 |         if (array[i][0]==array[i][1] && array[i][1]==array[i][2])
101 |             return array[i][0];
102 |     }
103 |     
104 |     /* stiles */
105 |     for (j=0; j<N; j++)
106 |     {
107 |         if (array[0][j]==array[1][j] && array[1][j]==array[2][j])
108 |             return array[0][j];
109 |     }
110 |     
111 |     /* diagwnioi */
112 |     
113 |     if (array[0][0]==array[1][1] && array[1][1]==array[2][2])
114 |         return array[0][0];
115 |         
116 |     if (array[0][2]==array[1][1] && array[1][1]==array[2][0])
117 |         return array[0][2];
118 |         
119 |     return '-';
120 | }
121 | 
122 | void tictactoe::print()
123 | {
124 |     int i,j; 
125 |     for (i=0; i<N; i++)
126 |     {
127 |         for (j=0; j<N; j++)
128 |             cout<<array[i][j];
129 |         cout<<endl;
130 |     }
131 | }


--------------------------------------------------------------------------------
/lesson05/cpp5.askisi2.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp5.askisi2 */
  2 | 
  3 | #include <iostream>
  4 | using namespace std; 
  5 | 
  6 | #define N 3
  7 | 
  8 | class tictactoe {
  9 |   public:
 10 |     tictactoe();
 11 |     bool play(int x, int y);
 12 |     char check_winner();
 13 |     void print(); 
 14 |     void next_player(); 
 15 |     char get_player() const;
 16 |   private:
 17 |     char array[N][N];
 18 |     char player; 
 19 | };
 20 | 
 21 | 
 22 | int main()
 23 | {
 24 |     tictactoe t; 
 25 |     int x,y, step=0;
 26 |     
 27 |     while(true)
 28 |     {
 29 |         cout<<"PLAISIO: "<<endl;
 30 |         t.print();  
 31 |         cout<<"Paizei o "<<t.get_player()<<endl; 
 32 |         
 33 |         cout<<"Dwse X sintetagmeni: ";
 34 |         cin>>x;
 35 |         cout<<"Dwse Y sintetagmeni: ";
 36 |         cin>>y;
 37 |         
 38 |         if (!t.play(x,y))
 39 |         {
 40 |             cout<<"Lathos Kinisi!";
 41 |             continue;
 42 |         }
 43 |         else
 44 |             step++; 
 45 |         
 46 |         if (t.check_winner()!='-')
 47 |         {
 48 |             t.print(); 
 49 |             cout<<"Nikise o "<<t.check_winner();
 50 |             break;
 51 |         }
 52 |         else if (step==9)
 53 |         {
 54 |             t.print(); 
 55 |             cout<<"Isopalia";
 56 |             break;
 57 |         }
 58 |         
 59 | 
 60 |         t.next_player(); 
 61 |     }
 62 |     
 63 | 
 64 |     return 0;
 65 | }
 66 | 
 67 | tictactoe::tictactoe()
 68 | {
 69 |     int i,j;
 70 |     
 71 |     for (i=0; i<N; i++)
 72 |         for (j=0; j<N; j++)
 73 |             array[i][j]='-';
 74 |             
 75 |     player = 'X';
 76 | }
 77 | 
 78 | bool tictactoe::play(int x, int y)
 79 | {
 80 |     if (array[x][y]=='-')
 81 |     {
 82 |         array[x][y]=player;
 83 |         return true; 
 84 |     }
 85 |     else 
 86 |         return false; 
 87 | }
 88 | 
 89 | char tictactoe::check_winner()
 90 | {
 91 |     int i,j; 
 92 |     
 93 |     /* grammes */
 94 |     for (i=0; i<N; i++)
 95 |     {
 96 |         if (array[i][0]==array[i][1] && array[i][1]==array[i][2])
 97 |             return array[i][0];
 98 |     }
 99 |     
100 |     /* stiles */
101 |     for (j=0; j<N; j++)
102 |     {
103 |         if (array[0][j]==array[1][j] && array[1][j]==array[2][j])
104 |             return array[0][j];
105 |     }
106 |     
107 |     /* diagwnioi */
108 |     
109 |     if (array[0][0]==array[1][1] && array[1][1]==array[2][2])
110 |         return array[0][0];
111 |         
112 |     if (array[0][2]==array[1][1] && array[1][1]==array[2][0])
113 |         return array[0][2];
114 |         
115 |     return '-';
116 | }
117 | 
118 | void tictactoe::print()
119 | {
120 |     int i,j; 
121 |     for (i=0; i<N; i++)
122 |     {
123 |         for (j=0; j<N; j++)
124 |             cout<<array[i][j];
125 |         cout<<endl;
126 |     }
127 | }
128 | 
129 | void tictactoe::next_player()
130 | {
131 |     if (player=='X')
132 |         player='O';
133 |     else 
134 |         player='X';
135 | }
136 | 
137 | char tictactoe::get_player() const
138 | {
139 |     return player; 
140 | }


--------------------------------------------------------------------------------
/lesson05/cpp5.askisi3.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp5.askisi3.cpp */
  2 | #include <iostream>
  3 | #include <cstdlib>
  4 | #include <ctime>
  5 | using namespace std;
  6 | 
  7 | class demigorgon 
  8 | {
  9 |     public:
 10 |         demigorgon();
 11 |         int attack();
 12 |     private:
 13 |         int height; 
 14 |         int weight;
 15 |         int health;
 16 | };
 17 | 
 18 | class demidog
 19 | {
 20 |     public:
 21 |         demidog();
 22 |         int attack();
 23 |     private:
 24 |         int health;
 25 | };
 26 | 
 27 | class hive
 28 | {
 29 |     public:
 30 |         hive(bool in_demigorgon);
 31 |         int attack(); 
 32 |     private:
 33 |         demigorgon *demi_ptr;
 34 |         demidog *array_demidogs; 
 35 |         int n_demidogs;
 36 | };
 37 | 
 38 | 
 39 | int main()
 40 | {
 41 |     hive h(true);
 42 |     int damage;
 43 |     
 44 |     damage = h.attack();
 45 |     
 46 |     cout<<"Total damage: "<<damage; 
 47 | 
 48 |     return 0; 
 49 | }
 50 | 
 51 | demigorgon::demigorgon()
 52 | {
 53 |     height=5;
 54 |     weight=500;
 55 |     health=10000; 
 56 | }
 57 | 
 58 | int demigorgon::attack()
 59 | {
 60 |     srand(time(0));
 61 |     
 62 |     return 300+rand()%(200-0+1);
 63 | }
 64 | 
 65 | demidog::demidog()
 66 | {
 67 |     health=100; 
 68 | }
 69 | 
 70 | int demidog::attack()
 71 | {
 72 |     return 10+rand()%(20-0+1);
 73 | }
 74 | 
 75 | hive::hive(bool in_demigorgon)
 76 | {
 77 |     if (in_demigorgon)
 78 |     {
 79 |         demi_ptr = new demigorgon; 
 80 |         if (!demi_ptr)
 81 |             cout<<"Error allocating memory";
 82 |     }
 83 |     else 
 84 |         demi_ptr = NULL; 
 85 |     
 86 |     n_demidogs = 10+rand()%41;
 87 |     
 88 |     array_demidogs = new demidog [n_demidogs];
 89 |     if (!array_demidogs)
 90 |         cout<<"Error allocating memory";
 91 | }
 92 | 
 93 | int hive::attack()
 94 | {
 95 |     int damage;
 96 |     int sum = 0; 
 97 |     if (demi_ptr!=NULL)
 98 |     {
 99 |         damage = demi_ptr->attack();
100 |         sum+=damage; 
101 |         cout<<"Demigorgon attacks! (damage: "<<damage<<")"<<endl; 
102 |     }
103 |     
104 |     for (int i=0; i<n_demidogs; i++)
105 |     {
106 |         damage = array_demidogs[i].attack();
107 |         sum+=damage; 
108 |         cout<<"Demidog "<<i<<" attacks! (damage: "<<damage<<")"<<endl; 
109 |     }
110 |     
111 |     return sum; 
112 | }


--------------------------------------------------------------------------------
/lesson05/cpp5.const_object.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp5.const_object.cpp Const Αντικείμενα */ 
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 | public:
 7 |     dummy (int in_x);
 8 |     int get_x() const;
 9 |     void set_x(int in_x);
10 | private:
11 |     int x;
12 | };
13 | 
14 | int main()
15 | {
16 |     const dummy ob(3); 
17 |     
18 |     //ob.set_x(4); //error
19 |     
20 |     return 0; 
21 | }
22 | 
23 | dummy::dummy(int in_x)
24 | {
25 |     x=in_x; 
26 | }
27 | 
28 | int dummy::get_x() const
29 | {
30 |     return x; 
31 | }
32 | 
33 | void dummy::set_x(int in_x)
34 | {
35 |     x=in_x; 
36 | }
37 | 


--------------------------------------------------------------------------------
/lesson05/cpp5.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson05/cpp5.pdf


--------------------------------------------------------------------------------
/lesson05/cpp5.pointer_to_const_object.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp5.pointer_to_const_object.cpp Δείκτης προς const αντικείμενο */ 
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 | public:
 7 |     dummy (int in_x);
 8 |     int get_x() const;
 9 |     void set_x(int in_x);
10 | private:
11 |     int x;
12 | };
13 | 
14 | void f(const dummy *p);
15 | 
16 | int main()
17 | {
18 |     dummy ob(3); 
19 |     
20 |     f(&ob);
21 |     
22 |     return 0; 
23 | }
24 | 
25 | dummy::dummy(int in_x)
26 | {
27 |     x=in_x; 
28 | }
29 | 
30 | int dummy::get_x() const
31 | {
32 |     return x; 
33 | }
34 | 
35 | void dummy::set_x(int in_x)
36 | {
37 |     x=in_x; 
38 | }
39 | 
40 | void f(const dummy *p)
41 | {
42 |     cout<<p->get_x();
43 |     // p->set_x(2); // error
44 | }


--------------------------------------------------------------------------------
/lesson05/cpp5.reference_to_const_object.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp5.reference_to_const_object.cpp Αναφορά προς const αντικείμενο */ 
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | class dummy {
 6 | public:
 7 |     dummy (int in_x);
 8 |     int get_x() const;
 9 |     void set_x(int in_x);
10 | private:
11 |     int x;
12 | };
13 | 
14 | void f(const dummy &ref);
15 | 
16 | int main()
17 | {
18 |     dummy ob(3); 
19 |     
20 |     f(ob);
21 |     
22 |     return 0; 
23 | }
24 | 
25 | dummy::dummy(int in_x)
26 | {
27 |     x=in_x; 
28 | }
29 | 
30 | int dummy::get_x() const
31 | {
32 |     return x; 
33 | }
34 | 
35 | void dummy::set_x(int in_x)
36 | {
37 |     x=in_x; 
38 | }
39 | 
40 | void f(const dummy &ref)
41 | {
42 |     cout<<ref.get_x();
43 |     // ref.set_x(2); // error
44 | }


--------------------------------------------------------------------------------
/lesson06/cpp6(4sl).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson06/cpp6(4sl).pdf


--------------------------------------------------------------------------------
/lesson06/cpp6.array_with_index_overloading.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp6.array_with_index_overloading.cpp */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class ARRAY {
 7 |   public:
 8 |     ARRAY(int in_n);
 9 |     ARRAY(const ARRAY &ob);
10 |     ~ARRAY();
11 |     int get_n() const; 
12 |     int &operator[] (int i);
13 |     void print();
14 |   private:
15 |     int *p;
16 |     int n;
17 | };
18 | 
19 | 
20 | int main()
21 | {
22 |     int n=10;
23 |     ARRAY pin(n);
24 |     
25 |     for (int i=0; i<n; i++)
26 |         pin[i]=i*i;
27 |     
28 |     pin.print();
29 | 
30 |     return 0;
31 | }
32 | 
33 | ARRAY::ARRAY(int in_n)
34 | {
35 |     n = in_n; 
36 |     
37 |     p = new int [n];
38 |     if (!p)
39 |         cout<<"Error allocating memory!";
40 | }
41 | 
42 | ARRAY::ARRAY(const ARRAY &ob)
43 | {
44 |     n = ob.get_n(); 
45 |     
46 |     p = new int [n];
47 |     if (!p) cout<<"Memory Allocation Error!";
48 | }
49 | 
50 | ARRAY::~ARRAY()
51 | {
52 |     delete [] p;
53 | }
54 | 
55 | int ARRAY::get_n() const
56 | {
57 |     return n;
58 | }
59 | 
60 | void ARRAY::print()
61 | {
62 |     int i;
63 |     
64 |     for (i=0; i<n; i++)
65 |         cout<<p[i]<<" ";
66 | }
67 | 
68 | int &ARRAY::operator[] (int i)
69 | {
70 |     if (i>=0 && i<n) 
71 |         return p[i]; 
72 |     else
73 |         cout<<"Index Error";
74 |     
75 | }
76 | 


--------------------------------------------------------------------------------
/lesson06/cpp6.askisi1.1.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp6.askisi1.1.cpp */
  2 | 
  3 | #include <iostream>
  4 | #include <cstring>
  5 | using namespace std;
  6 | 
  7 | class STRING {
  8 |     public:
  9 |         STRING();
 10 |         STRING(char *in_str);
 11 |         STRING(const STRING &ob);
 12 |         ~STRING();
 13 |         int get_length() const; 
 14 |         char *get_str() const; 
 15 |         void set_str(char *in_str);
 16 |         void print(); 
 17 |         STRING &operator=(STRING &right);
 18 |     private:
 19 |        int length;
 20 |        char *str; 
 21 | };
 22 | 
 23 | 
 24 | int main()
 25 | {
 26 |     char s[80]="This is a string";
 27 |     STRING s1(s);
 28 |     STRING s2; 
 29 |     
 30 |     s2=s1;
 31 | 
 32 |     s1.print(); 
 33 |     cout<<endl; 
 34 |     s2.print();
 35 |     
 36 |     return 0; 
 37 | }
 38 | 
 39 | STRING::STRING()
 40 | {
 41 |     length = 0;
 42 |     str = NULL; 
 43 | }
 44 | 
 45 | STRING::STRING(char *in_str)
 46 | {
 47 |     length = strlen(in_str);
 48 |     
 49 |     str = new char [length];
 50 |     if (!str) cout<<"Error Allocating Memory";
 51 |     
 52 |     strcpy(str, in_str);
 53 | }
 54 | 
 55 | STRING::STRING(const STRING &ob)
 56 | {
 57 |     length = ob.get_length(); 
 58 |     
 59 |     str = new char [length];
 60 |     if (!str) cout<<"Error Allocating Memory";
 61 |     
 62 |     strcpy(str, ob.get_str());    
 63 | }
 64 | 
 65 | STRING::~STRING()
 66 | {
 67 |     delete [] str; 
 68 | }
 69 | 
 70 | int STRING::get_length() const
 71 | {
 72 |     return length; 
 73 | }
 74 | 
 75 | char *STRING::get_str() const
 76 | {
 77 |     return str; 
 78 | }
 79 | 
 80 | void STRING::set_str(char *in_str)
 81 | {
 82 |     if (str!=NULL)
 83 |         delete str; 
 84 |     
 85 |     length = strlen(in_str);
 86 |     
 87 |     str = new char [length];
 88 |     if (!str) cout<<"Error Allocating Memory";
 89 |     
 90 |     strcpy(str, in_str);    
 91 | }
 92 | 
 93 | void STRING::print()
 94 | {
 95 |     cout<<str; 
 96 | }
 97 | 
 98 | STRING &STRING::operator=(STRING &right)
 99 | {
100 |     if (this==&right) return *this; 
101 |     
102 |     length=right.length; 
103 |     
104 |     delete [] str;
105 |     str = new char [length];
106 |     if (!str) cout<<"Error Allocating Memory";
107 |     
108 |     strcpy(str, right.str);
109 |     
110 |     return *this; 
111 | }
112 | 
113 | 


--------------------------------------------------------------------------------
/lesson06/cpp6.askisi1.2.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp6.askisi1.2.cpp */
  2 | 
  3 | #include <iostream>
  4 | #include <cstring>
  5 | using namespace std;
  6 | 
  7 | class STRING {
  8 |     public:
  9 |         STRING();
 10 |         STRING(char *in_str);
 11 |         STRING(const STRING &ob);
 12 |         ~STRING();
 13 |         int get_length() const; 
 14 |         char *get_str() const; 
 15 |         void set_str(char *in_str);
 16 |         void print(); 
 17 |         STRING &operator=(STRING &right);
 18 |         char &operator[](int i);
 19 |     private:
 20 |        int length;
 21 |        char *str; 
 22 | };
 23 | 
 24 | 
 25 | int main()
 26 | {
 27 |     char s[80]="This is a string";
 28 |     STRING s1(s);
 29 |     STRING s2; 
 30 |     
 31 |     s2=s1;
 32 | 
 33 |     s2[1]='a';
 34 |     
 35 |     s1.print(); 
 36 |     cout<<endl; 
 37 |     s2.print();
 38 |     
 39 |     return 0; 
 40 | }
 41 | 
 42 | STRING::STRING()
 43 | {
 44 |     length = 0;
 45 |     str = new char[1];
 46 |     str[0]='\0';
 47 | }
 48 | 
 49 | STRING::STRING(char *in_str)
 50 | {
 51 |     length = strlen(in_str);
 52 |     
 53 |     str = new char [length+1];
 54 |     if (!str) cout<<"Error Allocating Memory";
 55 |     
 56 |     strcpy(str, in_str);
 57 | }
 58 | 
 59 | STRING::STRING(const STRING &ob)
 60 | {
 61 |     length = ob.get_length(); 
 62 |     
 63 |     str = new char [length+1];
 64 |     if (!str) cout<<"Error Allocating Memory";
 65 |     
 66 |     strcpy(str, ob.get_str());    
 67 | }
 68 | 
 69 | STRING::~STRING()
 70 | {
 71 |     delete [] str; 
 72 | }
 73 | 
 74 | int STRING::get_length() const
 75 | {
 76 |     return length; 
 77 | }
 78 | 
 79 | char *STRING::get_str() const
 80 | {
 81 |     return str; 
 82 | }
 83 | 
 84 | void STRING::set_str(char *in_str)
 85 | {
 86 |     if (str!=NULL)
 87 |         delete str; 
 88 |     
 89 |     length = strlen(in_str);
 90 |     
 91 |     str = new char [length];
 92 |     if (!str) cout<<"Error Allocating Memory";
 93 |     
 94 |     strcpy(str, in_str);    
 95 | }
 96 | 
 97 | void STRING::print()
 98 | {
 99 |     cout<<str; 
100 | }
101 | 
102 | STRING &STRING::operator=(STRING &right)
103 | {
104 |     if (this==&right) return *this; 
105 |     
106 |     length=right.length; 
107 |     
108 |     delete [] str;
109 |     str = new char [length+1];
110 |     if (!str) cout<<"Error Allocating Memory";
111 |     
112 |     strcpy(str, right.str);
113 |     
114 |     return *this; 
115 | }
116 | 
117 | char &STRING::operator[](int i)
118 | {
119 |     if (i>=0 && i<=length)
120 |         return str[i];
121 |     else
122 |         cout<<"Index out of bounds!";
123 | }
124 | 


--------------------------------------------------------------------------------
/lesson06/cpp6.askisi1.3.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp6.askisi1.3.cpp */
  2 | 
  3 | #include <iostream>
  4 | #include <cstring>
  5 | using namespace std;
  6 | 
  7 | class STRING {
  8 |     public:
  9 |         STRING();
 10 |         STRING(char *in_str);
 11 |         STRING(const STRING &ob);
 12 |         ~STRING();
 13 |         int get_length() const; 
 14 |         char *get_str() const; 
 15 |         void set_str(char *in_str);
 16 |         void print(); 
 17 |         STRING &operator=(STRING &right);
 18 |         char &operator[](int i);
 19 |         bool operator<(STRING &right);
 20 |         bool operator>(STRING &right);
 21 |         bool operator==(STRING &right);
 22 |     private:
 23 |        int length;
 24 |        char *str; 
 25 | };
 26 | 
 27 | 
 28 | int main()
 29 | {
 30 |     char s[80]="This is a string";
 31 |     STRING s1(s);
 32 |     STRING s2; 
 33 |     
 34 |     s2=s1;
 35 | 
 36 |     //s2[1]='a';
 37 |     
 38 |     s1.print(); 
 39 |     cout<<endl; 
 40 |     s2.print();
 41 |     
 42 |     cout<<endl; 
 43 |     if (s1==s2)
 44 |         cout<<"true";
 45 |     else
 46 |         cout<<"false";
 47 |     
 48 |     return 0; 
 49 | }
 50 | 
 51 | STRING::STRING()
 52 | {
 53 |     length = 0;
 54 |     str = new char[1];
 55 |     str[0]='\0';
 56 | }
 57 | 
 58 | STRING::STRING(char *in_str)
 59 | {
 60 |     length = strlen(in_str);
 61 |     
 62 |     str = new char [length+1];
 63 |     if (!str) cout<<"Error Allocating Memory";
 64 |     
 65 |     strcpy(str, in_str);
 66 | }
 67 | 
 68 | STRING::STRING(const STRING &ob)
 69 | {
 70 |     length = ob.get_length(); 
 71 |     
 72 |     str = new char [length+1];
 73 |     if (!str) cout<<"Error Allocating Memory";
 74 |     
 75 |     strcpy(str, ob.get_str());    
 76 | }
 77 | 
 78 | STRING::~STRING()
 79 | {
 80 |     delete [] str; 
 81 | }
 82 | 
 83 | int STRING::get_length() const
 84 | {
 85 |     return length; 
 86 | }
 87 | 
 88 | char *STRING::get_str() const
 89 | {
 90 |     return str; 
 91 | }
 92 | 
 93 | void STRING::set_str(char *in_str)
 94 | {
 95 |     if (str!=NULL)
 96 |         delete str; 
 97 |     
 98 |     length = strlen(in_str);
 99 |     
100 |     str = new char [length];
101 |     if (!str) cout<<"Error Allocating Memory";
102 |     
103 |     strcpy(str, in_str);    
104 | }
105 | 
106 | void STRING::print()
107 | {
108 |     cout<<str; 
109 | }
110 | 
111 | STRING &STRING::operator=(STRING &right)
112 | {
113 |     if (this==&right) return *this; 
114 |     
115 |     length=right.length; 
116 |     
117 |     delete [] str;
118 |     str = new char [length+1];
119 |     if (!str) cout<<"Error Allocating Memory";
120 |     
121 |     strcpy(str, right.str);
122 |     
123 |     return *this; 
124 | }
125 | 
126 | char &STRING::operator[](int i)
127 | {
128 |     if (i>=0 && i<=length)
129 |         return str[i];
130 |     else
131 |         cout<<"Index out of bounds!";
132 | }
133 | 
134 | bool STRING::operator<(STRING &right)
135 | {
136 |     if (strcmp(str, right.str)<0)
137 |         return true;
138 |     return false; 
139 | }
140 | 
141 | bool STRING::operator>(STRING &right)
142 | {
143 |     if (strcmp(str, right.str)>0)
144 |         return true;
145 |     return false; 
146 | }
147 | 
148 | bool STRING::operator==(STRING &right)
149 | {
150 |     if (strcmp(str, right.str)==0)
151 |         return true;
152 |     return false; 
153 | }


--------------------------------------------------------------------------------
/lesson06/cpp6.askisi2.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp6.askisi2.cpp */
  2 | 
  3 | #include <iostream>
  4 | using namespace std;
  5 | 
  6 | class ARRAY {
  7 |   public:
  8 |     ARRAY(int in_n);
  9 |     ARRAY(const ARRAY &ob);
 10 |     ~ARRAY();
 11 |     int get_n() const; 
 12 |     void print();
 13 |     int &operator[] (int i);
 14 |     ARRAY &operator= (ARRAY &right);
 15 |     ARRAY &operator+= (int right);
 16 |   private:
 17 |     int *p;
 18 |     int n;
 19 | };
 20 | 
 21 | 
 22 | int main()
 23 | {
 24 |     int n=10;
 25 |     ARRAY pin(n);
 26 |     ARRAY pin2(2);
 27 |     
 28 |     for (int i=0; i<n; i++)
 29 |         pin[i]=i*i;
 30 |     
 31 |     pin.print();
 32 |     
 33 |     pin2=pin; 
 34 |     pin2+=5;
 35 |     cout<<endl;
 36 |     pin2.print();
 37 | 
 38 |     return 0;
 39 | }
 40 | 
 41 | ARRAY::ARRAY(int in_n)
 42 | {
 43 |     n = in_n; 
 44 |     
 45 |     p = new int [n];
 46 |     if (!p)
 47 |         cout<<"Error allocating memory!";
 48 | }
 49 | 
 50 | ARRAY::ARRAY(const ARRAY &ob)
 51 | {
 52 |     n = ob.get_n(); 
 53 |     
 54 |     p = new int [n];
 55 |     if (!p) cout<<"Memory Allocation Error!";
 56 | }
 57 | 
 58 | ARRAY::~ARRAY()
 59 | {
 60 |     delete [] p;
 61 | }
 62 | 
 63 | int ARRAY::get_n() const
 64 | {
 65 |     return n;
 66 | }
 67 | 
 68 | void ARRAY::print()
 69 | {
 70 |     int i;
 71 |     
 72 |     for (i=0; i<n; i++)
 73 |         cout<<p[i]<<" ";
 74 | }
 75 | 
 76 | int &ARRAY::operator[] (int i)
 77 | {
 78 |     if (i>=0 && i<n) 
 79 |         return p[i]; 
 80 |     else
 81 |         cout<<"Index Error";
 82 |     
 83 | }
 84 | 
 85 | ARRAY &ARRAY::operator= (ARRAY &right)
 86 | {
 87 |     if (this==&right) return *this; 
 88 |     
 89 |     n=right.n; 
 90 |     delete [] p;
 91 |     p=new int [n];
 92 |     if(!p) cout<<"Error Allcoating Memory";
 93 |     
 94 |     for (int i=0; i<n; i++)
 95 |         p[i]=right[i];
 96 |         
 97 |     return *this; 
 98 | }
 99 | 
100 | ARRAY &ARRAY::operator+= (int right)
101 | {
102 |     int newn=n+right;
103 |     int *newp;
104 |     int i; 
105 |     
106 |     if (right>0)
107 |     {
108 |         newp = new int [newn];
109 |         if (!newp) cout<<"Error Allocating Memory";
110 |         
111 |         for (i=0; i<n; i++)
112 |             newp[i]=p[i];
113 |         for (i=n; i<newn; i++)
114 |             newp[i]=0;
115 |             
116 |         delete [] p;
117 |         n=newn;
118 |         p=newp; 
119 |     }
120 |     else 
121 |         cout<<"Wrong index!";
122 |     return *this; 
123 | }
124 | 


--------------------------------------------------------------------------------
/lesson06/cpp6.operator_equal.cpp:
--------------------------------------------------------------------------------
  1 | /*cpp6.operator_equal.cpp Υπερφόρτωση του = */
  2 | 
  3 | #include <iostream>
  4 | using namespace std; 
  5 | 
  6 | 
  7 | class complex {
  8 |   public:  
  9 |     complex(); 
 10 |     complex(double in_real, double in_imag);
 11 |     void set_real(double in_real);
 12 |     void set_imag(double in_imag);
 13 |     double get_real() const; 
 14 |     double get_imag() const; 
 15 |     complex operator+ (const complex &right);
 16 |     complex operator+ (int right);
 17 |     complex operator- (const complex &right);
 18 |     complex operator++(int right);
 19 |     complex &operator++();
 20 |     complex &operator= (const complex &right);
 21 |   private:
 22 |     double real;
 23 |     double imag; 
 24 | };
 25 | 
 26 | int main()
 27 | {
 28 |     complex a(1.0,1.0);
 29 |     complex c;
 30 | 
 31 |     c=a;    
 32 | 
 33 |     cout<<"a="<<a.get_real()<<","<<a.get_imag()<<endl; 
 34 |     cout<<"c="<<c.get_real()<<","<<c.get_imag(); 
 35 |     
 36 |     return 0; 
 37 | }
 38 | 
 39 | complex::complex()
 40 | {
 41 |     real = 0.0;
 42 |     imag = 0.0; 
 43 | }
 44 | 
 45 | complex::complex(double in_real, double in_imag)
 46 | {
 47 |     real = in_real;
 48 |     imag = in_imag; 
 49 | }
 50 | 
 51 | void complex::set_real(double in_real)
 52 | {
 53 |     real = in_real;
 54 | }
 55 | 
 56 | void complex::set_imag(double in_imag)
 57 | {
 58 |     imag = in_imag;
 59 | }
 60 | 
 61 | double complex::get_real() const
 62 | {
 63 |     return real;
 64 | }
 65 | 
 66 | double complex::get_imag() const
 67 | {
 68 |     return imag;
 69 | }
 70 | 
 71 | complex complex::operator+ (const complex &right)
 72 | {
 73 |     complex result; 
 74 |     
 75 |     result.real=real+right.real; 
 76 |     result.imag=imag+right.imag; 
 77 |     
 78 |     return result;
 79 | }
 80 | 
 81 | complex complex::operator+ (int right)
 82 | {
 83 |     complex result; 
 84 |     
 85 |     result.real=real+5; 
 86 |     result.imag=imag+5; 
 87 |     
 88 |     return result;
 89 | }
 90 | 
 91 | complex complex::operator- (const complex &right)
 92 | {
 93 |     complex result; 
 94 |     
 95 |     result.real=real-right.real; 
 96 |     result.imag=imag-right.imag; 
 97 |     
 98 |     return result;
 99 | }
100 | 
101 | complex complex::operator++(int right)
102 | {
103 |     complex result=*this; 
104 |     
105 |     real++; 
106 |     imag++; 
107 |     
108 |     return result; 
109 | }
110 | 
111 | complex &complex::operator++()
112 | {
113 |     real++; 
114 |     imag++;
115 |     
116 |     return *this; 
117 | }
118 | 
119 | complex &complex::operator= (const complex &right)
120 | {
121 |     if (this==&right) return *this; 
122 |     
123 |     real=right.real; 
124 |     imag=right.imag;
125 |     
126 |     return *this;
127 | }
128 | 


--------------------------------------------------------------------------------
/lesson06/cpp6.operator_minus.cpp:
--------------------------------------------------------------------------------
 1 | /*cpp6.operator.minus.cpp Υπερφόρτωση του - */
 2 | 
 3 | #include <iostream>
 4 | using namespace std; 
 5 | 
 6 | class complex {
 7 |   public:  
 8 |     complex(); 
 9 |     complex(double in_real, double in_imag);
10 |     void set_real(double in_real);
11 |     void set_imag(double in_imag);
12 |     double get_real() const; 
13 |     double get_imag() const; 
14 |     complex operator+ (const complex &right);
15 |     complex operator+ (int right);
16 |     complex operator- (const complex &right);
17 |   private:
18 |     double real;
19 |     double imag; 
20 | };
21 | 
22 | int main()
23 | {
24 |     complex a(1.0,1.0);
25 |     complex b(2.0,3.0);
26 |     
27 |     complex c;
28 | 
29 |     c = a - b;    
30 | 
31 |     cout<<c.get_real()<<" "<<c.get_imag(); 
32 |     
33 |     return 0; 
34 | }
35 | 
36 | complex::complex()
37 | {
38 |     real = 0.0;
39 |     imag = 0.0; 
40 | }
41 | 
42 | complex::complex(double in_real, double in_imag)
43 | {
44 |     real = in_real;
45 |     imag = in_imag; 
46 | }
47 | 
48 | void complex::set_real(double in_real)
49 | {
50 |     real = in_real;
51 | }
52 | 
53 | void complex::set_imag(double in_imag)
54 | {
55 |     imag = in_imag;
56 | }
57 | 
58 | double complex::get_real() const
59 | {
60 |     return real;
61 | }
62 | 
63 | double complex::get_imag() const
64 | {
65 |     return imag;
66 | }
67 | 
68 | complex complex::operator+ (const complex &right)
69 | {
70 |     complex result; 
71 |     
72 |     result.real=real+right.real; 
73 |     result.imag=imag+right.imag; 
74 |     
75 |     return result;
76 | }
77 | 
78 | complex complex::operator+ (int right)
79 | {
80 |     complex result; 
81 |     
82 |     result.real=real+5; 
83 |     result.imag=imag+5; 
84 |     
85 |     return result;
86 | }
87 | 
88 | complex complex::operator- (const complex &right)
89 | {
90 |     complex result; 
91 |     
92 |     result.real=real-right.real; 
93 |     result.imag=imag-right.imag; 
94 |     
95 |     return result;
96 | }
97 | 


--------------------------------------------------------------------------------
/lesson06/cpp6.operator_plus.cpp:
--------------------------------------------------------------------------------
 1 | /*cpp6.operator.plus.cpp Υπερφόρτωση του + */
 2 | 
 3 | #include <iostream>
 4 | using namespace std; 
 5 | 
 6 | class complex {
 7 |   public:  
 8 |     complex(); 
 9 |     complex(double in_real, double in_imag);
10 |     void set_real(double in_real);
11 |     void set_imag(double in_imag);
12 |     double get_real() const; 
13 |     double get_imag() const; 
14 |     complex operator+ (const complex &right);
15 |   private:
16 |     double real;
17 |     double imag; 
18 | };
19 | 
20 | int main()
21 | {
22 |     complex a(1.0,1.0);
23 |     complex b(2.0,3.0);
24 |     
25 |     complex c;
26 | 
27 |     c = a + b;    
28 | 
29 |     cout<<c.get_real()<<" "<<c.get_imag(); 
30 |     
31 |     return 0; 
32 | }
33 | 
34 | 
35 | complex::complex()
36 | {
37 |     real = 0.0;
38 |     imag = 0.0; 
39 | }
40 | 
41 | complex::complex(double in_real, double in_imag)
42 | {
43 |     real = in_real;
44 |     imag = in_imag; 
45 | }
46 | 
47 | void complex::set_real(double in_real)
48 | {
49 |     real = in_real;
50 | }
51 | 
52 | void complex::set_imag(double in_imag)
53 | {
54 |     imag = in_imag;
55 | }
56 | 
57 | double complex::get_real() const
58 | {
59 |     return real;
60 | }
61 | 
62 | double complex::get_imag() const
63 | {
64 |     return imag;
65 | }
66 | 
67 | complex complex::operator+ (const complex &right)
68 | {
69 |     complex result; 
70 |     
71 |     result.real=real+right.real; 
72 |     result.imag=imag+right.imag; 
73 |     
74 |     return result;
75 | }
76 | 


--------------------------------------------------------------------------------
/lesson06/cpp6.operator_plus_int.cpp:
--------------------------------------------------------------------------------
 1 | /*cpp6.operator_plus_int.cpp Υπερφόρτωση του + */
 2 | 
 3 | #include <iostream>
 4 | using namespace std; 
 5 | 
 6 | class complex {
 7 |   public:  
 8 |     complex(); 
 9 |     complex(double in_real, double in_imag);
10 |     void set_real(double in_real);
11 |     void set_imag(double in_imag);
12 |     double get_real() const; 
13 |     double get_imag() const; 
14 |     complex operator+ (const complex &right);
15 |     complex operator+ (int right);
16 |   private:
17 |     double real;
18 |     double imag; 
19 | };
20 | 
21 | int main()
22 | {
23 |     complex a(1.0,1.0);
24 |     
25 |     complex c;
26 | 
27 |     c = a + 5;    
28 | 
29 |     cout<<c.get_real()<<" "<<c.get_imag(); 
30 |     
31 |     return 0; 
32 | }
33 | 
34 | complex::complex()
35 | {
36 |     real = 0.0;
37 |     imag = 0.0; 
38 | }
39 | 
40 | complex::complex(double in_real, double in_imag)
41 | {
42 |     real = in_real;
43 |     imag = in_imag; 
44 | }
45 | 
46 | void complex::set_real(double in_real)
47 | {
48 |     real = in_real;
49 | }
50 | 
51 | void complex::set_imag(double in_imag)
52 | {
53 |     imag = in_imag;
54 | }
55 | 
56 | double complex::get_real() const
57 | {
58 |     return real;
59 | }
60 | 
61 | double complex::get_imag() const
62 | {
63 |     return imag;
64 | }
65 | 
66 | complex complex::operator+ (const complex &right)
67 | {
68 |     complex result; 
69 |     
70 |     result.real=real+right.real; 
71 |     result.imag=imag+right.imag; 
72 |     
73 |     return result;
74 | }
75 | 
76 | complex complex::operator+ (int right)
77 | {
78 |     complex result; 
79 |     
80 |     result.real=real+5; 
81 |     result.imag=imag+5; 
82 |     
83 |     return result;
84 | }
85 | 


--------------------------------------------------------------------------------
/lesson06/cpp6.operator_plusplus_post.cpp:
--------------------------------------------------------------------------------
  1 | /*cpp6.operator_plusplus_post.cpp Υπερφόρτωση του ++ (μεταθεματικός) */
  2 | 
  3 | #include <iostream>
  4 | using namespace std; 
  5 | 
  6 | 
  7 | class complex {
  8 |   public:  
  9 |     complex(); 
 10 |     complex(double in_real, double in_imag);
 11 |     void set_real(double in_real);
 12 |     void set_imag(double in_imag);
 13 |     double get_real() const; 
 14 |     double get_imag() const; 
 15 |     complex operator+ (const complex &right);
 16 |     complex operator+ (int right);
 17 |     complex operator- (const complex &right);
 18 |     complex operator++(int right);
 19 |   private:
 20 |     double real;
 21 |     double imag; 
 22 | };
 23 | 
 24 | int main()
 25 | {
 26 |     complex a(1.0,1.0);
 27 |     complex c;
 28 | 
 29 |     c=a++;    
 30 | 
 31 |     cout<<"a="<<a.get_real()<<","<<a.get_imag()<<endl; 
 32 |     cout<<"c="<<c.get_real()<<","<<c.get_imag(); 
 33 |     
 34 |     return 0; 
 35 | }
 36 | 
 37 | complex::complex()
 38 | {
 39 |     real = 0.0;
 40 |     imag = 0.0; 
 41 | }
 42 | 
 43 | complex::complex(double in_real, double in_imag)
 44 | {
 45 |     real = in_real;
 46 |     imag = in_imag; 
 47 | }
 48 | 
 49 | void complex::set_real(double in_real)
 50 | {
 51 |     real = in_real;
 52 | }
 53 | 
 54 | void complex::set_imag(double in_imag)
 55 | {
 56 |     imag = in_imag;
 57 | }
 58 | 
 59 | double complex::get_real() const
 60 | {
 61 |     return real;
 62 | }
 63 | 
 64 | double complex::get_imag() const
 65 | {
 66 |     return imag;
 67 | }
 68 | 
 69 | complex complex::operator+ (const complex &right)
 70 | {
 71 |     complex result; 
 72 |     
 73 |     result.real=real+right.real; 
 74 |     result.imag=imag+right.imag; 
 75 |     
 76 |     return result;
 77 | }
 78 | 
 79 | complex complex::operator+ (int right)
 80 | {
 81 |     complex result; 
 82 |     
 83 |     result.real=real+5; 
 84 |     result.imag=imag+5; 
 85 |     
 86 |     return result;
 87 | }
 88 | 
 89 | complex complex::operator- (const complex &right)
 90 | {
 91 |     complex result; 
 92 |     
 93 |     result.real=real-right.real; 
 94 |     result.imag=imag-right.imag; 
 95 |     
 96 |     return result;
 97 | }
 98 | 
 99 | complex complex::operator++(int right)
100 | {
101 |     complex result=*this; 
102 |     
103 |     real++; 
104 |     imag++; 
105 |     
106 |     return result; 
107 | }
108 | 


--------------------------------------------------------------------------------
/lesson06/cpp6.operator_plusplus_pre.cpp:
--------------------------------------------------------------------------------
  1 | /*cpp6.operator_plusplus_pre.cpp Υπερφόρτωση του ++ (προθεματικός) */
  2 | 
  3 | #include <iostream>
  4 | using namespace std; 
  5 | 
  6 | 
  7 | class complex {
  8 |   public:  
  9 |     complex(); 
 10 |     complex(double in_real, double in_imag);
 11 |     void set_real(double in_real);
 12 |     void set_imag(double in_imag);
 13 |     double get_real() const; 
 14 |     double get_imag() const; 
 15 |     complex operator+ (const complex &right);
 16 |     complex operator+ (int right);
 17 |     complex operator- (const complex &right);
 18 |     complex operator++(int right);
 19 |     complex &operator++();
 20 |   private:
 21 |     double real;
 22 |     double imag; 
 23 | };
 24 | 
 25 | int main()
 26 | {
 27 |     complex a(1.0,1.0);
 28 |     complex c;
 29 | 
 30 |     c=++a;    
 31 | 
 32 |     cout<<"a="<<a.get_real()<<","<<a.get_imag()<<endl; 
 33 |     cout<<"c="<<c.get_real()<<","<<c.get_imag(); 
 34 |     
 35 |     return 0; 
 36 | }
 37 | 
 38 | complex::complex()
 39 | {
 40 |     real = 0.0;
 41 |     imag = 0.0; 
 42 | }
 43 | 
 44 | complex::complex(double in_real, double in_imag)
 45 | {
 46 |     real = in_real;
 47 |     imag = in_imag; 
 48 | }
 49 | 
 50 | void complex::set_real(double in_real)
 51 | {
 52 |     real = in_real;
 53 | }
 54 | 
 55 | void complex::set_imag(double in_imag)
 56 | {
 57 |     imag = in_imag;
 58 | }
 59 | 
 60 | double complex::get_real() const
 61 | {
 62 |     return real;
 63 | }
 64 | 
 65 | double complex::get_imag() const
 66 | {
 67 |     return imag;
 68 | }
 69 | 
 70 | complex complex::operator+ (const complex &right)
 71 | {
 72 |     complex result; 
 73 |     
 74 |     result.real=real+right.real; 
 75 |     result.imag=imag+right.imag; 
 76 |     
 77 |     return result;
 78 | }
 79 | 
 80 | complex complex::operator+ (int right)
 81 | {
 82 |     complex result; 
 83 |     
 84 |     result.real=real+5; 
 85 |     result.imag=imag+5; 
 86 |     
 87 |     return result;
 88 | }
 89 | 
 90 | complex complex::operator- (const complex &right)
 91 | {
 92 |     complex result; 
 93 |     
 94 |     result.real=real-right.real; 
 95 |     result.imag=imag-right.imag; 
 96 |     
 97 |     return result;
 98 | }
 99 | 
100 | complex complex::operator++(int right)
101 | {
102 |     complex result=*this; 
103 |     
104 |     real++; 
105 |     imag++; 
106 |     
107 |     return result; 
108 | }
109 | 
110 | complex &complex::operator++()
111 | {
112 |     real++; 
113 |     imag++;
114 |     
115 |     return *this; 
116 | }
117 | 


--------------------------------------------------------------------------------
/lesson06/cpp6.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson06/cpp6.pdf


--------------------------------------------------------------------------------
/lesson07/Cpp7(4sl).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson07/Cpp7(4sl).pdf


--------------------------------------------------------------------------------
/lesson07/Cpp7.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson07/Cpp7.pdf


--------------------------------------------------------------------------------
/lesson07/STRING.cpp:
--------------------------------------------------------------------------------
  1 | #include <cstring>
  2 | #include "STRING.h"
  3 | 
  4 | STRING::STRING()
  5 | {
  6 |     length = 0;
  7 |     str = new char[1];
  8 |     str[0]='\0';
  9 | }
 10 | 
 11 | STRING::STRING(char *in_str)
 12 | {
 13 |     length = strlen(in_str);
 14 |     
 15 |     str = new char [length+1];
 16 |     if (!str) cout<<"Error Allocating Memory";
 17 |     
 18 |     strcpy(str, in_str);
 19 | }
 20 | 
 21 | STRING::STRING(const char *in_str)
 22 | {
 23 |     length = strlen(in_str);
 24 |     
 25 |     str = new char [length+1];
 26 |     if (!str) cout<<"Error Allocating Memory";
 27 |     
 28 |     strcpy(str, in_str);
 29 | }
 30 | 
 31 | STRING::STRING(const STRING &ob)
 32 | {
 33 |     length = ob.get_length(); 
 34 |     
 35 |     str = new char [length+1];
 36 |     if (!str) cout<<"Error Allocating Memory";
 37 |     
 38 |     strcpy(str, ob.get_str());    
 39 | }
 40 | 
 41 | STRING::~STRING()
 42 | {
 43 |     delete [] str; 
 44 | }
 45 | 
 46 | int STRING::get_length() const
 47 | {
 48 |     return length; 
 49 | }
 50 | 
 51 | char *STRING::get_str() const
 52 | {
 53 |     return str; 
 54 | }
 55 | 
 56 | void STRING::set_str(char *in_str)
 57 | {
 58 |     if (str!=NULL)
 59 |         delete str; 
 60 |     
 61 |     length = strlen(in_str);
 62 |     
 63 |     str = new char [length];
 64 |     if (!str) cout<<"Error Allocating Memory";
 65 |     
 66 |     strcpy(str, in_str);    
 67 | }
 68 | 
 69 | STRING &STRING::operator=(STRING &right)
 70 | {
 71 |     if (this==&right) return *this; 
 72 |     
 73 |     length=right.length; 
 74 |     
 75 |     delete [] str;
 76 |     str = new char [length+1];
 77 |     if (!str) cout<<"Error Allocating Memory";
 78 |     
 79 |     strcpy(str, right.str);
 80 |     
 81 |     return *this; 
 82 | }
 83 | 
 84 | char &STRING::operator[](int i)
 85 | {
 86 |     if (i>=0 && i<=length)
 87 |         return str[i];
 88 |     else
 89 |         cout<<"Index out of bounds!";
 90 | }
 91 | 
 92 | bool STRING::operator<(STRING &right)
 93 | {
 94 |     if (strcmp(str, right.str)<0)
 95 |         return true;
 96 |     return false; 
 97 | }
 98 | 
 99 | bool STRING::operator>(STRING &right)
100 | {
101 |     if (strcmp(str, right.str)>0)
102 |         return true;
103 |     return false; 
104 | }
105 | 
106 | bool STRING::operator==(STRING &right)
107 | {
108 |     if (strcmp(str, right.str)==0)
109 |         return true;
110 |     return false; 
111 | }
112 | 
113 | ostream &operator<<(ostream &left, const STRING &ob)
114 | {
115 |     left<<ob.str;
116 |     
117 |     return left; 
118 | }
119 | 
120 | istream &operator>>(istream &left, STRING &ob)
121 | {
122 |     char in_str[80];
123 |     
124 |     left>>in_str; 
125 |     
126 |     if (ob.str!=NULL)
127 |         delete [] ob.str;
128 |         
129 |     ob.str = new char [strlen(in_str)+1];
130 |     if (ob.str==NULL)
131 |         cout<<"Error allocating memory";
132 |         
133 |     ob.length=strlen(in_str);
134 |     strcpy(ob.str,in_str); 
135 |     
136 |     return left; 
137 | }
138 | 
139 | 
140 | 
141 | 
142 | 


--------------------------------------------------------------------------------
/lesson07/STRING.h:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std; 
 3 | 
 4 | class STRING {
 5 |     public:
 6 |         STRING();
 7 |         STRING(char *in_str);
 8 |         STRING(const char *in_str);
 9 |         STRING(const STRING &ob);
10 |         ~STRING();
11 |         int get_length() const; 
12 |         char *get_str() const; 
13 |         void set_str(char *in_str);
14 |         STRING &operator=(STRING &right);
15 |         char &operator[](int i);
16 |         bool operator<(STRING &right);
17 |         bool operator>(STRING &right);
18 |         bool operator==(STRING &right);
19 |         friend ostream &operator<<(ostream &left, const STRING &ob);
20 |         friend istream &operator>>(istream &left, STRING &ob);
21 |     private:
22 |        int length;
23 |        char *str; 
24 | };
25 | 


--------------------------------------------------------------------------------
/lesson07/cpp7.askisi1.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp7.askisi1.cpp */
  2 | 
  3 | #include <iostream>
  4 | using namespace std;
  5 | 
  6 | class ARRAY {
  7 |   public:
  8 |     ARRAY(int in_n);
  9 |     ARRAY(const ARRAY &ob);
 10 |     ~ARRAY();
 11 |     int get_n() const; 
 12 |     int &operator[] (int i);
 13 |     ARRAY &operator= (ARRAY &right);
 14 |     ARRAY &operator+= (int right);
 15 |     friend ostream &operator<<(ostream &left, const ARRAY &ob);
 16 |   private:
 17 |     int *p;
 18 |     int n;
 19 | };
 20 | 
 21 | 
 22 | int main()
 23 | {
 24 |     int n=10;
 25 |     ARRAY pin(n);
 26 | 
 27 |     for (int i=0; i<n; i++)
 28 |         pin[i]=i*i;
 29 |     
 30 |     cout<<pin; 
 31 | 
 32 |     return 0;
 33 | }
 34 | 
 35 | ARRAY::ARRAY(int in_n)
 36 | {
 37 |     n = in_n; 
 38 |     
 39 |     p = new int [n];
 40 |     if (!p)
 41 |         cout<<"Error allocating memory!";
 42 | }
 43 | 
 44 | ARRAY::ARRAY(const ARRAY &ob)
 45 | {
 46 |     n = ob.get_n(); 
 47 |     
 48 |     p = new int [n];
 49 |     if (!p) cout<<"Memory Allocation Error!";
 50 |     
 51 | }
 52 | 
 53 | ARRAY::~ARRAY()
 54 | {
 55 |     delete [] p;
 56 | }
 57 | 
 58 | int ARRAY::get_n() const
 59 | {
 60 |     return n;
 61 | }
 62 | 
 63 | int &ARRAY::operator[] (int i)
 64 | {
 65 |     if (i>=0 && i<n) 
 66 |         return p[i]; 
 67 |     else
 68 |         cout<<"Index Error";
 69 |     
 70 | }
 71 | 
 72 | ARRAY &ARRAY::operator= (ARRAY &right)
 73 | {
 74 |     if (this==&right) return *this; 
 75 |     
 76 |     n=right.n; 
 77 |     delete [] p;
 78 |     p=new int [n];
 79 |     if(!p) cout<<"Error Allcoating Memory";
 80 |     
 81 |     for (int i=0; i<n; i++)
 82 |         p[i]=right[i];
 83 |         
 84 |     return *this; 
 85 | }
 86 | 
 87 | ARRAY &ARRAY::operator+= (int right)
 88 | {
 89 |     int newn=n+right;
 90 |     int *newp;
 91 |     int i; 
 92 |     
 93 |     if (right>0)
 94 |     {
 95 |         newp = new int [newn];
 96 |         if (!newp) cout<<"Error Allocating Memory";
 97 |         
 98 |         for (i=0; i<n; i++)
 99 |             newp[i]=p[i];
100 |         for (i=n; i<newn; i++)
101 |             newp[i]=0;
102 |             
103 |         delete [] p;
104 |         n=newn;
105 |         p=newp; 
106 |     }
107 |     else 
108 |         cout<<"Wrong index!";
109 |         
110 | }
111 | 
112 | ostream &operator<<(ostream &left, const ARRAY &ob)
113 | {
114 |     int i; 
115 |     
116 |     left<<"[";
117 |     for (i=0; i<ob.n-1; i++)
118 |         cout<<ob.p[i]<<" ";
119 |     left<<ob.p[ob.n-1];
120 |     left<<"]";
121 |     
122 |     return left; 
123 | }
124 | 
125 | 
126 | 


--------------------------------------------------------------------------------
/lesson07/cpp7.askisi3.cpp:
--------------------------------------------------------------------------------
 1 | /* askisi3.cpp */ 
 2 | #include <iostream>
 3 | #include "STRING.h"
 4 | using namespace std; 
 5 | 
 6 | class table; // fwd declaration
 7 | 
 8 | class chair {
 9 |     public:
10 |         chair(STRING in_color, int in_height);
11 |         friend ostream &operator<<(ostream &left, const chair &right);
12 |         friend void shrink(chair &c, table &t);
13 |     private:
14 |         STRING color; 
15 |         int height; 
16 | };
17 | 
18 | 
19 | class table {
20 |     public:
21 |         table(STRING in_color, int in_width, int in_length);
22 |         friend ostream &operator<<(ostream &left, const table &right);
23 |         friend void shrink(chair &c, table &t);
24 |     private:
25 |         STRING color; 
26 |         int width; 
27 |         int length;
28 | };
29 | 
30 | void shrink(chair &c, table &t)
31 | {
32 |     c.height = 0.9 * c.height;
33 |     t.width = 0.9 * t.width; 
34 |     t.length = 0.9 * t.length; 
35 | }
36 | 
37 | 
38 | int main()
39 | {
40 |     chair c("Mple", 150);
41 |     table t("Kokkino", 200, 200); 
42 |     
43 |     cout<<c<<endl<<t; 
44 |     
45 |     shrink(c,t);
46 |     
47 |     cout<<endl<<endl<<"NEES DIASTASEIS: "<<endl;
48 |     cout<<c<<endl<<t;
49 | }
50 | 
51 | chair::chair(STRING in_color, int in_height)
52 | {
53 |     color = in_color; 
54 |     height = in_height; 
55 | }
56 | 
57 | ostream &operator<<(ostream &left, const chair &right)
58 | {
59 |     left<<"KAREKLA: xrwma="<<right.color<<", ipsos: "<<right.height;
60 |     
61 |     return left; 
62 | }
63 | 
64 | table::table(STRING in_color, int in_width, int in_length)
65 | {
66 |     color = in_color; 
67 |     width = in_width;
68 |     length = in_length;
69 | }
70 | 
71 | ostream &operator<<(ostream &left, const table &right)
72 | {
73 |     left<<"TRAPEZI: xrwma="<<right.color<<", platos: "<<right.width<<", mikos: "<<right.length;
74 |     
75 |     return left; 
76 | }


--------------------------------------------------------------------------------
/lesson07/cpp7.askisi4.1.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp7.askisi4.1.cpp */ 
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class point
 7 | {
 8 |    public:
 9 |      point(int in_x, int in_y);
10 |      int get_x() const; 
11 |      int get_y() const; 
12 |      void set_x(int in_x);
13 |      void set_y(int in_y);
14 |      friend ostream &operator<<(ostream &left, const point &right);
15 |    private:
16 |      int x; 
17 |      int y; 
18 | };
19 | 
20 | 
21 | int main()
22 | {
23 |     point p(63,65);
24 |     
25 |     cout<<p; 
26 |     return 0; 
27 | }
28 | 
29 | point::point(int in_x, int in_y)
30 | {
31 |     if (in_x>=0 && in_x<60)
32 |         x = in_x; 
33 |     else
34 |     {
35 |         cout<<"Lathos stin x-syntetagmeni. ";
36 |         x = 0; 
37 |     }
38 |     
39 |     if (in_y>=0 && in_y<60)
40 |         y = in_y; 
41 |     else
42 |     {
43 |         cout<<"Lathos stin y-syntetagmeni. ";
44 |         y = 0; 
45 |     }
46 | }
47 | 
48 | int point::get_x() const
49 | {
50 |     return x; 
51 | }
52 | 
53 | int point::get_y() const
54 | {
55 |     return y;
56 | }
57 | void point::set_x(int in_x)
58 | {
59 |     x = in_x; 
60 | }
61 | 
62 | void point::set_y(int in_y)
63 | {
64 |     y = in_y;
65 | }
66 | 
67 | ostream &operator<<(ostream &left, const point &right)
68 | {
69 |     cout<<"("<<right.x<<","<<right.y<<")";
70 |     
71 |     return left; 
72 | }


--------------------------------------------------------------------------------
/lesson07/cpp7.friend_class_ex1.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std; 
 3 | 
 4 | class man 
 5 | {
 6 |    public:
 7 |       friend class god;
 8 |       man(int in_sins);
 9 |       int get_sins() const;
10 |    private:
11 |       int sins; 
12 | };
13 | 
14 | class god
15 | {
16 |    public:
17 |       void forgive(man &ob);
18 | };
19 | 
20 | int main()
21 | {
22 |     man Euthypro(100);
23 |     god Apollo;
24 |     
25 |     cout<<"Sins="<<Euthypro.get_sins()<<endl;    
26 |     Apollo.forgive(Euthypro);
27 |     cout<<"Sins="<<Euthypro.get_sins();
28 |     
29 |     return 0; 
30 | }
31 | 
32 | 
33 | man::man(int in_sins)
34 | {
35 |     sins = in_sins; 
36 | }
37 | 
38 | int man::get_sins() const
39 | {
40 |     return sins;
41 | }
42 | 
43 | void god::forgive(man &ob)
44 | {
45 |     ob.sins = 0; 
46 | }
47 | 


--------------------------------------------------------------------------------
/lesson07/cpp7.friend_class_linked_list.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp7.friend_class_linked_list.cpp: Φιλικές Κλάσεις */
 2 | #include <iostream>
 3 | using namespace std; 
 4 | 
 5 | class node
 6 | {
 7 |    public: 
 8 |       friend class linked_list; 
 9 |    private:
10 |       int data; 		 
11 |       node *next;     
12 | };
13 | 
14 | class linked_list
15 | {
16 |    public: 
17 |       linked_list();
18 |       bool insert_start(int in_data);
19 |       void print();
20 |    private:
21 |       node *head;     
22 | };
23 | 
24 | 
25 | int main()
26 | {
27 |     linked_list list;
28 |     
29 |     list.insert_start(5);
30 |     list.insert_start(4);
31 |     list.insert_start(3);
32 |     list.print();
33 |     
34 |     return 0; 
35 | }
36 | 
37 | linked_list::linked_list()
38 | {
39 |     head = NULL; 
40 | }
41 | 
42 | bool linked_list::insert_start(int x)
43 | {
44 |    node *newnode;
45 | 	
46 |    newnode = new node;
47 |    if (!newnode)
48 |    {
49 |       cout<<"Error allocating memory";
50 |       return false;
51 |    }
52 |    newnode->data=x;
53 | 
54 |    newnode->next=head;
55 |    head=newnode;
56 |    return true;
57 | }
58 | 
59 | void linked_list::print()
60 | {
61 |    node *current;
62 | 	
63 |    current=head;
64 |    while(current!=NULL)
65 |    {
66 |       cout<<current->data<<" ";
67 |       current=current->next;
68 |    }
69 | }
70 | 


--------------------------------------------------------------------------------
/lesson07/cpp7.friend_function.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp7.friend_function.cpp: Φιλικές Συναρτήσεις */
 2 | #include <iostream>
 3 | using namespace std; 
 4 | 
 5 | class man 
 6 | {
 7 |    public:
 8 |       friend void good_weather(man &ob);
 9 |       man(int in_mood);
10 |       void report_mood();
11 |    private:
12 |       int mood; 
13 | };
14 | 
15 | void good_weather(man &ob);
16 | 
17 | int main()
18 | {
19 |     man bob(5);
20 |     
21 |     bob.report_mood();
22 |     good_weather(bob);
23 |     bob.report_mood();
24 |     
25 |     return 0; 
26 | }
27 | 
28 | man::man(int in_mood)
29 | {
30 |     mood = in_mood; 
31 | }
32 | 
33 | void man::report_mood()
34 | {
35 |     if (mood<10)
36 |         cout<<"I am ok..."<<endl;
37 |     else 
38 |         cout<<"I feel good!"<<endl;
39 | }
40 | 
41 | void good_weather(man &ob)
42 | {
43 |     ob.mood +=10; 
44 | }


--------------------------------------------------------------------------------
/lesson07/cpp7.friend_method.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp7.friend_method.cpp Φιλική μέθοδος σε κλάση */ 
 2 | 
 3 | #include <iostream>
 4 | using namespace std; 
 5 | 
 6 | class man; //forward declaration
 7 | 
 8 | class state
 9 | {
10 |    public:
11 |       void withdraw(man &ob);
12 | };
13 | 
14 | class man 
15 | {
16 |    public:
17 |       friend void state::withdraw(man &ob);
18 |       man(int in_money);
19 |       int get_money() const;
20 |    private:
21 |       int money; 
22 | };
23 | 
24 | int main()
25 | {
26 |     man Papadakis(1500);
27 |     state Greece;
28 |     
29 |     cout<<"Papadakis' Money="
30 |          <<Papadakis.get_money()
31 |          <<endl;    
32 | 
33 |     Greece.withdraw(Papadakis);
34 | 
35 |     cout<<"Papadakis' Money="
36 |          <<Papadakis.get_money();
37 |     
38 |     return 0; 
39 | }
40 | 
41 | void state::withdraw(man &ob)
42 | {
43 |   ob.money=0;
44 | }
45 | 
46 | man::man(int in_money)
47 | {
48 |   money = in_money; 
49 | }
50 | 
51 | int man::get_money() const
52 | {
53 |   return money; 
54 | }
55 | 


--------------------------------------------------------------------------------
/lesson07/cpp7.friend_operator_plus.cpp:
--------------------------------------------------------------------------------
  1 | /*cpp7.friend_operator_plus.cpp Υπερφόρτωση του + με φιλική συνάρτηση */
  2 | 
  3 | #include <iostream>
  4 | using namespace std; 
  5 | 
  6 | 
  7 | class complex {
  8 |   public:  
  9 |     complex(); 
 10 |     complex(double in_real, double in_imag);
 11 |     void set_real(double in_real);
 12 |     void set_imag(double in_imag);
 13 |     double get_real() const; 
 14 |     double get_imag() const; 
 15 |     complex operator+ (const complex &right);
 16 |     complex operator- (const complex &right);
 17 |     complex operator++(int right);
 18 |     complex &operator++();
 19 |     complex &operator= (const complex &right);
 20 |     friend complex operator+(int left, complex &right);
 21 |   private:
 22 |     double real;
 23 |     double imag; 
 24 | };
 25 | 
 26 | complex operator+(int left, complex &right);
 27 | 
 28 | int main()
 29 | {
 30 |     complex a(1.0,1.0);
 31 |     complex c;
 32 | 
 33 |     c=5+a;    
 34 | 
 35 |     cout<<"c="<<c.get_real()<<","<<c.get_imag(); 
 36 |     
 37 |     return 0; 
 38 | }
 39 | 
 40 | complex::complex()
 41 | {
 42 |     real = 0.0;
 43 |     imag = 0.0; 
 44 | }
 45 | 
 46 | complex::complex(double in_real, double in_imag)
 47 | {
 48 |     real = in_real;
 49 |     imag = in_imag; 
 50 | }
 51 | 
 52 | void complex::set_real(double in_real)
 53 | {
 54 |     real = in_real;
 55 | }
 56 | 
 57 | void complex::set_imag(double in_imag)
 58 | {
 59 |     imag = in_imag;
 60 | }
 61 | 
 62 | double complex::get_real() const
 63 | {
 64 |     return real;
 65 | }
 66 | 
 67 | double complex::get_imag() const
 68 | {
 69 |     return imag;
 70 | }
 71 | 
 72 | complex complex::operator+ (const complex &right)
 73 | {
 74 |     complex result; 
 75 |     
 76 |     result.set_real(real+right.get_real()); 
 77 |     result.set_imag(imag+right.get_imag()); 
 78 |     
 79 |     return result;
 80 | }
 81 | 
 82 | complex complex::operator- (const complex &right)
 83 | {
 84 |     complex result; 
 85 |     
 86 |     result.set_real(real-right.get_real()); 
 87 |     result.set_imag(imag-right.get_imag()); 
 88 |     
 89 |     return result;
 90 | }
 91 | 
 92 | complex complex::operator++(int right)
 93 | {
 94 |     complex result=*this; 
 95 |     
 96 |     real++; 
 97 |     imag++; 
 98 |     
 99 |     return result; 
100 | }
101 | 
102 | complex &complex::operator++()
103 | {
104 |     real++; 
105 |     imag++;
106 |     
107 |     return *this; 
108 | }
109 | 
110 | complex &complex::operator= (const complex &right)
111 | {
112 |     if (this==&right) return *this; 
113 |     
114 |     real=right.get_real(); 
115 |     imag=right.get_imag();
116 |     
117 |     return *this;
118 | }
119 | 
120 | complex operator+(int left, complex &right)
121 | {
122 |     complex result;
123 | 
124 |     result.real = left+right.real; 
125 |     result.imag = left+right.imag; 
126 |     return result;
127 | }
128 | 


--------------------------------------------------------------------------------
/lesson07/cpp7.friend_operator_print.cpp:
--------------------------------------------------------------------------------
  1 | /*cpp7.friend_operator_print.cpp Υπερφόρτωση του << με φιλική συνάρτηση */
  2 | 
  3 | #include <iostream>
  4 | using namespace std; 
  5 | 
  6 | 
  7 | class complex {
  8 |   public:  
  9 |     complex(); 
 10 |     complex(double in_real, double in_imag);
 11 |     void set_real(double in_real);
 12 |     void set_imag(double in_imag);
 13 |     double get_real() const; 
 14 |     double get_imag() const; 
 15 |     complex operator+ (const complex &right);
 16 |     complex operator- (const complex &right);
 17 |     complex operator++(int right);
 18 |     complex &operator++();
 19 |     complex &operator= (const complex &right);
 20 |     friend complex operator+(int left, complex &right);
 21 |     friend ostream &operator<<(ostream &left, const complex &right);
 22 |   private:
 23 |     double real;
 24 |     double imag; 
 25 | };
 26 | 
 27 | ostream &operator<<(ostream &left, const complex &right);
 28 | complex operator+(int left, complex &right);
 29 | 
 30 | int main()
 31 | {
 32 |     complex a(1.0,1.0);
 33 |     
 34 |     cout<<a;    
 35 |     
 36 |     return 0; 
 37 | }
 38 | 
 39 | complex::complex()
 40 | {
 41 |     real = 0.0;
 42 |     imag = 0.0; 
 43 | }
 44 | 
 45 | complex::complex(double in_real, double in_imag)
 46 | {
 47 |     real = in_real;
 48 |     imag = in_imag; 
 49 | }
 50 | 
 51 | void complex::set_real(double in_real)
 52 | {
 53 |     real = in_real;
 54 | }
 55 | 
 56 | void complex::set_imag(double in_imag)
 57 | {
 58 |     imag = in_imag;
 59 | }
 60 | 
 61 | double complex::get_real() const
 62 | {
 63 |     return real;
 64 | }
 65 | 
 66 | double complex::get_imag() const
 67 | {
 68 |     return imag;
 69 | }
 70 | 
 71 | complex complex::operator+ (const complex &right)
 72 | {
 73 |     complex result; 
 74 |     
 75 |     result.set_real(real+right.get_real()); 
 76 |     result.set_imag(imag+right.get_imag()); 
 77 |     
 78 |     return result;
 79 | }
 80 | 
 81 | complex complex::operator- (const complex &right)
 82 | {
 83 |     complex result; 
 84 |     
 85 |     result.set_real(real-right.get_real()); 
 86 |     result.set_imag(imag-right.get_imag()); 
 87 |     
 88 |     return result;
 89 | }
 90 | 
 91 | complex complex::operator++(int right)
 92 | {
 93 |     complex result=*this; 
 94 |     
 95 |     real++; 
 96 |     imag++; 
 97 |     
 98 |     return result; 
 99 | }
100 | 
101 | complex &complex::operator++()
102 | {
103 |     real++; 
104 |     imag++;
105 |     
106 |     return *this; 
107 | }
108 | 
109 | complex &complex::operator= (const complex &right)
110 | {
111 |     if (this==&right) return *this; 
112 |     
113 |     real=right.get_real(); 
114 |     imag=right.get_imag();
115 |     
116 |     return *this;
117 | }
118 | 
119 | complex operator+(int left, complex &right)
120 | {
121 |     complex result;
122 | 
123 |     result.real = left+right.real; 
124 |     result.imag = left+right.imag; 
125 |     return result;
126 | }
127 | 
128 | ostream &operator<<(ostream &left, const complex &right)
129 | {
130 |     left<<"("<<right.real<<", "<<right.imag<<")"; 
131 | 
132 |     return left;
133 | }
134 | 


--------------------------------------------------------------------------------
/lesson08/cpp8(4sl).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson08/cpp8(4sl).pdf


--------------------------------------------------------------------------------
/lesson08/cpp8.askisi1.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp8.askisi1.cpp */
  2 | 
  3 | #include <iostream>
  4 | using namespace std;
  5 | 
  6 | class ARRAY {
  7 |   public:
  8 |     static int MAX_LENGTH; 
  9 |     ARRAY(int in_n);
 10 |     ARRAY(const ARRAY &ob);
 11 |     ~ARRAY();
 12 |     int get_n() const; 
 13 |     int &operator[] (int i);
 14 |     ARRAY &operator= (ARRAY &right);
 15 |     ARRAY &operator+= (int right);
 16 |     friend ostream &operator<<(ostream &left, const ARRAY &ob);
 17 |   private:
 18 |     int *p;
 19 |     int n;
 20 | };
 21 | 
 22 | int ARRAY::MAX_LENGTH = 1000; 
 23 | 
 24 | 
 25 | int main()
 26 | {
 27 |     int n=1001;
 28 |     ARRAY pin(n);
 29 | 
 30 | 
 31 |     return 0;
 32 | }
 33 | 
 34 | ARRAY::ARRAY(int in_n)
 35 | {
 36 |     if (in_n>MAX_LENGTH)
 37 |     {
 38 |         cout<<"n is too big!";
 39 |         n=0; 
 40 |     }
 41 |         
 42 |     else
 43 |     {
 44 |         n = in_n; 
 45 |         
 46 |         p = new int [n];
 47 |         if (!p)
 48 |             cout<<"Error allocating memory!";
 49 |     }
 50 | }
 51 | 
 52 | ARRAY::ARRAY(const ARRAY &ob)
 53 | {
 54 |     n = ob.get_n(); 
 55 |     
 56 |     p = new int [n];
 57 |     if (!p) cout<<"Memory Allocation Error!";
 58 | }
 59 | 
 60 | ARRAY::~ARRAY()
 61 | {
 62 |     if (n>0)
 63 |         delete [] p;
 64 | }
 65 | 
 66 | int ARRAY::get_n() const
 67 | {
 68 |     return n;
 69 | }
 70 | 
 71 | int &ARRAY::operator[] (int i)
 72 | {
 73 |     if (i>=0 && i<n) 
 74 |         return p[i]; 
 75 |     else
 76 |         cout<<"Index Error";
 77 |     
 78 | }
 79 | 
 80 | ARRAY &ARRAY::operator= (ARRAY &right)
 81 | {
 82 |     if (this==&right) return *this; 
 83 |     
 84 |     n=right.n; 
 85 |     delete [] p;
 86 |     p=new int [n];
 87 |     if(!p) cout<<"Error Allcoating Memory";
 88 |     
 89 |     for (int i=0; i<n; i++)
 90 |         p[i]=right[i];
 91 |         
 92 |     return *this; 
 93 | }
 94 | 
 95 | ARRAY &ARRAY::operator+= (int right)
 96 | {
 97 |     int newn=n+right;
 98 |     int *newp;
 99 |     int i; 
100 |     
101 |     if (right>0)
102 |     {
103 |         newp = new int [newn];
104 |         if (!newp) cout<<"Error Allocating Memory";
105 |         
106 |         for (i=0; i<n; i++)
107 |             newp[i]=p[i];
108 |         for (i=n; i<newn; i++)
109 |             newp[i]=0;
110 |             
111 |         delete [] p;
112 |         n=newn;
113 |         p=newp; 
114 |     }
115 |     else 
116 |         cout<<"Wrong index!";
117 |         
118 | }
119 | 
120 | ostream &operator<<(ostream &left, const ARRAY &ob)
121 | {
122 |     int i; 
123 |     
124 |     left<<"[";
125 |     for (i=0; i<ob.n-1; i++)
126 |         cout<<ob.p[i]<<" ";
127 |     left<<ob.p[ob.n-1];
128 |     left<<"]";
129 |     
130 |     return left; 
131 | }
132 | 


--------------------------------------------------------------------------------
/lesson08/cpp8.askisi2.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp8.askisi2.cpp */
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | int fib(int n);
 6 | 
 7 | int main()
 8 | {
 9 |     cout<<fib(17);
10 |     return 0;
11 | }
12 | 
13 | int fib(int n)
14 | {
15 |     static int calls = 0; 
16 |     
17 |     calls++; 
18 |     cout<<calls<<endl; 
19 |     
20 |     if (n==1 || n==2)
21 |         return 1; 
22 |     else
23 |         return fib(n-1)+fib(n-2);
24 | }


--------------------------------------------------------------------------------
/lesson08/cpp8.lifespan.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp8.lifespan.cpp */ 
 2 | #include <iostream>
 3 | using namespace std; 
 4 | 
 5 | class life {
 6 | public: 
 7 | 	int x; 
 8 | 	life(int in_x);
 9 | 	~life(); 
10 | };
11 | 
12 | int main()
13 | {
14 | 	static life ob1(1);
15 | 	cout<<"Start Main"<<endl; 
16 | 	{
17 | 		life ob2(2);
18 | 	}
19 | 
20 | 	life *ob3 = new life(3);
21 | 	delete ob3; 
22 | 	cout<<"End Main"<<endl; 
23 | 
24 | 	return 0;
25 | }
26 | 
27 | life::life(int in_x)
28 | {
29 | 	x = in_x; 
30 | 	cout<<"Constructing "<<x<<endl; 
31 | }
32 | 
33 | life::~life()
34 | {
35 | 	cout<<"Destructing "<<x<<endl;
36 | }


--------------------------------------------------------------------------------
/lesson08/cpp8.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson08/cpp8.pdf


--------------------------------------------------------------------------------
/lesson08/cpp8.static_local_variables.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp8.static_local_variables.cpp */ 
 2 | #include <iostream>
 3 | using namespace std; 
 4 | 
 5 | void func();
 6 | 
 7 | int main()
 8 | {
 9 |       int i;
10 |       
11 |       for (i=0; i<10; i++)
12 |           func();
13 | 
14 |       return 0; 
15 | }
16 | void func()
17 | {
18 |     int y=0;
19 |     static int x=0; 
20 |   
21 |     x=x+1;
22 |     y=y+1;
23 |     cout<<endl<<"x="<<x<<", y="<<y;
24 | }
25 | 


--------------------------------------------------------------------------------
/lesson08/cpp8.static_members.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp8.static_members.cpp */ 
 2 | 
 3 | #include <iostream>
 4 | #include <cstdlib>
 5 | using namespace std;
 6 | 
 7 | #define N 5
 8 | 
 9 | class orc {
10 |   public:
11 |     static int alive_orcs;
12 |     orc(); 
13 |     ~orc(); 
14 |   private:
15 |     int h; 
16 | };
17 | 
18 | int orc::alive_orcs = 0; 
19 | 
20 | int main()
21 | {
22 |     orc *arr[N];
23 |     int i, pos; 
24 |     
25 |     for (i=0; i<N; i++) 
26 |         arr[i]=NULL;
27 |     
28 |     for (i=0; i<100; i++)
29 |     {
30 |         pos = rand()%N; 
31 |         
32 |         if (arr[pos]==NULL)
33 |         {
34 |             arr[pos]=new orc; 
35 |             if (!arr[pos]) exit(0);
36 |         }
37 |         else 
38 |         {
39 |             delete arr[pos];
40 |             arr[pos]=NULL;
41 |         }
42 |             
43 |             
44 |         if (i%10==0)
45 |             cout<<"Step "<<i<<": Alive orcs = "<<orc::alive_orcs<<endl; 
46 |     }
47 |     return 0; 
48 | }
49 | 
50 | orc::orc()
51 | {
52 |     alive_orcs++; 
53 | }
54 | 
55 | orc::~orc()
56 | {
57 |     alive_orcs--; 
58 | }


--------------------------------------------------------------------------------
/lesson08/cpp8.static_methods.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp8.static_methods.cpp */ 
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class orc {
 7 |   public:
 8 |     static int alive_orcs;
 9 |     static bool frenzy_mode; 
10 |     static void toggle_frenzy_mode(); 
11 |     orc(); 
12 |     ~orc(); 
13 |     friend ostream &operator<<(ostream &left, const orc &right);
14 |   private:
15 |     int h; 
16 | };
17 | 
18 | int orc::alive_orcs = 0; 
19 | bool orc::frenzy_mode = false; 
20 | 
21 | int main()
22 | {
23 |     orc orc1,orc2; 
24 |     
25 |     cout<<"NORMAL MODE"<<endl; 
26 |     cout<<"Orc1: "<<orc1<<endl; 
27 |     cout<<"Orc2: "<<orc2<<endl; 
28 |     
29 |     orc::toggle_frenzy_mode();
30 |     cout<<"FRENZY MODE"<<endl; 
31 |     cout<<"Orc1: "<<orc1<<endl; 
32 |     cout<<"Orc2: "<<orc2<<endl; 
33 | 
34 |     return 0; 
35 | }
36 | 
37 | orc::orc()
38 | {
39 |     alive_orcs++; 
40 | }
41 | 
42 | orc::~orc()
43 | {
44 |     alive_orcs--; 
45 | }
46 | 
47 | void orc::toggle_frenzy_mode()
48 | {
49 |     if (frenzy_mode)
50 |         frenzy_mode=false;
51 |     else
52 |         frenzy_mode=true; 
53 | }
54 | 
55 | ostream &operator<<(ostream &left, const orc &right)
56 | {
57 |     if (orc::frenzy_mode)
58 |         cout<<"AARFFGHHRHHHHR";
59 |     else
60 |         cout<<"ougba";
61 | }


--------------------------------------------------------------------------------
/lesson09/cpp9(4sl).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson09/cpp9(4sl).pdf


--------------------------------------------------------------------------------
/lesson09/cpp9.askisi1.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp9.askisi1.cpp */
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | #define SIZE 10
 8 | 
 9 | void insertion_sort(string *pinakas, int N);
10 | void swap(string &s1, string &s2);
11 | 
12 | int main()
13 | {
14 |     string pin[SIZE]={"abcd","adas","asdr","aqwe","qwetyy","asdasd","asdasdq","xcvxc","ytreh","werwer"};
15 |     
16 |     insertion_sort(pin,SIZE);
17 |     
18 |     for (int i=0; i<SIZE; i++)
19 |     {
20 |         cout<<pin[i]<<endl; 
21 |     }
22 |     
23 |     return 0; 
24 | }
25 | 
26 | /* Taksinomisi me Eisagogi */
27 | 
28 | void insertion_sort(string *pinakas, int N)
29 | {
30 |     int i,j; 
31 |     
32 |     for (i=1; i<N; i++)
33 |     {
34 |        for (j=i; j>=1; j--)
35 |        {
36 |           if (pinakas[j]<pinakas[j-1])
37 |              swap(pinakas[j], pinakas[j-1]);
38 |           else
39 |              break;
40 |        }
41 |     }
42 | }
43 | 
44 | void swap(string &s1, string &s2)
45 | {
46 |     string k = s1; 
47 |     s1=s2;
48 |     s2=k; 
49 | }


--------------------------------------------------------------------------------
/lesson09/cpp9.askisi2.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp9.askisi2.cpp */ 
 2 | 
 3 | #include <iostream>
 4 | #include <cstdlib>
 5 | #include <ctime>
 6 | using namespace std;
 7 | 
 8 | #define N 10
 9 | 
10 | int main()
11 | {
12 |     string words[N]={"bond", "neo", "boromir", "saruman", "gandalf", "sansha", "stark", "spiderman", "frodo", "morpheus"};
13 |     
14 |     /* Choose random words */
15 |     
16 |     srand(time(0));
17 |     
18 |     string hidden = words[rand()%10];
19 | 
20 |     /* Arxikopoiisi game */
21 |     
22 |     string game(hidden.length(), '-');
23 |     
24 |     /* Guesses */
25 |     
26 |     string bad_guesses; 
27 |     string right_guesses; 
28 |     
29 |     /* MAX */
30 |     
31 |     int MAX = 10; 
32 |     int wrong_guesses = 0; 
33 |     
34 |     /* algorithm */
35 |     char letter; 
36 |     
37 |     while (true)
38 |     {
39 |         cout<<game<<endl;
40 |         cout<<"Choose letter: ";
41 |         cin>>letter; 
42 |         
43 |         if (bad_guesses.find(letter)!=bad_guesses.npos)
44 |         {
45 |             cout<<"To gramma exei epilexthei"<<endl;
46 |             continue; 
47 |         }
48 |         
49 |         if (right_guesses.find(letter)!=right_guesses.npos)
50 |         {
51 |             cout<<"To gramma exei epilexthei"<<endl;
52 |             continue; 
53 |         }
54 |         
55 |         if (hidden.find(letter)!=hidden.npos) // yparxei
56 |         {
57 |             int pos; 
58 |             
59 |             cout<<"Swsti epilogi!"<<endl; 
60 |             
61 |             pos = hidden.find(letter);
62 |             
63 |             while (pos<hidden.length())
64 |             {
65 |                 game[pos]=hidden[pos];    
66 |                 pos = hidden.find(letter, pos+1);
67 |             }
68 |             
69 |             right_guesses.push_back(letter);
70 |             
71 |             if (game.find('-')==hidden.npos)
72 |             {
73 |                 cout<<"Kerdises!!!!!"<<endl;
74 |                 cout<<"H leksh itan: "<<game;
75 |                 break; 
76 |             }
77 |         }
78 |         else //den yparxei
79 |         {
80 |             cout<<"To gramma den yparxei"<<endl; 
81 |             wrong_guesses ++; 
82 |             cout<<"Apomenoun "<<MAX-wrong_guesses<<" prospatheies"<<endl;
83 |             bad_guesses.push_back(letter);
84 |             
85 |             if (wrong_guesses==MAX)
86 |             {
87 |                 cout<<"Exases!";
88 |                 cout<<"H leksi itan: "<<hidden;
89 |                 break; 
90 |             }
91 |         }
92 |     }
93 | }


--------------------------------------------------------------------------------
/lesson09/cpp9.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson09/cpp9.pdf


--------------------------------------------------------------------------------
/lesson09/cpp9.string.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp8.string.cpp */ 
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s("Initial string");
10 |     
11 |     cout<<s<<endl; 
12 |     
13 |     cout<<"Give new string: ";
14 |     getline(cin, s);
15 |     
16 |     cout<<s; 
17 | 
18 |     return 0; 
19 | }
20 | 


--------------------------------------------------------------------------------
/lesson09/cpp9.string_add_rem_upd.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp8.string_add_rem_upd.cpp */ 
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s("0123456789");
10 |     
11 |     cout<<"Initial:    "<<s<<endl;
12 |     
13 |     s.append("abcd");
14 |     s.push_back('.');
15 |     s.insert(3,"ABC");
16 |     
17 |     cout<<"Insertions: "<<s<<endl;
18 |     
19 |     s.pop_back();
20 |     s.erase(3,3);
21 |     
22 |     cout<<"Deletions:  "<<s<<endl;
23 | 
24 |     s.replace(2,4,string("ABCD"),0,4);
25 |     
26 |     cout<<"Replace:    "<<s<<endl;
27 | 
28 | 
29 |     s.clear();
30 | 
31 |     cout<<"Cleared:    "<<s<<endl;
32 |     
33 |     return 0; 
34 | }
35 | 


--------------------------------------------------------------------------------
/lesson09/cpp9.string_capacity.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp8.string_capacity.cpp */ 
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s1;
10 |     string s2("Medium");
11 |     string s3("A rather large one");
12 |     
13 |     cout<<"Capacity s1: "<<s1.capacity()<<endl;
14 |     cout<<"Length s1:"<<s1.size()<<endl; 
15 |     
16 |     cout<<"Capacity s2: "<<s2.capacity()<<endl;
17 |     cout<<"Length s2:"<<s2.length()<<endl; 
18 |     
19 |     cout<<"Capacity s3: "<<s3.capacity()<<endl;
20 |     cout<<"Length s3:"<<s3.length()<<endl; 
21 |     
22 |     s3+=s1+s2; 
23 | 
24 |     cout<<"Capacity s3: "<<s3.capacity()<<endl;
25 |     cout<<"Length s3:"<<s3.length()<<endl; 
26 |     
27 |     s3.resize(10);
28 | 
29 |     cout<<"Capacity s3: "<<s3.capacity()<<endl;
30 |     cout<<"Length s3:"<<s3.length()<<endl; 
31 | 
32 |     s3.shrink_to_fit();
33 | 
34 |     cout<<"Capacity s3: "<<s3.capacity()<<endl;
35 |     cout<<"Length s3:"<<s3.length()<<endl; 
36 |     
37 |     return 0; 
38 | }
39 | 


--------------------------------------------------------------------------------
/lesson09/cpp9.string_find.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp9.string_find.cpp */ 
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s("0123456789");
10 |     string f("345");
11 |     
12 |     s+=s;
13 |     cout<<"str-   find-345c: pos: "<<s.find("345")<<endl;
14 |     cout<<"str-   find-345s: pos: "<<s.find(f)<<endl;
15 |     cout<<"str-   find-1c  : pos: "<<s.find('1')<<endl;
16 |     cout<<"str-  rfind-345 : pos: "<<s.rfind("345")<<endl;
17 |     cout<<"str-firstof-345 : pos: "<<s.find_first_of("345")<<endl;
18 |     cout<<"str-last of-345 : pos: "<<s.find_last_of("345")<<endl;
19 |     return 0; 
20 | }
21 | 


--------------------------------------------------------------------------------
/lesson09/cpp9.string_operators.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp8.string_operators.cpp */ 
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s1("abcd");
10 |     string s2; 
11 |     
12 |     s2=s1+s1+s1;
13 |     
14 |     s2[4]='A';
15 |     
16 |     if (s1>s2)
17 |         cout<<s1;
18 |     else 
19 |         cout<<s2;
20 | 
21 |     return 0; 
22 | }
23 | 


--------------------------------------------------------------------------------
/lesson10/cpp10(4sl).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson10/cpp10(4sl).pdf


--------------------------------------------------------------------------------
/lesson10/cpp10.askisi1.1-1.2.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp10.askisi1.1-1.2.cpp */
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | #define SIZE 100
  8 | 
  9 | class video {
 10 |   public:
 11 |     int get_duration() const;
 12 |     void set_video(string in_artist_name, string in_track_name, int in_duration);
 13 |     friend ostream &operator<<(ostream &left, video &right);
 14 |   private:
 15 |     string artist_name;
 16 |     string track_name; 
 17 |     int duration; 
 18 | };
 19 | 
 20 | 
 21 | class playlist {
 22 |   public:
 23 |     playlist(string in_name, string in_descr);
 24 |     void add_video(video in_video);
 25 |     friend ostream &operator<<(ostream &left, playlist &right);
 26 |   private:
 27 |     string name; 
 28 |     string descr; 
 29 |     int duration; 
 30 |     video videos[SIZE];
 31 |     int videos_size; 
 32 | };
 33 | 
 34 | int main()
 35 | {
 36 |     playlist l("my playlist", "the best songs");
 37 |     
 38 |     video temp; 
 39 |     
 40 |     temp.set_video("Mpagianteras", "Sa magemeno to mialo moy", 207);
 41 |     l.add_video(temp);
 42 |     temp.set_video("Sin Boy", "Mama", 400);
 43 |     l.add_video(temp);
 44 |     
 45 |     cout<<l; 
 46 |     return 0;
 47 | }
 48 | 
 49 | 
 50 | 
 51 | 
 52 | int video::get_duration() const
 53 | {
 54 |     return duration; 
 55 | }
 56 | 
 57 | void video::set_video(string in_artist_name, string in_track_name, int in_duration)
 58 | {
 59 |     artist_name = in_artist_name;
 60 |     track_name = in_track_name;
 61 |     duration = in_duration; 
 62 | }
 63 | 
 64 | ostream &operator<<(ostream &left, video &right)
 65 | {
 66 |     left<<"("<<right.artist_name<<","<<right.track_name<<","<<right.duration<<")";
 67 |     
 68 |     return left; 
 69 | }
 70 | 
 71 | 
 72 | 
 73 | 
 74 | playlist::playlist(string in_name, string in_descr)
 75 | {
 76 |     name = in_name; 
 77 |     descr = in_descr; 
 78 |     duration = 0; 
 79 |     videos_size = 0; 
 80 | }
 81 | 
 82 | void playlist::add_video(video in_video)
 83 | {
 84 |     videos[videos_size] = in_video; 
 85 |     videos_size++; 
 86 |     
 87 |     duration+=in_video.get_duration(); 
 88 | }
 89 | 
 90 | ostream &operator<<(ostream &left, playlist &right)
 91 | {
 92 |     left<<"["<<right.name<<","<<right.descr<<","<<right.duration;
 93 |     
 94 |     for (int i=0; i<right.videos_size; i++)
 95 |         left<<endl<<right.videos[i];
 96 |     
 97 |     left<<"]";
 98 |     
 99 |     return left; 
100 | }


--------------------------------------------------------------------------------
/lesson10/cpp10.askisi1.3-1.4.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp10.askisi1.3-1.4.cpp */
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | #define SIZE 100
  8 | 
  9 | class video {
 10 |   public:
 11 |     int get_duration() const;
 12 |     void set_video(string in_artist_name, string in_track_name, int in_duration);
 13 |     friend ostream &operator<<(ostream &left, video &right);
 14 |   private:
 15 |     string artist_name;
 16 |     string track_name; 
 17 |     int duration; 
 18 | };
 19 | 
 20 | class playlist {
 21 |   public:
 22 |     playlist(string in_name, string in_descr);
 23 |     void add_video(video in_video);
 24 |     friend ostream &operator<<(ostream &left, playlist &right);
 25 |   protected:
 26 |     string name; 
 27 |     string descr; 
 28 |     int duration; 
 29 |     video videos[SIZE];
 30 |     int videos_size; 
 31 | };
 32 | 
 33 | class classical_playlist: public playlist {
 34 |   public:
 35 |     classical_playlist(string in_name, string in_descr, string in_period);
 36 |     friend ostream &operator<<(ostream &left, classical_playlist &right);
 37 |   private:
 38 |     string period; 
 39 | };
 40 | 
 41 | int main()
 42 | {
 43 |     classical_playlist l("my playlist", "the best songs", "rempetiko");
 44 |     
 45 |     video temp; 
 46 |     
 47 |     temp.set_video("Mpagianteras", "Sa magemeno to mialo moy", 207);
 48 |     l.add_video(temp);
 49 |     temp.set_video("Sin Boy", "Mama", 400);
 50 |     l.add_video(temp);
 51 |     
 52 |     cout<<l; 
 53 |     return 0;
 54 | }
 55 | 
 56 | 
 57 | 
 58 | 
 59 | int video::get_duration() const
 60 | {
 61 |     return duration; 
 62 | }
 63 | 
 64 | void video::set_video(string in_artist_name, string in_track_name, int in_duration)
 65 | {
 66 |     artist_name = in_artist_name;
 67 |     track_name = in_track_name;
 68 |     duration = in_duration; 
 69 | }
 70 | 
 71 | ostream &operator<<(ostream &left, video &right)
 72 | {
 73 |     left<<"("<<right.artist_name<<","<<right.track_name<<","<<right.duration<<")";
 74 |     
 75 |     return left; 
 76 | }
 77 | 
 78 | 
 79 | 
 80 | 
 81 | playlist::playlist(string in_name, string in_descr)
 82 | {
 83 |     name = in_name; 
 84 |     descr = in_descr; 
 85 |     duration = 0; 
 86 |     videos_size = 0; 
 87 | }
 88 | 
 89 | void playlist::add_video(video in_video)
 90 | {
 91 |     videos[videos_size] = in_video; 
 92 |     videos_size++; 
 93 |     
 94 |     duration+=in_video.get_duration(); 
 95 | }
 96 | 
 97 | ostream &operator<<(ostream &left, playlist &right)
 98 | {
 99 |     left<<"["<<right.name<<","<<right.descr<<","<<right.duration;
100 |     
101 |     for (int i=0; i<right.videos_size; i++)
102 |         left<<endl<<right.videos[i];
103 |     
104 |     left<<"]";
105 |     
106 |     return left; 
107 | }
108 | 
109 | 
110 | 
111 | classical_playlist::classical_playlist(string in_name, string in_descr, string in_period):
112 |     playlist(in_name, in_descr)
113 | {
114 |     period = in_period;
115 | }
116 | 
117 | 
118 | ostream &operator<<(ostream &left, classical_playlist &right)
119 | {
120 |     left<<"["<<right.name<<","<<right.descr<<","<<right.period<<","<<right.duration;
121 |     
122 |     for (int i=0; i<right.videos_size; i++)
123 |         left<<endl<<right.videos[i];
124 |     
125 |     left<<"]";
126 |     
127 |     return left; 
128 | }


--------------------------------------------------------------------------------
/lesson10/cpp10.askisi2.1-2.2.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp10.askisi2.1-2.2.cpp */
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | class card {
 8 |   public:
 9 |     card(string in_name, string in_color, string in_rarity);
10 |     friend ostream &operator<<(ostream &left, card &right);
11 |   protected:
12 |     string name; 
13 |     string color; 
14 |     string rarity; 
15 | };
16 | 
17 | class creature: public card {
18 |   public:
19 |     creature(string in_name, string in_color, string in_rarity, int in_attack, int in_defense, string in_kind);
20 |     friend ostream &operator<<(ostream &left, creature &right);
21 |   private:
22 |     int attack;
23 |     int defense; 
24 |     string kind; 
25 | };
26 | 
27 | 
28 | int main()
29 | {
30 |     creature c("Akroan Crusader", "red", "common",1,1,"Human Soldier");
31 |     cout<<c; 
32 |     
33 |     creature c2("Rune-Scarred Demon", "black", "rare",6,6,"Demon");
34 |     cout<<c2; 
35 |     
36 |     return 0;
37 | }
38 | 
39 | card::card(string in_name, string in_color, string in_rarity)
40 | {
41 |     name = in_name;
42 |     color = in_color; 
43 |     rarity = in_rarity; 
44 | }
45 | 
46 | ostream &operator<<(ostream &left, card &right)
47 | {
48 |     left<<"("<<right.name<<","<<right.color<<","<<right.rarity<<")";
49 |     
50 |     return left; 
51 | }
52 | 
53 | 
54 | creature::creature(string in_name, string in_color, string in_rarity, int in_attack, int in_defense, string in_kind):
55 |   card(in_name, in_color, in_rarity)
56 | {
57 |     attack = in_attack;
58 |     defense = in_defense; 
59 |     kind = in_kind; 
60 | }
61 | 
62 | ostream &operator<<(ostream &left, creature &right)
63 | {
64 |     left<<"("<<right.name<<","<<right.color<<","<<right.rarity<<",";
65 |     left<<right.attack<<","<<right.defense<<","<<right.kind<<")";
66 |     
67 |     return left; 
68 | }


--------------------------------------------------------------------------------
/lesson10/cpp10.askisi2.3-2.4.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp10.askisi2.3-2.4.cpp */
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | class card {
  8 |   public:
  9 |     card(string in_name, string in_color, string in_rarity);
 10 |     friend ostream &operator<<(ostream &left, card &right);
 11 |   protected:
 12 |     string name; 
 13 |     string color; 
 14 |     string rarity; 
 15 | };
 16 | 
 17 | class creature: public card {
 18 |   public:
 19 |     creature(string in_name, string in_color, string in_rarity, int in_attack, int in_defense, string in_kind);
 20 |     friend ostream &operator<<(ostream &left, creature &right);
 21 |   private:
 22 |     int attack;
 23 |     int defense; 
 24 |     string kind; 
 25 | };
 26 | 
 27 | class land: public card {
 28 |   public:
 29 |     land(string in_name, string in_color, string in_rarity, int in_mana, string in_descr, bool in_tap);
 30 |     friend ostream &operator<<(ostream &left, land &right);
 31 |   private: 
 32 |     int mana; 
 33 |     string descr; 
 34 |     bool tap; 
 35 | };
 36 | 
 37 | int main()
 38 | {
 39 |     creature c("Akroan Crusader", "red", "common",1,1,"Human Soldier");
 40 |     cout<<c; 
 41 |     
 42 |     creature c2("Rune-Scarred Demon", "black", "rare",6,6,"Demon");
 43 |     cout<<c2; 
 44 |     
 45 |     land c3("Plains", "white", "uncommon", 1, "Basic Land - Plains", false);
 46 |     cout<<c3; 
 47 |  
 48 |     card pin[7];
 49 |     
 50 |     return 0;
 51 | }
 52 | 
 53 | card::card(string in_name, string in_color, string in_rarity)
 54 | {
 55 |     name = in_name;
 56 |     color = in_color; 
 57 |     rarity = in_rarity; 
 58 | }
 59 | 
 60 | ostream &operator<<(ostream &left, card &right)
 61 | {
 62 |     left<<"("<<right.name<<","<<right.color<<","<<right.rarity<<")";
 63 |     
 64 |     return left; 
 65 | }
 66 | 
 67 | 
 68 | creature::creature(string in_name, string in_color, string in_rarity, int in_attack, int in_defense, string in_kind):
 69 |   card(in_name, in_color, in_rarity)
 70 | {
 71 |     attack = in_attack;
 72 |     defense = in_defense; 
 73 |     kind = in_kind; 
 74 | }
 75 | 
 76 | ostream &operator<<(ostream &left, creature &right)
 77 | {
 78 |     left<<"("<<right.name<<","<<right.color<<","<<right.rarity<<",";
 79 |     left<<right.attack<<","<<right.defense<<","<<right.kind<<")";
 80 |     
 81 |     return left; 
 82 | }
 83 | 
 84 | 
 85 | 
 86 | land::land(string in_name, string in_color, string in_rarity, int in_mana, string in_descr, bool in_tap):
 87 |   card(in_name, in_color, in_rarity)
 88 | {
 89 |     mana = in_mana; 
 90 |     descr = in_descr; 
 91 |     tap = in_tap; 
 92 | }
 93 | 
 94 | ostream &operator<<(ostream &left, land &right)
 95 | {
 96 |     left<<"("<<right.name<<","<<right.color<<","<<right.rarity<<",";
 97 |     left<<right.mana<<","<<right.descr<<",";
 98 |     if (right.tap)
 99 |         left<<"tapped";
100 |     else
101 |         left<<"untapped";
102 |     
103 |     left<<")";
104 |     
105 |     return left; 
106 | }


--------------------------------------------------------------------------------
/lesson10/cpp10.inheritance_constructors.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp10.inheritance_constructors.cpp */ 
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | class animal {
 8 |   public:
 9 |     animal(int in_weight, int in_height); 
10 |     int get_weight() const; 
11 |     int get_height() const; 
12 |     void set_weight(int in_weight);
13 |     void set_height(int in_height);
14 |   private:
15 |     int weight; 
16 |     int height; 
17 | };
18 | 
19 | class dog: public animal {
20 |   public:
21 |     dog(int in_weight, int in_height, string in_house_address);
22 |     void bark(); 
23 |     void set_house_address(string in_house_address);
24 |     string get_house_address() const;
25 |     friend ostream &operator<<(ostream &left, const dog &right);
26 |   private:
27 |     string house_address; 
28 | };
29 | 
30 | 
31 | int main()
32 | {
33 |     dog piko(10,35,"Left Hill 154"); 
34 |     
35 |     piko.bark();
36 |     cout<<piko; 
37 |     return 0; 
38 | }
39 | 
40 | 
41 | animal::animal(int in_weight, int in_height)
42 | {
43 |     cout<<"Constructing Animal..."<<endl;
44 |     weight = in_weight; 
45 |     height = in_height; 
46 | }
47 | 
48 | void animal::set_weight(int in_weight)
49 | {
50 |     weight = in_weight; 
51 | }
52 | 
53 | void animal::set_height(int in_height)
54 | {
55 |     height = in_height; 
56 | }
57 | 
58 | int animal::get_weight() const
59 | {
60 |     return weight; 
61 | }
62 | 
63 | int animal::get_height() const
64 | {
65 |     return height; 
66 | }
67 | 
68 | 
69 | 
70 | dog::dog(int in_weight, int in_height, string in_house_address):
71 |   animal(in_weight, in_height)
72 | {
73 |     cout<<"Constructing Dog..."<<endl;
74 |     house_address=in_house_address; 
75 | }
76 | 
77 | void dog::bark()
78 | {
79 |     cout<<"arf arf!"<<endl;
80 | }
81 | 
82 | void dog::set_house_address(string in_house_address)
83 | {
84 |     house_address = in_house_address; 
85 | }
86 | 
87 | string dog::get_house_address() const
88 | {
89 |     return house_address; 
90 | }
91 | 
92 | ostream &operator<<(ostream &left, const dog &right)
93 | {
94 |     //left<<"weight: "<<weight;  //doesn't work 
95 |     left<<"weight: "<<right.get_weight()<<endl;  
96 |     //left<<"height: "<<height;  //doesn't work 
97 |     left<<"height: "<<right.get_height()<<endl;  
98 |     left<<"address: "<<right.house_address; 
99 | }


--------------------------------------------------------------------------------
/lesson10/cpp10.inheritance_destructors.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp10.inheritance_destructors.cpp */ 
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | class animal {
  8 |   public:
  9 |     animal(int in_weight, int in_height); 
 10 |     ~animal();
 11 |     int get_weight() const; 
 12 |     int get_height() const; 
 13 |     void set_weight(int in_weight);
 14 |     void set_height(int in_height);
 15 |   private:
 16 |     int weight; 
 17 |     int height; 
 18 | };
 19 | 
 20 | class dog: public animal {
 21 |   public:
 22 |     dog(int in_weight, int in_height, string in_house_address);
 23 |     ~dog(); 
 24 |     void bark(); 
 25 |     void set_house_address(string in_house_address);
 26 |     string get_house_address() const;
 27 |     friend ostream &operator<<(ostream &left, const dog &right);
 28 |   private:
 29 |     string house_address; 
 30 | };
 31 | 
 32 | 
 33 | int main()
 34 | {
 35 |     dog piko(10,35,"Left Hill 154"); 
 36 |     
 37 |     piko.bark();
 38 |     cout<<piko; 
 39 |     return 0; 
 40 | }
 41 | 
 42 | 
 43 | animal::animal(int in_weight, int in_height)
 44 | {
 45 |     cout<<"Constructing Animal..."<<endl;
 46 |     weight = in_weight; 
 47 |     height = in_height; 
 48 | }
 49 | 
 50 | animal::~animal()
 51 | {
 52 |     cout<<"Destructing Animal..."<<endl;
 53 | }
 54 | 
 55 | void animal::set_weight(int in_weight)
 56 | {
 57 |     weight = in_weight; 
 58 | }
 59 | 
 60 | void animal::set_height(int in_height)
 61 | {
 62 |     height = in_height; 
 63 | }
 64 | 
 65 | int animal::get_weight() const
 66 | {
 67 |     return weight; 
 68 | }
 69 | 
 70 | int animal::get_height() const
 71 | {
 72 |     return height; 
 73 | }
 74 | 
 75 | 
 76 | 
 77 | dog::dog(int in_weight, int in_height, string in_house_address):
 78 |   animal(in_weight, in_height)
 79 | {
 80 |     cout<<"Constructing Dog..."<<endl;
 81 |     house_address=in_house_address; 
 82 | }
 83 | 
 84 | dog::~dog()
 85 | {
 86 |     cout<<"Destructing Dog..."<<endl;
 87 | }
 88 | 
 89 | void dog::bark()
 90 | {
 91 |     cout<<"arf arf!"<<endl;
 92 | }
 93 | 
 94 | void dog::set_house_address(string in_house_address)
 95 | {
 96 |     house_address = in_house_address; 
 97 | }
 98 | 
 99 | string dog::get_house_address() const
100 | {
101 |     return house_address; 
102 | }
103 | 
104 | ostream &operator<<(ostream &left, const dog &right)
105 | {
106 |     //left<<"weight: "<<weight;  //doesn't work 
107 |     left<<"weight: "<<right.get_weight()<<endl;  
108 |     //left<<"height: "<<height;  //doesn't work 
109 |     left<<"height: "<<right.get_height()<<endl;  
110 |     left<<"address: "<<right.house_address<<endl; 
111 | }


--------------------------------------------------------------------------------
/lesson10/cpp10.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson10/cpp10.pdf


--------------------------------------------------------------------------------
/lesson10/cpp10.protected_members.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp10.protected_members.cpp */ 
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | class B {
 8 |     public: 
 9 |       int pub; 
10 |       void f();
11 |     protected:
12 |       int pro; 
13 |     private:
14 |       int pri;
15 | };
16 | 
17 | class D: public B {
18 |     public:
19 |       void g();
20 | };
21 | 
22 | int main()
23 | {
24 |     B b; 
25 |     b.pub=1;
26 |     //b.pro=1; //no access
27 |     //b.pri=1; //no access
28 |     D d;
29 |     d.pub=1;
30 |     //d.bpro=1; //no access
31 |     //d.bpri=1; //no access
32 | }
33 | 
34 | void B::f()
35 | {
36 |     pub=1;
37 |     pro=1;
38 |     pri=1; 
39 | }
40 | 
41 | void D::g()
42 | {
43 |     pub=1;
44 |     pro=1;
45 |     //pri=1; //no access
46 | }


--------------------------------------------------------------------------------
/lesson10/cpp10.public_inheritance.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp10.public_inheritance.cpp */ 
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | class animal {
 8 |   public:
 9 |     int get_weight() const; 
10 |     int get_height() const; 
11 |     void set_weight(int in_weight);
12 |     void set_height(int in_height);
13 |   private:
14 |     int weight; 
15 |     int height; 
16 | };
17 | 
18 | class dog: public animal {
19 |   public:
20 |     void bark(); 
21 |     void set_house_address(string in_house_address);
22 |     string get_house_address() const;
23 |     friend ostream &operator<<(ostream &left, const dog &right);
24 |   private:
25 |     string house_address; 
26 | };
27 | 
28 | 
29 | int main()
30 | {
31 |     dog piko; 
32 |     
33 |     piko.set_house_address("Left Hill 154");
34 |     piko.set_weight(10);
35 |     piko.set_height(35);
36 | 
37 | 
38 |     piko.bark();
39 |     cout<<piko; 
40 |     return 0; 
41 | }
42 | 
43 | void animal::set_weight(int in_weight)
44 | {
45 |     weight = in_weight; 
46 | }
47 | 
48 | void animal::set_height(int in_height)
49 | {
50 |     height = in_height; 
51 | }
52 | 
53 | int animal::get_weight() const
54 | {
55 |     return weight; 
56 | }
57 | 
58 | int animal::get_height() const
59 | {
60 |     return height; 
61 | }
62 | 
63 | 
64 | 
65 | void dog::bark()
66 | {
67 |     cout<<"arf arf!"<<endl;
68 | }
69 | 
70 | void dog::set_house_address(string in_house_address)
71 | {
72 |     house_address = in_house_address; 
73 | }
74 | 
75 | string dog::get_house_address() const
76 | {
77 |     return house_address; 
78 | }
79 | 
80 | ostream &operator<<(ostream &left, const dog &right)
81 | {
82 |     //left<<"weight: "<<weight;  //doesn't work 
83 |     left<<"weight: "<<right.get_weight()<<endl;  
84 |     //left<<"height: "<<height;  //doesn't work 
85 |     left<<"height: "<<right.get_height()<<endl;  
86 |     left<<"address: "<<right.house_address; 
87 | }


--------------------------------------------------------------------------------
/lesson11/cpp11(4sl).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson11/cpp11(4sl).pdf


--------------------------------------------------------------------------------
/lesson11/cpp11.abstract_class.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp11.abstract_class.cpp */ 
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | class animal {
  8 |   public:
  9 |     animal(int in_weight, int in_height); 
 10 |     int get_weight() const; 
 11 |     int get_height() const; 
 12 |     void set_weight(int in_weight);
 13 |     void set_height(int in_height);
 14 |     virtual void make_sound() = 0; 
 15 |   private:
 16 |     int weight; 
 17 |     int height; 
 18 | };
 19 | 
 20 | class dog: public animal {
 21 |   public:
 22 |     dog(int in_weight, int in_height, string in_house_address);
 23 |     void set_house_address(string in_house_address);
 24 |     string get_house_address() const;
 25 |     void make_sound(); 
 26 |     friend ostream &operator<<(ostream &left, const dog &right);
 27 |   private:
 28 |     string house_address; 
 29 | };
 30 | 
 31 | class cat: public animal {
 32 |   public:
 33 |     cat(int in_weight, int in_height);
 34 |     void make_sound(); 
 35 |     friend ostream &operator<<(ostream &left, const cat &right);
 36 | };
 37 | 
 38 | 
 39 | int main()
 40 | {
 41 |     animal *bp = new dog(10,35,"Left Hill 154");
 42 | 
 43 |     delete bp;
 44 |     
 45 |     return 0; 
 46 | }
 47 | 
 48 | 
 49 | animal::animal(int in_weight, int in_height)
 50 | {
 51 |     weight = in_weight; 
 52 |     height = in_height; 
 53 | }
 54 | 
 55 | 
 56 | void animal::set_weight(int in_weight)
 57 | {
 58 |     weight = in_weight; 
 59 | }
 60 | 
 61 | void animal::set_height(int in_height)
 62 | {
 63 |     height = in_height; 
 64 | }
 65 | 
 66 | int animal::get_weight() const
 67 | {
 68 |     return weight; 
 69 | }
 70 | 
 71 | int animal::get_height() const
 72 | {
 73 |     return height; 
 74 | }
 75 | 
 76 | 
 77 | 
 78 | dog::dog(int in_weight, int in_height, string in_house_address):
 79 |   animal(in_weight, in_height)
 80 | {
 81 |     house_address=in_house_address; 
 82 | }
 83 | 
 84 | void dog::set_house_address(string in_house_address)
 85 | {
 86 |     house_address = in_house_address; 
 87 | }
 88 | 
 89 | string dog::get_house_address() const
 90 | {
 91 |     return house_address; 
 92 | }
 93 | 
 94 | void dog::make_sound() 
 95 | {
 96 |     cout<<"Arf arf"<<endl;
 97 | }
 98 | 
 99 | ostream &operator<<(ostream &left, const dog &right)
100 | {
101 |     left<<"weight: "<<right.get_weight()<<endl;  
102 |     left<<"height: "<<right.get_height()<<endl;  
103 |     left<<"address: "<<right.house_address<<endl; 
104 | }
105 | 
106 | 
107 | 
108 | cat::cat(int in_weight, int in_height):
109 |    animal(in_weight, in_height)
110 | {}
111 | 
112 | void cat::make_sound()
113 | {
114 |     cout<<"Meooooww"<<endl;
115 | }
116 | 
117 | ostream &operator<<(ostream &left, const cat &right)
118 | {
119 |     left<<"weight: "<<right.get_weight()<<endl;  
120 |     left<<"height: "<<right.get_height()<<endl;  
121 | }


--------------------------------------------------------------------------------
/lesson11/cpp11.destructor_base_pointer.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp11.destructor_base_pointer.cpp */ 
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | class animal {
  8 |   public:
  9 |     animal(int in_weight, int in_height); 
 10 |     ~animal(); 
 11 |     int get_weight() const; 
 12 |     int get_height() const; 
 13 |     void set_weight(int in_weight);
 14 |     void set_height(int in_height);
 15 |     void make_sound(); 
 16 |   private:
 17 |     int weight; 
 18 |     int height; 
 19 | };
 20 | 
 21 | class dog: public animal {
 22 |   public:
 23 |     dog(int in_weight, int in_height, string in_house_address);
 24 |     ~dog(); 
 25 |     void set_house_address(string in_house_address);
 26 |     string get_house_address() const;
 27 |     void make_sound(); 
 28 |     friend ostream &operator<<(ostream &left, const dog &right);
 29 |   private:
 30 |     string house_address; 
 31 | };
 32 | 
 33 | class cat: public animal {
 34 |   public:
 35 |     cat(int in_weight, int in_height);
 36 |     void make_sound(); 
 37 |     friend ostream &operator<<(ostream &left, const cat &right);
 38 | };
 39 | 
 40 | 
 41 | int main()
 42 | {
 43 |     animal *bp = new dog(10,35,"Left Hill 154");
 44 | 
 45 |     delete bp;
 46 |     
 47 |     return 0; 
 48 | }
 49 | 
 50 | 
 51 | animal::animal(int in_weight, int in_height)
 52 | {
 53 |     weight = in_weight; 
 54 |     height = in_height; 
 55 | }
 56 | 
 57 | animal::~animal()
 58 | {
 59 |     cout<<"Destructing animal...";
 60 | }
 61 | 
 62 | void animal::set_weight(int in_weight)
 63 | {
 64 |     weight = in_weight; 
 65 | }
 66 | 
 67 | void animal::set_height(int in_height)
 68 | {
 69 |     height = in_height; 
 70 | }
 71 | 
 72 | int animal::get_weight() const
 73 | {
 74 |     return weight; 
 75 | }
 76 | 
 77 | int animal::get_height() const
 78 | {
 79 |     return height; 
 80 | }
 81 | 
 82 | void animal::make_sound() 
 83 | {
 84 |     cout<<"Animal sound"<<endl;
 85 | }
 86 | 
 87 | 
 88 | 
 89 | dog::dog(int in_weight, int in_height, string in_house_address):
 90 |   animal(in_weight, in_height)
 91 | {
 92 |     house_address=in_house_address; 
 93 | }
 94 | 
 95 | dog::~dog()
 96 | {
 97 |     cout<<"Destructing dog...";
 98 | }
 99 | 
100 | void dog::set_house_address(string in_house_address)
101 | {
102 |     house_address = in_house_address; 
103 | }
104 | 
105 | string dog::get_house_address() const
106 | {
107 |     return house_address; 
108 | }
109 | 
110 | void dog::make_sound() 
111 | {
112 |     cout<<"Arf arf"<<endl;
113 | }
114 | 
115 | ostream &operator<<(ostream &left, const dog &right)
116 | {
117 |     left<<"weight: "<<right.get_weight()<<endl;  
118 |     left<<"height: "<<right.get_height()<<endl;  
119 |     left<<"address: "<<right.house_address<<endl; 
120 | }
121 | 
122 | 
123 | 
124 | cat::cat(int in_weight, int in_height):
125 |    animal(in_weight, in_height)
126 | {}
127 | 
128 | void cat::make_sound()
129 | {
130 |     cout<<"Meooooww"<<endl;
131 | }
132 | 
133 | ostream &operator<<(ostream &left, const cat &right)
134 | {
135 |     left<<"weight: "<<right.get_weight()<<endl;  
136 |     left<<"height: "<<right.get_height()<<endl;  
137 | }


--------------------------------------------------------------------------------
/lesson11/cpp11.destructor_derived_pointer.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp11.destructor_derived_pointer.cpp */ 
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | class animal {
  8 |   public:
  9 |     animal(int in_weight, int in_height); 
 10 |     ~animal(); 
 11 |     int get_weight() const; 
 12 |     int get_height() const; 
 13 |     void set_weight(int in_weight);
 14 |     void set_height(int in_height);
 15 |     void make_sound(); 
 16 |   private:
 17 |     int weight; 
 18 |     int height; 
 19 | };
 20 | 
 21 | class dog: public animal {
 22 |   public:
 23 |     dog(int in_weight, int in_height, string in_house_address);
 24 |     ~dog(); 
 25 |     void set_house_address(string in_house_address);
 26 |     string get_house_address() const;
 27 |     void make_sound(); 
 28 |     friend ostream &operator<<(ostream &left, const dog &right);
 29 |   private:
 30 |     string house_address; 
 31 | };
 32 | 
 33 | class cat: public animal {
 34 |   public:
 35 |     cat(int in_weight, int in_height);
 36 |     void make_sound(); 
 37 |     friend ostream &operator<<(ostream &left, const cat &right);
 38 | };
 39 | 
 40 | 
 41 | int main()
 42 | {
 43 |     dog *dp= new dog(10,35,"Left Hill 154");
 44 | 
 45 |     delete dp;
 46 |     
 47 |     return 0; 
 48 | }
 49 | 
 50 | 
 51 | animal::animal(int in_weight, int in_height)
 52 | {
 53 |     weight = in_weight; 
 54 |     height = in_height; 
 55 | }
 56 | 
 57 | animal::~animal()
 58 | {
 59 |     cout<<"Destructing animal...";
 60 | }
 61 | 
 62 | void animal::set_weight(int in_weight)
 63 | {
 64 |     weight = in_weight; 
 65 | }
 66 | 
 67 | void animal::set_height(int in_height)
 68 | {
 69 |     height = in_height; 
 70 | }
 71 | 
 72 | int animal::get_weight() const
 73 | {
 74 |     return weight; 
 75 | }
 76 | 
 77 | int animal::get_height() const
 78 | {
 79 |     return height; 
 80 | }
 81 | 
 82 | void animal::make_sound() 
 83 | {
 84 |     cout<<"Animal sound"<<endl;
 85 | }
 86 | 
 87 | 
 88 | 
 89 | dog::dog(int in_weight, int in_height, string in_house_address):
 90 |   animal(in_weight, in_height)
 91 | {
 92 |     house_address=in_house_address; 
 93 | }
 94 | 
 95 | dog::~dog()
 96 | {
 97 |     cout<<"Destructing dog...";
 98 | }
 99 | 
100 | void dog::set_house_address(string in_house_address)
101 | {
102 |     house_address = in_house_address; 
103 | }
104 | 
105 | string dog::get_house_address() const
106 | {
107 |     return house_address; 
108 | }
109 | 
110 | void dog::make_sound() 
111 | {
112 |     cout<<"Arf arf"<<endl;
113 | }
114 | 
115 | ostream &operator<<(ostream &left, const dog &right)
116 | {
117 |     left<<"weight: "<<right.get_weight()<<endl;  
118 |     left<<"height: "<<right.get_height()<<endl;  
119 |     left<<"address: "<<right.house_address<<endl; 
120 | }
121 | 
122 | 
123 | 
124 | cat::cat(int in_weight, int in_height):
125 |    animal(in_weight, in_height)
126 | {}
127 | 
128 | void cat::make_sound()
129 | {
130 |     cout<<"Meooooww"<<endl;
131 | }
132 | 
133 | ostream &operator<<(ostream &left, const cat &right)
134 | {
135 |     left<<"weight: "<<right.get_weight()<<endl;  
136 |     left<<"height: "<<right.get_height()<<endl;  
137 | }


--------------------------------------------------------------------------------
/lesson11/cpp11.method_overriding.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp11.method_overriding.cpp */ 
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | class animal {
  8 |   public:
  9 |     animal(int in_weight, int in_height); 
 10 |     int get_weight() const; 
 11 |     int get_height() const; 
 12 |     void set_weight(int in_weight);
 13 |     void set_height(int in_height);
 14 |     void make_sound(); 
 15 |   private:
 16 |     int weight; 
 17 |     int height; 
 18 | };
 19 | 
 20 | class dog: public animal {
 21 |   public:
 22 |     dog(int in_weight, int in_height, string in_house_address);
 23 |     void set_house_address(string in_house_address);
 24 |     string get_house_address() const;
 25 |     void make_sound(); 
 26 |     friend ostream &operator<<(ostream &left, const dog &right);
 27 |   private:
 28 |     string house_address; 
 29 | };
 30 | 
 31 | class cat: public animal {
 32 |   public:
 33 |     cat(int in_weight, int in_height);
 34 |     void make_sound(); 
 35 |     friend ostream &operator<<(ostream &left, const cat &right);
 36 | };
 37 | 
 38 | 
 39 | int main()
 40 | {
 41 |     dog piko(10,35,"Left Hill 154"); 
 42 |     cat kitty(6, 20);
 43 |     animal an(40, 80);
 44 |     
 45 |     piko.make_sound();
 46 |     kitty.make_sound();
 47 |     an.make_sound();
 48 |     
 49 |     return 0; 
 50 | }
 51 | 
 52 | 
 53 | animal::animal(int in_weight, int in_height)
 54 | {
 55 |     weight = in_weight; 
 56 |     height = in_height; 
 57 | }
 58 | 
 59 | void animal::set_weight(int in_weight)
 60 | {
 61 |     weight = in_weight; 
 62 | }
 63 | 
 64 | void animal::set_height(int in_height)
 65 | {
 66 |     height = in_height; 
 67 | }
 68 | 
 69 | int animal::get_weight() const
 70 | {
 71 |     return weight; 
 72 | }
 73 | 
 74 | int animal::get_height() const
 75 | {
 76 |     return height; 
 77 | }
 78 | 
 79 | void animal::make_sound() 
 80 | {
 81 |     cout<<"Animal sound"<<endl;
 82 | }
 83 | 
 84 | 
 85 | 
 86 | dog::dog(int in_weight, int in_height, string in_house_address):
 87 |   animal(in_weight, in_height)
 88 | {
 89 |     house_address=in_house_address; 
 90 | }
 91 | 
 92 | void dog::set_house_address(string in_house_address)
 93 | {
 94 |     house_address = in_house_address; 
 95 | }
 96 | 
 97 | string dog::get_house_address() const
 98 | {
 99 |     return house_address; 
100 | }
101 | 
102 | void dog::make_sound() 
103 | {
104 |     cout<<"Arf arf"<<endl;
105 | }
106 | 
107 | ostream &operator<<(ostream &left, const dog &right)
108 | {
109 |     left<<"weight: "<<right.get_weight()<<endl;  
110 |     left<<"height: "<<right.get_height()<<endl;  
111 |     left<<"address: "<<right.house_address<<endl; 
112 | }
113 | 
114 | 
115 | 
116 | cat::cat(int in_weight, int in_height):
117 |    animal(in_weight, in_height)
118 | {}
119 | 
120 | void cat::make_sound()
121 | {
122 |     cout<<"Meooooww"<<endl;
123 | }
124 | 
125 | ostream &operator<<(ostream &left, const cat &right)
126 | {
127 |     left<<"weight: "<<right.get_weight()<<endl;  
128 |     left<<"height: "<<right.get_height()<<endl;  
129 | }


--------------------------------------------------------------------------------
/lesson11/cpp11.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson11/cpp11.pdf


--------------------------------------------------------------------------------
/lesson11/cpp11.pointer_to_base_class1.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp11.pointer_to_base_class1.cpp */ 
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | class animal {
  8 |   public:
  9 |     animal(int in_weight, int in_height); 
 10 |     int get_weight() const; 
 11 |     int get_height() const; 
 12 |     void set_weight(int in_weight);
 13 |     void set_height(int in_height);
 14 |     void make_sound(); 
 15 |   private:
 16 |     int weight; 
 17 |     int height; 
 18 | };
 19 | 
 20 | class dog: public animal {
 21 |   public:
 22 |     dog(int in_weight, int in_height, string in_house_address);
 23 |     void set_house_address(string in_house_address);
 24 |     string get_house_address() const;
 25 |     void make_sound(); 
 26 |     friend ostream &operator<<(ostream &left, const dog &right);
 27 |   private:
 28 |     string house_address; 
 29 | };
 30 | 
 31 | class cat: public animal {
 32 |   public:
 33 |     cat(int in_weight, int in_height);
 34 |     void make_sound(); 
 35 |     friend ostream &operator<<(ostream &left, const cat &right);
 36 | };
 37 | 
 38 | 
 39 | int main()
 40 | {
 41 |     animal *bpd= new dog(10,35,"Left Hill 154");
 42 |     animal *bpc= new cat(6, 20);
 43 |     animal *bpa=new animal(40, 80);
 44 |     
 45 |     bpd->make_sound();
 46 |     bpc->make_sound();
 47 |     bpa->make_sound();
 48 |     
 49 |     delete bpd; 
 50 |     delete bpc; 
 51 |     delete bpa; 
 52 | 
 53 |     return 0; 
 54 | }
 55 | 
 56 | 
 57 | animal::animal(int in_weight, int in_height)
 58 | {
 59 |     weight = in_weight; 
 60 |     height = in_height; 
 61 | }
 62 | 
 63 | void animal::set_weight(int in_weight)
 64 | {
 65 |     weight = in_weight; 
 66 | }
 67 | 
 68 | void animal::set_height(int in_height)
 69 | {
 70 |     height = in_height; 
 71 | }
 72 | 
 73 | int animal::get_weight() const
 74 | {
 75 |     return weight; 
 76 | }
 77 | 
 78 | int animal::get_height() const
 79 | {
 80 |     return height; 
 81 | }
 82 | 
 83 | void animal::make_sound() 
 84 | {
 85 |     cout<<"Animal sound"<<endl;
 86 | }
 87 | 
 88 | 
 89 | 
 90 | dog::dog(int in_weight, int in_height, string in_house_address):
 91 |   animal(in_weight, in_height)
 92 | {
 93 |     house_address=in_house_address; 
 94 | }
 95 | 
 96 | void dog::set_house_address(string in_house_address)
 97 | {
 98 |     house_address = in_house_address; 
 99 | }
100 | 
101 | string dog::get_house_address() const
102 | {
103 |     return house_address; 
104 | }
105 | 
106 | void dog::make_sound() 
107 | {
108 |     cout<<"Arf arf"<<endl;
109 | }
110 | 
111 | ostream &operator<<(ostream &left, const dog &right)
112 | {
113 |     left<<"weight: "<<right.get_weight()<<endl;  
114 |     left<<"height: "<<right.get_height()<<endl;  
115 |     left<<"address: "<<right.house_address<<endl; 
116 | }
117 | 
118 | 
119 | 
120 | cat::cat(int in_weight, int in_height):
121 |    animal(in_weight, in_height)
122 | {}
123 | 
124 | void cat::make_sound()
125 | {
126 |     cout<<"Meooooww"<<endl;
127 | }
128 | 
129 | ostream &operator<<(ostream &left, const cat &right)
130 | {
131 |     left<<"weight: "<<right.get_weight()<<endl;  
132 |     left<<"height: "<<right.get_height()<<endl;  
133 | }


--------------------------------------------------------------------------------
/lesson11/cpp11.pointer_to_base_class2.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp11.pointer_to_base_class2.cpp */ 
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | class animal {
  8 |   public:
  9 |     animal(int in_weight, int in_height); 
 10 |     int get_weight() const; 
 11 |     int get_height() const; 
 12 |     void set_weight(int in_weight);
 13 |     void set_height(int in_height);
 14 |     void make_sound(); 
 15 |   private:
 16 |     int weight; 
 17 |     int height; 
 18 | };
 19 | 
 20 | class dog: public animal {
 21 |   public:
 22 |     dog(int in_weight, int in_height, string in_house_address);
 23 |     void set_house_address(string in_house_address);
 24 |     string get_house_address() const;
 25 |     void make_sound(); 
 26 |     friend ostream &operator<<(ostream &left, const dog &right);
 27 |   private:
 28 |     string house_address; 
 29 | };
 30 | 
 31 | class cat: public animal {
 32 |   public:
 33 |     cat(int in_weight, int in_height);
 34 |     void make_sound(); 
 35 |     friend ostream &operator<<(ostream &left, const cat &right);
 36 | };
 37 | 
 38 | 
 39 | int main()
 40 | {
 41 |     animal *pin[3];
 42 |     pin[0] = new dog(10,35,"Left Hill 154");
 43 |     pin[1] = new cat(6, 20);
 44 |     pin[2] = new animal(40, 80);
 45 |     
 46 |     for (int i=0; i<3; i++)
 47 |         pin[i]->make_sound();
 48 |   
 49 |     return 0; 
 50 | }
 51 | 
 52 | 
 53 | 
 54 | animal::animal(int in_weight, int in_height)
 55 | {
 56 |     weight = in_weight; 
 57 |     height = in_height; 
 58 | }
 59 | 
 60 | void animal::set_weight(int in_weight)
 61 | {
 62 |     weight = in_weight; 
 63 | }
 64 | 
 65 | void animal::set_height(int in_height)
 66 | {
 67 |     height = in_height; 
 68 | }
 69 | 
 70 | int animal::get_weight() const
 71 | {
 72 |     return weight; 
 73 | }
 74 | 
 75 | int animal::get_height() const
 76 | {
 77 |     return height; 
 78 | }
 79 | 
 80 | void animal::make_sound() 
 81 | {
 82 |     cout<<"Animal sound"<<endl;
 83 | }
 84 | 
 85 | 
 86 | 
 87 | dog::dog(int in_weight, int in_height, string in_house_address):
 88 |   animal(in_weight, in_height)
 89 | {
 90 |     house_address=in_house_address; 
 91 | }
 92 | 
 93 | void dog::set_house_address(string in_house_address)
 94 | {
 95 |     house_address = in_house_address; 
 96 | }
 97 | 
 98 | string dog::get_house_address() const
 99 | {
100 |     return house_address; 
101 | }
102 | 
103 | void dog::make_sound() 
104 | {
105 |     cout<<"Arf arf"<<endl;
106 | }
107 | 
108 | ostream &operator<<(ostream &left, const dog &right)
109 | {
110 |     left<<"weight: "<<right.get_weight()<<endl;  
111 |     left<<"height: "<<right.get_height()<<endl;  
112 |     left<<"address: "<<right.house_address<<endl; 
113 | }
114 | 
115 | 
116 | 
117 | cat::cat(int in_weight, int in_height):
118 |    animal(in_weight, in_height)
119 | {}
120 | 
121 | void cat::make_sound()
122 | {
123 |     cout<<"Meooooww"<<endl;
124 | }
125 | 
126 | ostream &operator<<(ostream &left, const cat &right)
127 | {
128 |     left<<"weight: "<<right.get_weight()<<endl;  
129 |     left<<"height: "<<right.get_height()<<endl;  
130 | }


--------------------------------------------------------------------------------
/lesson11/cpp11.virtual_destructor_derived_pointer.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp11.virtual_destructor_derived_pointer.cpp */ 
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | class animal {
  8 |   public:
  9 |     animal(int in_weight, int in_height); 
 10 |     virtual ~animal(); 
 11 |     int get_weight() const; 
 12 |     int get_height() const; 
 13 |     void set_weight(int in_weight);
 14 |     void set_height(int in_height);
 15 |     void make_sound(); 
 16 |   private:
 17 |     int weight; 
 18 |     int height; 
 19 | };
 20 | 
 21 | class dog: public animal {
 22 |   public:
 23 |     dog(int in_weight, int in_height, string in_house_address);
 24 |     ~dog(); 
 25 |     void set_house_address(string in_house_address);
 26 |     string get_house_address() const;
 27 |     void make_sound(); 
 28 |     friend ostream &operator<<(ostream &left, const dog &right);
 29 |   private:
 30 |     string house_address; 
 31 | };
 32 | 
 33 | class cat: public animal {
 34 |   public:
 35 |     cat(int in_weight, int in_height);
 36 |     void make_sound(); 
 37 |     friend ostream &operator<<(ostream &left, const cat &right);
 38 | };
 39 | 
 40 | 
 41 | int main()
 42 | {
 43 |     animal *bp = new dog(10,35,"Left Hill 154");
 44 | 
 45 |     delete bp;
 46 |     
 47 |     return 0; 
 48 | }
 49 | 
 50 | 
 51 | animal::animal(int in_weight, int in_height)
 52 | {
 53 |     weight = in_weight; 
 54 |     height = in_height; 
 55 | }
 56 | 
 57 | animal::~animal()
 58 | {
 59 |     cout<<"Destructing animal...";
 60 | }
 61 | 
 62 | void animal::set_weight(int in_weight)
 63 | {
 64 |     weight = in_weight; 
 65 | }
 66 | 
 67 | void animal::set_height(int in_height)
 68 | {
 69 |     height = in_height; 
 70 | }
 71 | 
 72 | int animal::get_weight() const
 73 | {
 74 |     return weight; 
 75 | }
 76 | 
 77 | int animal::get_height() const
 78 | {
 79 |     return height; 
 80 | }
 81 | 
 82 | void animal::make_sound() 
 83 | {
 84 |     cout<<"Animal sound"<<endl;
 85 | }
 86 | 
 87 | 
 88 | 
 89 | dog::dog(int in_weight, int in_height, string in_house_address):
 90 |   animal(in_weight, in_height)
 91 | {
 92 |     house_address=in_house_address; 
 93 | }
 94 | 
 95 | dog::~dog()
 96 | {
 97 |     cout<<"Destructing dog...";
 98 | }
 99 | 
100 | void dog::set_house_address(string in_house_address)
101 | {
102 |     house_address = in_house_address; 
103 | }
104 | 
105 | string dog::get_house_address() const
106 | {
107 |     return house_address; 
108 | }
109 | 
110 | void dog::make_sound() 
111 | {
112 |     cout<<"Arf arf"<<endl;
113 | }
114 | 
115 | ostream &operator<<(ostream &left, const dog &right)
116 | {
117 |     left<<"weight: "<<right.get_weight()<<endl;  
118 |     left<<"height: "<<right.get_height()<<endl;  
119 |     left<<"address: "<<right.house_address<<endl; 
120 | }
121 | 
122 | 
123 | 
124 | cat::cat(int in_weight, int in_height):
125 |    animal(in_weight, in_height)
126 | {}
127 | 
128 | void cat::make_sound()
129 | {
130 |     cout<<"Meooooww"<<endl;
131 | }
132 | 
133 | ostream &operator<<(ostream &left, const cat &right)
134 | {
135 |     left<<"weight: "<<right.get_weight()<<endl;  
136 |     left<<"height: "<<right.get_height()<<endl;  
137 | }


--------------------------------------------------------------------------------
/lesson11/cpp11.virtual_method.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp11.virtual_method.cpp */ 
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | class animal {
  8 |   public:
  9 |     animal(int in_weight, int in_height); 
 10 |     int get_weight() const; 
 11 |     int get_height() const; 
 12 |     void set_weight(int in_weight);
 13 |     void set_height(int in_height);
 14 |     virtual void make_sound(); 
 15 |   private:
 16 |     int weight; 
 17 |     int height; 
 18 | };
 19 | 
 20 | class dog: public animal {
 21 |   public:
 22 |     dog(int in_weight, int in_height, string in_house_address);
 23 |     void set_house_address(string in_house_address);
 24 |     string get_house_address() const;
 25 |     void make_sound(); 
 26 |     friend ostream &operator<<(ostream &left, const dog &right);
 27 |   private:
 28 |     string house_address; 
 29 | };
 30 | 
 31 | class cat: public animal {
 32 |   public:
 33 |     cat(int in_weight, int in_height);
 34 |     void make_sound(); 
 35 |     friend ostream &operator<<(ostream &left, const cat &right);
 36 | };
 37 | 
 38 | 
 39 | int main()
 40 | {
 41 |     animal *pin[3];
 42 |     pin[0] = new dog(10,35,"Left Hill 154");
 43 |     pin[1] = new cat(6, 20);
 44 |     pin[2] = new animal(40, 80);
 45 |     
 46 |     for (int i=0; i<3; i++)
 47 |         pin[i]->make_sound();
 48 | 
 49 |     for (int i=0; i<3; i++)
 50 |         delete pin[i];  
 51 | 
 52 |     return 0; 
 53 | }
 54 | 
 55 | 
 56 | 
 57 | animal::animal(int in_weight, int in_height)
 58 | {
 59 |     weight = in_weight; 
 60 |     height = in_height; 
 61 | }
 62 | 
 63 | void animal::set_weight(int in_weight)
 64 | {
 65 |     weight = in_weight; 
 66 | }
 67 | 
 68 | void animal::set_height(int in_height)
 69 | {
 70 |     height = in_height; 
 71 | }
 72 | 
 73 | int animal::get_weight() const
 74 | {
 75 |     return weight; 
 76 | }
 77 | 
 78 | int animal::get_height() const
 79 | {
 80 |     return height; 
 81 | }
 82 | 
 83 | void animal::make_sound() 
 84 | {
 85 |     cout<<"Animal sound"<<endl;
 86 | }
 87 | 
 88 | 
 89 | 
 90 | dog::dog(int in_weight, int in_height, string in_house_address):
 91 |   animal(in_weight, in_height)
 92 | {
 93 |     house_address=in_house_address; 
 94 | }
 95 | 
 96 | void dog::set_house_address(string in_house_address)
 97 | {
 98 |     house_address = in_house_address; 
 99 | }
100 | 
101 | string dog::get_house_address() const
102 | {
103 |     return house_address; 
104 | }
105 | 
106 | void dog::make_sound() 
107 | {
108 |     cout<<"Arf arf"<<endl;
109 | }
110 | 
111 | ostream &operator<<(ostream &left, const dog &right)
112 | {
113 |     left<<"weight: "<<right.get_weight()<<endl;  
114 |     left<<"height: "<<right.get_height()<<endl;  
115 |     left<<"address: "<<right.house_address<<endl; 
116 | }
117 | 
118 | 
119 | 
120 | cat::cat(int in_weight, int in_height):
121 |    animal(in_weight, in_height)
122 | {}
123 | 
124 | void cat::make_sound()
125 | {
126 |     cout<<"Meooooww"<<endl;
127 | }
128 | 
129 | ostream &operator<<(ostream &left, const cat &right)
130 | {
131 |     left<<"weight: "<<right.get_weight()<<endl;  
132 |     left<<"height: "<<right.get_height()<<endl;  
133 | }


--------------------------------------------------------------------------------
/lesson11/cpp11.virtual_method_object.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp11.virtual_method_object.cpp */ 
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | class animal {
  8 |   public:
  9 |     animal(int in_weight, int in_height); 
 10 |     int get_weight() const; 
 11 |     int get_height() const; 
 12 |     void set_weight(int in_weight);
 13 |     void set_height(int in_height);
 14 |     virtual void make_sound(); 
 15 |   private:
 16 |     int weight; 
 17 |     int height; 
 18 | };
 19 | 
 20 | class dog: public animal {
 21 |   public:
 22 |     dog(int in_weight, int in_height, string in_house_address);
 23 |     void set_house_address(string in_house_address);
 24 |     string get_house_address() const;
 25 |     void make_sound(); 
 26 |     friend ostream &operator<<(ostream &left, const dog &right);
 27 |   private:
 28 |     string house_address; 
 29 | };
 30 | 
 31 | class cat: public animal {
 32 |   public:
 33 |     cat(int in_weight, int in_height);
 34 |     void make_sound(); 
 35 |     friend ostream &operator<<(ostream &left, const cat &right);
 36 | };
 37 | 
 38 | 
 39 | int main()
 40 | {
 41 |     animal pin[3] = {
 42 |         dog(10,35,"Left Hill 154"),
 43 |         cat(6, 20),
 44 |         animal(40, 80)
 45 |     };
 46 | 
 47 |     for (int i=0; i<3; i++)
 48 |         pin[i].make_sound();
 49 |   
 50 |     return 0; 
 51 | }
 52 | 
 53 | 
 54 | 
 55 | animal::animal(int in_weight, int in_height)
 56 | {
 57 |     weight = in_weight; 
 58 |     height = in_height; 
 59 | }
 60 | 
 61 | void animal::set_weight(int in_weight)
 62 | {
 63 |     weight = in_weight; 
 64 | }
 65 | 
 66 | void animal::set_height(int in_height)
 67 | {
 68 |     height = in_height; 
 69 | }
 70 | 
 71 | int animal::get_weight() const
 72 | {
 73 |     return weight; 
 74 | }
 75 | 
 76 | int animal::get_height() const
 77 | {
 78 |     return height; 
 79 | }
 80 | 
 81 | void animal::make_sound() 
 82 | {
 83 |     cout<<"Animal sound"<<endl;
 84 | }
 85 | 
 86 | 
 87 | 
 88 | dog::dog(int in_weight, int in_height, string in_house_address):
 89 |   animal(in_weight, in_height)
 90 | {
 91 |     house_address=in_house_address; 
 92 | }
 93 | 
 94 | void dog::set_house_address(string in_house_address)
 95 | {
 96 |     house_address = in_house_address; 
 97 | }
 98 | 
 99 | string dog::get_house_address() const
100 | {
101 |     return house_address; 
102 | }
103 | 
104 | void dog::make_sound() 
105 | {
106 |     cout<<"Arf arf"<<endl;
107 | }
108 | 
109 | ostream &operator<<(ostream &left, const dog &right)
110 | {
111 |     left<<"weight: "<<right.get_weight()<<endl;  
112 |     left<<"height: "<<right.get_height()<<endl;  
113 |     left<<"address: "<<right.house_address<<endl; 
114 | }
115 | 
116 | 
117 | 
118 | cat::cat(int in_weight, int in_height):
119 |    animal(in_weight, in_height)
120 | {}
121 | 
122 | void cat::make_sound()
123 | {
124 |     cout<<"Meooooww"<<endl;
125 | }
126 | 
127 | ostream &operator<<(ostream &left, const cat &right)
128 | {
129 |     left<<"weight: "<<right.get_weight()<<endl;  
130 |     left<<"height: "<<right.get_height()<<endl;  
131 | }


--------------------------------------------------------------------------------
/lesson11/cpp11.virtual_method_reference.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp11.virtual_method_reference.cpp */ 
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | class animal {
  8 |   public:
  9 |     animal(int in_weight, int in_height); 
 10 |     int get_weight() const; 
 11 |     int get_height() const; 
 12 |     void set_weight(int in_weight);
 13 |     void set_height(int in_height);
 14 |     virtual void make_sound(); 
 15 |   private:
 16 |     int weight; 
 17 |     int height; 
 18 | };
 19 | 
 20 | class dog: public animal {
 21 |   public:
 22 |     dog(int in_weight, int in_height, string in_house_address);
 23 |     void set_house_address(string in_house_address);
 24 |     string get_house_address() const;
 25 |     void make_sound(); 
 26 |     friend ostream &operator<<(ostream &left, const dog &right);
 27 |   private:
 28 |     string house_address; 
 29 | };
 30 | 
 31 | class cat: public animal {
 32 |   public:
 33 |     cat(int in_weight, int in_height);
 34 |     void make_sound(); 
 35 |     friend ostream &operator<<(ostream &left, const cat &right);
 36 | };
 37 | 
 38 | void f(animal &ob)
 39 | {
 40 |     ob.make_sound(); 
 41 | }
 42 | 
 43 | int main()
 44 | {
 45 |     dog d(10,35,"Left Hill 154");
 46 | 
 47 |     f(d); 
 48 |     
 49 |     return 0; 
 50 | }
 51 | 
 52 | 
 53 | 
 54 | animal::animal(int in_weight, int in_height)
 55 | {
 56 |     weight = in_weight; 
 57 |     height = in_height; 
 58 | }
 59 | 
 60 | void animal::set_weight(int in_weight)
 61 | {
 62 |     weight = in_weight; 
 63 | }
 64 | 
 65 | void animal::set_height(int in_height)
 66 | {
 67 |     height = in_height; 
 68 | }
 69 | 
 70 | int animal::get_weight() const
 71 | {
 72 |     return weight; 
 73 | }
 74 | 
 75 | int animal::get_height() const
 76 | {
 77 |     return height; 
 78 | }
 79 | 
 80 | void animal::make_sound() 
 81 | {
 82 |     cout<<"Animal sound"<<endl;
 83 | }
 84 | 
 85 | 
 86 | 
 87 | dog::dog(int in_weight, int in_height, string in_house_address):
 88 |   animal(in_weight, in_height)
 89 | {
 90 |     house_address=in_house_address; 
 91 | }
 92 | 
 93 | void dog::set_house_address(string in_house_address)
 94 | {
 95 |     house_address = in_house_address; 
 96 | }
 97 | 
 98 | string dog::get_house_address() const
 99 | {
100 |     return house_address; 
101 | }
102 | 
103 | void dog::make_sound() 
104 | {
105 |     cout<<"Arf arf"<<endl;
106 | }
107 | 
108 | ostream &operator<<(ostream &left, const dog &right)
109 | {
110 |     left<<"weight: "<<right.get_weight()<<endl;  
111 |     left<<"height: "<<right.get_height()<<endl;  
112 |     left<<"address: "<<right.house_address<<endl; 
113 | }
114 | 
115 | 
116 | 
117 | cat::cat(int in_weight, int in_height):
118 |    animal(in_weight, in_height)
119 | {}
120 | 
121 | void cat::make_sound()
122 | {
123 |     cout<<"Meooooww"<<endl;
124 | }
125 | 
126 | ostream &operator<<(ostream &left, const cat &right)
127 | {
128 |     left<<"weight: "<<right.get_weight()<<endl;  
129 |     left<<"height: "<<right.get_height()<<endl;  
130 | }


--------------------------------------------------------------------------------
/lesson12/cpp12(4sl).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson12/cpp12(4sl).pdf


--------------------------------------------------------------------------------
/lesson12/cpp12.askisi1.1.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp12.askisi1.1.cpp */
 2 | #include <iostream>
 3 | #include <string>
 4 | using namespace std;
 5 | 
 6 | 
 7 | class movie {
 8 |   public:
 9 |     movie(string in_title, double in_imdb_score, int in_weeks);
10 |     virtual double score(); 
11 |   private:
12 |     string title; 
13 |     double imdb_score; 
14 |     int weeks; 
15 | };
16 | 
17 | 
18 | class thriller: public movie {
19 |   public:
20 |     thriller(string in_title, double in_imdb_score, int in_weeks, double in_fear_factor);
21 |     double score(); 
22 |   private:
23 |     double fear_factor; 
24 | };
25 | 
26 | 
27 | int main()
28 | {
29 |     thriller m1("It Chapter 2", 6.8, 10, 8.0);
30 |     thriller m2("Us", 6.9, 30, 7.0);
31 |     thriller m3("The Silence of Lambs", 8.6, 1540, 9.0);
32 |     
33 |     cout<<m1.score()<<endl; 
34 |     cout<<m2.score()<<endl; 
35 |     cout<<m3.score()<<endl; 
36 |     
37 |     return 0;
38 | }
39 | 
40 | movie::movie(string in_title, double in_imdb_score, int in_weeks)
41 | {
42 |     title = in_title;
43 |     imdb_score = in_imdb_score;
44 |     weeks = in_weeks; 
45 | }
46 | 
47 | double movie::score()
48 | {
49 |     return imdb_score/(0.5*weeks);
50 | }
51 | 
52 | 
53 | thriller::thriller(string in_title, double in_imdb_score, int in_weeks, double in_fear_factor):
54 |    movie(in_title, in_imdb_score, in_weeks)
55 | {
56 |     fear_factor = in_fear_factor; 
57 | }
58 | 
59 | double thriller::score()
60 | {
61 |     return fear_factor*movie::score();
62 | }


--------------------------------------------------------------------------------
/lesson12/cpp12.askisi1.2.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp12.askisi1.2 */
  2 | #include <iostream>
  3 | #include <string>
  4 | using namespace std;
  5 | 
  6 | 
  7 | class movie {
  8 |   public:
  9 |     movie();
 10 |     movie(string in_title, double in_imdb_score, int in_weeks);
 11 |     virtual double score(); 
 12 |   private:
 13 |     string title; 
 14 |     double imdb_score; 
 15 |     int weeks; 
 16 | };
 17 | 
 18 | 
 19 | class thriller: virtual public movie {
 20 |   public:
 21 |     thriller(double in_fear_factor);
 22 |     thriller(string in_title, double in_imdb_score, int in_weeks, double in_fear_factor);
 23 |     virtual double score(); 
 24 |   protected:
 25 |     double fear_factor; 
 26 | };
 27 | 
 28 | 
 29 | class comedy: virtual public movie {
 30 |   public:
 31 |     comedy(double in_fun_factor);
 32 |     comedy(string in_title, double in_imdb_score, int in_weeks, double in_fun_factor);
 33 |     virtual double score(); 
 34 |   protected:
 35 |     double fun_factor; 
 36 | };
 37 | 
 38 | class comedy_thriller: public thriller, public comedy {
 39 |   public:
 40 |     comedy_thriller(string in_title, double in_imdb_score, int in_weeks, double in_fear_factor, double in_fun_factor);
 41 |     double score();
 42 | };
 43 | 
 44 | 
 45 | int main()
 46 | {
 47 |     thriller m1("It Chapter 2", 6.8, 10, 8.0);
 48 |     thriller m2("Us", 6.9, 30, 7.0);
 49 |     thriller m3("The Silence of Lambs", 8.6, 1540, 9.0);
 50 |     comedy m4("Jexi", 6.6, 4, 3.0);
 51 |     comedy_thriller m5("Addams Family", 5.9, 5, 3.0, 4.0);
 52 |     comedy_thriller m6("Shaun of the Dead", 7.9, 825, 4.0, 9.0);
 53 |     
 54 |     cout<<m1.score()<<endl; 
 55 |     cout<<m2.score()<<endl; 
 56 |     cout<<m3.score()<<endl; 
 57 |     cout<<m4.score()<<endl; 
 58 |     cout<<m5.score()<<endl; 
 59 |     cout<<m6.score()<<endl; 
 60 |     
 61 |     return 0;
 62 | }
 63 | 
 64 | movie::movie()
 65 | {}
 66 | 
 67 | movie::movie(string in_title, double in_imdb_score, int in_weeks)
 68 | {
 69 |     title = in_title;
 70 |     imdb_score = in_imdb_score;
 71 |     weeks = in_weeks; 
 72 | }
 73 | 
 74 | double movie::score()
 75 | {
 76 |     return imdb_score/(0.5*weeks);
 77 | }
 78 | 
 79 | 
 80 | thriller::thriller(double in_fear_factor)
 81 | {
 82 |     fear_factor = in_fear_factor; 
 83 | }
 84 | 
 85 | thriller::thriller(string in_title, double in_imdb_score, int in_weeks, double in_fear_factor):
 86 |    movie(in_title, in_imdb_score, in_weeks)
 87 | {
 88 |     fear_factor = in_fear_factor; 
 89 | }
 90 | 
 91 | double thriller::score()
 92 | {
 93 |     return fear_factor*movie::score();
 94 | }
 95 | 
 96 | 
 97 | comedy::comedy(double in_fun_factor)
 98 | {
 99 |     fun_factor = in_fun_factor; 
100 | }
101 | 
102 | comedy::comedy(string in_title, double in_imdb_score, int in_weeks, double in_fun_factor):
103 |    movie(in_title, in_imdb_score, in_weeks)
104 | {
105 |     fun_factor = in_fun_factor; 
106 | }
107 | 
108 | 
109 | double comedy::score()
110 | {
111 |     return fun_factor*movie::score();
112 | }
113 | 
114 | 
115 | comedy_thriller::comedy_thriller(string in_title, double in_imdb_score, int in_weeks, double in_fear_factor, double in_fun_factor):
116 |   movie(in_title, in_imdb_score, in_weeks), thriller(in_fear_factor), comedy(in_fun_factor)
117 | { }
118 | 
119 | double comedy_thriller::score()
120 | {
121 |     return ((fun_factor+fear_factor)/2)*movie::score();
122 | }
123 | 
124 | 
125 | 


--------------------------------------------------------------------------------
/lesson12/cpp12.askisi2.1.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp12.askisi2.1.cpp */ 
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | class person {
 8 |   public:
 9 |     person(); 
10 |     person(string in_name, int in_salary);
11 |   private:
12 |     string name; 
13 |     int salary; 
14 | };
15 | 
16 | class barista: virtual public person {
17 |   public:
18 |     barista(); 
19 |     barista(string in_name, int in_salary);
20 |     void prepare();
21 |   private:
22 | };
23 | 
24 | class waiter: virtual public person {
25 |   public:
26 |     waiter(); 
27 |     waiter(string in_name, int in_salary);
28 |     void serve(int customers, barista &b);
29 |   private:
30 |     int customers_served; 
31 | };
32 | 
33 | class owner: public barista, public waiter {
34 |   public:
35 |     owner(string in_name, int in_salary);
36 |   private: 
37 |   
38 | };
39 | 
40 | int main()
41 | {
42 |     
43 |     return 0; 
44 | }
45 | 
46 | person::person(string in_name, int in_salary)
47 | {
48 |     name=in_name;
49 |     salary=in_salary;
50 | }
51 | 
52 | person::person()
53 | {}
54 | 
55 | 
56 | waiter::waiter(string in_name, int in_salary):
57 |   person(in_name, in_salary)
58 | {
59 |     customers_served=0; 
60 | }
61 | 
62 | waiter::waiter()
63 | {
64 |     customers_served=0; 
65 | }
66 | 
67 | void waiter::serve(int customers, barista &b)
68 | {
69 |     b.prepare(); 
70 |     customers+=customers; 
71 | }
72 | 
73 | 
74 | 
75 | barista::barista(string in_name, int in_salary):
76 |   person(in_name, in_salary)
77 | {
78 |     
79 | }
80 | 
81 | barista::barista()
82 | {}
83 | 
84 | 
85 | void barista::prepare()
86 | {
87 |     // cout<<....
88 | }
89 | 
90 | 
91 | owner::owner(string in_name, int in_salary):
92 |   person(in_name, in_salary)
93 | { }
94 | 


--------------------------------------------------------------------------------
/lesson12/cpp12.askisi2.2.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp12.askisi2.2.cpp */ 
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | #include <cstdlib>
  6 | #include <ctime>
  7 | using namespace std;
  8 | 
  9 | class person {
 10 |   public:
 11 |     person(); 
 12 |     person(string in_name, int in_salary);
 13 |   private:
 14 |     string name; 
 15 |     int salary; 
 16 | };
 17 | 
 18 | class barista: virtual public person {
 19 |   public:
 20 |     barista(); 
 21 |     barista(string in_name, int in_salary);
 22 |     void prepare();
 23 |   private:
 24 | };
 25 | 
 26 | class waiter: virtual public person {
 27 |   public:
 28 |     waiter(); 
 29 |     waiter(string in_name, int in_salary);
 30 |     void serve(int in_customers, barista &b);
 31 |     void print();
 32 |   private:
 33 |     int customers_served; 
 34 | };
 35 | 
 36 | class owner: public barista, public waiter {
 37 |   public:
 38 |     owner(string in_name, int in_salary);
 39 |   private: 
 40 |   
 41 | };
 42 | 
 43 | int main()
 44 | {
 45 |     int clients, waiter_to_serve, barista_to_serve;
 46 |     owner *o = new owner("Joe", 500);
 47 |     waiter *w1 = new waiter("Jack", 700);
 48 |     waiter *w2 = new waiter("Suzy", 1000);
 49 |     barista *b = new barista("bob", 400);
 50 |     
 51 |     waiter *waiters[3]={o,w1,w2};
 52 |     barista *baristas[2]={o,b};
 53 |     
 54 |     
 55 |     
 56 |     srand(time(NULL));
 57 |     for (int i=0; i<100; i++)
 58 |     {
 59 |         clients=1+rand()%5; 
 60 |         
 61 |         waiter_to_serve=rand()%3; 
 62 |         barista_to_serve=rand()%2;
 63 |         
 64 |         waiters[waiter_to_serve]->serve(clients, *baristas[barista_to_serve]);
 65 |     }
 66 |     
 67 |     for (int i=0; i<3; i++)
 68 |     {
 69 |         waiters[i]->print(); 
 70 |         cout<<endl; 
 71 |     }
 72 |     
 73 | 
 74 |     delete o;
 75 |     delete w1;
 76 |     delete w2;
 77 |     delete b;
 78 |     
 79 |     return 0; 
 80 | }
 81 | 
 82 | person::person(string in_name, int in_salary)
 83 | {
 84 |     name=in_name;
 85 |     salary=in_salary;
 86 | }
 87 | 
 88 | person::person()
 89 | {}
 90 | 
 91 | 
 92 | waiter::waiter(string in_name, int in_salary):
 93 |   person(in_name, in_salary)
 94 | {
 95 |     customers_served=0; 
 96 | }
 97 | 
 98 | waiter::waiter()
 99 | {
100 |     customers_served=0; 
101 | }
102 | 
103 | void waiter::serve(int in_customers, barista &b)
104 | {
105 |     b.prepare(); 
106 |     customers_served+=in_customers; 
107 | }
108 | 
109 | void waiter::print()
110 | {
111 |     cout<<customers_served; 
112 | }
113 | 
114 | 
115 | barista::barista(string in_name, int in_salary):
116 |   person(in_name, in_salary)
117 | {
118 |     
119 | }
120 | 
121 | barista::barista()
122 | {}
123 | 
124 | 
125 | void barista::prepare()
126 | {
127 |     // cout<<....
128 | }
129 | 
130 | 
131 | owner::owner(string in_name, int in_salary):
132 |   person(in_name, in_salary)
133 | { }
134 | 


--------------------------------------------------------------------------------
/lesson12/cpp12.diamond_problem.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp12.diamond_problem.cpp */
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | 
  8 | class person {
  9 |     public:
 10 |         person(string in_name);
 11 |     protected:
 12 |         string name; 
 13 | };
 14 | 
 15 | class king: public person {
 16 |     public:
 17 |         king(string in_name, string in_realm);
 18 |         void set_realm(string in_realm);
 19 |         void rule(); 
 20 |     protected:
 21 |         string realm; 
 22 | };
 23 | 
 24 | class philosopher: public person {
 25 |     public:
 26 |         philosopher(string in_name, string in_philosophy);
 27 |         void set_philosophy(string in_philosophy);
 28 |         void think(); 
 29 |     protected:
 30 |         string philosophy; 
 31 | };
 32 | 
 33 | class phil_king: public king, public philosopher {
 34 |     public:
 35 |         phil_king(string in_name, string in_realm, string in_philosophy);
 36 |         void routine();
 37 |         friend ostream &operator<<(ostream &left, phil_king right);
 38 | };
 39 | 
 40 | 
 41 | int main()
 42 | {
 43 |     phil_king The_King("Marcus Aurelius", "Roman Empire", "stoic");
 44 | 
 45 |     The_King.routine(); 
 46 | }
 47 | 
 48 | person::person(string in_name)
 49 | {
 50 |     name = in_name; 
 51 | }
 52 | 
 53 | king::king(string in_name, string in_realm):
 54 |     person(in_name)
 55 | {
 56 |     realm = in_realm; 
 57 | }
 58 | 
 59 | void king::set_realm(string in_realm)
 60 | {
 61 |     realm = in_realm; 
 62 | }
 63 | 
 64 | void king::rule()
 65 | {
 66 |     cout<<"Now, I rule"<<endl;
 67 | }
 68 | 
 69 | 
 70 | philosopher::philosopher(string in_name, string in_philosophy):
 71 |     person(in_name)
 72 | {
 73 |     philosophy = in_philosophy; 
 74 | }
 75 | 
 76 | void philosopher::set_philosophy(string in_philosophy)
 77 | {
 78 |     philosophy = in_philosophy;
 79 | }
 80 | 
 81 | void philosopher::think()
 82 | {
 83 |     cout<<"Now, I think"<<endl;
 84 | }
 85 | 
 86 | 
 87 | 
 88 | phil_king::phil_king(string in_name, string in_realm, string in_philosophy):
 89 |     king(in_name, in_realm), philosopher(in_name, in_philosophy)
 90 | {
 91 | }
 92 | 
 93 | void phil_king::routine()
 94 | {
 95 |     think();
 96 |     rule();
 97 |     think(); 
 98 | }
 99 | 
100 | ostream &operator<<(ostream &left, phil_king right)
101 | {
102 |     left<<right.name<<endl;
103 |     left<<"Ruling "<<right.realm<<endl; 
104 |     left<<"using "<<right.philosophy<<" philosophy"<<endl;
105 | }


--------------------------------------------------------------------------------
/lesson12/cpp12.mi_constructors.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp12.mi_constructors.cpp */
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | class king {
  8 |     public:
  9 |         king(string in_realm);
 10 |         ~king(); 
 11 |         void set_realm(string in_realm);
 12 |         void rule(); 
 13 |     private:
 14 |         string realm; 
 15 | };
 16 | 
 17 | class philosopher {
 18 |     public:
 19 |         philosopher(string in_philosophy);
 20 |         ~philosopher(); 
 21 |         void set_philosophy(string in_philosophy);
 22 |         void think(); 
 23 |     private:
 24 |         string philosophy; 
 25 | };
 26 | 
 27 | class phil_king: public king, public philosopher {
 28 |     public:
 29 |         phil_king(string in_realm, 
 30 |                           string in_philosophy);
 31 |         ~phil_king();     
 32 |         void routine();
 33 | };
 34 | 
 35 | 
 36 | int main()
 37 | {
 38 |     phil_king marcus_aurelius("Roman Empire", "stoic");
 39 | 
 40 |     marcus_aurelius.routine(); 
 41 | }
 42 | 
 43 | 
 44 | king::king(string in_realm)
 45 | {
 46 |     realm = in_realm; 
 47 |     cout<<"Constructing King"<<endl;
 48 | }
 49 | king::~king()
 50 | {
 51 |     cout<<"Destructing King"<<endl; 
 52 | }
 53 | 
 54 | void king::set_realm(string in_realm)
 55 | {
 56 |     realm = in_realm; 
 57 | }
 58 | 
 59 | void king::rule()
 60 | {
 61 |     cout<<"Now, I rule"<<endl;
 62 | }
 63 | 
 64 | 
 65 | 
 66 | philosopher::philosopher(string in_philosophy)
 67 | {
 68 |     philosophy = in_philosophy; 
 69 |     cout<<"Constructing Philosopher"<<endl;
 70 | }
 71 | philosopher::~philosopher()
 72 | {
 73 |     cout<<"Destructing Philosopher"<<endl;
 74 | }
 75 | 
 76 | void philosopher::set_philosophy(string in_philosophy)
 77 | {
 78 |     philosophy = in_philosophy;
 79 | }
 80 | 
 81 | void philosopher::think()
 82 | {
 83 |     cout<<"Now, I think"<<endl;
 84 | }
 85 | 
 86 | 
 87 | phil_king::phil_king(string in_realm, string in_philosophy):
 88 |     king(in_realm), philosopher(in_philosophy)
 89 | {
 90 |     cout<<"Constructing Philosopher King"<<endl;
 91 | }
 92 | phil_king::~phil_king() {
 93 |     cout<<"Destructing Philosopher King"<<endl;
 94 | }
 95 | 
 96 | void phil_king::routine()
 97 | {
 98 |     think();
 99 |     rule();
100 |     think(); 
101 | }
102 | 


--------------------------------------------------------------------------------
/lesson12/cpp12.multiple_inheritance.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp12.multiple_inheritance.cpp */
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | class king {
 8 |     public:
 9 |         void set_realm(string in_realm);
10 |         void rule(); 
11 |     private:
12 |         string realm; 
13 | };
14 | 
15 | class philosopher {
16 |     public:
17 |         void set_philosophy(string in_philosophy);
18 |         void think(); 
19 |     private:
20 |         string philosophy; 
21 | };
22 | 
23 | class phil_king: public king, public philosopher {
24 |     public:
25 |         void routine();
26 | };
27 | 
28 | 
29 | int main()
30 | {
31 |     phil_king marcus_aurelius;
32 |     
33 |     marcus_aurelius.set_realm("Roman Empire");
34 |     marcus_aurelius.set_philosophy("stoic");
35 |     
36 |     marcus_aurelius.routine(); 
37 | }
38 | 
39 | void king::set_realm(string in_realm)
40 | {
41 |     realm = in_realm; 
42 | }
43 | 
44 | void king::rule()
45 | {
46 |     cout<<"Now, I rule"<<endl;
47 | }
48 | 
49 | 
50 | void philosopher::set_philosophy(string in_philosophy)
51 | {
52 |     philosophy = in_philosophy;
53 | }
54 | 
55 | void philosopher::think()
56 | {
57 |     cout<<"Now, I think"<<endl;
58 | }
59 | 
60 | void phil_king::routine()
61 | {
62 |     think();
63 |     rule();
64 |     think(); 
65 | }
66 | 


--------------------------------------------------------------------------------
/lesson12/cpp12.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson12/cpp12.pdf


--------------------------------------------------------------------------------
/lesson12/cpp12.use_of_resolution_scope_operator.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp12.use_of_resolution_scope_operator.cpp */
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | 
  8 | class person {
  9 |     public:
 10 |         person(string in_name);
 11 |     protected:
 12 |         string name; 
 13 | };
 14 | 
 15 | class king: public person {
 16 |     public:
 17 |         king(string in_name, string in_realm);
 18 |         void set_realm(string in_realm);
 19 |         void rule(); 
 20 |     protected:
 21 |         string realm; 
 22 | };
 23 | 
 24 | class philosopher: public person {
 25 |     public:
 26 |         philosopher(string in_name, string in_philosophy);
 27 |         void set_philosophy(string in_philosophy);
 28 |         void think(); 
 29 |     protected:
 30 |         string philosophy; 
 31 | };
 32 | 
 33 | class phil_king: public king, public philosopher {
 34 |     public:
 35 |         phil_king(string in_name, string in_realm, string in_philosophy);
 36 |         void routine();
 37 |         friend ostream &operator<<(ostream &left, phil_king right);
 38 | };
 39 | 
 40 | 
 41 | int main()
 42 | {
 43 |     phil_king The_King("Marcus Aurelius", "Roman Empire", "stoic");
 44 | 
 45 |     The_King.routine(); 
 46 | }
 47 | 
 48 | person::person(string in_name)
 49 | {
 50 |     name = in_name; 
 51 | }
 52 | 
 53 | king::king(string in_name, string in_realm):
 54 |     person(in_name)
 55 | {
 56 |     realm = in_realm; 
 57 | }
 58 | 
 59 | void king::set_realm(string in_realm)
 60 | {
 61 |     realm = in_realm; 
 62 | }
 63 | 
 64 | void king::rule()
 65 | {
 66 |     cout<<"Now, I rule"<<endl;
 67 | }
 68 | 
 69 | 
 70 | philosopher::philosopher(string in_name, string in_philosophy):
 71 |     person(in_name)
 72 | {
 73 |     philosophy = in_philosophy; 
 74 | }
 75 | 
 76 | void philosopher::set_philosophy(string in_philosophy)
 77 | {
 78 |     philosophy = in_philosophy;
 79 | }
 80 | 
 81 | void philosopher::think()
 82 | {
 83 |     cout<<"Now, I think"<<endl;
 84 | }
 85 | 
 86 | 
 87 | 
 88 | phil_king::phil_king(string in_name, string in_realm, string in_philosophy):
 89 |     king(in_name, in_realm), philosopher(in_name, in_philosophy)
 90 | {
 91 | }
 92 | 
 93 | void phil_king::routine()
 94 | {
 95 |     think();
 96 |     rule();
 97 |     think(); 
 98 | }
 99 | 
100 | ostream &operator<<(ostream &left, phil_king right)
101 | {
102 |     left<<right.philosopher::name<<endl;
103 |     left<<"Ruling "<<right.realm<<endl; 
104 |     left<<"using "<<right.philosophy<<" philosophy"<<endl;
105 | }


--------------------------------------------------------------------------------
/lesson12/cpp12.virtual_class.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp12.virtual_class.cpp */
  2 | 
  3 | #include <iostream>
  4 | #include <string>
  5 | using namespace std;
  6 | 
  7 | 
  8 | class person {
  9 |     public:
 10 |         person(); 
 11 |         person(string in_name);
 12 |     protected:
 13 |         string name; 
 14 | };
 15 | 
 16 | class king: virtual public person {
 17 |     public:
 18 |         king(string in_realm);
 19 |         void set_realm(string in_realm);
 20 |         void rule(); 
 21 |     protected:
 22 |         string realm; 
 23 | };
 24 | 
 25 | class philosopher: virtual public person {
 26 |     public:
 27 |         philosopher(string in_philosophy);
 28 |         void set_philosophy(string in_philosophy);
 29 |         void think(); 
 30 |     protected:
 31 |         string philosophy; 
 32 | };
 33 | 
 34 | class phil_king: public king, public philosopher {
 35 |     public:
 36 |         phil_king(string in_name, string in_realm, string in_philosophy);
 37 |         void routine();
 38 |         friend ostream &operator<<(ostream &left, phil_king right);
 39 | };
 40 | 
 41 | 
 42 | int main()
 43 | {
 44 |     phil_king The_King("Marcus Aurelius", "Roman Empire", "stoic");
 45 | 
 46 |     The_King.routine(); 
 47 | }
 48 | 
 49 | person::person() 
 50 | {}
 51 | 
 52 | person::person(string in_name)
 53 | {
 54 |     name = in_name; 
 55 | }
 56 | 
 57 | 
 58 | king::king(string in_realm)
 59 | {
 60 |     realm = in_realm; 
 61 | }
 62 | 
 63 | void king::set_realm(string in_realm)
 64 | {
 65 |     realm = in_realm; 
 66 | }
 67 | 
 68 | void king::rule()
 69 | {
 70 |     cout<<"Now, I rule"<<endl;
 71 | }
 72 | 
 73 | 
 74 | philosopher::philosopher(string in_philosophy)
 75 | {
 76 |     philosophy = in_philosophy; 
 77 | }
 78 | 
 79 | void philosopher::set_philosophy(string in_philosophy)
 80 | {
 81 |     philosophy = in_philosophy;
 82 | }
 83 | 
 84 | void philosopher::think()
 85 | {
 86 |     cout<<"Now, I think"<<endl;
 87 | }
 88 | 
 89 | 
 90 | 
 91 | phil_king::phil_king(string in_name, string in_realm, string in_philosophy):
 92 |     person(in_name), king(in_realm), philosopher(in_philosophy)
 93 | {
 94 | }
 95 | 
 96 | void phil_king::routine()
 97 | {
 98 |     think();
 99 |     rule();
100 |     think(); 
101 | }
102 | 
103 | ostream &operator<<(ostream &left, phil_king right)
104 | {
105 |     left<<right.name<<endl;
106 |     left<<"Ruling "<<right.realm<<endl; 
107 |     left<<"using "<<right.philosophy<<" philosophy"<<endl;
108 | }
109 | 


--------------------------------------------------------------------------------
/lesson13/cpp13(4sl).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson13/cpp13(4sl).pdf


--------------------------------------------------------------------------------
/lesson13/cpp13.askisi1.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp13.askisi1.cpp */
  2 | 
  3 | #include <iostream>
  4 | using namespace std;
  5 | 
  6 | template <typename T>
  7 | class ARRAY {
  8 |   public:
  9 |     ARRAY(int in_n);
 10 |     ARRAY(const ARRAY<T> &ob);
 11 |     ~ARRAY();
 12 |     int get_n() const; 
 13 |     T &operator[] (int i);
 14 |     ARRAY<T> &operator= (ARRAY<T> &right);
 15 |     ARRAY<T> &operator+= (int right);
 16 |     template <typename U> friend ostream &operator<<(ostream &left, const ARRAY<U> &ob);
 17 |   private:
 18 |     T *p;
 19 |     int n;
 20 | };
 21 | 
 22 | 
 23 | int main()
 24 | {
 25 |     int n=10;
 26 |     ARRAY<double> pin(n);
 27 | 
 28 |     for (int i=0; i<n; i++)
 29 |         pin[i]=i*0.1;
 30 |     
 31 |     cout<<pin; 
 32 | 
 33 |     return 0;
 34 | }
 35 | 
 36 | template <typename T>
 37 | ARRAY<T>::ARRAY(int in_n)
 38 | {
 39 |     n = in_n; 
 40 |     
 41 |     p = new T [n];
 42 |     if (!p)
 43 |         cout<<"Error allocating memory!";
 44 | }
 45 | 
 46 | template <typename T>
 47 | ARRAY<T>::ARRAY(const ARRAY<T> &ob)
 48 | {
 49 |     n = ob.get_n(); 
 50 |     
 51 |     p = new T [n];
 52 |     if (!p) cout<<"Memory Allocation Error!";
 53 |     
 54 | }
 55 | 
 56 | template <typename T>
 57 | ARRAY<T>::~ARRAY()
 58 | {
 59 |     delete [] p;
 60 | }
 61 | 
 62 | template <typename T>
 63 | int ARRAY<T>::get_n() const
 64 | {
 65 |     return n;
 66 | }
 67 | 
 68 | template <typename T>
 69 | T &ARRAY<T>::operator[] (int i)
 70 | {
 71 |     if (i>=0 && i<n) 
 72 |         return p[i]; 
 73 |     else
 74 |         cout<<"Index Error";
 75 |     
 76 | }
 77 | 
 78 | template <typename T>
 79 | ARRAY<T> &ARRAY<T>::operator= (ARRAY<T> &right)
 80 | {
 81 |     if (this==&right) return *this; 
 82 |     
 83 |     n=right.n; 
 84 |     delete [] p;
 85 |     p=new T [n];
 86 |     if(!p) cout<<"Error Allcoating Memory";
 87 |     
 88 |     for (int i=0; i<n; i++)
 89 |         p[i]=right[i];
 90 |         
 91 |     return *this; 
 92 | }
 93 | 
 94 | template <typename T>
 95 | ARRAY<T> &ARRAY<T>::operator+= (int right)
 96 | {
 97 |     int newn=n+right;
 98 |     int *newp;
 99 |     int i; 
100 |     
101 |     if (right>0)
102 |     {
103 |         newp = new T [newn];
104 |         if (!newp) cout<<"Error Allocating Memory";
105 |         
106 |         for (i=0; i<n; i++)
107 |             newp[i]=p[i];
108 |         for (i=n; i<newn; i++)
109 |             newp[i]=0;
110 |             
111 |         delete [] p;
112 |         n=newn;
113 |         p=newp; 
114 |     }
115 |     else 
116 |         cout<<"Wrong index!";
117 |         
118 | }
119 | 
120 | template <typename T>
121 | ostream &operator<<(ostream &left, const ARRAY<T> &ob)
122 | {
123 |     int i; 
124 |     
125 |     left<<"[";
126 |     for (i=0; i<ob.n-1; i++)
127 |         cout<<ob.p[i]<<" ";
128 |     left<<ob.p[ob.n-1];
129 |     left<<"]";
130 |     
131 |     return left; 
132 | }


--------------------------------------------------------------------------------
/lesson13/cpp13.askisi2.cpp:
--------------------------------------------------------------------------------
  1 | /* cpp13.askisi2.cpp */
  2 | #include <iostream>
  3 | using namespace std; 
  4 | 
  5 | template <typename T>
  6 | class linked_list;
  7 | 
  8 | template <typename T>
  9 | class node
 10 | {
 11 |    public: 
 12 |       friend class linked_list<T>; 
 13 |    private:
 14 |       T data; 		 
 15 |       node<T> *next;     
 16 | };
 17 | 
 18 | template <typename T>
 19 | class linked_list
 20 | {
 21 |    public: 
 22 |       linked_list();
 23 |       ~linked_list();
 24 |       bool empty();
 25 |       T data(node<T> *p);
 26 |       bool insert_start(T in_data);
 27 |       bool insert_after(node<T> *p, T x);
 28 |       bool delete_start(T *x);
 29 |       bool delete_after(node<T> *prev, T *x);
 30 |       void print();
 31 |    private:
 32 |       node<T> *head;     
 33 | };
 34 | 
 35 | 
 36 | int main()
 37 | {
 38 |     linked_list<string> list;
 39 |     string temp; 
 40 |     
 41 |     list.insert_start("5.1");
 42 |     list.insert_start("4.2");
 43 |     list.insert_start("3.3");
 44 |     list.delete_start(&temp);
 45 |     list.print();
 46 | 
 47 |     cout<<endl<<endl<<temp;
 48 |     
 49 |     return 0; 
 50 | }
 51 | 
 52 | template <typename T>
 53 | linked_list<T>::linked_list()
 54 | {
 55 |     head = NULL; 
 56 | }
 57 | 
 58 | template <typename T>
 59 | linked_list<T>::~linked_list()
 60 | {
 61 | 	node<T> *ptr;
 62 | 	
 63 | 	while (head!=NULL)
 64 | 	{
 65 | 		ptr=head;
 66 | 		head=head->next;
 67 | 		delete ptr;
 68 | 	}
 69 | }
 70 | 
 71 | 
 72 | template <typename T>
 73 | bool linked_list<T>::empty()
 74 | {
 75 |     return head == NULL;
 76 | }
 77 | 
 78 | template <typename T>
 79 | T linked_list<T>::data(node<T> *p)
 80 | {
 81 | 	return p->data;
 82 | }
 83 | 
 84 | template <typename T>
 85 | bool linked_list<T>::insert_start(T x)
 86 | {
 87 |    node<T> *newnode;
 88 | 	
 89 |    newnode = new node<T>;
 90 |    if (!newnode)
 91 |    {
 92 |       cout<<"Error allocating memory";
 93 |       return false;
 94 |    }
 95 |    newnode->data=x;
 96 | 
 97 |    newnode->next=head;
 98 |    head=newnode;
 99 |    return true;
100 | }
101 | 
102 | template <typename T>
103 | bool linked_list<T>::insert_after(node<T> *p, T x)
104 | {
105 | 	node<T> *newnode;
106 | 	
107 | 	newnode=new node<T>;
108 | 	if (!newnode)
109 | 	{
110 | 		cout<<"Adynamia desmeusis mnimis";
111 | 		return false;
112 | 	}
113 | 	newnode->data=x;
114 | 	
115 | 	newnode->next=p->next;
116 | 	p->next=newnode;
117 | 	return true;
118 | }
119 | 
120 | template <typename T>
121 | bool linked_list<T>::delete_start(T *x)
122 | {
123 | 	node<T> *current;
124 | 	
125 | 	if (head==NULL)
126 | 		return false;
127 | 		
128 | 	current=head;
129 | 	*x=current->data;
130 | 	
131 | 	head=head->next;
132 | 	delete current;
133 | 	
134 | 	return true;
135 | }
136 | 
137 | template <typename T>
138 | bool linked_list<T>::delete_after(node<T> *prev, T *x)
139 | {
140 | 	node<T> *current;
141 | 	
142 | 	if (prev->next==NULL)
143 | 		return false;
144 | 		
145 | 	current=prev->next;
146 | 	*x=current->data;
147 | 	
148 | 	prev->next=current->next;
149 | 	delete current;
150 | 	return true;
151 | }
152 | 
153 | 
154 | 
155 | 
156 | template <typename T>
157 | void linked_list<T>::print()
158 | {
159 |    node<T> *current;
160 | 	
161 |    current=head;
162 |    while(current!=NULL)
163 |    {
164 |       cout<<current->data<<" ";
165 |       current=current->next;
166 |    }
167 | }


--------------------------------------------------------------------------------
/lesson13/cpp13.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/psounis/CPP-programming/3350f77306648649679dd092aad224d875f3e1d3/lesson13/cpp13.pdf


--------------------------------------------------------------------------------
/lesson13/cpp13.swap.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp13.swap.cpp Template function */
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | template <typename T>
 7 | void myswap(T &a, T &b);
 8 | 
 9 | 
10 | int main()
11 | {
12 |     int a=2, b=3;
13 |     
14 |     cout<<"a="<<a<<" b="<<b<<endl;
15 |     
16 |     myswap<int>(a,b);
17 |     
18 |     cout<<"a="<<a<<" b="<<b<<endl;
19 |     return 0; 
20 | }
21 | 
22 | template <typename T>
23 | void myswap(T &a, T &b)
24 | {
25 |     T temp;
26 |     temp=a;
27 |     a=b;
28 |     b=temp; 
29 | }


--------------------------------------------------------------------------------
/lesson13/cpp13.template.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp13.template.cpp Template stack */
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | #define STACK_SIZE 100
 8 | 
 9 | template <typename T>
10 | class stack {
11 |   public:
12 |     stack(); 
13 |     bool empty();
14 |     bool full(); 
15 |     bool push(T elem);
16 |     bool pop(T *elem);
17 |   private:
18 |     T array[STACK_SIZE];
19 |     int top; 
20 | };
21 | 
22 | int main()
23 | {
24 |     /* integer stack */
25 |     stack<int> st;
26 |     int temp; 
27 |     
28 |     st.push(2);
29 |     st.push(5);
30 |     
31 |     st.pop(&temp);
32 |     cout<<temp<<" ";
33 |     st.pop(&temp);
34 |     cout<<temp<<" ";
35 | 
36 |     /* string stack */
37 |     stack<string> st2;
38 |     string temp2; 
39 |     
40 |     st2.push("Hello");
41 |     st2.push("World");
42 |     
43 |     st2.pop(&temp2);
44 |     cout<<endl<<temp2<<" ";
45 |     st2.pop(&temp2);
46 |     cout<<temp2<<" ";
47 |     
48 |     return 0; 
49 | }
50 | 
51 | 
52 | template <typename T>
53 | stack<T>::stack()
54 | {
55 |     top=-1; 
56 | }
57 | 
58 | template <typename T>
59 | bool stack<T>::empty()
60 | {
61 |     return top==-1; 
62 | }
63 | 
64 | template <typename T>
65 | bool stack<T>::full()
66 | {
67 |     return top==STACK_SIZE-1; 
68 | }
69 | 
70 | template <typename T>
71 | bool stack<T>::push(T elem)
72 | {
73 |     if (full())
74 |         return false; 
75 |     
76 |     top++; 
77 |     array[top]=elem; 
78 |     return true; 
79 | }
80 | 
81 | template <typename T>
82 | bool stack<T>::pop(T *elem)
83 | {
84 |     if (empty())
85 |         return false; 
86 |     
87 |     *elem = array[top]; 
88 |     top--; 
89 |     return true; 
90 | }
91 | 


--------------------------------------------------------------------------------
/lesson13/cpp13.template_non_type_param.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp13.template_non_type_param.cpp Template stack */
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | template <typename T, int STACK_SIZE>
 8 | class stack {
 9 |   public:
10 |     stack(); 
11 |     bool empty();
12 |     bool full(); 
13 |     bool push(T elem);
14 |     bool pop(T *elem);
15 |   private:
16 |     T array[STACK_SIZE];
17 |     int top; 
18 | };
19 | 
20 | int main()
21 | {
22 |     /* integer stack */
23 |     stack<int, 100> st;
24 |     int temp; 
25 |     
26 |     st.push(2);
27 |     st.push(5);
28 |     
29 |     st.pop(&temp);
30 |     cout<<temp<<" ";
31 |     st.pop(&temp);
32 |     cout<<temp<<" ";
33 | 
34 |     /* string stack */
35 |     stack<string, 100> st2;
36 |     string temp2; 
37 |     
38 |     st2.push("Hello");
39 |     st2.push("World");
40 |     
41 |     st2.pop(&temp2);
42 |     cout<<endl<<temp2<<" ";
43 |     st2.pop(&temp2);
44 |     cout<<temp2<<" ";
45 |     
46 |     return 0; 
47 | }
48 | 
49 | 
50 | template <typename T, int STACK_SIZE>
51 | stack<T, STACK_SIZE>::stack()
52 | {
53 |     top=-1; 
54 | }
55 | 
56 | template <typename T, int STACK_SIZE>
57 | bool stack<T, STACK_SIZE>::empty()
58 | {
59 |     return top==-1; 
60 | }
61 | 
62 | template <typename T, int STACK_SIZE>
63 | bool stack<T, STACK_SIZE>::full()
64 | {
65 |     return top==STACK_SIZE-1; 
66 | }
67 | 
68 | template <typename T, int STACK_SIZE>
69 | bool stack<T, STACK_SIZE>::push(T elem)
70 | {
71 |     if (full())
72 |         return false; 
73 |     
74 |     top++; 
75 |     array[top]=elem; 
76 |     return true; 
77 | }
78 | 
79 | template <typename T, int STACK_SIZE>
80 | bool stack<T, STACK_SIZE>::pop(T *elem)
81 | {
82 |     if (empty())
83 |         return false; 
84 |     
85 |     *elem = array[top]; 
86 |     top--; 
87 |     return true; 
88 | }
89 | 


--------------------------------------------------------------------------------
/lesson13/cpp13.template_with_friend.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp13.template_with_friend.cpp Template stack */
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | #define STACK_SIZE 100
 8 | 
 9 | 
10 | template <typename T>
11 | class stack {
12 |   public:
13 |     stack(); 
14 |     bool empty();
15 |     bool full(); 
16 |     bool push(T elem);
17 |     bool pop(T *elem);
18 |     template <typename U>friend ostream &operator<<(ostream &left, const stack<U> &right);
19 |   private:
20 |     T array[STACK_SIZE];
21 |     int top; 
22 | };
23 | 
24 | int main()
25 | {
26 |     /* integer stack */
27 |     stack<int> st;
28 |     int temp; 
29 |     
30 |     st.push(1);
31 |     cout<<st<<endl; 
32 |     st.push(2);
33 |     cout<<st<<endl; 
34 |     st.pop(&temp);
35 |     cout<<st<<endl; 
36 |     st.push(3);
37 |     cout<<st<<endl; 
38 |     st.push(4);
39 |     cout<<st<<endl; 
40 | 
41 |     return 0; 
42 | }
43 | 
44 | 
45 | template <typename T>
46 | stack<T>::stack()
47 | {
48 |     top=-1; 
49 | }
50 | 
51 | template <typename T>
52 | bool stack<T>::empty()
53 | {
54 |     return top==-1; 
55 | }
56 | 
57 | template <typename T>
58 | bool stack<T>::full()
59 | {
60 |     return top==STACK_SIZE-1; 
61 | }
62 | 
63 | template <typename T>
64 | bool stack<T>::push(T elem)
65 | {
66 |     if (full())
67 |         return false; 
68 |     
69 |     top++; 
70 |     array[top]=elem; 
71 |     return true; 
72 | }
73 | 
74 | template <typename T>
75 | bool stack<T>::pop(T *elem)
76 | {
77 |     if (empty())
78 |         return false; 
79 |     
80 |     *elem = array[top]; 
81 |     top--; 
82 |     return true; 
83 | }
84 | 
85 | template <typename T>
86 | ostream &operator<<(ostream &left, const stack<T> &right)
87 | {
88 |     for (int i=0; i<=right.top; i++)
89 |         left<<right.array[i]<<" ";
90 |     
91 |     return left; 
92 | }
93 | 


--------------------------------------------------------------------------------
/lesson13/cpp13.template_with_static.cpp:
--------------------------------------------------------------------------------
 1 | /* cpp13.template_with_static.cpp */
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | using namespace std;
 6 | 
 7 | #define STACK_SIZE 100
 8 | 
 9 | template <typename T>
10 | class stack {
11 |   public:
12 |     static int ob_cnt; 
13 |     stack(); 
14 |     bool empty();
15 |     bool full(); 
16 |     bool push(T elem);
17 |     bool pop(T *elem);
18 |   private:
19 |     T array[STACK_SIZE];
20 |     int top; 
21 | };
22 | 
23 | template <typename T>
24 | int stack<T>::ob_cnt = 0; 
25 | 
26 | int main()
27 | {
28 |     /* integer stack */
29 |     stack<int> st;
30 |     stack<int> st2;
31 |     stack<string> st3;
32 | 
33 |     cout<<stack<int>::ob_cnt<<endl; 
34 |     cout<<stack<string>::ob_cnt; 
35 | 
36 |     return 0; 
37 | }
38 | 
39 | 
40 | template <typename T>
41 | stack<T>::stack()
42 | {
43 |     top=-1; 
44 |     ob_cnt++;
45 | }
46 | 
47 | template <typename T>
48 | bool stack<T>::empty()
49 | {
50 |     return top==-1; 
51 | }
52 | 
53 | template <typename T>
54 | bool stack<T>::full()
55 | {
56 |     return top==STACK_SIZE-1; 
57 | }
58 | 
59 | template <typename T>
60 | bool stack<T>::push(T elem)
61 | {
62 |     if (full())
63 |         return false; 
64 |     
65 |     top++; 
66 |     array[top]=elem; 
67 |     return true; 
68 | }
69 | 
70 | template <typename T>
71 | bool stack<T>::pop(T *elem)
72 | {
73 |     if (empty())
74 |         return false; 
75 |     
76 |     *elem = array[top]; 
77 |     top--; 
78 |     return true; 
79 | }
80 | 


--------------------------------------------------------------------------------