├── Avoid_diamond_using_scope_resolution_operator.cpp
├── Avoid_diamond_using_virtual_key_word.cpp
├── Diamond.cpp
├── Diamond2.cpp
├── Dynamic_memory_allocate.cpp
├── LICENSE
├── README.md
├── car&motor.cpp
├── class1.cpp
├── class_func.cpp
├── class_in_to_class.cpp
├── complex.cpp
├── constructor2.cpp
├── constructor4.cpp
├── constructor_1.cpp
├── constructor_3.cpp
├── copy_constructor.cpp
├── data_conversion_1.cpp
├── data_conversion_2.cpp
├── data_conversion_3.cpp
├── encapsulation.cpp
├── exeption_handling_01.cpp
├── exeption_handling_02.cpp
├── exeption_handling_03.cpp
├── friend_function.cpp
├── global_variables.cpp
├── inheritance1.cpp
├── inheritance2.cpp
├── inheritance3.cpp
├── inheritance4.cpp
├── opertor_overloading.cpp
├── opertor_overloading_2.cpp
├── polumoprisam 3.cpp
├── polymoprisam 1.cpp
├── polymoprisam 2.cpp
├── polymoprisam 4.cpp
├── public class.cpp
├── static_variables.cpp
├── template_3.cpp
├── templates.cpp
├── templates_2.cpp
├── templates_4.cpp
└── volume&area.cpp


/Avoid_diamond_using_scope_resolution_operator.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | class A{
 4 |     int a;
 5 | public:
 6 | 
 7 |     void set(int x){
 8 |       a=x;
 9 |     }
10 |     void print(){
11 |     cout<<a<<endl;
12 |     }
13 | 
14 | 
15 | };
16 | class B:public A{
17 |     public:
18 |     B(){ set(20);}
19 | 
20 | };
21 | 
22 | class C:public A{
23 |     public:
24 |     C(){set(10);}
25 | 
26 | };
27 | 
28 | class D:public B,public C{};
29 | int main(){
30 |     D d;
31 |     d.B::print();
32 |     d.C::print();
33 | 
34 | }
35 | 


--------------------------------------------------------------------------------
/Avoid_diamond_using_virtual_key_word.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | class A{
 4 |     int a;
 5 | public:
 6 | 
 7 |     void set(int x){
 8 |       a=x;
 9 |     }
10 |     void print(){
11 |     cout<<a<<endl;
12 |     }
13 | 
14 | 
15 | };
16 | class B:virtual public A{
17 |     public:
18 |     B(){ set(20);}
19 | 
20 | };
21 | 
22 | class C:virtual public A{
23 |     public:
24 |     C(){set(10);}
25 | 
26 | };
27 | 
28 | class D:public B,public C{};
29 | 
30 | int main(){
31 |     D d;
32 |     d.print();
33 | 
34 | 
35 | }
36 | 


--------------------------------------------------------------------------------
/Diamond.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class person
 5 | {
 6 | protected:
 7 |     int age;
 8 | public:
 9 |     person(int x):age(x)
10 |     {
11 |         cout<<"I am person "<<x<<endl;
12 |     }
13 | 
14 | 
15 | };
16 | 
17 | class student : public person
18 | {
19 | public:
20 |     student(int x):person(x)
21 |     {
22 |         cout<<"I am student "<<x<<endl;
23 |     }
24 | };
25 | 
26 | class faculty : public person
27 | {
28 | public:
29 |     faculty(int x):person(x)
30 |     {
31 |         cout<<"This is faculty "<<x<<endl;
32 |     }
33 | };
34 | 
35 | class TA : public student,public faculty
36 | {
37 | public:
38 |     TA(int x):student(x),faculty(x)
39 |     {
40 |         cout<<"This is TA "<<x<<endl;
41 |     }
42 | };
43 | int main()
44 | {
45 |     TA p(1);
46 | }
47 | 


--------------------------------------------------------------------------------
/Diamond2.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | class A
 4 | {
 5 |     int x;
 6 | public:
 7 |     void set(int i)
 8 |     {
 9 |        x=i;
10 |     }
11 |     void print(){
12 |     cout<<x;
13 |     }
14 | };
15 | 
16 | class B:virtual public A
17 | {
18 |     public:
19 |     B(){set(10);}
20 | };
21 | class C:virtual public A
22 | {
23 |     public:
24 |     C(){set(20);}
25 | };
26 | class D:public B,public C{};
27 | int main()
28 | {
29 |     D d;
30 |     d.print();
31 | 
32 | }
33 | 


--------------------------------------------------------------------------------
/Dynamic_memory_allocate.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int a=5;
 7 | 
 8 |     //Allocate dynamic memory
 9 |     int *ptr1 = new int;
10 |     int *ptr2 = new int[5];
11 | 
12 |     ptr1=&a;
13 | 
14 |     for(int i=0;i<5;i++){
15 |         *(ptr2+i)=i+1;
16 |     }
17 | 
18 |     //How to print that value
19 |     cout<<*ptr1<<endl;
20 | 
21 |     for(int i=0;i<5;i++){
22 |        cout<<*(ptr2+i)<<" ";
23 |    }
24 | 
25 |     //How to deallocate dynamic memory allocated
26 |     delete  ptr1;
27 |     delete[]  ptr2;
28 | 
29 | }
30 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 Hirun Mihisara Kariyawasam
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # CPP--Concepts


