├── Find_Element_In_Array.cpp
├── Find_Max_In_Array.cpp
├── Find_Min_In_Array.cpp
├── First_Program.cpp
├── Function overloading.cpp
├── README.md
├── Reverse_An_Array.cpp
├── Template_Calculator.cpp
├── template.cpp
├── template_Array.cpp
├── template_Loop.cpp
├── template_Swap.cpp
├── template_functions.cpp
├── template_max.cpp
├── template_min.cpp
└── template_with_diff_dtype_arg.cpp


/Find_Element_In_Array.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 | int input[100], count, i, num;
 6 |        
 7 |     cout << "Enter Number of Elements in Array\n";
 8 |     cin >> count;
 9 |      
10 |     cout << "Enter " << count << " numbers \n";
11 |       
12 |     // Read array elements
13 |     for(i = 0; i < count; i++){
14 |         cin >> input[i];
15 |     }
16 |       
17 |     cout << "Enter a number to serach in Array\n";
18 |     cin >> num;
19 |       
20 |     // search num in inputArray from index 0 to elementCount-1 
21 |     for(i = 0; i < count; i++){
22 |         if(input[i] == num){
23 |             cout << "Element found at index " << i;
24 |             break;
25 |         }
26 |     }
27 |       
28 |     if(i == count){
29 |         cout  << "Element Not Present in Input Array\n";
30 |     }
31 | 
32 | 
33 | return 0;
34 | }
35 | 
36 | 


