├── CPP001_First_Program.cpp
├── CPP002_Variables.cpp
├── CPP003_Variables_Types.cpp
├── CPP004_Input.cpp
├── CPP005_Arithmetic_Assignment_Increment_Decrement_Operators.cpp
├── CPP006_Relational_Operators.cpp
├── CPP007_Logical_Operators.cpp
├── CPP008_Calculator_Exercise.cpp
├── CPP009_Arrays.cpp
├── CPP010_Multidimensional_Arrays.cpp
├── CPP011_For.cpp
├── CPP012_While_DoWhile.cpp
├── CPP013_Counting_Digits_Exercise.cpp
├── CPP014_Nested_Loops.cpp
├── CPP015_Break_Continue.cpp
├── CPP016_Variables_Scope.cpp
├── CPP017_Functions.cpp
├── CPP018_Overloading_Functions.cpp
├── CPP019_CalculateArea_Exercise.cpp
├── CPP020_Enumeration.cpp
├── CPP021_ReferenceVariables.cpp
├── CPP022_ReferenceVariables_Functions.cpp
├── CPP023_Pointers.cpp
├── CPP024_Pointers_in_Arrays.cpp
├── CPP025_Dynamic_Memory_Allocation.cpp
├── CPP026_String_Char_Pointers.cpp
├── CPP027_Functions_and_Pointers.cpp
├── CPP028_Lottery_Exercise.cpp
├── CPP029_Type_Casting.cpp
├── CPP030_Structure.cpp
├── CPP031_Classes.cpp
├── CPP032_StaticVariables_StaticFunctions.cpp
├── CPP033_Constant_Variables_and_Methods.cpp
├── CPP034_Friend_Function.cpp
├── CPP035_Friend_Classes.cpp
├── CPP036_Copy_Constructor.cpp
├── CPP037_Operator_Overloading.cpp
├── CPP038_Virtual_Function.cpp
├── CPP039_AbstractClass_PureVirtualFunction.cpp
├── CPP040_Exception_Handling.cpp
├── CPP041_Namespaces.cpp
└── README.md


/CPP001_First_Program.cpp:
--------------------------------------------------------------------------------
1 | #include<iostream>
2 | using namespace std;
3 | 
4 | main()
5 | {
6 |     cout<<"Hello World !";
7 | }
8 | 


--------------------------------------------------------------------------------
/CPP002_Variables.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | main()
 6 | {
 7 |     //Declaring an integer type variable A, allocates 4 bytes of memory.
 8 |     int A=4;
 9 | 
10 |     cout<<A <<endl;
11 |     //Prints the address of the variable A.
12 |     cout<<&A <<endl;
13 | 
14 |     /*
15 |         1. Variables cant have the same name.
16 |         2. Variable name cant start with a number.
17 |         3. Variable name should not contain spaces.
18 |         4. Variable name should be self-descriptive.
19 |         5. Variable name can't have special characters or keywords.
20 |     */
21 | 
22 |     //Re-initialization of A.
23 |     A=10;
24 |     cout<<A <<endl;
25 |     cout<<&A;
26 | }
27 | 


--------------------------------------------------------------------------------
/CPP003_Variables_Types.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | main()
 6 | {
 7 |     int a=10,b=35; // 4 bytes
 8 |     cout<<"Value of a : "<<a<<" Address of a : "<<&a <<endl;
 9 |     cout<<"Value of b : "<<b<<" Address of b : "<<&b <<endl;
10 | 
11 |     short s=20; //2 bytes
12 |     cout <<"Value of s : "<< s << endl;
13 | 
14 |     float f1=20.03; //4 bytes
15 |     double d1=50.55416416; //8 bytes
16 |     cout <<"Value of f1 : "<< f1 << endl;
17 |     cout <<"Value of d1 : "<< d1 << endl;
18 | 
19 |     char c1='A';
20 |     cout<<c1<<endl;
21 | 
22 |     string s1="Hello Tridib";
23 |     cout<<s1<<endl;
24 | 
25 |     string s2="Welcome to CPP !";
26 |     cout<<s2<<endl;
27 | 
28 |     string combineStrings=s1+", "+s2;
29 |     cout<<combineStrings<<endl;
30 | 
31 |     bool b1=true; //Boolean is true or false. FALSE IS ALWAYS ZERO, EVERY OTHER NUMBER IS TRUE.
32 |     cout<<b1<<endl;
33 |     b1=1515;
34 |     cout<<b1<<endl;
35 |     b1=-445;
36 |     cout<<b1<<endl;
37 |     b1=0;
38 |     cout<<b1<<endl;
39 | 
40 |     //Positive numbers or unsigned numbers. Increases the positive range.
41 |     unsigned short int u1=60445;
42 |     cout<< u1 <<endl;
43 | 
44 |     const string myname="Tridib";
45 |     cout << myname << endl;
46 | 
47 | }
48 | 


--------------------------------------------------------------------------------
/CPP004_Input.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | main()
 6 | {
 7 |     // cin - console input
 8 |     int a;
 9 |     cin >> a;
10 |     cout << "Variable name a = " << a << endl;
11 | 
12 |     string name,surname;
13 | 
14 |     cout << "Enter your name : ";
15 |     cin >> name;
16 | 
17 |     cout << "Enter your surname : ";
18 |     cin >> surname;
19 | 
20 |     cout << "Welcome "<<name<<" "<<surname<<endl;
21 | 
22 | }
23 | 


--------------------------------------------------------------------------------
/CPP005_Arithmetic_Assignment_Increment_Decrement_Operators.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | main()
 6 | {
 7 |     int a=10,b=5;
 8 | 
 9 |     cout << a + b <<endl; //Addition
10 |     cout << a - b <<endl; //Subtraction
11 |     cout << a / b <<endl; //Division
12 |     cout << a * b <<endl; //Multiplication
13 | 
14 |     cout << a % b <<endl; //Modulo -> Remainder
15 | 
16 |     cout << ++a <<endl; //Pre-Increment
17 |     cout << --a <<endl; //Pre-decrement
18 |     cout << a++ <<endl; //Post-Increment
19 |     cout << a-- <<endl; //Post-decrement
20 | 
21 | }
22 | 


--------------------------------------------------------------------------------
/CPP006_Relational_Operators.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   14.11.2019
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | 
 8 | using namespace std;
 9 | 