--------------------------------------------------------------------------------
/car&motor.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | class engine{
 4 |     int cylinders;//number of cylinders
 5 |     double capacity;//capacity in liters
 6 | 
 7 | public:
 8 |     engine(int c,double l);
 9 | 
10 | };
11 | 
12 | engine :: engine (int c, double l):cylinders(c),capacity(l)
13 | {
14 |     cout<<"constructor engine intilizing finished"<<endl;
15 |     cout<<"cylinders in engine:"<<cylinders<<endl;
16 |     cout<<"fuel capacity in engine:"<<capacity<<endl;
17 | 
18 | }
19 | 
20 | class car{
21 |     int Mnumber;
22 |     engine motor;
23 | 
24 | public:
25 |     car(int m,int c,double l);
26 | 
27 | };
28 | car :: car(int m,int c,double l):Mnumber(m),motor(c,l)
29 | {
30 |     cout<<"Constructor Car finished initializing"<<endl;
31 |     cout<<"Model of car:"<<Mnumber<<endl;
32 | }
33 | int main()
34 | {
35 |     car c(12390,4,5.5);
36 | }
37 | 


--------------------------------------------------------------------------------
/class1.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class outside{
 5 | public :
 6 |     int x=0;
 7 | 
 8 |     class inside {
 9 |     public :
10 |         int x=5;
11 | 
12 |         static int y;
13 |         int func(){
14 |         return x;
15 |         }
16 |     };
17 | };
18 | int outside :: inside :: y=10;
19 | int main()
20 | {
21 |     outside A;
22 |     outside :: inside B;
23 |     cout<< B.func() << endl;
24 |     cout << B.y << endl;
25 | 
26 | }
27 | 


--------------------------------------------------------------------------------
/class_func.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int a=3;
 5 | 
 6 | class X {
 7 |     int a;
 8 | 
 9 | public :
10 |     X(){
11 |     a=0;
12 |     }
13 |     int increment_a(){
14 |     return a++;
15 |     }
16 | 
17 |     print(){
18 |     cout<<"X-a = "<<a<<endl;
19 |     }
20 | }b;
21 | 
22 | int main()
23 | {
24 |     int a=40;
25 |     cout<<"main a value:"<< a << endl;
26 |     cout<<"Value of global a:"<<::a<<endl;
27 | 
28 |     a=b.increment_a();
29 |     a=b.increment_a();
30 |     b.print();
31 |     cout<<"value of a:"<<a<<endl;
32 | 
33 | 
34 | }
35 | 


--------------------------------------------------------------------------------
/class_in_to_class.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class outside {
 5 | public :
 6 |     int x=0;
 7 | 
 8 |     class inside {
 9 |         public:
10 |         int x=10;
11 |          int func(){
12 |           return x;
13 |         }
14 | 
15 | };
16 | 
17 | 
18 | };
19 | int main()
20 | {
21 |     outside A;
22 |     outside :: inside B;
23 | 
24 |     cout<<B.func();
25 | 
26 | 
27 | 
28 | 
29 | 
30 | }
31 | 


--------------------------------------------------------------------------------
/complex.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | class complex{
 4 | public:
 5 | 
 6 |     int real1;
 7 |     int noreal1;
 8 | 
 9 |     int real2;
10 |     int noreal2;
11 | 
12 |   int sumreal(int r1,int r2)
13 |   {
14 |      real1=r1;
15 |      real2=r2;
16 |      return real1+real2;
17 |   }
18 | 
19 |   int sumnoreal(int n1,int n2)
20 |   {
21 |      noreal1=n1;
22 |      noreal2=n2;
23 |      return noreal1+noreal2;
24 |   }
25 |   int differencereal(int r1,int r2)
26 |   {
27 |      real1=r1;
28 |      real2=r2;
29 |      return real1-real2;
30 |   }
31 |   int differencenoreal(int n1,int n2)
32 |   {
33 |      noreal1=n1;
34 |      noreal2=n2;
35 |      return noreal1-noreal2;
36 |   }
37 | 
38 | };
39 | int main()
40 | {
41 |     int i1=0,i2=0,j1=0,j2=0;
42 |     complex c1;
43 |     cout<<"Enter first complex num real part:";
44 |     cin>>i1;
45 |     cout<<"Enter first complex num noreal part:";
46 |     cin>>j1;
47 |     cout<<"Enter second complex num real part:";
48 |     cin>>i2;
49 |     cout<<"Enter second complex num noreal part:";
50 |     cin>>j2;
51 | 
52 |     cout<<"result = "<<c1.sumreal(i1,i2)<<"+("<<c1.sumnoreal(j1,j2)<<")i"<<endl;
53 |     cout<<"result = "<<c1.differencereal(i1,i2)<<"+("<<c1.differencenoreal(j1,j2)<<")i"<<endl;
54 | }
55 | 