--------------------------------------------------------------------------------
/Find_Max_In_Array.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |    
 4 | int main(){
 5 |     int inputArray[500], N, i, max;
 6 |        
 7 |     cout << "Enter Number of Elements in Array\n";
 8 |     cin >> N;
 9 |     cout << "Enter " << N << " numbers\n";
10 |       
11 |     /* Read array elements */
12 |     for(i = 0; i < N; i++){
13 |         cin >> inputArray[i];
14 |     }
15 |       
16 |     max = inputArray[0];
17 |     /* traverse array elements */
18 |     for(i = 1; i < N; i++){
19 |         if(inputArray[i] > max)
20 |             max = inputArray[i];
21 |     }
22 |       
23 |     cout << "Maximum Element : " << max;
24 |            
25 |     return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/Find_Min_In_Array.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |    
 4 | int main(){
 5 |     int input[100], count, i, min;
 6 |        
 7 |     cout << "Enter Number of Elements in Array\n";
 8 |     cin >> count;
 9 |      
10 |     cout << "Enter " << count << " numbers \n";
11 |       
12 |     // Read array elements
13 |     for(i = 0; i < count; i++){
14 |         cin >> input[i];
15 |     }
16 |      
17 |     min = input[0];
18 |     // search num in inputArray from index 0 to elementCount-1 
19 |     for(i = 0; i < count; i++){
20 |         if(input[i] < min){
21 |             min = input[i];
22 |         }
23 |     }
24 |  
25 |     cout  << "Minimum Element\n" << min;
26 |  
27 |     return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/First_Program.cpp:
--------------------------------------------------------------------------------
 1 | // First Program using C++
 2 | // Date : 29 September 2021
 3 | // Course : Object Oriented Programming 
 4 | 
 5 | #include <iostream> // Add Preprocessor Directives
 6 | using namespace std;
 7 | 
 8 | 	int main() {
 9 | 	cout << "Start Pogramming with C++";
10 | 	return 0;
11 | 	}
12 | 


--------------------------------------------------------------------------------
/Function overloading.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<iomanip>
 3 | using namespace std;
 4 | 
 5 | //Function Overloading 
 6 | 
 7 | int add(int x ,int y)
 8 | {
 9 | 	return x+y;
10 | }
11 | 
12 | float add(float x ,float y)
13 | {
14 | 	return x+y; 
15 | }
16 | 
17 | double add (double x ,double y)
18 | {
19 | 	return x+y;
20 | }
21 | 
22 | int main()
23 | {
24 | 
25 | cout<<"Addition of 2 integer 2 and 4 is : "<<add(2,4)<<endl;
26 | cout<<"Addition of 2 float 5.5 and 6.5 is: "<<add(5.5,6.5)<<endl;
27 | cout<<"Addition of 2 double 5.0256545 and 6.125588 is: "<<add(5.0256,6.125);
28 | 
29 | return 0;
30 | }
31 | 
32 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Object-Oriented-C-plus-plus
2 | This Repository contain C++ code from Beginner to Intermediate level
3 | 


--------------------------------------------------------------------------------
/Reverse_An_Array.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |   
 4 | int main(){
 5 |     int input[500], output[500], count, i;
 6 |       
 7 |     cout << "Enter number of elements in array\n";
 8 |     cin >> count;
 9 |      
10 |     cout << "Enter " << count << " numbers \n";
11 |       
12 |     for(i = 0; i < count; i++){
13 |         cin >> input[i];
14 |     }
15 |       
16 |     // Copy numbers from inputArray to outputArray in 
17 |     // reverse order 
18 |     for(i = 0; i < count; i++){
19 |         output[i] = input[count-i-1];
20 |     }    
21 |     // Print Reversed array
22 |     cout << "Reversed Array\n";
23 |     for(i = 0; i < count; i++){
24 |         cout << output[i] << " ";
25 |     }
26 |           
27 |     return 0;
28 | }
29 | 
30 | 


--------------------------------------------------------------------------------
/Template_Calculator.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | template <class T>
 5 | class Calculator {
 6 |    private:
 7 |     T num1, num2;
 8 | 
 9 |    public:
10 |     Calculator(T n1, T n2) {
11 |         num1 = n1;
12 |         num2 = n2;
13 |     }
14 | 
15 |     void displayResult() {
16 |         cout << "Numbers: " << num1 << " and " << num2 << "." << endl;
17 |         cout << num1 << " + " << num2 << " = " << add() << endl;
18 |         cout << num1 << " - " << num2 << " = " << subtract() << endl;
19 |         cout << num1 << " * " << num2 << " = " << multiply() << endl;
20 |         cout << num1 << " / " << num2 << " = " << divide() << endl;
21 |     }
22 | 
23 |     T add() { return num1 + num2; }
24 |     T subtract() { return num1 - num2; }
25 |     T multiply() { return num1 * num2; }
26 |     T divide() { return num1 / num2; }
27 | };
28 | 
29 | int main() {
30 |     Calculator<int> intCalc(2, 1);
31 |     Calculator<float> floatCalc(2.4, 1.2);
32 | 
33 |     cout << "Int results:" << endl;
34 |     intCalc.displayResult();
35 | 
36 |     cout << endl
37 |          << "Float results:" << endl;
38 |     floatCalc.displayResult();
39 | 
40 |     return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/template.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<iomanip>
 3 | using namespace std;
 4 | 
 5 | //Templete in C++  
 6 | 
 7 | template <typename T>
 8 | T add(T	x,T y)
 9 | {
10 | 	return x+y;
11 | }
12 | 
13 | 
14 | 
15 | int main()
16 | {
17 | 
18 | cout<<"Addition of 2 integer 2 and 4 is : "<<add(2,4)<<endl;
19 | cout<<"Addition of 2 float 5.5 and 6.5 is: "<<add(5.5,6.5)<<endl;
20 | cout<<"Addition of 2 double 5.0256545 and 6.125588 is: "<<add(5.0256,6.125);
21 | 
22 | return 0;
23 | }
24 | 
25 | 


--------------------------------------------------------------------------------
/template_Array.cpp:
--------------------------------------------------------------------------------
 1 | /*  Sum of Array using function template  */
 2 | 
 3 | #include <iostream>
 4 | 
 5 | using namespace std;
 6 | 
 7 | 
 8 | template<class T> T sum(T a[], int length)
 9 | {
10 |         T result = a[0];
11 |         for (int i = 1; i < length; i ++)
12 |                 result += a[i];
13 | 
14 |         return result;
15 | }
16 | 
17 | int main(void) {
18 |         int int_data[5];
19 |         float float_data[5];
20 |         int i = 0;
21 | 
22 |         // input 5 integers
23 |         cout << "\nInput 5 integers :: \n" << endl;
24 |         for (; i < 5; i++)
25 |                 cin >> int_data[i];
26 |         // print sum of 5 integers
27 |         cout << "\nSum of above is :: " << sum(int_data, 5) << endl;
28 | 
29 |         // input 5 float numbers
30 |         cout << "\nInput 5 floats :: \n" << endl;
31 |         for (i = 0; i < 5; i ++)
32 |                 cin >> float_data[i];
33 |         // print sum of 5 float numbers
34 |         cout << "\nSum of above is :: " << sum(float_data, 5) << endl;
35 | 
36 |         cin.get();
37 |         return 0;
38 | }
39 | 
40 | 


--------------------------------------------------------------------------------
/template_Loop.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>  
 2 | using namespace std;  
 3 | template<class T, int size>  
 4 | class A   
 5 | {  
 6 |     public:  
 7 |     T arr[size];  
 8 |     void insert()  
 9 |     {  
10 |         int i =1;  
11 |         for (int j=0;j<size;j++)  
12 |         {  
13 |             arr[j] = i;  
14 |             i++;  
15 |         }  
16 |     }  
17 |       
18 |     void display()  
19 |     {  
20 |         for(int i=0;i<size;i++)  
21 |         {  
22 |             std::cout << arr[i] << " ";  
23 |         }  
24 |     }  
25 | };  
26 | int main()  
27 | {  
28 |     A<int,10> t1;  
29 |     t1.insert();  
30 |     t1.display();  
31 |     return 0;  
32 | }  
33 | 


--------------------------------------------------------------------------------
/template_Swap.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 |  
 4 | template <typename T>
 5 | void func_swap(T &arg1, T &arg2)
 6 | {
 7 |   T temp;
 8 |   temp = arg1;
 9 |   arg1 = arg2;
10 |   arg2 = temp;
11 | }
12 |  
13 | int main()
14 | {
15 |   int num1 = 10, num2 = 20;
16 |   double d1 = 100.53, d2 = 435.54;
17 |   char ch1 = 'A', ch2 = 'Z';
18 |    
19 |   cout << "Original data\n";
20 |   cout << "num1 = " << num1 << "\tnum2 = " << num2<<endl;
21 |   cout << "d1 = " << d1 << "\td2 = " << d2<<endl;
22 |   cout << "ch1 = " << ch1 << "\t\tch2 = " << ch2<<endl;
23 |    
24 |   func_swap(num1, num2);
25 |   func_swap(d1, d2);
26 |   func_swap(ch1, ch2);
27 |    
28 |   cout << "\n\nData after swapping\n";
29 |   cout << "num1 = " << num1 << "\tnum2 = " << num2<<endl;
30 |   cout << "d1 = " << d1 << "\td2 = " << d2<<endl;
31 |   cout << "ch1 = " << ch1 << "\t\tch2 = " << ch2<<endl;
32 |    
33 |   return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/template_functions.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 |  
 4 | // class template:
 5 | template <class T>
 6 | class myIncrement {
 7 |   T value;
 8 |   public:
 9 |   myIncrement (T arg) {value=arg;}
10 |   T toIncrement () {return ++value;}
11 | };
12 | // class template specialization:
13 | template <>
14 | class myIncrement <char> {
15 |    char value;
16 |   public:
17 |    myIncrement (char arg) {value=arg;}
18 |    char uppercase ()
19 |   {
20 |     if ((value>='a')&&(value<='z'))
21 |     value+='A'-'a';
22 |     return value;
23 |   }
24 | };
25 | int main () {
26 |   myIncrement<int> myint (7);
27 |   myIncrement<char> mychar ('s');
28 |   myIncrement<double> mydouble(11.0);
29 |   
30 |   cout<<"Incremented int value: "<< myint.toIncrement()<< endl;
31 |   cout<<"Uppercase value: "<<mychar.uppercase()<< endl;
32 |   cout<<"Incremented double value: "<<mydouble.toIncrement()<< endl;
33 |   return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/template_max.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | template <typename P>
 4 | P maxm(P x, P y){
 5 | 	return x>y ? x:y;
 6 | }
 7 | int main(){
 8 | 	cout<<"Max:"<<maxm(8,5)<<endl;
 9 | 	cout<<"Max:"<<maxm(7.5,5.9)<<endl;
10 | 	cout<<"Max:"<<maxm(7.7,5.5)<<endl;
11 | return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/template_min.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | template <typename T>
 4 | T mini(T x, T y){
 5 | 	return x < y ? x:y;
 6 | 
 7 | }
 8 | 
 9 | int main(){
10 | 	cout<<"Mini:"<<mini(7,5)<<endl;
11 | 	cout<<"Mini:"<<mini(7.5,5.9)<<endl;
12 | 	cout<<"Mini:"<<mini<int>(7.7,5)<<endl;
13 | 
14 | return 0;
15 | }
16 | 
17 | 


--------------------------------------------------------------------------------
/template_with_diff_dtype_arg.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<iomanip>
 3 | using namespace std;
 4 | 
 5 | //Templete in C++  
 6 | 
 7 | template <typename T, typename U>
 8 | U add(T	x,U y)
 9 | {
10 | 	return x+y;
11 | }
12 | 
13 | 
14 | 
15 | int main()
16 | {
17 | 
18 | cout<<"Addition of 2 integer and double 2 and 4.5 is : "<<add<int,double>(2,4.5)<<endl;
19 | cout<<"Addition of 2 float 5.5 and 6.5 is: "<<add<float,double>(5.5f,6.5)<<endl;
20 | cout<<"Addition of 2 double 5.0256545 and 6.125588 is: "<<add<double,int>(5.0256,6);
21 | 
22 | return 0;
23 | }
24 | 
25 | 


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