10 | main()
11 | {
12 |     cout<<"Relational Operators !"<<endl;
13 | 
14 |     int a=10;
15 |     int b=5;
16 |     //True=1 ; False=0 ;
17 |     cout << (a==b)<<endl; //Returns true when value of variable a is equal to variable b.
18 |     cout << (a!=b)<<endl; //Returns true when value of variable a is not equal to variable b.
19 |     cout << (a<b)<<endl;
20 |     cout << (a>b)<<endl;
21 |     cout << (a<=b)<<endl;
22 |     cout << (a>=b)<<endl;
23 |     cout << !(a==b)<<endl; // (a!=b)
24 | }
25 | 


--------------------------------------------------------------------------------
/CPP007_Logical_Operators.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   14.11.2019
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | 
 8 | using namespace std;
 9 | 
10 | main()
11 | {
12 |     // AND - &&
13 |     // True only when both the expressions are true
14 | 
15 |     cout << (7>5 && 5!=10) <<endl;
16 |     cout << (2>5 && 5!=10) <<endl;
17 | 
18 |     // OR - ||
19 |     // True when both the expressions are true or only one of them is true.
20 | 
21 |     cout << (2>5 || 5!=10) <<endl;
22 |     cout << (2>5 || 5!=5) <<endl;
23 | 
24 |     // NOT - !
25 |     // Return true if result is false and vice versa.
26 |     cout << !(7>5 && 5!=10) <<endl;
27 | 
28 | }
29 | 


--------------------------------------------------------------------------------
/CPP008_Calculator_Exercise.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   17.11.2019
 4 |  **/
 5 | 
 6 | #include <iostream>
 7 | using namespace std;
 8 | 
 9 | main()
10 | {
11 |     double var1, var2;
12 | 
13 |     beginning:
14 | 
15 |     cout << "Enter first number: " << endl;
16 |     cin >> var1;
17 | 
18 |     cout << "Enter second number: " << endl;
19 |     cin >> var2;
20 | 
21 |     cout << "What do you want to do with that numbers?" << endl;
22 |     cout << "+ - add" << endl;
23 |     cout << "- - substract" << endl;
24 |     cout << "* - multiply" << endl;
25 |     cout << "/ - divide" << endl;
26 | 
27 |     char decision;
28 | 
29 |     cin >> decision;
30 | 
31 | 
32 | 
33 |     switch(decision)
34 |     {
35 |         case '+':
36 |             cout << var1 << " + " << var2 << " = " << (var1 + var2) << endl;
37 |             break;
38 |         case '-':
39 |             cout << var1 << " - " << var2 << " = " << (var1 - var2) << endl;
40 |             break;
41 |         case '*':
42 |             cout << var1 << " * " << var2 << " = " << (var1 * var2) << endl;
43 |             break;
44 |         case '/':
45 |             if (var2) //var2 != 0
46 |                 cout << var1 << " / " << var2 << " = " << (var1 / var2) << endl;
47 |             else
48 |                 cout << "You can't divide by 0" << endl;
49 |             break;
50 |         default:
51 |             cout << "You typed wrong character";
52 | 
53 |     }
54 | 
55 |     char decision2;
56 | 
57 |     cout << "Do you want to continue that program? (Y/N)" << endl;
58 |     cin >> decision2;
59 | 
60 |     if (decision2 == 'y' || decision2 == 'Y')
61 |         goto beginning;
62 | }
63 | 


--------------------------------------------------------------------------------
/CPP009_Arrays.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   17.11.2019
 4 |  **/
 5 | 
 6 | #include <iostream>
 7 | using namespace std;
 8 | 
 9 | main()
10 | {
11 |     int array[4]; //Type_Name[Size_of_Elements]
12 | 
13 |     //Initialization
14 |     array[0]=10;
15 |     array[1]=20;
16 |     array[2]=30;
17 |     array[3]=40;
18 | 
19 |     //Printing the array elements and address of each element
20 |     cout<<"array[0] = "<<array[0]<<" , Address = "<<&array[0]<<endl;
21 |     cout<<"array[0] = "<<array[1]<<" , Address = "<<&array[1]<<endl;
22 |     cout<<"array[0] = "<<array[2]<<" , Address = "<<&array[2]<<endl;
23 |     cout<<"array[0] = "<<array[3]<<" , Address = "<<&array[3]<<endl;
24 | 
25 |     if(&array[0] == array)
26 |         cout<<"TRUE";
27 | }
28 | 


--------------------------------------------------------------------------------
/CPP010_Multidimensional_Arrays.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   17.11.2019
 4 |  **/
 5 | 
 6 | #include <iostream>
 7 | using namespace std;
 8 | 
 9 | main()
10 | {
11 |     int biArray[3][4]={0}; //Initialize all array elements to zero
12 | 
13 |     //Initialize individual array elements to respective values
14 |     biArray[0][0]=11;
15 |     biArray[0][1]=12;
16 |     biArray[0][2]=13;
17 |     biArray[0][3]=14;
18 | 
19 |     biArray[1][0]=21;
20 |     biArray[1][1]=22;
21 |     biArray[1][2]=23;
22 |     biArray[1][3]=24;
23 | 
24 |     biArray[2][0]=31;
25 |     biArray[2][1]=32;
26 |     biArray[2][2]=33;
27 |     biArray[2][3]=34;
28 | 
29 |     //Print all array elements
30 |     cout<<biArray[0][0]<<","<<biArray[0][1]<<","<<biArray[0][2]<<","<<biArray[0][3]<<endl;
31 |     cout<<biArray[1][0]<<","<<biArray[1][1]<<","<<biArray[1][2]<<","<<biArray[1][3]<<endl;
32 |     cout<<biArray[2][0]<<","<<biArray[2][1]<<","<<biArray[2][2]<<","<<biArray[2][3]<<endl;
33 | }
34 | 


--------------------------------------------------------------------------------
/CPP011_For.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   18.11.2019
 4 |  **/
 5 | 
 6 |  #include<iostream>
 7 |  using namespace std;
 8 | 
 9 |  main() {
10 |     /*
11 |         for(initialization;condition;inc/dec)
12 |             instructions_to_repeat;
13 |     */
14 | 
15 |     for(int i=0;i<3;i++)
16 |         cout<<"Hello"<<endl;
17 | 
18 |     int array[4];
19 | 
20 |     for(int i=0;i<4;i++)
21 |         array[i]=i; //Initialization
22 | 
23 |     for(int i=0;i<4;i++)
24 |         cout<<array[i]<<endl; //Print array elements
25 | 
26 |     //Infinite Loop
27 |     /*
28 |     for(;;)
29 |         cout<<"Stop me if you can !"<<endl;
30 |     */
31 |  }
32 | 