--------------------------------------------------------------------------------
/constructor2.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class rectangle {
 5 | 
 6 |     int width;
 7 |     int height;
 8 | public:
 9 |     rectangle()
10 |     {
11 |         width=0;
12 |         height=0;
13 |     }
14 | 
15 |     rectangle(int w)
16 |     {
17 |         width=w;
18 |         height=2;
19 |     }
20 | 
21 |     rectangle(int h,int w)
22 |     {
23 |         width=w;
24 |         height=h;
25 | 
26 |     }
27 | 
28 |     ~rectangle()
29 |     {
30 |         cout<<"Destructor called"<<endl;
31 |         cout<<height<<" "<<width<<endl;
32 |     }
33 | 
34 |     area();
35 | };
36 | 
37 | rectangle :: area()
38 | {
39 |     int result;
40 |     result= height*width;
41 |     cout<<"Area = "<<result<<endl;
42 | }
43 | 
44 | int main()
45 | {
46 |     rectangle A;
47 |     A.area();
48 | 
49 |     rectangle B(4);
50 |     B.area();
51 | 
52 |     rectangle C(5,4);
53 |     C.area();
54 | 
55 | 
56 | }
57 | 


--------------------------------------------------------------------------------
/constructor4.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | class destroy
 4 | {
 5 |     int id;
 6 |     string msg;
 7 | public:
 8 |     destroy(int,string);
 9 | 
10 |     ~destroy();
11 | };
12 | destroy :: destroy(int i,string m):id(i),msg(m)
13 | {
14 | 
15 | 
16 |     cout<<"constructor run"<<" "<<i<<" "<<m<<endl;
17 | }
18 | destroy :: ~destroy()
19 | {
20 |     cout<<"destructor run"<<" "<<id<<" "<<msg<<endl;
21 |     cout<<"end run desconstructor"<<endl;
22 | }
23 | int main()
24 | {
25 |     cout<<"start execute main function"<<endl;
26 |     destroy a(001,"constructor 1 run");
27 |     destroy b(002,"constructor 2 run");
28 |     destroy c(003,"constructor 3 run");
29 | 
30 |     cout<<"end run constructor"<<endl;
31 | }
32 | 


--------------------------------------------------------------------------------
/constructor_1.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class Hello{
 5 | public:
 6 |     Hello(){
 7 |     cout<<"This is consrtuctor"<<endl;
 8 |     }
 9 | 
10 |     ~Hello(){
11 |     cout<<"This is destructor"<<endl;
12 |     }
13 | 
14 |     void print(){
15 |     cout<<"Hello world"<<endl;
16 |     }
17 | };
18 | 
19 | int main ()
20 | {
21 |     Hello obj;
22 |     obj.print();
23 | 
24 | }
25 | 


--------------------------------------------------------------------------------
/constructor_3.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cassert>
 3 | using namespace std;
 4 | 
 5 | class list
 6 | {
 7 |     int length;
 8 |     int *array;
 9 |     public:
10 |     list()
11 |     {
12 |         length = 10;
13 |        assert(array !=0);
14 |         array=new int[length];
15 |         for(int i=0;i<length;i++){
16 |             array[i]=0;
17 |           }
18 | 
19 |     }
20 | 
21 |     list(int size)
22 |     {
23 |         length = size;
24 |         if(length<=0){
25 |             array=0;
26 |         }
27 |         else{
28 |          array=new int[length];
29 |          for(int i=0;i<length;i++){
30 |             array[i]=3;
31 |           }
32 |        }
33 |     }
34 | 
35 |     display()
36 |     {
37 |         int length;
38 |         for(int i=0;i<length;i++){
39 |             cout<<array[i]<<" "<<endl;
40 |         }
41 |     }
42 | 
43 |     set()
44 |     {
45 |         for(int i=0;i<length;i++){
46 |             array[i]=i+2;
47 |         }
48 |     }
49 | 
50 |     ~list()
51 |     {
52 |         delete[] array;
53 |         cout<<"called destructor"<<endl;
54 |     }
55 | };
56 | 
57 | int main()
58 | {
59 |     list a;
60 |     a.display();
61 | 
62 | 
63 | 
64 | }
65 | 


--------------------------------------------------------------------------------
/copy_constructor.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class Hello{
 5 | 
 6 |     string name;
 7 | public:
 8 | 
 9 |     Hello();
10 | 
11 |     Hello(string);
12 | 
13 |     ~Hello(){
14 |         int i=1;
15 |         cout<<"called destructor"<<i<<endl;
16 |         i++;
17 |     }
18 |     void display();
19 | };
20 | Hello :: Hello()
21 | {
22 |    name="_ _ _";
23 | 
24 | }
25 | Hello :: Hello(string n)
26 | {
27 |     name=n;
28 | 
29 | }
30 | void Hello :: display()
31 | {
32 |     cout<<"constructor called:"<<name<<endl;
33 | }
34 | 
35 | int main()
36 | {
37 |     Hello a1,a2("sachith");
38 |     a1.display();
39 |     a2.display();
40 | 
41 |     Hello a3=a2; //copy constructor
42 | 
43 |     a3.display();
44 |     a2.display();
45 | }
46 | 


--------------------------------------------------------------------------------
/data_conversion_1.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class time
 5 | {
 6 |     int hour;
 7 |     int mins;
 8 | public:
 9 |     time()
10 |     {
11 |         cout<<"defult constructor"<<endl;
12 |     }
13 |      time(int t)
14 |     {
15 |         hour=t/60;
16 |         mins=t%60;
17 |     }
18 |     void display()
19 |     {
20 |         cout<<"TIME"<<endl;
21 |         cout<<hour<<":"<<mins<<endl;
22 |     }
23 | };
24 | int main()
25 | {
26 |     int T;
27 | 
28 |     cout<<"Enter time in mins:";
29 |     cin>>T;
30 |     time t(T);
31 | 
32 |     t.display();
33 | }
34 | 


--------------------------------------------------------------------------------
/data_conversion_2.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class time
 5 | {
 6 |     int hour;
 7 |     int min;
 8 | public:
 9 |     time(int a,int b)
10 | {
11 |     hour=a;
12 |     min=b;
13 | }
14 |     operator int()
15 | {
16 |     return (hour*60+min);
17 | }
18 | 
19 | };
20 | 
21 | int main()
22 | {
23 |     time t(3,45);
24 |     cout<<"Time in to minitues"<<t.operator int()<<"min"<<endl;
25 | }
26 | 


--------------------------------------------------------------------------------
/data_conversion_3.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class time
 5 | {
 6 | public:
 7 |     int hour,min;
 8 | 
 9 |     time(int h,int m):hour(h),min(m){}
10 | 
11 |     int mins()
12 |     {
13 |         return ((hour*60)+min);
14 |     }
15 | };
16 | class minitues
17 | {
18 |     int mins;
19 | public:
20 |     minitues(){}
21 | public:
22 |     operator=(time T)
23 |     {
24 |         mins=T.min;
25 |     }
26 |     void show()
27 |     {
28 |         cout<<"Total min:"<<mins<<endl;
29 |     }
30 | 
31 | };
32 | int main()
33 | {
34 |     time a(3,40);
35 |     cout<<"minitues="<<a.mins()<<endl;
36 | 
37 |     minitues b;
38 |     b.show();
39 |     b=a;
40 |     b.show();
41 | }
42 | 


--------------------------------------------------------------------------------
/encapsulation.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | class car
 4 | {
 5 |     int year;
 6 |     string brand;
 7 | 
 8 | public:
 9 |     void setbrand(string b)
10 |     {
11 |       brand=b;
12 |     }
13 |     string getbrand()
14 |     {
15 |         return brand;
16 |     }
17 |     void setyear(int y)
18 |     {
19 |         year=y;
20 |     }
21 |     int getyear()
22 |     {
23 |         return year;
24 |     }
25 |     void display()
26 |     {
27 |         cout<<"Car brand:"<<getbrand()<<"\t"<<"Year:"<<getyear()<<endl;
28 |     }
29 | };
30 | int main()
31 | {
32 |     car car1;
33 |     car1.setbrand("BMW");
34 |     car1.setyear(2020);
35 |     car1.display();
36 | }
37 | 