--------------------------------------------------------------------------------
/CPP012_While_DoWhile.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   14.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | main() {
10 |     int i=0;
11 |     while(i<10) {
12 |         cout<<"Hello"<<endl;
13 |         //Increment inside the body of the loop
14 |         i++;
15 |     }
16 |     int j=10;
17 |     while(j--)
18 |         cout<<j<<endl;
19 | 
20 |     //Does not check the condition at the beginning
21 |     //Hence execute instructions inside the do block at least once
22 |     do {
23 |         cout<<"Hello"<<endl;
24 |         i--;
25 |     }
26 |     while(i);
27 | }
28 | 


--------------------------------------------------------------------------------
/CPP013_Counting_Digits_Exercise.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   14.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | main() {
10 |     int num,digits_count=1;
11 |     cin>>num;
12 |     int temp=num;
13 |     //Divide the number by 10, until we get quotient as 0
14 |     while(temp/=10)
15 |         //Increase the digit count by 1
16 |         digits_count++;
17 | 
18 |     cout<<"The number "<<num<<" has "<<digits_count<<" digit(s)"<<endl;
19 | }
20 | 


--------------------------------------------------------------------------------
/CPP014_Nested_Loops.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   14.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | main() {
10 |     for(int i=1;i<=10;i++) {
11 |         cout<<"Multiplication table of "<<i<<endl;
12 |         for(int j=1;j<=10;j++) {
13 |             //This inner loop will execute 10 times for each iteration of the outer loop
14 |             cout<<i<<" x "<<j<<" = "<<(i*j)<<endl;
15 |         }
16 |         cout<<endl;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/CPP015_Break_Continue.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   14.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | main() {
10 |     for(int i=1;i<=10;i++) {
11 |         if(i==3)
12 |             continue; //Everything after continue WONT BE executed.
13 |         //But the loop wont stop, it skips the current iteration instructions.
14 |         if(i==5)
15 |             break;//Everything after break WONT BE executed and the control comes out from the loop.
16 |         //The particular loop stops execution once break statement is encountered.
17 |         cout<<"Multiplication table of "<<i<<endl;
18 |         for(int j=1;j<=10;j++) {
19 |                 if(j==5)
20 |                     break; //Wont print after first 4 rows for each table
21 |             cout<<i<<" x "<<j<<" = "<<(i*j)<<endl;
22 |         }
23 |         cout<<endl;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/CPP016_Variables_Scope.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   15.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | //Variables created outside the curly brackets are called Global Variables.
10 | 
11 | int globalVariable;
12 | 
13 | main() {
14 | 
15 |     //Variables declared within a block are called Local Variables.
16 |     int localVariable;
17 | 
18 |     cout<<"Value of Global Variable is : "<<globalVariable<<endl; //Default value is 0
19 |     cout<<"Value of Local Variable is : "<<localVariable<<endl; //Default value is garbage value
20 | 
21 |     /*
22 |     int a=10; //Local Variable
23 | 
24 |     if(a==10)
25 |         int result = a*10;
26 | 
27 |     cout<<result; // Error as result is local to the if block
28 |     */
29 | 
30 | }
31 | 


--------------------------------------------------------------------------------
/CPP017_Functions.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   15.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | void welcome(); // Declaration of function
10 | bool isNumber(string tmp);
11 | //bool isNumber(string); Mentioning variable name during declaration not mandatory
12 | void enterString();
13 | 
14 | //Inline Function
15 | double add(double a,double b) {return a+b;}
16 | 
17 | void changeValueTO10(int x) { x=10; }
18 | //main() is a function
19 | int main() {
20 | 
21 |     welcome();
22 | 
23 |     char ch;
24 |     cout<<"Do you want to end the program ? (Y/N)"<<endl;
25 |     cin>>ch;
26 |     if(ch=='Y'||ch=='y')
27 |         return 0;
28 | 
29 |     cout<<add(4.5+2,4.0)<<endl;
30 | 
31 |     int a=5;
32 |     //A copy of the variable a is sent as the function paramenter
33 |     changeValueTO10(a);
34 |     cout<<a<<endl; //The value of a will still be 5 as because the original value at address of a is not changed.
35 | 
36 | 
37 |     enterString();
38 |     enterString();
39 |     enterString();
40 | 
41 |     return 0;
42 | }
43 | 
44 | void welcome() {
45 |     cout<<"Hello welcome to my function !"<<endl;
46 | }
47 | 
48 | bool isNumber(string tmp) {
49 |     if(tmp[0]=='0')
50 |         return false; //When function returns a value its the end of execution of the function
51 |     for(int i=0;i<tmp.length();i++) {
52 |         if(!(tmp[i] >= 48 && tmp[i] <= 57))
53 |             return false; //Once false is returned it wont execute the loop anymore
54 |     }
55 | 
56 |     return true;
57 | }
58 | 
59 | void enterString() {
60 |     string tmp;
61 |     cout<<"Enter the number : "<<endl;
62 |     cin>>tmp;
63 | 
64 |     if(isNumber(tmp))
65 |         cout<<"Number entered properly"<<endl;
66 |     else
67 |         cout<<"Number entered is incorrect"<<endl;
68 | }
69 | 


--------------------------------------------------------------------------------
/CPP018_Overloading_Functions.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   15.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | int power(int,int);
10 | double power(double,int);
11 | //While overloading functions the function name will be the same.
12 | //Function return type and function parameters will be different.
13 | 
14 | int main() {
15 | 
16 |     cout<<power(2.8,3)<<endl;
17 |     cout<<power(2,3)<<endl;
18 |     return 0;
19 | }
20 | 
21 | int power(int b,int e) {
22 |     int tmp=b;
23 |     while(e>1) {
24 |         b = b*tmp;
25 |         e--;
26 |     }
27 |     return b;
28 | }
29 | 
30 | double power(double b,int e) {
31 |     int tmp=b;
32 |     while(e>1) {
33 |         b = b*tmp;
34 |         e--;
35 |     }
36 |     return b;
37 | }
38 | 


--------------------------------------------------------------------------------
/CPP019_CalculateArea_Exercise.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   15.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | #define PI 3.14
 8 | using namespace std;
 9 | 
10 | void initMenu();
11 | void menuDecision(int);
12 | double areaCircle(double);
13 | double areaSquare(double);
14 | double areaRectangle(double,double);
15 | double areaTriangle(double,double);
16 | 
17 | 
18 | int main() {
19 | 
20 |     int choice;
21 |     char cont;
22 | 
23 |     do {
24 |         //system("cls");
25 |         initMenu();
26 |         cin>>choice;
27 | 
28 |         menuDecision(choice);
29 | 
30 |         cout<<"Do you want to continue ? (Y/N)"<<endl;
31 |         cin>>cont;
32 |     } while(cont=='Y'||cont=='y');
33 | 
34 |     return 0;
35 | }
36 | 
37 | void initMenu() {
38 |     cout<<"Select from the options :"<<endl;
39 |     cout<<"1.Circle"<<endl;
40 |     cout<<"2.Square"<<endl;
41 |     cout<<"3.Rectangle"<<endl;
42 |     cout<<"4.Triangle"<<endl;
43 | }
44 | 
45 | void menuDecision(int ch) {
46 |     double r,a,b,h;
47 |     switch(ch) {
48 |     case 1:
49 |         cout<<"Enter the radius : "<<endl;
50 |         cin>>r;
51 |         areaCircle(r);
52 |         break;
53 |     case 2:
54 |         cout<<"Enter a side of the square : "<<endl;
55 |         cin>>a;
56 |         areaSquare(a);
57 |         break;
58 |     case 3:
59 |         cout<<"Enter the width and height of the rectangle : "<<endl;
60 |         cin>>a>>b;
61 |         areaRectangle(a,b);
62 |         break;
63 |     case 4:
64 |         cout<<"Enter the base and height of the triangle : "<<endl;
65 |         cin>>a>>h;
66 |         areaTriangle(a,h);
67 |         break;
68 |     default:
69 |         cout<<"Wrong choice !"<<endl;
70 |     }
71 | }
72 | 
73 | double areaCircle(double r) {
74 |     double result = PI *r *r;
75 |     cout<<"The area of the circle is : "<<result<<endl;
76 |     return result;
77 | }
78 | 
79 | double areaSquare(double a) {
80 |     double result = a* a;
81 |     cout<<"The area of the Square is : "<<result<<endl;
82 |     return result;
83 | }
84 | 
85 | double areaRectangle(double a,double b) {
86 |     double result = a* b;
87 |     cout<<"The area of the Rectangle is : "<<result<<endl;
88 |     return result;
89 | }
90 | 
91 | double areaTriangle(double a,double h) {
92 |     double result = (1/2.0)*a*h;
93 |     cout<<"The area of the Triangle is : "<<result<<endl;
94 |     return result;
95 | }
96 | 
97 | 


--------------------------------------------------------------------------------
/CPP020_Enumeration.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   16.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | enum dayOfWeek {Monday = 1, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday};
10 | 
11 | string getDay(dayOfWeek);
12 | 
13 | int main() {
14 | 
15 |     //dayOfWeek d = Wednesday;
16 |     //cout<<d<<endl;
17 |     //cout<<getDay(Tuesday)<<endl;
18 | 
19 |     cout<<"Enter a day of the week ?"<<endl;
20 |     int i;
21 |     cin>>i;
22 |     cout<<getDay(dayOfWeek(i))<<endl;
23 | 
24 |     return 0;
25 | }
26 | 
27 | string getDay(dayOfWeek d) {
28 |     switch(d) {
29 |     case Monday:
30 |         return "Hey ! You have selected Monday";
31 |     case Tuesday:
32 |         return "Hey ! You have selected Tuesday";
33 |     case Wednesday:
34 |         return "Hey ! You have selected Wednesday";
35 |     case Thursday:
36 |         return "Hey ! You have selected Thursday";
37 |     case Friday:
38 |         return "Hey ! You have selected Friday";
39 |     case Saturday:
40 |         return "Hey ! You have selected Saturday";
41 |     case Sunday:
42 |         return "Hey ! You have selected Sunday";
43 |     default:
44 |         return "Hey ! Wrong input !";
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/CPP021_ReferenceVariables.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   16.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | /*
10 | ~ Reference Variables are the alias to another variable.
11 | ~ Must be initialized when created.
12 | ~ They cant change the connections/associations.
13 | ~ Must be of the same type as associated variables.
14 | */
15 | 
16 | int main() {
17 | 
18 |     string name="Peter";
19 |     cout<<"Value of variable is : "<<name<<". Address of variable is : "<<&name<<endl;
20 | 
21 |     string &ref_1 = name; // Creating a reference variable
22 |     cout<<"Value of variable is : "<<ref_1<<". Address of variable is : "<<&ref_1<<endl;
23 | 
24 |     ref_1 = "Sam";
25 |     cout<<"Value of variable is : "<<name<<". Address of variable is : "<<&name<<endl;
26 |     cout<<"Value of variable is : "<<ref_1<<". Address of variable is : "<<&ref_1<<endl;
27 | 
28 |     return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/CPP022_ReferenceVariables_Functions.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   16.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | void swap(int &, int &);
10 | 
11 | int main() {
12 | 
13 |     int a=10,b=20;
14 |     swap(a,b);
15 | 
16 |     cout<<"a : "<<a<<endl;
17 |     cout<<"b : "<<b<<endl;
18 | 
19 |     return 0;
20 | }
21 | 
22 | void swap(int &a, int &b) {
23 |     int t;
24 |     t=a;
25 |     a=b;
26 |     b=t;
27 | 
28 | }
29 | 


--------------------------------------------------------------------------------
/CPP023_Pointers.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   16.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | int main() {
10 | 
11 |     int var = 5;
12 |     cout<<&var<<endl; //Prints the address
13 |     cout<<*&var<<endl; //Prints the value
14 | 
15 |     int *p; //*p - This indicates that p is a pointer type variable that points to address of another variable
16 |     p=&var;
17 | 
18 |     cout<<p<<endl; //Prints the address of var
19 |     cout<<*p<<endl; //Prints the value stored at the indicated address in the memory
20 | 
21 |     int a=20;
22 |     cout<<"a : "<<a<<endl;
23 |     int *p1=&a;
24 |     *p1=60;
25 |     cout<<"a : "<<a<<endl;
26 |     cout<<"*p1 : "<<*p1<<endl;
27 | 
28 |     int * const p_const = &a; //Cannot change the ADDRESS afterwards
29 |     const int *p2 = &a; //Cannot change the VALUE
30 |     const int * const p3 = &a; //Cannot change the VALUE as well as ADDRESS
31 | 
32 |     int my_var=10;
33 |     int *my_p=&my_var;
34 | 
35 |     cout<<endl<<endl;
36 |     cout<<"my_var : "<<my_var<<endl; //Integer value
37 |     cout<<"my_p : "<<my_p<<endl; //Address
38 |     cout<<"*my_p : "<<*my_p<<endl; //Integer value from pointed variable (my_var)
39 |     cout<<"&my_p : "<<&my_p<<endl; //Address of pointer itself
40 | 
41 |     int **pp=&my_p; //Pointer pointing to address of another pointer
42 |     cout<<"pp : "<<pp<<endl;
43 |     cout<<"&pp : "<<&pp<<endl;
44 |     cout<<"*pp : "<<*pp<<endl;
45 |     cout<<"**pp : "<<**pp<<endl;
46 | 
47 |     return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/CPP024_Pointers_in_Arrays.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   16.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | int main() {
10 | 
11 |     int a[3]={10,20,30};
12 |     short int zm;
13 |     int * const p = &a[0];
14 | 
15 |     cout<<p<<endl; //Pointer p stores the base address of the array
16 |     cout<<a<<endl; //Base address - a[0]
17 | 
18 |     cout<<endl<<endl;
19 | 
20 |     cout<<&a[0]<<endl; //Prints address of a[0] (Base address of the array)
21 |     cout<<&a[1]<<endl;
22 |     cout<<&a[2]<<endl;
23 | 
24 |     cout<<endl<<endl;
25 | 
26 |     cout<<a<<endl;
27 |     cout<<a+1<<endl; //Moves by one position of the size of the type of array element
28 |     cout<<a+2<<endl;
29 | 
30 |     cout<<endl<<endl;
31 | 
32 |     cout<<*a<<endl;
33 |     cout<<*(a+1)<<endl;
34 |     cout<<*(a+2)<<endl;
35 | 
36 |     return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/CPP025_Dynamic_Memory_Allocation.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   16.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | int main() {
10 | 
11 |     int amount;
12 |     cout<<"How many numbers would you like to store in the array ? "<<endl;
13 |     cin>>amount;
14 | 
15 |     int *p = new (nothrow) int(amount);
16 | 
17 |     if(p != NULL) {
18 |         for(int i=0;i<amount;i++) {
19 |             cout<<"Enter the "<<(i+1)<<" number : "<<endl;
20 |             cin>>p[i];
21 |         }
22 | 
23 |         cout<<endl<<endl;
24 | 
25 |         for(int i=0;i<amount;i++) {
26 |             cout<<"p["<<i<<"] = "<<p[i]<<endl;
27 |         }
28 |     }
29 |     else
30 |         cout<<"Not enough Memory ! "<<endl;
31 | 
32 |     return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/CPP026_String_Char_Pointers.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   17.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | int main() {
10 | 
11 |     string text = "Hello"; // H e l l o \0
12 | 
13 |     char ch = text[0];
14 | 
15 |     char characters[]="Hello World";
16 | 
17 |     cout<<characters<<endl;
18 | 
19 |     cout<<characters[0]<<endl;
20 |     cout<<*(characters)<<endl;
21 |     cout<<characters[1]<<endl;
22 |     cout<<*(characters+1)<<endl;
23 | 
24 |     cout<<endl<<endl;
25 | 
26 |     char *p = characters;
27 | 
28 |     cout<<p[0]<<endl;
29 |     cout<<*p<<endl;
30 | 
31 |     cout<<p[1]<<endl;
32 |     cout<<*(p+1)<<endl;
33 | 
34 |     cout<<endl<<endl;
35 | 
36 |     string text1="Hey";
37 | 
38 |     const char * text2 = text1.c_str();
39 |     cout<<text2<<endl;
40 | 
41 |     char array[]="Sample Text";
42 |     string test = array;
43 |     cout<<test<<endl;
44 | 
45 |     const char * a = "Test";
46 |     cout<<a<<endl;
47 | 
48 |     char * const dynamic_array = new char[50];
49 |     dynamic_array[0]='k';
50 |     dynamic_array[1]='\0';
51 |     cout<<dynamic_array<<endl;
52 |     delete [] dynamic_array;
53 | 
54 |     cout<<endl<<endl;
55 | 
56 |     string array_of_strings[5]="qwerty";
57 | 
58 |     array_of_strings[0]="abc";
59 |     array_of_strings[1]="def";
60 | 
61 |     cout<<array_of_strings[0]<<endl;
62 |     cout<<array_of_strings[1]<<endl;
63 |     cout<<array_of_strings[2]<<endl;
64 |     //...
65 | 
66 |     return 0;
67 | }
68 | 


--------------------------------------------------------------------------------
/CPP027_Functions_and_Pointers.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   17.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | void multiplyBy(int *, int);
10 | void multiplyArrayBy(int *, int, int);
11 | int main() {
12 | 
13 |     int a = 10;
14 | 
15 |     multiplyBy(&a,5);
16 | 
17 |     cout<<a<<endl;
18 |     cout<<endl;
19 | 
20 |     int array[10];
21 |     //cout<<sizeof(array)/sizeof(array[0])<<endl;
22 | 
23 |     for(int i=0;i<sizeof(array)/sizeof(array[0]);i++) {
24 |         array[i]=i;
25 |         //cout<<"array ["<<i<<"] = "<<array[i]<<endl;
26 |     }
27 | 
28 |     multiplyArrayBy(array,5,sizeof(array)/sizeof(array[0])); // array = &array[0]
29 | 
30 |     for(int i=0;i<sizeof(array)/sizeof(array[0]);i++) {
31 |         cout<<"array ["<<i<<"] = "<<array[i]<<endl;
32 |     }
33 | 
34 |     return 0;
35 | }
36 | 
37 | void multiplyBy(int *var, int amount) {
38 |     *var = *var * amount;
39 | }
40 | 
41 | void multiplyArrayBy(int *array, int amount, int sizeOfArray) {
42 |     while(sizeOfArray--)
43 |         array[sizeOfArray] *= amount;
44 | 
45 |     /*
46 |     for(int i=0;i<sizeOfArray;i++) {
47 |         array[i] *= amount;
48 |     } */
49 | }
50 | 


--------------------------------------------------------------------------------
/CPP028_Lottery_Exercise.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   27.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | #include <cstdlib>
 8 | #include <ctime>
 9 | using namespace std;
10 | 
11 | void lottery(int, int);
12 | 
13 | int main() {
14 | 
15 |     int total_people,total_winners;
16 |     cout<<"Enter the total number of people : "<<endl;
17 |     cin>>total_people;
18 |     cout<<"Enter the total number of prizes : "<<endl;
19 |     cin>>total_winners;
20 |     lottery(total_people,total_winners);
21 |     return 0;
22 | }
23 | 
24 | void lottery(int total_balls, int balls_to_draw)
25 | {
26 |     if(total_balls < balls_to_draw) {
27 |         cout<<"Draw not possible";
28 |         return;
29 |     }
30 | 
31 |     cout<<"The winners are : "<<endl;
32 | 
33 |     srand(time(NULL));
34 | 
35 |     int *balls = new int[balls_to_draw];
36 | 
37 |     for(int i=0;i<balls_to_draw;i++) {
38 | 
39 |         balls[i] = rand() % total_balls + 1;
40 | 
41 |         for(int j=0;j<i+1;j++) {
42 |             if(balls[i]==balls[j] && i!=j) {
43 |                 i--;
44 |                 break;
45 |             }
46 |             else if(j==i)
47 |                 cout<<balls[i]<<endl;
48 |         }
49 |     }
50 | 
51 |     delete[] balls;
52 | }
53 | 


--------------------------------------------------------------------------------
/CPP029_Type_Casting.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   27.01.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | int main() {
10 | 
11 |     double val=5.5;
12 | 
13 |     cout<<val<<endl;
14 |     cout<<(int)val<<endl; //Explicit Casting
15 | 
16 |     int a=5,b=7;
17 |     cout<<a/b<<endl;
18 |     cout<<(double)a/b<<endl; //Explicit Casting
19 | 
20 |     int x = 444;
21 |     short y=x; //Implicit Casting
22 |     cout<<y<<endl;
23 | 
24 |     cout<< static_cast<int>(val)<<endl; //C++
25 | 
26 |     char ch='t';
27 |     cout<<(int)ch<<endl; //Check ASCII value of a character
28 |     cout<<static_cast<int>(ch)<<endl;
29 | 
30 |     return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/CPP030_Structure.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   02.02.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | struct personalData {
10 |     string name;
11 |     string address;
12 |     string contactNo;
13 |     short age;
14 | };
15 | 
16 | void modify(personalData *);
17 | 
18 | int main() {
19 | 
20 |     personalData person[5];
21 | 
22 |     person[0].name = "Tridib Samanta";
23 |     person[0].address = "Kolkata";
24 |     person[0].contactNo = "+91 9000000000";
25 |     person[0].age = 21;
26 | 
27 |     person[1].name = "Nikola Tesla";
28 | 
29 |     cout<<person[0].name<<endl;
30 |     cout<<person[0].address<<endl;
31 |     cout<<person[0].contactNo<<endl;
32 |     cout<<person[0].age<<endl;
33 | 
34 |     cout<<endl;
35 | 
36 |     //Ways of fetching the values using pointer
37 | 
38 |     cout<<(*person).name<<endl;
39 |     cout<<(*(person+1)).name<<endl;
40 |     cout<<(*&person[0]).name<<endl;
41 |     cout<<(person+1)->name<<endl;
42 | 
43 |     personalData *p = person;
44 |     cout<<p->name<<endl;
45 | 
46 |     cout<<endl;
47 | 
48 |     modify(p);
49 |     cout<<(p+1)->name<<endl;
50 | 
51 |     return 0;
52 | }
53 | 
54 | void modify(personalData *person) {
55 |     (person+1)->name="Peter";
56 | }
57 | 


--------------------------------------------------------------------------------
/CPP031_Classes.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   02.02.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | class MyDetails {
10 | 
11 |     private:
12 |         short age;
13 |         int *p;
14 |     public:
15 | 
16 |         MyDetails() //Constructor
17 |         {
18 |             static int i=0;
19 |             cout<<"This constructor has been just invoked "<<++i<<" time"<<endl;
20 |             age=50;
21 | 
22 |             p=new int[10];
23 |         }
24 | 
25 |         ~MyDetails() //Destructor
26 |         {
27 |             static int j=0;
28 |             cout<<"This Destructor has been just invoked "<<++j<<" time"<<endl;
29 | 
30 |             delete [] p;
31 |         }
32 | 
33 |         void setAge(int value) {
34 |                 if(value<0)
35 |                     age=0;
36 |                 else
37 |                     age=value;
38 |         }
39 |         short getAge() {
40 |             return age;
41 |         }
42 | };
43 | 
44 | int main() {
45 | 
46 |     MyDetails p1;
47 |     MyDetails p2;
48 | 
49 |     p1.setAge(-55);
50 |     p2.setAge(20);
51 | 
52 |     cout<<p1.getAge()<<endl;
53 |     cout<<p2.getAge()<<endl;
54 | 
55 |     return 0;
56 | }
57 | 
58 | 


--------------------------------------------------------------------------------
/CPP032_StaticVariables_StaticFunctions.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   02.02.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | class StaticFunction
10 | {
11 |    public:
12 |     static int my_var;
13 |     static void display()
14 |     {
15 |         cout<<"Static member function"<<endl;
16 |     }
17 | };
18 | 
19 | int StaticFunction::my_var=50;
20 | 
21 | void demo()
22 | {
23 |     static int count = 1;
24 |     cout <<"Value of count is - "<< count <<endl;
25 |     count++;
26 | }
27 | 
28 | int main()
29 | {
30 |     for (int i=1; i<=5; i++)
31 |         demo();
32 | 
33 |     StaticFunction::display();
34 | 
35 |     StaticFunction ob;
36 |     cout <<"Value is : "<<ob.my_var<<endl;
37 | 
38 |     return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/CPP033_Constant_Variables_and_Methods.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   02.02.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | class Demo
10 | {
11 |     public:
12 |     void showMessage()
13 |     {
14 |         cout<<"Hello World inside showMessage()"<<endl;
15 |     }
16 |     void display()const
17 |     {
18 |         const double PI=3.14;
19 |         cout<<"Hello world inside display()"<<endl;
20 |         cout<<PI<<endl;
21 |     }
22 | };
23 | 
24 | int main()
25 | {
26 |     const Demo d1;
27 |     //d1.showMessage(); Error occurred if uncomment.
28 |     d1.display();
29 |     return(0);
30 | }
31 | 


--------------------------------------------------------------------------------
/CPP034_Friend_Function.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   02.02.2020
 4 |  **/
 5 | 
 6 | #include <iostream>
 7 | using namespace std;
 8 | class Box
 9 | {
10 |     private:
11 |         int length;
12 |     public:
13 |         Box(): length(0) { }
14 |         friend int printLength(Box);
15 | };
16 | int printLength(Box b)
17 | {
18 |     b.length += 10;
19 |     return b.length;
20 | }
21 | int main()
22 | {
23 |     Box b;
24 |     cout<<"Length of box: "<< printLength(b)<<endl;
25 |     return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/CPP035_Friend_Classes.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   08.02.2020
 4 |  **/
 5 | 
 6 |  // A friend class is a class that can access the private
 7 |  //and protected members of a class in which it is declared as friend
 8 | 
 9 | #include <iostream>
10 | using namespace std;
11 | 
12 | class XYZ {
13 | 
14 | private:
15 |    string message ="Hello Tridib";
16 |    int pin = 700150;
17 | public:
18 |    /* This statement would make class ABC
19 |     * a friend class of XYZ, this means that
20 |     * ABC can access the private and protected
21 |     * members of XYZ class.
22 |     */
23 |    friend class ABC;
24 | };
25 | 
26 | class ABC {
27 | public:
28 |    void disp(XYZ obj){
29 |       cout<<obj.message<<endl;
30 |       cout<<obj.pin<<endl;
31 |    }
32 | };
33 | 
34 | int main() {
35 |    ABC obj;
36 |    XYZ obj2;
37 |    obj.disp(obj2);
38 |    return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/CPP036_Copy_Constructor.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   08.02.2020
 4 |  **/
 5 | 
 6 | /*
 7 | Copy Constructor is a type of constructor which is used to create a copy of an already existing object of a class type.
 8 | It is usually of the form X (X&), where X is the class name.
 9 | The compiler provides a default Copy Constructor to all the classes.
10 | */
11 | 
12 | #include<iostream>
13 | using namespace std;
14 | class Samplecopyconstructor
15 | {
16 |     private:
17 |     int x, y;   //data members
18 | 
19 |     public:
20 |     Samplecopyconstructor(int x1, int y1)
21 |     {
22 |         x = x1;
23 |         y = y1;
24 |     }
25 | 
26 |     /* Copy constructor */
27 |     Samplecopyconstructor (const Samplecopyconstructor &sam)
28 |     {
29 |         x = sam.x;
30 |         y = sam.y;
31 |     }
32 | 
33 |     void display()
34 |     {
35 |         cout<<x<<" "<<y<<endl;
36 |     }
37 | };
38 | /* main function */
39 | int main()
40 | {
41 |     Samplecopyconstructor obj1(10, 15);     // Normal constructor
42 |     Samplecopyconstructor obj2 = obj1;      // Copy constructor
43 |     cout<<"Normal constructor : ";
44 |     obj1.display();
45 |     cout<<"Copy constructor : ";
46 |     obj2.display();
47 |     return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/CPP037_Operator_Overloading.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   09.02.2020
 4 |  **/
 5 | 
 6 | /*
 7 | Operator that are not overloaded are follows
 8 | ~ scope operator - ::
 9 | ~ sizeof
10 | ~ member selector - .
11 | ~ member pointer selector - *
12 | ~ ternary operator - ?:
13 | */
14 | 
15 | #include <iostream>
16 | using namespace std;
17 | 
18 | class MinusOverload {
19 | private:
20 |  int a;
21 |  int b;
22 | 
23 | public:
24 |  void Distance()
25 |  {
26 |  a = 0;
27 |  b = 0;
28 |  }
29 | 
30 |  MinusOverload(int f, int i)
31 |  {
32 |  int c;
33 |  a = f;
34 |  b = i;
35 |  c = a - b;
36 |  cout << "\nC:" << c<<endl;
37 |  }
38 | 
39 |  void display()
40 |  {
41 |  cout << "A: " << a << " B: " << b << endl;
42 |  }
43 | 
44 |  MinusOverload operator-()
45 |  {
46 |  a = -a;
47 |  b = -b;
48 |  return MinusOverload(a, b);
49 |  }
50 | };
51 | 
52 | int main()
53 | {
54 |  MinusOverload M1(6, 8), M2(-3, -4);
55 |  -M1;
56 |  M1.display();
57 |  -M2;
58 |  M2.display();
59 |  return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/CPP038_Virtual_Function.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   09.02.2020
 4 |  **/
 5 | 
 6 | #include <iostream>
 7 | using namespace std;
 8 | 
 9 | class A
10 | {
11 |  public:
12 |  virtual void display()
13 |  {
14 |   cout << "Base class is invoked"<<endl;
15 |  }
16 | };
17 | class B:public A
18 | {
19 |  public:
20 |  void display()
21 |  {
22 |   cout << "Derived Class is invoked"<<endl;
23 |  }
24 | };
25 | int main()
26 | {
27 |  A* a;    //pointer of base class
28 |  B b;     //object of derived class
29 |  a = &b;
30 |  a->display();   //Late Binding occurs
31 | }
32 | 


--------------------------------------------------------------------------------
/CPP039_AbstractClass_PureVirtualFunction.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   09.02.2020
 4 |  **/
 5 | 
 6 | /*
 7 | One important thing to note is that, you should override the pure virtual function of the base class in the derived class.
 8 | If you fail the override it, the derived class will become an abstract class as well.
 9 | */
10 | 
11 | #include <iostream>
12 | using namespace std;
13 | // Abstract class
14 | class Shape
15 | {
16 |     protected:
17 |        float l;
18 |     public:
19 |        void getData()
20 |        {
21 |            cin >> l;
22 |        }
23 | 
24 |        // virtual Function
25 |        virtual float calculateArea() = 0;
26 | };
27 | class Square : public Shape
28 | {
29 |     public:
30 |        float calculateArea()
31 |        {   return l*l;  }
32 | };
33 | class Circle : public Shape
34 | {
35 |     public:
36 |        float calculateArea()
37 |        { return 3.14*l*l; }
38 | };
39 | int main()
40 | {
41 |     Square s;
42 |     Circle c;
43 |     cout << "Enter length to calculate the area of a square: ";
44 |     s.getData();
45 |     cout<<"Area of square: " << s.calculateArea();
46 |     cout<<"\nEnter radius to calculate the area of a circle: ";
47 |     c.getData();
48 |     cout << "Area of circle: " << c.calculateArea();
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/CPP040_Exception_Handling.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   03.03.2020
 4 |  **/
 5 | 
 6 |  #include<iostream>
 7 |  using namespace std;
 8 | 
 9 |  class DivisionByZeroException
10 |  {
11 |     public:
12 |         void getErrorMessage()
13 |         {
14 |             cout<<"Error : Do not divide by zero !"<<endl;
15 |         }
16 |  };
17 | 
18 |  double division(double a,double b) throw(DivisionByZeroException)
19 |  {
20 |      if(b==0)
21 |         throw DivisionByZeroException();
22 |     return a/b;
23 |  }
24 | 
25 |  int main() {
26 |     double result;
27 |     try {
28 |         result = division(13,0);
29 |         cout<<"The result is = "<<result<<endl;
30 |     }
31 |     //This catch block handles DivisionByZeroException type of exception only
32 |     catch(DivisionByZeroException e) {
33 |         e.getErrorMessage();
34 |     }
35 |     //This catch block handles all other types of exceptions
36 |     catch(...)
37 |     {
38 |         cout<<"Error !"<<endl;
39 |     }
40 |     return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/CPP041_Namespaces.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Author:    Tridib Samanta
 3 |  * Created:   03.03.2020
 4 |  **/
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | namespace A
10 | {
11 |     int var = 20;
12 | }
13 | 
14 | namespace B
15 | {
16 |     int var = 40;
17 | }
18 | 
19 | int main() {
20 |     int var = 50;
21 |     //Accessing var from namespace std
22 |     cout<<var<<endl;
23 |     //Accessing var from namespace A
24 |     cout<<A::var<<endl;
25 |     //Accessing var from namespace B
26 |     cout<<B::var<<endl;
27 |     return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # C++ (Beginner to Expert)
 2 | 
 3 | ![C++](https://upload.wikimedia.org/wikipedia/commons/thumb/1/18/ISO_C%2B%2B_Logo.svg/213px-ISO_C%2B%2B_Logo.svg.png)
 4 | 
 5 | ***Basic to Expert level concepts implemented using the C++ language.***
 6 | 
 7 | The following topics are covered in my repository : 
 8 | 
 9 | :white_check_mark: CPP001_First_Program.cpp - First program, display "Hello World !"
10 | 
11 | :white_check_mark: CPP002_Variables.cpp - Introduction to variables
12 | 
13 | :white_check_mark: CPP003_Variables_Types.cpp - Getting familier with the datatypes 
14 | 
15 | :white_check_mark: CPP004_Input.cpp - Console Input / Output
16 | 
17 | :white_check_mark: CPP005_Arithmetic_Assignment_Increment_Decrement_Operators.cpp - Arithmetic, Assignment, Increment, Decrement Operators
18 | 
19 | :white_check_mark: CPP006_Relational_Operators.cpp - Relational Operators 
20 | 
21 | :white_check_mark: CPP007_Logical_Operators.cpp - Logical Operators 
22 | 
23 | :white_check_mark: CPP008_Calculator_Exercise.cpp - Simple Calculator Program
24 | 
25 | :white_check_mark: CPP009_Arrays.cpp - Arrays
26 | 
27 | :white_check_mark: CPP010_Multidimensional_Arrays.cpp - Multidimensional Arrays
28 | 
29 | :white_check_mark: CPP011_For.cpp - For Loop
30 | 
31 | :white_check_mark: CPP012_While_DoWhile.cpp - While Loop & Do While Loop
32 | 
33 | :white_check_mark: CPP013_Counting_Digits_Exercise.cpp - Counting the number of digits in a number
34 | 
35 | :white_check_mark: CPP014_Nested_Loops.cpp - Nested Loops
36 | 
37 | :white_check_mark: CPP015_Break_Continue.cpp - Break & Continue
38 | 
39 | :white_check_mark: CPP016_Variables_Scope.cpp - Scope of Variables
40 | 
41 | :white_check_mark: CPP017_Functions.cpp - Understanding Functions
42 | 
43 | :white_check_mark: CPP018_Overloading_Functions.cpp - Function Overloading
44 | 
45 | :white_check_mark: CPP019_CalculateArea_Exercise.cpp - Calculate the area of Circle, Square, Rectangle, Triangle using functions
46 | 
47 | :white_check_mark: CPP020_Enumeration.cpp - Enumerated Types
48 | 
49 | :white_check_mark: CPP021_ReferenceVariables.cpp - Reference Variables
50 | 
51 | :white_check_mark: CPP022_ReferenceVariables_Functions.cpp - Reference Variables and Functions 
52 | 
53 | :white_check_mark: CPP023_Pointers.cpp - Pointers
54 | 
55 | :white_check_mark: CPP024_Pointers_in_Arrays.cpp - Pointers & Arrays
56 | 
57 | :white_check_mark: CPP025_Dynamic_Memory_Allocation.cpp - Dynamic Memory Allocation
58 | 
59 | :white_check_mark: CPP026_String_Char_Pointers.cpp - Dealing with string, char & pointers
60 | 
61 | :white_check_mark: CPP027_Functions_and_Pointers.cpp - Passing pointer array to functions
62 | 
63 | :white_check_mark: CPP028_Lottery_Exercise.cpp - Generate random winners in a lottery
64 | 
65 | :white_check_mark: CPP029_Type_Casting.cpp - Type casting
66 | 
67 | :white_check_mark: CPP030_Structure.cpp - Structures
68 | 
69 | :white_check_mark: CPP031_Classes.cpp - Classes, Constructors, Destructors 
70 | 
71 | :white_check_mark: CPP032_StaticVariables_StaticFunctions.cpp - Static variables and functions
72 | 
73 | :white_check_mark: CPP033_Constant_Variables_and_Methods.cpp - Constant variables and methods
74 | 
75 | :white_check_mark: CPP034_Friend_Function.cpp - Friend function
76 | 
77 | :white_check_mark: CPP035_Friend_Classes.cpp - Friend Classes
78 | 
79 | :white_check_mark: CPP036_Copy_Constructor.cpp - Copy Constructor
80 | 
81 | :white_check_mark: CPP037_Operator_Overloading.cpp - Operator Overloading
82 | 
83 | :white_check_mark: CPP038_Virtual_Function.cpp - Virtual Function
84 | 
85 | :white_check_mark: CPP039_AbstractClass_PureVirtualFunction.cpp - Abstract Class & Pure Virtual Function
86 | 
87 | :white_check_mark: CPP040_Exception_Handling.cpp - Handling Exceptions
88 | 
89 | :white_check_mark: CPP041_Namespaces.cpp - Understanding Namespaces
90 | 
91 | 
92 | ***Contributed with  :blue_heart:  by Tridib***
93 | 


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