--------------------------------------------------------------------------------
/exeption_handling_01.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int x=0;
 6 |     try
 7 |     {
 8 |         if(x<=0){
 9 | 
10 |             cout<<"X throw to catch..."<<endl;
11 |             throw x;
12 |         }
13 |     }
14 |     catch(int x)
15 |     {
16 |         cout<<"I am catch 'x' "<<x<<endl;
17 | 
18 |     }
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/exeption_handling_02.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | class A{};
 4 | class B:public A{};
 5 | int main()
 6 | {
 7 |     A b;
 8 |     try{
 9 |     throw b;
10 |     }
11 |     catch (B a){
12 |     cout<<"q"<<endl;
13 |     }
14 |     catch (A a){
15 |     cout<<"a"<<endl;
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/exeption_handling_03.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | char ABC(char Y)
 4 | {
 5 |     if('A'<=Y&&Y<='Z'){
 6 |         return Y;
 7 |     }
 8 |     throw int(Y);
 9 | }
10 | int main()
11 | {
12 |     try
13 |     {
14 |         char ch='1';
15 |         cout<<ABC(ch);
16 |     }
17 |     catch(int x)
18 |     {
19 |         cout<<x<<endl;
20 | 
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/friend_function.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | class MyClass {
 4 | private:
 5 |     int privateVar;
 6 |     int privatevar2;
 7 | 
 8 | public:
 9 |     MyClass() : privateVar(0) {}
10 | 
11 |     // Declaring a friend function
12 |     friend void friendFunction(MyClass);
13 | 
14 |     // Declaring a friend class
15 |     friend class FriendClass;
16 | };
17 | 
18 | // Defining the friend function
19 | void friendFunction(MyClass obj) {
20 |     // Accessing private member of MyClass
21 |     obj.privateVar = 10;
22 |     obj.privatevar2=100;
23 |     std::cout << "Friend function accessing privateVar: " << obj.privateVar <<" "<<obj.privatevar2<< std::endl;
24 | }
25 | 
26 | // Defining the friend class
27 | class FriendClass {
28 | public:
29 |     void modifyPrivateVar(MyClass obj) {
30 |         // Accessing private member of MyClass
31 |         obj.privateVar = 20;
32 |         std::cout << "Friend class accessing privateVar: " << obj.privateVar << std::endl;
33 |     }
34 | };
35 | 
36 | int main() {
37 |     MyClass obj;
38 |     friendFunction(obj); // Call to friend function
39 |     FriendClass fc;
40 |     fc.modifyPrivateVar(obj); // Call to friend class method
41 |     return 0;
42 | }
43 | 
44 | 


--------------------------------------------------------------------------------
/global_variables.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int a=100;
 5 | 
 6 | void print()
 7 | {
 8 |     int b=10,a=1;
 9 |     cout<<"value of print a: "<< a << endl;
10 |     cout<<"Value of global a: " << :: a << endl;
11 |     cout<<"Value of b: "<< b << endl;
12 | }
13 | int main()
14 | {
15 |     int a=0;
16 |     cout<<"Value of main a: "<< a << endl;
17 | 
18 |     print();
19 | 
20 | 
21 | 
22 | }
23 | 


--------------------------------------------------------------------------------
/inheritance1.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class vehical{
 5 | 
 6 | public:
 7 |     vehical()
 8 |     {
 9 |         cout<<"First call vehical"<<endl;
10 | 
11 |     }
12 | };
13 | class car:public vehical{
14 | 
15 | public:
16 |     car()
17 |     {
18 |         cout<<"This vehical is car"<<endl;
19 | 
20 |     }
21 | };
22 | class bmw:public car{
23 | 
24 | public:
25 |     bmw()
26 |     {
27 |         cout<<"This car is BMW"<<endl;
28 | 
29 |     }
30 | };
31 | int main()
32 | {
33 |     bmw o;
34 | 
35 | }
36 | 


--------------------------------------------------------------------------------
/inheritance2.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class Base
 4 | {
 5 | public :
 6 |     int x, y;
 7 | public:
 8 |     Base(int i, int j)
 9 |     {
10 |         x = i;
11 |         y = j;
12 |     }
13 | };
14 | class Derived : public Base
15 | {
16 | public:
17 |     Derived(int i, int j):Base(i,j) {}
18 | 
19 |     void print()
20 |     {
21 |         cout << x <<" "<< y;
22 |     }
23 | };
24 | int main(void)
25 | {
26 |     Derived q(10, 10);
27 |     q.print();
28 |     return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/inheritance3.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class dad{
 5 | public:
 6 |     dad()
 7 |     {
 8 |     cout<<"Dad of child1 and child 2"<<endl;
 9 |     }
10 | };
11 | class child1:public dad{
12 | public:
13 |     child1()
14 |     {
15 |     cout<<"This is child one"<<endl;
16 |     }
17 | };
18 | class child2:public dad{
19 | public:
20 |     child2()
21 |     {
22 |     cout<<"This is child two"<<endl;
23 |     }
24 | };
25 | class grandchild:public child1,public child2{
26 | public:
27 |     grandchild()
28 |     {
29 |     cout<<"Mom of child1 and child 2"<<endl;
30 |     }
31 | };
32 | int main()
33 | {
34 |     grandchild o1;
35 | 
36 | }
37 | 
38 | 


--------------------------------------------------------------------------------
/inheritance4.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | class mammals
 4 | {
 5 | public:
 6 | 
 7 |     void function1()
 8 |     {
 9 |         cout<<"I am mammal"<<endl;
10 |     }
11 | };
12 | class marineanimals
13 | {
14 | public:
15 | 
16 |     void function2()
17 |     {
18 |         cout<<"I am a marine animal"<<endl;
19 |     }
20 | 
21 | };
22 | class bluewhale:public mammals,public marineanimals
23 | {
24 | public:
25 | 
26 |     void function3()
27 |     {
28 |         cout<<"I belong to both the categories:Mammals as well as Marine Animals"<<endl;
29 |     }
30 | };
31 | int main()
32 | {
33 |     mammals mammal;
34 |     mammal.function1();
35 | 
36 |     marineanimals marineanimal;
37 |     marineanimal.function2();
38 | 
39 |     bluewhale bluewhale;
40 |     bluewhale.function3();
41 | 
42 |     bluewhale.function1();
43 |     bluewhale.function2();
44 | 
45 | 
46 | }
47 | 
48 | 


--------------------------------------------------------------------------------
/opertor_overloading.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | class number
 4 | {
 5 |     int num;
 6 | public:
 7 |     number(int n):num(n){}
 8 | 
 9 |     void display()
10 |     {
11 |         cout<<"number:"<<num;
12 |     }
13 |     void operator -()
14 |     {
15 |         this->num=-num;
16 |     }
17 | };
18 | int main()
19 | {
20 |     number a(10);
21 |     -a;
22 |     a.display();
23 | }
24 | 


--------------------------------------------------------------------------------
/opertor_overloading_2.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | class number {
 4 |     unsigned int count;
 5 | public:
 6 |     number():count(0){}
 7 |     void operator++()
 8 |     {
 9 |         ++count;
10 |     }
11 | 
12 |     void display()
13 |     {
14 |         cout<<"count:"<<count;
15 |     }
16 | };
17 | int main()
18 | {
19 |     number a;
20 |     ++a;
21 |     a.display();
22 | }
23 | 


--------------------------------------------------------------------------------
/polumoprisam 3.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class Transaction {
 5 | protected:
 6 |     int transaction_ID;
 7 |     string date;
 8 | 
 9 | public:
10 |     virtual void recordTransaction() = 0;
11 |     virtual void displayInfo() = 0;
12 | };
13 | 
14 | class IncomeTransaction : public Transaction {
15 | protected:
16 |     string source;
17 |     int amount;
18 | 
19 | public:
20 |     void recordTransaction() override {
21 |         cout << "Enter transaction id: ";
22 |         cin >> transaction_ID;
23 |         cout << "Enter date: ";
24 |         cin >> date;
25 |         cout << "Enter source: ";
26 |         cin >> source;
27 |         cout << "Enter amount: ";
28 |         cin >> amount;
29 |     }
30 | 
31 |     void displayInfo() override {
32 |         cout << "Transaction id: " << transaction_ID << endl;
33 |         cout << "Date: " << date << endl;
34 |         cout << "Source: " << source << endl;
35 |         cout << "Amount: " << amount << endl;
36 |     }
37 | };
38 | 
39 | class ExpenseTransaction : public Transaction {
40 | protected:
41 |     string reason;
42 |     int amount;
43 | 
44 | public:
45 |     void recordTransaction() override {
46 |         cout << "Enter transaction id: ";
47 |         cin >> transaction_ID;
48 |         cout << "Enter date: ";
49 |         cin >> date;
50 |         cout << "Enter reason: ";
51 |         cin >> reason;
52 |         cout << "Enter amount: ";
53 |         cin >> amount;
54 |     }
55 | 
56 |     void displayInfo() override {
57 |         cout << "Transaction id: " << transaction_ID << endl;
58 |         cout << "Date: " << date << endl;
59 |         cout << "Reason: " << reason << endl;
60 |         cout << "Amount: " << amount << endl;
61 |     }
62 | };
63 | 
64 | int main() {
65 |     IncomeTransaction income;
66 |     ExpenseTransaction expense;
67 | 
68 |     cout << "Recording Income Transaction:" << endl;
69 |     income.recordTransaction();
70 |     cout << "\nDisplaying Income Transaction:" << endl;
71 |     income.displayInfo();
72 | 
73 |     cout << "\nRecording Expense Transaction:" << endl;
74 |     expense.recordTransaction();
75 |     cout << "\nDisplaying Expense Transaction:" << endl;
76 |     expense.displayInfo();
77 | 
78 |     return 0;
79 | }
80 | 
81 | 


--------------------------------------------------------------------------------
/polymoprisam 1.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class Employee
 5 | {
 6 | public:
 7 |     int salary=0;
 8 |     virtual void calculate_salary()
 9 |     {
10 |       salary=0;
11 |       cout<<"Salary="<<salary;
12 |     }
13 | };
14 | class FullTimeEmployee:Employee
15 | {
16 | public:
17 |     void calculate_salary(string name,int s)
18 |     {
19 |       salary=s;
20 |       cout<<name<<" Salary="<<salary<<endl;
21 |     }
22 | };
23 | class PartTimeEmployee:Employee
24 | {
25 | public:
26 |     void calculate_salary(string name,int s,int time)
27 |     {
28 |       salary=s*time;
29 |       cout<<name<<" Salary="<<salary<<endl;
30 |     }
31 | };
32 | class ContractEmployee:Employee
33 | {
34 | public:
35 |     void calculate_salary(string name,int s,int month)
36 |     {
37 |       salary=s*month;
38 |       cout<<name<<" Salary="<<salary<<endl;
39 |     }
40 | };
41 | int main()
42 | {
43 |     FullTimeEmployee a;
44 |     a.calculate_salary("Kamal",60000);
45 | 
46 |     PartTimeEmployee b;
47 |     b.calculate_salary("Piyal",2000,20);
48 | 
49 |     ContractEmployee c;
50 |     c.calculate_salary("Damith",30000,2);
51 | }
52 | 


--------------------------------------------------------------------------------
/polymoprisam 2.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class person
 5 | {
 6 | protected:
 7 |     string name;
 8 |     int age;
 9 |     static int nextID;
10 |     virtual void getdata()
11 |     {
12 |         cout<<"give me correct data"<<endl;
13 |     }
14 |     virtual void putdata(){}
15 | };
16 |     int person::nextID=1;
17 | 
18 | class doctor:person
19 | {
20 | protected:
21 |     int doctor_specialist,doctor_id=nextID;
22 | public:
23 | 
24 |     void getdata()
25 |     {
26 |         cout<<"Enter name:";
27 |         cin>>name;
28 |         cout<<"Enter age:";
29 |         cin>>age;
30 |         cout<<"Enter specialist:";
31 |         cin>>doctor_specialist;
32 | 
33 |     }
34 |     void putdata()
35 |     {
36 |         cout<<"doctor name:"<<name<<"   age:"<<age<<"   special:"<<doctor_specialist<<endl;
37 |     }
38 | };
39 | class patient:person
40 | {
41 | protected:
42 | 
43 |     string addmission_date;
44 |     int patient_id;
45 | 
46 | public:
47 |     void getdata()
48 |     {
49 |      cout<<"Enter name:";
50 |      cin>>name;
51 |      cout<<"Enter age:";
52 |      cin>>age;
53 |      cout<<"Enter addmission date:";
54 |      cin>>addmission_date;
55 |     }
56 |     void putdata()
57 |     {
58 |         cout<<"patient name:"<< name<<"   age:"<< age<<"   patient_id:"<<nextID++<<endl;
59 |     }
60 | };
61 | int main()
62 | {
63 |     doctor a;
64 |     a.getdata();
65 |     a.putdata();
66 | 
67 |     patient b;
68 |     b.getdata();
69 |     b.putdata();
70 | }
71 | 


--------------------------------------------------------------------------------
/polymoprisam 4.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <string>
  3 | #include <vector>
  4 | 
  5 | using namespace std;
  6 | 
  7 | class Book {
  8 | private:
  9 |     string title;
 10 |     string author;
 11 |     string ISBN;
 12 |     bool available;
 13 | 
 14 | public:
 15 |     Book(const string& title, const string& author, const string& ISBN)
 16 |         : title(title), author(author), ISBN(ISBN), available(true) {}
 17 | 
 18 | 
 19 |     string getTitle() const {
 20 |         return title;
 21 |     }
 22 | 
 23 |     string getAuthor() const {
 24 |         return author;
 25 |     }
 26 | 
 27 |     string getISBN() const {
 28 |         return ISBN;
 29 |     }
 30 | 
 31 |     bool isAvailable() const {
 32 |         return available;
 33 |     }
 34 | 
 35 | 
 36 |     void setTitle(const string& title) {
 37 |         this->title = title;
 38 |     }
 39 | 
 40 |     void setAuthor(const string& author) {
 41 |         this->author = author;
 42 |     }
 43 | 
 44 |     void setISBN(const string& ISBN) {
 45 |         this->ISBN = ISBN;
 46 |     }
 47 | 
 48 | 
 49 |     void checkOut() {
 50 |         if (available)
 51 |             available = false;
 52 |         else
 53 |             cout << "This book is already checked out." << endl;
 54 |     }
 55 | 
 56 |     void returnBook() {
 57 |         if (!available)
 58 |             available = true;
 59 |         else
 60 |             cout << "This book is already available." << endl;
 61 |     }
 62 | 
 63 | 
 64 |     void displayInfo() const {
 65 |         cout << "Title: " << title << endl;
 66 |         cout << "Author: " << author << endl;
 67 |         cout << "ISBN: " << ISBN << endl;
 68 |         cout << "Availability: " << (available ? "Available" : "Checked out") << endl;
 69 |     }
 70 | };
 71 | 
 72 | class Patron {
 73 | private:
 74 |     string name;
 75 |     string libraryCardNumber;
 76 |     vector<Book*> borrowedBooks;
 77 | 
 78 | public:
 79 |     Patron(const string& name, const string& libraryCardNumber)
 80 |         : name(name), libraryCardNumber(libraryCardNumber) {}
 81 | 
 82 | 
 83 |     string getName() const {
 84 |         return name;
 85 |     }
 86 | 
 87 |     string getLibraryCardNumber() const {
 88 |         return libraryCardNumber;
 89 |     }
 90 | 
 91 | 
 92 |     void setName(const string& name) {
 93 |         this->name = name;
 94 |     }
 95 | 
 96 |     void setLibraryCardNumber(const string& libraryCardNumber) {
 97 |         this->libraryCardNumber = libraryCardNumber;
 98 |     }
 99 | 
100 | 
101 |     void borrowBook(Book* book) {
102 |         if (book->isAvailable()) {
103 |             borrowedBooks.push_back(book);
104 |             book->checkOut();
105 |             cout << "Book '" << book->getTitle() << "' has been borrowed." << endl;
106 |         } else {
107 |             cout << "Book '" << book->getTitle() << "' is not available for borrowing." << endl;
108 |         }
109 |     }
110 | 
111 |     void returnBook(Book* book) {
112 |         auto it = find(borrowedBooks.begin(), borrowedBooks.end(), book);
113 |         if (it != borrowedBooks.end()) {
114 |             borrowedBooks.erase(it);
115 |             book->returnBook();
116 |             cout << "Book '" << book->getTitle() << "' has been returned." << endl;
117 |         } else {
118 |             cout << "You haven't borrowed this book." << endl;
119 |         }
120 |     }
121 | 
122 | 
123 |     void displayInfo() const {
124 |         cout << "Name: " << name << endl;
125 |         cout << "Library Card Number: " << libraryCardNumber << endl;
126 |         cout << "Borrowed Books:" << endl;
127 |         if (borrowedBooks.empty()) {
128 |             cout << "No books borrowed." << endl;
129 |         } else {
130 |             for (const auto& book : borrowedBooks) {
131 |                 cout << "- " << book->getTitle() << endl;
132 |             }
133 |         }
134 |     }
135 | };
136 | 
137 | int main() {
138 | 
139 |     Book book1("The Great Gatsby", "F. Scott Fitzgerald", "9780743273565");
140 |     Book book2("To Kill a Mockingbird", "Harper Lee", "9780061120084");
141 |     Book book3("1984", "George Orwell", "9780451524935");
142 | 
143 |     Patron patron("John Doe", "123456");
144 | 
145 |     patron.borrowBook(&book1);
146 |     patron.borrowBook(&book2);
147 |     patron.borrowBook(&book3);
148 | 
149 |     cout << "\nPatron's Information:" << endl;
150 |     patron.displayInfo();
151 | 
152 |     patron.returnBook(&book1);
153 | 
154 |     cout << "\nUpdated Patron's Information:" << endl;
155 |     patron.displayInfo();
156 | 
157 |     return 0;
158 | }
159 | 


--------------------------------------------------------------------------------
/public class.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | class car
 4 | {
 5 | 
 6 |     string brand;
 7 |     string model;
 8 |     int year;
 9 | };
10 | int main()
11 | {
12 |     car obj;
13 |     obj.brand="toyata";
14 |     obj.model="wagon";
15 |     obj.year=2020;
16 | 
17 |     cout<<obj.brand;
18 | 
19 |     return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/static_variables.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using  namespace std;
 3 | 
 4 | void demo()
 5 | {
 6 |     static int co = 0;
 7 |     int c = 0;
 8 |     cout << co << " " <<c<<endl;
 9 |     co++;
10 |     c++;
11 | 
12 | }
13 | int main()
14 | {
15 |     for (int i=0;i<5;i++)
16 |     demo();
17 | }
18 | 
19 | 


--------------------------------------------------------------------------------
/template_3.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | template<typename T,int x>
 4 |     T func1(T y)
 5 | {
 6 |     return y+x;
 7 | }
 8 | 
 9 | template<typename T,int x>
10 |     T func2(T y)
11 | {
12 |     return y*x;
13 | }
14 | 
15 | int main()
16 | {
17 |     cout<<func1<int,10>(20)<<endl;
18 |     cout<<func2<int,1>(2)<<endl;
19 | }
20 | 


--------------------------------------------------------------------------------
/templates.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | template<typename T>
 4 | T mymax(T x,T y)
 5 | {
 6 |     return (x>y)?x:y;
 7 | }
 8 | int main()
 9 | {
10 | 
11 |     cout<<"MAX="<<mymax<int>(29,11)<<endl;
12 | 
13 |     cout<<"letter="<<mymax<char>('s','d')<<endl;
14 | }
15 | 


--------------------------------------------------------------------------------
/templates_2.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | template<typename t1,typename t2>
 4 | t1 multi(t1 x,t2 y)
 5 | {
 6 |     return x*y;
 7 | }
 8 | int main()
 9 | {
10 |     cout<<multi<int,double>(2,2.3)<<endl;
11 |     cout<<multi<char,int>('A',2)<<endl;
12 | }
13 | 


--------------------------------------------------------------------------------
/templates_4.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | template <typename t,int max>
 4 | int arraymin(t array[],int n)
 5 | {
 6 |     int m=max;
 7 |     for(int i=0;i<n;i++){
 8 |         if(array[i]<m){
 9 |             m=array[i];
10 |         }
11 |     }
12 |     return m;
13 | }
14 | int main()
15 | {
16 |     int array1[]={1,2,3,4,5};
17 |     char array2[]={2,10,20,5};
18 |     int n1=sizeof(array1);
19 |     int n2=sizeof(array2);
20 |     cout<<arraymin<int,10>(array1,n1)<<endl;
21 |     cout<<arraymin<char,256>(array2,n2)<<endl;
22 |     return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/volume&area.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | class circle{
 4 |     double radius;
 5 | public:
 6 |     circle(double r):radius(r){}
 7 | 
 8 |     double area()
 9 |     {
10 | 
11 |        return 3.14*radius*radius;
12 |     }
13 | };
14 | 
15 | class cylinder{
16 |     double height;
17 |     circle base;
18 | public:
19 |     cylinder(double h,double r):height(h),base(r){}
20 | 
21 |     double volume()
22 |     {
23 |         return base.area()*height;
24 |     }
25 | };
26 | 
27 | int main()
28 | {
29 |     circle a(7);
30 |     cylinder b(10.10,7);
31 |     cout<<"area of base circle:"<<a.area()<<endl;
32 |     cout<<"Volume of cylinder:"<<b.volume()<<endl;
33 | }
34 | 


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