├── Commandline.cpp
├── Convert.cpp
├── DoubleLL.cpp
├── Expt_1_1.cpp
├── Expt_1_2.cpp
├── Expt_2_1_1.cpp
├── Expt_2_1_2.cpp
├── Expt_2_2.cpp
├── Expt_2_3.cpp
├── Expt_3_1.cpp
├── Expt_3_2.cpp
├── Expt_3_3.cpp
├── Expt_4_1_1.cpp
├── Expt_4_1_2.cpp
├── Independence.txt
├── Inheritance.cpp
├── Inheritance
    ├── single_private.cpp
    ├── single_protected.cpp
    └── single_public.cpp
├── README.md
├── bestgenericfunction.cpp
├── binaryclass.cpp
├── binaryfile.cpp
├── binarytree.cpp
├── binarytrees.cpp
├── class.cpp
├── class1.cpp
├── class_write_basic.cpp
├── constructor.cpp
├── copycons (1).cpp
├── copycons.cpp
├── defaultarg.cpp
├── destructor.cpp
├── dynamic.cpp
├── file_write_basic.txt
├── friendone.cpp
├── friendtwo.cpp
├── functionoverload.cpp
├── genfunc_twotypes.cpp
├── graph1.cpp
├── hybridex.cpp
├── hybridvirtual.cpp
├── independence.cpp
├── inheritance.cpp
├── init_nocons.cpp
├── inline.cpp
├── linkedmain.cpp
├── multilevel.cpp
├── multipleambiguity.cpp
├── object_argunment.cpp
├── pub_pri_call.cpp
├── read_file_basic.cpp
├── read_write_basic.cpp
├── sampleprogram.cpp
├── single_private.cpp
├── single_protected.cpp
├── single_public.cpp
├── static.cpp
├── string.cpp
└── write_file_basic.cpp


/Commandline.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main(int argc,char *argv[])
 4 | {
 5 | int i=1;
 6 | cout<<"The name of the file is"<<argv[0]<<endl;
 7 | while(i<argc)
 8 | {
 9 | cout<<"The "<<i<<" string is "<<argv[i]<<endl;
10 | i++;
11 | }
12 | return 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/Convert.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 | 	int n,m,i,j,k,count=0;
 6 | 	cin>>n>>m;
 7 | 	k=n*m;
 8 | 	int arr1[n][m];
 9 | 	int arr2[k];
10 | 	for(i=0;i<n;i++)
11 | 	{
12 | 		for(j=0;j<m;j++)
13 | 		{
14 | 			cin>>arr1[i][j];
15 | 		}
16 | 	}
17 | 	for(i=0;i<n;i++)
18 | 	{
19 | 		for(j=0;j<m;j++)
20 | 		{
21 | 			arr2[count++]=arr1[i][j];
22 | 		}
23 | 	}
24 | 	cout<<"Displaying 2D array\n";
25 | 	for(i=0;i<n;i++)
26 | 	{
27 | 		for(j=0;j<m;j++)
28 | 		{
29 | 			cout<<arr1[i][j]<<"\t";
30 | 		}
31 | 		cout<<"\n";
32 | 	}
33 | 	cout<<"Displaying 1D array\n";
34 | 	for(i=0;i<k;i++)
35 | 	{
36 | 		cout<<arr2[i]<<"\t";
37 | 	}
38 | }
39 | 


--------------------------------------------------------------------------------
/DoubleLL.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | using namespace std;
  3 | class student
  4 | {
  5 | 	public:
  6 | string rollno;
  7 | string sapid;
  8 | string name;
  9 | string specialization;
 10 | student *next; 
 11 | student *prev;
 12 | student()
 13 | {
 14 | rollno="R171217041";
 15 | sapid="500060720";
 16 | name="Nishkarsh Raj Khare";
 17 | specialization="DevOps";	
 18 | }	
 19 | void insert()
 20 | {
 21 | 	cout<<"Enter the name of the person"<<endl;
 22 | 	cin>>name;
 23 | 	cout<<"Enter the sapid of the student"<<endl;
 24 | 	cin>>sapid;
 25 | 	cout<<"Enter the rollno of the student"<<endl;
 26 | 	cin>>rollno;
 27 | 	cout<<"Enter the Specialization of the student"<<endl;
 28 | 	cin>>specialization;
 29 | }
 30 | void show()
 31 | {
 32 | 	cout<<"Name of the student is :"<<name<<endl;
 33 | 	cout<<"Roll Number of the student is :"<<rollno<<endl;
 34 | 	cout<<"Sapid of the student is :"<<sapid<<endl;
 35 | 	cout<<"Specialization of the student is :"<<specialization<<endl;
 36 | }
 37 | };
 38 | int main()
 39 | {
 40 | 	cout<<"Hello! This is a code of Double Linked List on Student's Data"<<endl;
 41 | 	//Creation of first node
 42 | 	student *node,*ptr,*p,*start;
 43 | 	node=new student;
 44 | 	cout<<"Lets insert the first node data"<<endl;
 45 | 	node->insert();
 46 | 	node->next=NULL;
 47 | 	node->prev=NULL;
 48 | 	cout<<"Lets see the details of first node"<<endl;
 49 | 	node->show();
 50 | 	start=node;
 51 | 	string n,n2;
 52 | 	int flag=0;
 53 | 	int quit=0,choice;
 54 | 	do
 55 | 	{
 56 | 	cout<<"\t\t\t\tOption Menu\n\n"<<endl;
 57 | 	cout<<"1) Insertion at Beginning"<<endl;
 58 | 	cout<<"2) Insertion at End"<<endl;
 59 | 	cout<<"3) Insertion at any point"<<endl;
 60 | 	cout<<"4) Deletion at Beginning"<<endl;
 61 | 	cout<<"5) Deleltion at end"<<endl;
 62 | 	cout<<"6) Deletion at any point"<<endl;
 63 | 	cout<<"7) Traversal of nodes from start"<<endl;
 64 | 	cout<<"8) Traversal of nodes from last"<<endl;
 65 | 	cout<<"9) Quit"<<endl;
 66 | 	cout<<"Enter your choice"<<endl;
 67 | 	cin>>choice;
 68 | 	switch(choice)
 69 | 	{
 70 | 		case 1: cout<<"Insertion at Beginning"<<endl;
 71 | 				ptr=new student;
 72 | 				ptr->insert();
 73 | 				start->prev=ptr;
 74 | 				ptr->next=start;
 75 | 				ptr->prev=NULL;
 76 | 				start=ptr;
 77 | 			break;
 78 | 		case 2: cout<<"Insertion at End"<<endl;
 79 | 				node=new student;
 80 | 				node->insert();
 81 | 				node->next=NULL;
 82 | 				for(ptr=start;ptr->next!=NULL;ptr=ptr->next);
 83 | 				ptr->next=node;
 84 | 				node->prev=ptr;
 85 | 				break;
 86 | 		case 3: cout<<"Insertion at any point"<<endl;
 87 | 				cout<<"Enter the name of the student after which you want to make the insertion"<<endl;
 88 | 				cin>>n;
 89 | 				for(ptr=start;ptr!=NULL;ptr=ptr->next)
 90 | 				{
 91 | 					if(ptr->name==n)
 92 | 					break;
 93 | 				}
 94 | 				node=new student;
 95 | 				node->insert();
 96 | 				p=ptr->next;
 97 | 				node->next=ptr->next;
 98 | 				node->prev=p->prev;
 99 | 				ptr->next=node;
100 | 			break;
101 | 		case 4: cout<<"Deletion at beginning"<<endl;
102 | 				ptr=start;
103 | 				start=ptr->next;
104 | 				delete ptr;
105 | 			break;
106 | 		case 5: cout<<"Deletion at End"<<endl;
107 | 				for(ptr=start;ptr->next!=NULL;p=ptr,ptr=ptr->next);
108 | 				delete ptr;
109 | 				p->next=NULL;
110 | 			break;
111 | 		case 6: cout<<"Deletion anywhere"<<endl;
112 | 				cout<<"Enter name of the student whose record you want to delete"<<endl;
113 | 				cin>>n2;
114 | 				for(ptr=start;ptr->next!=NULL;p=ptr,ptr=ptr->next)
115 | 				{
116 | 					if(ptr->name==n2)
117 | 					{
118 | 					flag=1;
119 | 					break;
120 | 					}
121 | 					if(flag==1)
122 | 					{
123 | 						cout<<"Record Does not exist"<<endl;
124 | 					}
125 | 					else
126 | 					{
127 | 						p->next=ptr->next;
128 | 						delete ptr;
129 | 					}
130 | 				}
131 | 			break;
132 | 		case 7: cout<<"Traversal from start"<<endl;
133 | 				for(ptr=start;ptr!=NULL;ptr=ptr->next)
134 | 				ptr->show();
135 | 			break;
136 | 		case 8: cout<<"Traversal from the end"<<endl;
137 | 				for(ptr=start;ptr->next!=NULL;ptr=ptr->next);
138 | 				for(;ptr!=NULL;ptr=ptr->prev)
139 | 				{
140 | 					ptr->show();
141 | 				}
142 | 			break;
143 | 		case 9: quit=1;
144 | 			break;
145 | 		default: cout<<"Wrong Choice! Please Try Again"<<endl;
146 | 	}
147 |     }while(quit!=1);  
148 | 	return 0;
149 | }
150 | 


--------------------------------------------------------------------------------
/Expt_1_1.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class lenght1 //unlike main its not allowed to make variable declarations within member functions/
 4 | {
 5 | float lenght;
 6 | float l1;
 7 | public:
 8 | void setlenght(float l)
 9 | {
10 | lenght=l;
11 | }
12 | void convert()
13 | {
14 | if(lenght>12)
15 | {
16 | l1=(int)lenght/12;
17 | lenght=int(lenght)%12; //note that float does not allow mod function to work upon
18 | }
19 | cout<<"Lenght is "<<l1<<" feets and "<<lenght<<" inches"<<endl;
20 | }
21 | };
22 | int main()
23 | {
24 | cout<<"Program to convert Lenght from inches to foot+inches"<<endl;
25 | float l;
26 | cout<<"Enter lenght in inches"<<endl;
27 | cin>>l;
28 | lenght1 obj;
29 | obj.setlenght(l);
30 | obj.convert();
31 | cout<<endl;
32 | return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/Expt_1_2.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class Queue
 4 | {
 5 | public: //all public needed to access outside in main
 6 | string name;
 7 | int roll_number;
 8 | double total_marks;
 9 | Queue *next;
10 | void show()
11 | {
12 | cout<<endl; 
13 | cout<<"Name of the person is "<<name<<endl<<"Roll number of the person is "<<roll_number<<endl<<"Total marks of the person are "<<total_marks<<endl;
14 | }
15 | }*rear,*front,*node,*ptr,*p;
16 | int main()
17 | {
18 | int quit=0;
19 | cout<<"Hello! This is a program to demonstrate Queue implementation using Classes and Objects"<<endl;
20 | 	node=new Queue;
21 | 	cout<<"Enter the name of this person"<<endl;
22 | 	cin>>node->name;
23 | 	cout<<"Enter the roll number of this person"<<endl;
24 | 	cin>>node->roll_number;
25 | 	cout<<"Enter the total marks of this person"<<endl;
26 | 	cin>>node->total_marks;
27 | 	node->next=NULL;
28 | front=node;
29 | rear=node;
30 | node->show();
31 | cout<<endl;
32 | cout<<"Let the party begins"<<endl;
33 | do
34 | {
35 | cout<<"\t\t\t\tOption Menu"<<endl;
36 | cout<<"1) Insert"<<endl;
37 | cout<<"2) Delete"<<endl;
38 | cout<<"3) Show"<<endl;
39 | cout<<"4) Exit"<<endl;
40 | int ch;
41 | cout<<"Enter your choice"<<endl;
42 | cin>>ch;
43 | switch(ch)
44 | {
45 | case 1: cout<<"Insertion at end"<<endl;
46 | 	p=new Queue;
47 | 	cout<<"Enter the name of this person"<<endl;
48 | 	cin>>p->name;
49 | 	cout<<"Enter the roll number of this person"<<endl;
50 | 	cin>>p->roll_number;
51 | 	cout<<"Enter the total marks of this person"<<endl;
52 | 	cin>>p->total_marks;
53 | 	rear->next=p;
54 | p->next=NULL;
55 | rear=p;
56 | break;
57 | case 2: cout<<"Deletion at beginning"<<endl;
58 | cout<<"Object to be deleted is"<<endl;
59 | front->show();
60 | ptr=front;
61 | front=front->next;
62 | delete ptr;
63 | break;
64 | case 3: cout<<"Traversal"<<endl;
65 | for(ptr=front;ptr!=NULL;ptr=ptr->next)
66 | {
67 | int i=1;
68 | cout<<"The "<<i++<<" Record is of";
69 | ptr->show();
70 | }
71 | break;
72 | case 4: quit=1;
73 | break;
74 | default: cout<<"Wrong Choice! Try again"<<endl;
75 | }
76 | }while(quit!=1);
77 | return 0;
78 | }
79 | 


--------------------------------------------------------------------------------
/Expt_2_1_1.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class lenght1 //unlike main its not allowed to make variable declarations within member functions/
 4 | {
 5 | float lenght;
 6 | float l1;
 7 | public:
 8 | lenght1()
 9 | {
10 | lenght=100;
11 | l1=50;
12 | }
13 | ~lenght1()
14 | {
15 | cout<<"Object Destroyed"<<endl;
16 | }
17 | void setlenght(float l)
18 | {
19 | lenght=l;
20 | }
21 | void convert()
22 | {
23 | if(lenght>12)
24 | {
25 | l1=(int)lenght/12;
26 | lenght=int(lenght)%12; //note that float does not allow mod function to work upon
27 | }
28 | cout<<"Lenght is "<<l1<<" feets and "<<lenght<<" inches"<<endl;
29 | }
30 | };
31 | int main()
32 | {
33 | cout<<"Program to convert Lenght from inches to foot+inches"<<endl;
34 | float l;
35 | cout<<"Enter lenght in inches"<<endl;
36 | cin>>l;
37 | lenght1 obj;
38 | obj.setlenght(l);
39 | obj.convert();
40 | cout<<endl;
41 | return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/Expt_2_1_2.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class Queue
 4 | {
 5 | public: //all public needed to access outside in main
 6 | string name;
 7 | int roll_number;
 8 | double total_marks;
 9 | Queue *next;
10 | Queue()
11 | {
12 | name="Nishkarsh";
13 | roll_number=41;
14 | total_marks=256.60;
15 | }
16 | ~Queue()
17 | {
18 | cout<<"Object Destroyed"<<endl;
19 | }
20 | void show()
21 | {
22 | cout<<endl; 
23 | cout<<"Name of the person is "<<name<<endl<<"Roll number of the person is "<<roll_number<<endl<<"Total marks of the person are "<<total_marks<<endl;
24 | }
25 | }*rear,*front,*node,*ptr,*p;
26 | int main()
27 | {
28 | int quit=0;
29 | cout<<"Hello! This is a program to demonstrate Queue implementation using Classes and Objects"<<endl;
30 | 	node=new Queue;
31 | 	cout<<"Enter the name of this person"<<endl;
32 | 	cin>>node->name;
33 | 	cout<<"Enter the roll number of this person"<<endl;
34 | 	cin>>node->roll_number;
35 | 	cout<<"Enter the total marks of this person"<<endl;
36 | 	cin>>node->total_marks;
37 | 	node->next=NULL;
38 | front=node;
39 | rear=node;
40 | node->show();
41 | cout<<endl;
42 | cout<<"Let the party begins"<<endl;
43 | do
44 | {
45 | cout<<"\t\t\t\tOption Menu"<<endl;
46 | cout<<"1) Insert"<<endl;
47 | cout<<"2) Delete"<<endl;
48 | cout<<"3) Show"<<endl;
49 | cout<<"4) Exit"<<endl;
50 | int ch;
51 | cout<<"Enter your choice"<<endl;
52 | cin>>ch;
53 | switch(ch)
54 | {
55 | case 1: cout<<"Insertion at end"<<endl;
56 | 	p=new Queue;
57 | 	cout<<"Enter the name of this person"<<endl;
58 | 	cin>>p->name;
59 | 	cout<<"Enter the roll number of this person"<<endl;
60 | 	cin>>p->roll_number;
61 | 	cout<<"Enter the total marks of this person"<<endl;
62 | 	cin>>p->total_marks;
63 | 	rear->next=p;
64 | p->next=NULL;
65 | rear=p;
66 | break;
67 | case 2: cout<<"Deletion at beginning"<<endl;
68 | cout<<"Object to be deleted is"<<endl;
69 | front->show();
70 | ptr=front;
71 | front=front->next;
72 | delete ptr;
73 | break;
74 | case 3: cout<<"Traversal"<<endl;
75 | for(ptr=front;ptr!=NULL;ptr=ptr->next)
76 | {
77 | int i=1;
78 | cout<<"The "<<i++<<" Record is of";
79 | ptr->show();
80 | }
81 | break;
82 | case 4: quit=1;
83 | break;
84 | default: cout<<"Wrong Choice! Try again"<<endl;
85 | }
86 | }while(quit!=1);
87 | return 0;
88 | }
89 | 


--------------------------------------------------------------------------------
/Expt_2_2.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class WWE
 4 | {
 5 | string name;
 6 | float salary;
 7 | string nickname;
 8 | public:
 9 | WWE()
10 | {
11 | name="Seth Rollins";
12 | salary=2000000;
13 | nickname="The Architect";
14 | }
15 | ~WWE()
16 | {
17 | cout<<"Object Destroyed"<<endl;
18 | }
19 | WWE(string n,float s,string nn)
20 | {
21 | name=n;
22 | salary=s;
23 | nickname=nn;
24 | }
25 | WWE(WWE &x)
26 | {
27 | name=x.name;
28 | nickname=x.name;
29 | salary=x.salary;
30 | }
31 | void show()
32 | {
33 | cout<<"Name is "<<name<<endl<<"Salary is "<<salary<<endl<<"Nickname is "<<nickname<<endl;
34 | }
35 | };
36 | int main()
37 | {
38 | cout<<"WWE class try out";
39 | WWE a;
40 | a.show();
41 | WWE b("AJ Styles",256643532,"Phenomenal");
42 | b.show();
43 | WWE c=b;
44 | c.show();
45 | return 0;
46 | }
47 | 
48 | 


--------------------------------------------------------------------------------
/Expt_2_3.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class Stack
 4 | {
 5 | public: //all public needed to access outside in main
 6 | string name;
 7 | int roll_number;
 8 | double total_marks;
 9 | Stack *next;
10 | void show()
11 | {
12 | cout<<endl; 
13 | cout<<"Name of the person is "<<name<<endl<<"Roll number of the person is "<<roll_number<<endl<<"Total marks of the person are "<<total_marks<<endl;
14 | }
15 | }*top,*node,*ptr,*p;
16 | int main()
17 | {
18 | int quit=0;
19 | cout<<"Hello! This is a program to demonstrate Stack implementation using Classes and Objects"<<endl;
20 | 	node=new Stack;
21 | 	cout<<"Enter the name of this person"<<endl;
22 | 	cin>>node->name;
23 | 	cout<<"Enter the roll number of this person"<<endl;
24 | 	cin>>node->roll_number;
25 | 	cout<<"Enter the total marks of this person"<<endl;
26 | 	cin>>node->total_marks;
27 | 	node->next=NULL;
28 | top=node;
29 | node->show();
30 | cout<<endl;
31 | cout<<"Let the party begins"<<endl;
32 | do
33 | {
34 | cout<<"\t\t\t\tOption Menu"<<endl;
35 | cout<<"1) Insert"<<endl;
36 | cout<<"2) Delete"<<endl;
37 | cout<<"3) Show"<<endl;
38 | cout<<"4) Exit"<<endl;
39 | int ch;
40 | cout<<"Enter your choice"<<endl;
41 | cin>>ch;
42 | switch(ch)
43 | {
44 | case 1: cout<<"Insertion at end"<<endl;
45 | 	p=new Stack;
46 | 	cout<<"Enter the name of this person"<<endl;
47 | 	cin>>p->name;
48 | 	cout<<"Enter the roll number of this person"<<endl;
49 | 	cin>>p->roll_number;
50 | 	cout<<"Enter the total marks of this person"<<endl;
51 | 	cin>>p->total_marks;
52 | 	p->next=top;
53 | top=p;
54 | break;
55 | case 2: cout<<"Deletion at End"<<endl;
56 | cout<<"Object to be deleted is"<<endl;
57 | ptr=top;
58 | ptr->show();
59 | top=top->next;
60 | delete ptr;
61 | break;
62 | case 3: cout<<"Traversal"<<endl;
63 | for(ptr=top;ptr!=NULL;ptr=ptr->next)
64 | {
65 | int i=1;
66 | cout<<"The "<<i++<<" Record is of";
67 | ptr->show();
68 | }
69 | break;
70 | case 4: quit=1;
71 | break;
72 | default: cout<<"Wrong Choice! Try again"<<endl;
73 | }
74 | }while(quit!=1);
75 | return 0;
76 | }
77 | 


--------------------------------------------------------------------------------
/Expt_3_1.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | using namespace std;
  3 | class hydrogen;
  4 | class sulphur;
  5 | class oxygen;
  6 | class oxygen
  7 | {
  8 | public:
  9 | int mass;
 10 | oxygen()
 11 | {
 12 | mass=64;
 13 | }
 14 | void input(int m)
 15 | {
 16 | mass=m;
 17 | }
 18 | friend void empiricalmass(oxygen o,hydrogen h,sulphur s);
 19 | };
 20 | class hydrogen
 21 | {
 22 | public:
 23 | int mass;
 24 | hydrogen()
 25 | {
 26 | mass=2;
 27 | }
 28 | void input(int m)
 29 | {
 30 | mass=m;
 31 | }
 32 | friend void empiricalmass(oxygen o,hydrogen h,sulphur s);
 33 | };
 34 | class sulphur
 35 | {
 36 | public:
 37 | int mass;
 38 | sulphur()
 39 | {
 40 | mass=32;
 41 | }
 42 | void input(int m)
 43 | {
 44 | mass=m;
 45 | }
 46 | friend void empiricalmass(oxygen o,hydrogen h,sulphur s);
 47 | };
 48 | void empiricalmass(oxygen o,hydrogen h,sulphur s)
 49 | {
 50 | int x,y,z;
 51 | float n1,n2,n3;
 52 | cout<<"Lets see the masses you have entered"<<endl;
 53 | cout<<"Mass of oxygen is "<<o.mass<<endl;
 54 | cout<<"Mass of hydrogen is "<<h.mass<<endl;
 55 | cout<<"Mass of sulphur is "<<s.mass<<endl;
 56 | cout<<"Lets now see the number of moles of all the elements"<<endl;
 57 | n1=o.mass/16;
 58 | n2=h.mass/1;
 59 | n3=s.mass/32;
 60 | cout<<"Moles of oxygen are "<<n1<<endl;
 61 | cout<<"Moles of hydrogen are "<<n2<<endl;
 62 | cout<<"Moles of sulphur are "<<n3<<endl;
 63 | cout<<"Now please enter the corrected rounded figures of moles"<<endl;
 64 | cout<<"Enter the number of moles of oxygen "<<endl;
 65 | cin>>x;
 66 | cout<<"Enter the number of moles of hydrogen "<<endl;
 67 | cin>>y;
 68 | cout<<"Enter the number of moles of sulphur "<<endl;
 69 | cin>>z;
 70 | cout<<"The Emperical mass of oxygen, hydrogen and sulphur compounds is H"<<y<<"O"<<x<<"S"<<z<<endl;
 71 | }
 72 | int main()
 73 | {
 74 | float x,y,z;
 75 | cout<<"Program to calculate the emperical formulae and molecular formulae of compound of S,H and O"<<endl;
 76 | cout<<"Enter the mass of oxygen in grams"<<endl;
 77 | cin>>x;
 78 | cout<<"Enter the mass of Hydrogen in grams"<<endl;
 79 | cin>>y;
 80 | cout<<"Enter the mass of Sulphur in grams"<<endl;
 81 | cin>>z;
 82 | oxygen o;
 83 | o.input(x);
 84 | sulphur s;
 85 | s.input(z);
 86 | hydrogen h;
 87 | h.input(y);
 88 | empiricalmass(o,h,s);
 89 | cout<<"Goodbye"<<endl;
 90 | return 0;
 91 | }
 92 | 
 93 | 
 94 | 
 95 | 
 96 | 
 97 | 
 98 | 
 99 | 
100 | 
101 | 
102 | 
103 | 
104 | 
105 | 
106 | 
107 | 
108 | 
109 | 
110 | 
111 | 
112 | 
113 | 
114 | 
115 | 


--------------------------------------------------------------------------------
/Expt_3_2.cpp:
--------------------------------------------------------------------------------
  1 | #include<math.h>
  2 | #include<iostream>
  3 | using namespace std;
  4 | class shape
  5 | {
  6 | float l,b;
  7 | public:
  8 | shape()
  9 | {
 10 | l=10;
 11 | b=20;
 12 | }
 13 | virtual void calculate_area()
 14 | {
 15 | cout<<"Area of Shape"<<endl;
 16 | float area;
 17 | area=l*b;
 18 | }
 19 | void input()
 20 | {
 21 | cout<<"Who cares"<<endl;
 22 | }
 23 | };
 24 | class rectangle: public shape
 25 | {
 26 | float l,b;
 27 | public:
 28 | rectangle()
 29 | {
 30 | l=15;
 31 | b=20;
 32 | }
 33 | void input(float x,float y)
 34 | {
 35 | l=x;
 36 | b=y;
 37 | }
 38 | void calculate_area()
 39 | {
 40 | cout<<"Area of rectangle"<<endl;
 41 | float area=l*b;
 42 | cout<<"Area of rectangle is "<<area;
 43 | }
 44 | };
 45 | class triangle: public shape
 46 | {
 47 | float s1,s2,s3;
 48 | public:
 49 | triangle()
 50 | {
 51 | s1=3;
 52 | s2=4;
 53 | s3=5;
 54 | }
 55 | void input(float x,float y,float z)
 56 | {
 57 | s1=x;
 58 | s2=y;
 59 | s3=z;
 60 | }
 61 | void calculate_area()
 62 | {
 63 | cout<<"Area of triangle by Heron's Formulae"<<endl;
 64 | float area,s,a;
 65 | s=(s1+s2+s3)/2;
 66 | a=s*(s-s1)*(s-s2)*(s-s3);
 67 | area=pow(a,0.5);
 68 | cout<<"Area of triangle is "<<area;
 69 | }
 70 | };
 71 | int main()
 72 | {
 73 | int ch;
 74 | shape *p;
 75 | rectangle r;
 76 | triangle t;
 77 | cout<<"Program to enter area of a given shape"<<endl;
 78 | cout<<"Option Menu"<<endl;
 79 | cout<<"1: Area of Rectangle"<<endl;
 80 | cout<<"2: Area of Triangle"<<endl;
 81 | cout<<"3: Exit"<<endl;
 82 | cout<<"Enter your choice"<<endl;
 83 | cin>>ch;
 84 | switch(ch)
 85 | {
 86 | case 1: 
 87 | p=&r;
 88 | cout<<"Rectangle"<<endl<<"Enter the length and breadth of rectangle"<<endl;
 89 | float l,b;
 90 | cin>>l>>b;
 91 | r.input(l,b);
 92 | p->calculate_area();
 93 | break;
 94 | case 2:
 95 | p=&t;
 96 | cout<<"Triangle"<<endl<<"Enter three sides of the triangle"<<endl;
 97 | float s1,s2,s3;
 98 | cin>>s1>>s2>>s3;
 99 | t.input(s1,s2,s3);
100 | p->calculate_area();
101 | break;
102 | case 3: cout<<"Exit please"<<endl;
103 | break;
104 | default: cout<<"Wrong Choice"<<endl;
105 | }
106 | cout<<endl;
107 | return 0;
108 | }
109 | ///////////////////////////////////Break the walls maen! Note only those functions that are initialized at base as virtual functions can be binded at runtime! Use the pointer with derived only for these functions and not for all.
110 | 
111 | 
112 | 
113 | 
114 | 
115 | 
116 | 
117 | 
118 | 
119 | 
120 | 
121 | 
122 | 
123 | 


--------------------------------------------------------------------------------
/Expt_3_3.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | using namespace std;
  3 | class student
  4 | {
  5 | protected:
  6 | string name,rollno,gender;
  7 | public:
  8 | student()
  9 | {
 10 | name="Nishkarsh Raj";
 11 | rollno="R171217041";
 12 | gender="Male";
 13 | }
 14 | void student_details(string s1,string s2, string s3)
 15 | {
 16 | name=s1;
 17 | rollno=s2;
 18 | gender=s3;
 19 | }
 20 | void display_student_details()
 21 | {
 22 | cout<<"Details of the student are"<<endl;
 23 | cout<<"Name: "<<name<<endl;
 24 | cout<<"Roll No: "<<rollno<<endl;
 25 | cout<<"Gender: "<<gender<<endl;
 26 | }
 27 | };
 28 | /////////////////////////////////////////
 29 | class internal_marks: virtual public student
 30 | {
 31 | protected:
 32 | float marks1[6];
 33 | int i;
 34 | public:
 35 | void get_marks(float m[6])
 36 | {
 37 | for(i=0;i<6;i++)
 38 | {
 39 | marks1[i]=m[i];
 40 | }
 41 | }
 42 | void display_marks()
 43 | {
 44 | cout<<"Lets see the Internal Marks of the student"<<endl;
 45 | for(i=0;i<6;i++)
 46 | {
 47 | cout<<"Marks in subject number "<<i+1<<" are "<<marks1[i]<<endl;
 48 | }
 49 | }
 50 | };
 51 | /////////////////////////////////////////
 52 | class external_marks: public virtual student
 53 | {
 54 | protected:
 55 | float marks2[6];
 56 | public:
 57 | int i;
 58 | void get_marks(float m[6])
 59 | {
 60 | for(i=0;i<6;i++)
 61 | {
 62 | marks2[i]=m[i];
 63 | }
 64 | }
 65 | void display_marks()
 66 | {
 67 | cout<<"Lets see the External Marks of the student"<<endl;
 68 | for(i=0;i<6;i++)
 69 | {
 70 | cout<<"Marks in subject number "<<i+1<<" are "<<marks2[i]<<endl;
 71 | }
 72 | }
 73 | };
 74 | ////////////////////////////////////////
 75 | class result: public internal_marks,public external_marks
 76 | {
 77 | public:
 78 | float marks[6];
 79 | int i;
 80 | void display_result()
 81 | {
 82 | for(i=0;i<6;i++)
 83 | {
 84 | marks[i]=marks1[i]+marks2[i];
 85 | cout<<"Marks in subject "<<i+1<<" out of 100 are "<<marks[i]<<endl;
 86 | }
 87 | }
 88 | };
 89 | ////////////////////////////////////////
 90 | int main()
 91 | {
 92 | int i;
 93 | string name,roll,gender;
 94 | cout<<"Program for Student marks calculation"<<endl;
 95 | cout<<"Enter the name of the student"<<endl;
 96 | getline(cin,name);
 97 | cout<<"Enter the roll number of the student"<<endl;
 98 | getline(cin,roll);
 99 | cout<<"Enter the gender of the student"<<endl;
100 | cin>>gender;
101 | student s;
102 | s.student_details(name,roll,gender);
103 | cout<<"Enter the marks of student in internals 6 subject out of 30"<<endl;
104 | float marks[6],marks1[6];
105 | for(i=0;i<6;i++)
106 | {
107 | cout<<"Enter marks in subject "<<i+1<<endl;
108 | cin>>marks[i];
109 | }
110 | cout<<"Enter the marks of student in Externals 6 subject out of 70"<<endl;
111 | for(i=0;i<6;i++)
112 | {
113 | cout<<"Enter marks in subject "<<i+1<<endl;
114 | cin>>marks1[i];
115 | }
116 | internal_marks i1;
117 | i1.get_marks(marks);
118 | external_marks e;
119 | e.get_marks(marks1);
120 | result r;
121 | ////////////////////////////////////
122 | cout<<"Lets see the result of the student"<<endl;
123 | s.display_student_details();
124 | i1.display_marks();
125 | e.display_marks();
126 | r.display_result();
127 | return 0;
128 | }
129 | 


--------------------------------------------------------------------------------
/Expt_4_1_1.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class location
 4 | {
 5 | public:
 6 | int latitude,longitude;
 7 | location()
 8 | {
 9 | latitude=10;
10 | longitude=25;
11 | }
12 | location(int x,int y)
13 | {
14 | latitude=x;
15 | longitude=y;
16 | }
17 | void show()
18 | {
19 | cout<<"Longitude of the location is "<<longitude<<endl<<"Latitude of the location is "<<latitude<<endl;
20 | }
21 | friend location operator+(location obj1,location obj2);
22 | };
23 | location operator+(location o1,location o2)
24 | {
25 | location temp;
26 | temp.latitude=o1.latitude+o2.latitude;
27 | temp.longitude=o1.longitude+o2.longitude;
28 | return temp;
29 | }
30 | int main()
31 | {
32 | location obj1(10,20),obj2(14,35),obj3;
33 | obj1.show();
34 | obj2.show();
35 | obj3=obj1+obj2+obj3;
36 | obj3.show();
37 | /*obj3=obj3+100;
38 | obj3.show();
39 | obj3=10+obj3;
40 | obj3.show();*/   //not working
41 | return 0;
42 | }
43 | 
44 | 


--------------------------------------------------------------------------------
/Expt_4_1_2.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class location
 4 | {
 5 | int latitude,longitude;
 6 | public: location()
 7 | {
 8 | latitude=25;
 9 | longitude=20;
10 | }
11 | location(int x,int y)
12 | {
13 | latitude=x;
14 | longitude=y;
15 | }
16 | void show()
17 | {
18 | cout<<"Latitude of the location is "<<latitude<<endl<<"Longitude of the location is "<<longitude<<endl;
19 | }
20 | location operator+(location obj);
21 | };
22 | location location::operator+(location obj)
23 | {
24 | location temp;
25 | temp.latitude=obj.latitude+latitude;
26 | temp.longitude=obj.longitude+longitude;
27 | return temp;
28 | }
29 | int main()
30 | {
31 | location obj1(10,20),obj2(25,13),obj3;
32 | obj1.show();
33 | obj2.show();
34 | obj3=obj1+obj2;
35 | obj3.show();
36 | return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/Independence.txt:
--------------------------------------------------------------------------------
1 | Nishkarsh Raj Khare is the best baaybaaay!!!
2 | 


--------------------------------------------------------------------------------
/Inheritance.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class WWE
 4 | {
 5 | int serial;
 6 | public:
 7 | string name;
 8 | float salary;
 9 | WWE()
10 | {
11 | serial=1;
12 | name="Finn Balor";
13 | salary=40000;
14 | }
15 | void insert()
16 | {
17 | cout<<"Make the entries of the superstar"<<endl;
18 | cout<<"Enter the serial number of the superstar ";
19 | cin>>serial;
20 | cout<<endl;
21 | cout<<"Enter the name of the superstar ";
22 | cin>>name;
23 | cout<<endl;
24 | cout<<"Enter the salary of the superstar ";
25 | cin>>salary;
26 | cout<<endl;
27 | }
28 | void show()
29 | {
30 | cout<<"Name of the superstar is "<<name<<endl<<"Serial of the superstar "<<serial<<endl<<"Salary of the superstar "<<salary<<endl;
31 | }
32 | };
33 | /////////////////////////////////////////////////////////////////////////////////////////////////////
34 | class record:public WWE
35 | {
36 | string sex;
37 | public:
38 | record()
39 | {
40 | sex="male";
41 | }
42 | void show1()
43 | {
44 | cout<<"Name of the superstar is "<<name<<endl;
45 | cout<<"Win/Loss Record of the Superstar is 80 wins to 6 losses "<<endl;
46 | cout<<"Salary of the superstar is "<<salary<<endl;
47 | cout<<"Sex of the superstar is "<<sex<<endl;
48 | }
49 | };
50 | ///////////////////////////////////////////////////////////////////////////////////////////////////
51 | int main()
52 | {
53 | cout<<"Hello! This is a program depicting Inheritance"<<endl;
54 | WWE nish;
55 | nish.show();
56 | nish.insert();
57 | nish.show();
58 | record nish1;
59 | nish1.show1();
60 | return 0;
61 | }
62 | 
63 | 


--------------------------------------------------------------------------------
/Inheritance/single_private.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class base 
 4 | {
 5 | int a;
 6 | protected:
 7 | int b;
 8 | public:
 9 | int c;
10 | void set_data(int a1,int b1, int c1)
11 | {
12 | a=a1; b=b1; c=c1;
13 | }
14 | base()
15 | {
16 | a=10; b=15; c=20;
17 | }
18 | };
19 | class derived: private base
20 | {
21 | int a2;
22 | protected:
23 | int b2;
24 | public:
25 | int c2;
26 | derived()
27 | {
28 | a2=5;
29 | b2=6;
30 | c2=10;
31 | }
32 | void show()
33 | {
34 | //cout<<"Protected Member of base "<<b<<endl;
35 | //cout<<"Public Member of base "<<c<<endl;
36 | cout<<"Private Member of Derived "<<a2<<endl;
37 | cout<<"Protected Member of Derived "<<b2<<endl;
38 | cout<<"Public Member of Derived "<<c2<<endl;
39 | cout<<endl;
40 | }
41 | };
42 | int main()
43 | {
44 | cout<<"Single Level Inheritance with private derivation"<<endl;
45 | derived obj;
46 | obj.show();
47 | //obj.set_data(5,14,16);
48 | //obj.show();
49 | return 0;
50 | }
51 | 
52 | 
53 | /* Note that in private derivation all the data members and member functions are inheritable yet all are inaccessible as well. The linux CLI also states that the base is an inaccessible in the child class */
54 | 
55 | 
56 | 
57 | 
58 | 


--------------------------------------------------------------------------------
/Inheritance/single_protected.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class base 
 4 | {
 5 | int a;
 6 | protected:
 7 | int b;
 8 | public:
 9 | int c;
10 | void set_data(int a1,int b1, int c1)
11 | {
12 | a=a1; b=b1; c=c1;
13 | }
14 | base()
15 | {
16 | a=10; b=15; c=20;
17 | }
18 | };
19 | class derived: protected base
20 | {
21 | int a2;
22 | protected:
23 | int b2;
24 | public:
25 | int c2;
26 | derived()
27 | {
28 | a2=5;
29 | b2=6;
30 | c2=10;
31 | }
32 | void show()
33 | {
34 | cout<<"Protected Member of base "<<b<<endl;
35 | cout<<"Public Member of base "<<c<<endl;
36 | cout<<"Private Member of Derived "<<a2<<endl;
37 | cout<<"Protected Member of Derived "<<b2<<endl;
38 | cout<<"Public Member of Derived "<<c2<<endl;
39 | cout<<endl;
40 | }
41 | void show1()
42 | {
43 | set_data(5,6,10);
44 | cout<<"Protected Member of base "<<b<<endl;
45 | cout<<"Public Member of base "<<c<<endl;
46 | cout<<"Private Member of Derived "<<a2<<endl;
47 | cout<<"Protected Member of Derived "<<b2<<endl;
48 | cout<<"Public Member of Derived "<<c2<<endl;
49 | }
50 | };
51 | int main()
52 | {
53 | cout<<"Single Level Inheritance with protected derivation"<<endl;
54 | derived obj;
55 | obj.show();
56 | obj.show1();
57 | return 0;
58 | }
59 | /* Note that in protected derivations public and private members are accessible only as protected. That is they can be accessed within child class but not in main with the object. Thats why here we have called set_data function within the derived class and not in main.
60 | "Protected members are like private for a given class" */
61 | 
62 | 
63 | 
64 | 
65 | 


--------------------------------------------------------------------------------
/Inheritance/single_public.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class base 
 4 | {
 5 | int a;
 6 | protected:
 7 | int b;
 8 | public:
 9 | int c;
10 | void set_data(int a1,int b1, int c1)
11 | {
12 | a=a1; b=b1; c=c1;
13 | }
14 | base()
15 | {
16 | a=10; b=15; c=20;
17 | }
18 | };
19 | class derived: public base
20 | {
21 | int a2;
22 | protected:
23 | int b2;
24 | public:
25 | int c2;
26 | derived()
27 | {
28 | a2=5;
29 | b2=6;
30 | c2=10;
31 | }
32 | void show()
33 | {
34 | cout<<"Protected Member of base "<<b<<endl;
35 | cout<<"Public Member of base "<<c<<endl;
36 | cout<<"Private Member of Derived "<<a2<<endl;
37 | cout<<"Protected Member of Derived "<<b2<<endl;
38 | cout<<"Public Member of Derived "<<c2<<endl;
39 | cout<<endl;
40 | }
41 | };
42 | int main()
43 | {
44 | cout<<"Single Level Inheritance with public derivation"<<endl;
45 | derived obj;
46 | obj.show();
47 | obj.set_data(5,14,16);
48 | obj.show();
49 | return 0;
50 | }
51 | /* Note that in public derivations the constructor of the parent class is invoked without even making the object of parent class if the object of the derived class is made because derived class inherits the constructor publically with its values */
52 | 
53 | 
54 | 
55 | 
56 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # CPP-programming-with-Data-Structures
2 | Advanced Data Structure using CPP programming
3 | 
4 | Object Oriented Programming.
5 | Data Structures
6 | Hashing
7 | Graph
8 | 


--------------------------------------------------------------------------------
/bestgenericfunction.cpp:
--------------------------------------------------------------------------------
 1 | #include<cstdlib>
 2 | #include<iostream>
 3 | using namespace std;
 4 | template<typename X>
 5 | void sort(X *arr,int size) //generic sort
 6 | {
 7 | int i,j;
 8 | X temp;
 9 | 	for(i=0;i<size;i++)	
10 | 	{
11 | 	for(j=0;j<size-1;j++)
12 | 	{
13 | 		if(arr[j+1]<arr[j])
14 | 		{
15 | 		temp=arr[j];
16 | 		arr[j]=arr[j+1];
17 | 		arr[j+1]=temp;
18 | 		}
19 | 	}
20 | 	}
21 | }
22 | template<typename Y> //generic insertions
23 | void insert(Y *arr,int size)
24 | {
25 | int i;
26 | cout<<"Lets make the insertions now"<<endl;
27 | for(i=0;i<size;i++)
28 | {
29 | cout<<"Enter the "<<i+1<<" element now"<<endl;
30 | cin>>arr[i];
31 | }
32 | }
33 | template<typename Z> //generic display
34 | void display(Z *arr,int size)
35 | {
36 | int i;
37 | cout<<"Sorted array is now being displayed"<<endl;
38 | for(i=0;i<size;i++)
39 | {
40 | cout<<arr[i]<<endl;
41 | }
42 | }
43 | int main()
44 | {
45 | int quit=0,ch,n;
46 | cout<<"Sorting program in Templates"<<endl;
47 | cout<<"Enter the size of the array you want to sort"<<endl;
48 | cin>>n;
49 | int A[n];
50 | float B[n];
51 | char C[n];
52 | do
53 | {
54 | cout<<"Option Menu"<<endl;
55 | cout<<"1: Int array"<<endl;
56 | cout<<"2: Float array"<<endl;
57 | cout<<"3: Character array"<<endl;
58 | cout<<"4: Quit"<<endl;
59 | cout<<"Enter you choice"<<endl;
60 | cin>>ch;
61 | switch(ch)
62 | /*Note that you cannot declare arrays inside switch*/
63 | {
64 | case 1: 
65 | insert(A,n);
66 | sort(A,n);
67 | display(A,n);
68 | break;
69 | case 2:
70 | insert(B,n);
71 | sort(B,n);
72 | display(B,n);
73 | break;
74 | case 3:
75 | insert(C,n);
76 | sort(C,n);
77 | display(C,n);
78 | break;
79 | case 4: quit=1;
80 | break;
81 | default: cout<<"Wrong Choice"<<endl;
82 | }
83 | }while(quit!=1);
84 | return 0;
85 | system("clear");
86 | }
87 | 


--------------------------------------------------------------------------------
/binaryclass.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | using namespace std;
 4 | class student
 5 | {
 6 | int roll;
 7 | string name;
 8 | public:
 9 | student()
10 | {
11 | roll=41;
12 | name="Nishkarsh Raj Khare";
13 | }
14 | void insert()
15 | {
16 | cout<<"Lets insert the value"<<endl;
17 | cout<<"Enter the name of the student"<<endl;
18 | getline(cin,name);
19 | cout<<"Enter the roll number of the student"<<endl;
20 | cin>>roll;
21 | }
22 | void show()
23 | {
24 | cout<<"Name of the student is "<<name<<endl;
25 | cout<<"Roll number of the student is "<<roll<<endl;
26 | }
27 | };
28 | int main()
29 | {
30 | cout<<"Binary files with classes"<<endl;
31 | fstream nish1;
32 | nish1.open("classbin.txt",ios::binary|ios::app);
33 | student s1;
34 | s1.insert();
35 | nish1.write((char*)&s1,sizeof(s1));
36 | cout<<"We have written the contents inside the file"<<endl<<"Lets Read it Maaaaaaaaaaaaan"<<endl;
37 | student s2;
38 | nish1.close();
39 | fstream nish2;
40 | int i;
41 | nish2.open("classbin.txt",ios::binary|ios::in);
42 | for(i=0;i<2;i++)
43 | {
44 | nish2.read((char*)&s2,sizeof(s2));
45 | s2.show();
46 | }
47 | cout<<"Goodbye"<<endl;
48 | return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/binaryfile.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | using namespace std;
 4 | int main()
 5 | {
 6 | cout<<"Binary files!"<<endl;
 7 | fstream nish;  //general declaration of logical name 
 8 | nish.open("Nishkarsh.txt",ios::binary|ios::out); //explicitly open as out mode to write to the file
 9 | //even text files can be written as binary files only defined by the write and read functions
10 | int ch,quit=0,num,k=-1;
11 | do
12 | {
13 | cout<<"1: Enter a number"<<endl;
14 | cout<<"2: Quit"<<endl;
15 | cout<<"Enter your choice"<<endl;
16 | cin>>ch;
17 | switch(ch)
18 | {
19 | case 1:
20 | cout<<"Enter the number you want to enter to the file"<<endl;
21 | cin>>num;
22 | nish.write((char*)&num,sizeof(num));
23 | break;
24 | case 2: quit=1;
25 | break;
26 | }
27 | k++;
28 | }while(quit!=1);
29 | nish.close();
30 | cout<<"Writing Over! Lets see what you have inserted"<<endl;
31 | fstream nish1;
32 | nish1.open("Nishkarsh.txt",ios::binary|ios::in);
33 | cout<<"There were "<<k<<" insertions"<<endl;
34 | int A[k];
35 | int i;
36 | for(i=0;i<k;i++)
37 | {
38 | nish1.read((char*)&A[i],sizeof(int));
39 | }
40 | for(i=0;i<k;i++)
41 | {
42 | cout<<"The "<<i+1<<" insertion is "<<A[i]<<endl;
43 | }
44 | return 0;
45 | }
46 | 
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/binarytree.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class human
 4 | {
 5 | public:
 6 | string name;
 7 | int age;
 8 | string sex;
 9 | string DOB;
10 | human *left;  //left child
11 | human *right;  //right child
12 | human()
13 | {
14 | name="Maya Rani Khare";
15 | age=76;
16 | sex="Female";
17 | DOB="18/11/1941";
18 | }
19 | void insert()
20 | {
21 | cout<<"Enter the name of the person"<<endl;
22 | getline(cin,name);
23 | cout<<"Enter the age of the person"<<endl;
24 | cin>>age;
25 | cout<<"Enter the sex of the person"<<endl;
26 | cin>>sex;
27 | cout<<"Enter the DOB of the person"<<endl;
28 | cin>>DOB;
29 | }
30 | void show()
31 | {
32 | cout<<"Name of the person is "<<name<<endl;
33 | cout<<"Age of the person is "<<age<<endl;
34 | cout<<"Sex of the person is "<<sex<<endl;
35 | cout<<"DOB of the person is "<<DOB<<endl;
36 | }
37 | };
38 | int main()
39 | {
40 | human *node,*ptr,*root;
41 | cout<<"Program for Binary Trees"<<endl;
42 | cout<<"Lets enter the root node"<<endl;
43 | node=new human;
44 | node->insert();
45 | node->left=NULL;
46 | node->right=NULL;
47 | root=node;
48 | cout<<"Lets see the root details of the Family"<<endl;
49 | node->show();
50 | return 0;
51 | }
52 | 
53 | 
54 | 


--------------------------------------------------------------------------------
/binarytrees.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<string>
  3 | #include<cstdlib>
  4 | using namespace std;
  5 | //create a binary tree for a person having two people he trusts the most starting with yourself
  6 | //here left is most trusted and right is second most trusted
  7 | class person 
  8 | {
  9 | public:
 10 | int keyid;
 11 | string name,gender,contact_number;
 12 | person *left;
 13 | person *right;
 14 | person()
 15 | {
 16 | name="Nishkarsh Raj Khare";
 17 | gender="Male";
 18 | contact_number="9005445752";
 19 | }
 20 | void insert()
 21 | {
 22 | cout<<"Enter key id of the person"<<endl;
 23 | cin>>keyid;
 24 | cout<<"Enter name of the person (Only First Name)"<<endl;
 25 | cin>>name;
 26 | cout<<"Enter the gender of the person"<<endl;
 27 | cin>>gender;
 28 | cout<<"Enter the contact number of the person"<<endl;
 29 | cin>>contact_number;
 30 | }
 31 | void show()
 32 | {
 33 | cout<<"The key ID of the person is "<<keyid<<endl;
 34 | cout<<"The name of the person is "<<name<<endl;
 35 | cout<<"Gender of the person is "<<gender<<endl;
 36 | cout<<"Contact number of the person is "<<contact_number<<endl;
 37 | }
 38 | };
 39 | void print_inorder(person *node);
 40 | void print_preorder(person *node);
 41 | void print_postorder(person *node);
 42 | void printlevelorder(person *node);
 43 | void printgivenlevel(person *node,int level);
 44 | int height(person *node);
 45 | void printlevelorder(person *node)
 46 | {
 47 | int h=height(node);
 48 | int i;
 49 | for(i=1;i<h;i++)
 50 | {
 51 | printgivenlevel(node,i);
 52 | }
 53 | }
 54 | int height(person *node)
 55 | {
 56 | if(node==NULL)
 57 | {
 58 | return 0;
 59 | }
 60 | else
 61 | {
 62 | int lheight,rheight;
 63 | if(node->left!=NULL)
 64 | {
 65 | lheight=height(node->left);
 66 | }
 67 | if(node->right!=NULL)
 68 | {
 69 | rheight=height(node->right);
 70 | }
 71 | if(lheight>rheight)
 72 | return(lheight+1);
 73 | else
 74 | return(rheight+1);
 75 | }
 76 | }
 77 | void printgivenlevel(person *node,int level)
 78 | {
 79 | if(node==NULL)
 80 | {
 81 | return;
 82 | }
 83 | if(level==1)
 84 | {
 85 | node->show();
 86 | }
 87 | else if(level>1)
 88 | {
 89 | printgivenlevel(node->left,level-1);
 90 | printgivenlevel(node->right,level-1);
 91 | }
 92 | }
 93 | void print_inorder(person *node)
 94 | {
 95 | if(node->left!=NULL)
 96 | print_inorder(node->left);
 97 | node->show();
 98 | if(node->right!=NULL)
 99 | print_inorder(node->right);
100 | }
101 | void print_preorder(person *node)
102 | {
103 | node->show();
104 | if(node->left!=NULL)
105 | print_preorder(node->left);
106 | if(node->right!=NULL)
107 | print_preorder(node->right);
108 | }
109 | void print_postorder(person *node)
110 | {
111 | if(node->left!=NULL)
112 | print_postorder(node->left);
113 | if(node->right!=NULL)
114 | print_postorder(node->right);
115 | node->show();
116 | }
117 | int main()
118 | {
119 | person *node,*root,*ptr,*p1,*p2;
120 | root=NULL;
121 | int i,quit=0;
122 | char reply;
123 | string name;
124 | cout<<"Welcome to the first ever program of Binary Trees done by Nishkarsh Raj Khare"<<endl;
125 | cout<<"Here you have to create the root of the tree as yourself"<<endl<<"Also, fill the trees with nodes where a node has child as its most trusted contacts where left child is more close to him/her"<<endl;
126 | cout<<"Let us begin! Shall we?? ;) "<<endl;
127 | cout<<"Are you ready?? No I asked you are you ready??????????????"<<endl;
128 | cout<<"Enter your name please"<<endl;
129 | getline(cin,name);
130 | system("clear");
131 | cout<<"Hello Dear "<<name<<endl<<"To enter this creative exercise please type y below"<<endl;
132 | cin>>reply;
133 | if((reply=='y')||(reply=='Y'))
134 | {
135 | for(i=0;i<50000;i++)
136 | {
137 | cout<<"Please Wait!!! Loading Boot files of the program into the Active Memory case number "<<i+1<<endl;
138 | if(i<10000)
139 | {
140 | cout<<"Copying files from source location to active memory"<<endl;
141 | }
142 | else if((i>=10000)&&(i<40000))
143 | {
144 | cout<<"Processing the files and Optimising Disk Space"<<endl;
145 | }
146 | else
147 | {
148 | cout<<"File is about to be opened! Brace Yourselves"<<endl;
149 | }
150 | }
151 | system("clear");
152 | cout<<"Congratulations! "<<name<<endl<<"You have successfully entered the Tree program execution"<<endl;
153 | do
154 | {
155 | int choice;
156 | cout<<"\n\n\n\t\t\tOptions Menu"<<endl;
157 | cout<<"1) Creation of root"<<endl;
158 | cout<<"2) Insertion of nodes"<<endl;
159 | cout<<"3) Inorder Traversal of nodes"<<endl;
160 | cout<<"4) Preorder Traversal of nodes"<<endl;
161 | cout<<"5) Postorder Traversal of nodes"<<endl;
162 | cout<<"6) Breadth level Traversal of nodes"<<endl;
163 | cout<<"7) Quit"<<endl;
164 | cout<<"Enter your choice"<<endl;
165 | cin>>choice;
166 | switch(choice)
167 | {
168 | case 1: cout<<"Creation of Roots"<<endl;
169 | if(root!=NULL)
170 | {
171 | cout<<"You know that the tree root has already been created but still you wanted to check if I am good enough huh\nYours arms are too short to box with GOD"<<endl;
172 | break;
173 | }
174 | else
175 | {
176 | cout<<"Lets now create the Root node of the Tree"<<endl;
177 | node= new person;
178 | node->insert();
179 | node->left=NULL;
180 | node->right=NULL;
181 | cout<<"Lets See the root of the Tree"<<endl;
182 | node->show();
183 | root=node;
184 | }
185 | break; 
186 | case 2: cout<<"Insertion of nodes"<<endl;
187 | if(root==NULL)
188 | {
189 | cout<<"Root does not exists but you just wanted to act stupid! Please be careful you have to be Good with me"<<endl;
190 | }
191 | else
192 | {
193 | if((root->left==NULL)&&(root->right==NULL))
194 | {
195 | cout<<"Both the left and right sides of the root are free to be filled"<<endl;
196 | }
197 | else if((root->left!=NULL)&&(root->right==NULL))
198 | {
199 | cout<<"Right side of the root is free to be filled"<<endl;
200 | }
201 | else if((root->left==NULL)&&(root->right!=NULL))
202 | {
203 | cout<<"Left side of the root is free to be filled"<<endl;
204 | }
205 | else if((root->left!=NULL)&&(root->right!=NULL))
206 | {
207 | cout<<"Both the sides of root are filled"<<endl;
208 | }
209 | cout<<"Options Menu Part 2"<<endl;
210 | cout<<"1: Insert at Left"<<endl;
211 | cout<<"2: Insert at Right"<<endl;
212 | int cc;
213 | cout<<"Enter your choice"<<endl;
214 | cin>>cc;
215 | system("clear");
216 | switch(cc)
217 | {
218 | case 1: if(root->left!=NULL)
219 | cout<<"Left of the root is filled! Please keep a check"<<endl;
220 | else
221 | {
222 | cout<<"Lets enter the values to the left of root!!"<<endl;
223 | p1=new person;
224 | p1->insert();
225 | p1->left=NULL;
226 | p1->right=NULL;
227 | root->left=p1;
228 | }
229 | break;
230 | case 2:
231 | if(root->right!=NULL)
232 | cout<<"Right of the root is filled! Please keep a check"<<endl;
233 | else
234 | {
235 | cout<<"Lets enter the values to the Right of root!!"<<endl;
236 | p2=new person;
237 | p2->insert();
238 | p2->left=NULL;
239 | p2->right=NULL;
240 | root->right=p2;
241 | }
242 | break;
243 | default: cout<<"Please improve your Eyesight"<<endl;
244 | }
245 | }
246 | break;
247 | case 3: cout<<"Inorder traversal of nodes"<<endl;
248 | if(root==NULL)
249 | {
250 | cout<<"Root does not exists but you just wanted to act stupid! Please be careful you have to be Good with me"<<endl;
251 | }
252 | else
253 | {
254 | print_inorder(root);
255 | }
256 | break;
257 | case 4: cout<<"Preorder traversal of Nodes"<<endl;
258 | if(root==NULL)
259 | {
260 | cout<<"Root does not exists but you just wanted to act stupid! Please be careful you have to be Good with me"<<endl;
261 | }
262 | else
263 | {
264 | print_preorder(root);
265 | }
266 | break;
267 | case 5: cout<<"Postorder traversal of Nodes"<<endl;
268 | if(root==NULL)
269 | {
270 | cout<<"Root does not exists but you just wanted to act stupid! Please be careful you have to be Good with me"<<endl;
271 | }
272 | else
273 | {
274 | print_postorder(root);
275 | }
276 | break;
277 | case 6: cout<<"Breadth level traversal of Nodes"<<endl;
278 | if(root==NULL)
279 | {
280 | cout<<"Root does not exists but you just wanted to act stupid! Please be careful you have to be Good with me"<<endl;
281 | }
282 | else
283 | {
284 | printlevelorder(root);
285 | }
286 | break;
287 | case 7: cout<<"Quitting Now"<<endl;
288 | quit=1;
289 | break;
290 | default: cout<<"Damn! You can't see the choice includes only seven integer number\nNow feel sorry and retry"<<endl;
291 | }
292 | }while(quit!=1);
293 | system("clear");
294 | cout<<"Thats the end of our journey together for now"<<endl;
295 | cout<<"Every Great thing must come to an end"<<endl;
296 | cout<<name<<" You are a great person that you gave so much time to see this work!"<<endl<<"Kindly check www.github.com/NishkarshRaj for more exciting codes"<<endl;
297 | }//end of reply if
298 | else
299 | {
300 | system("clear");
301 | cout<<"You have successfully wasted a chance only rare people get to witness"<<endl;
302 | cout<<"Congratulations for being such a great person"<<endl;
303 | cout<<"Leave now! I can't hold my tears for long now"<<endl;
304 | }
305 | return 0;
306 | }
307 | 
308 | 
309 | ///////exceptional handling
310 | ///////Do Your Work in Typical Graph Form
311 | 


--------------------------------------------------------------------------------
/class.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string>
 3 | class employee
 4 | {
 5 | 	int emp_id;
 6 | 	string emp_name[20];
 7 | 	public:
 8 | 	void read(int a,string n)
 9 | 	{
10 | 		emp_id=a;
11 | 		emp_name=n;
12 | 	}
13 | 	friend void show(employee E);
14 | };
15 | void show(employee E)
16 | {
17 | 	cout<<"Name of the employee is "<<emp_name<<endl<<"ID of the employee is "<<emp_id;
18 | }
19 | int main()
20 | {
21 | 	employee E;
22 | 	E.read(23402,"Nishkarsh Raj Khare");
23 | 	show(E);
24 | 	return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/class1.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string>
 3 | using namespace std;
 4 | class student
 5 | {
 6 | string student_name;
 7 | int roll_no;
 8 | int SAP_ID;
 9 | string Specialisation;
10 | public:
11 | void Read_data()
12 | {
13 | cout<<"Enter Student's Name"<<endl;
14 | cin>>student_name;
15 | cout<<"Enter Roll number of student"<<endl;
16 | cin>>roll_no;
17 | cout<<"Enter SAP_ID of the student"<<endl;
18 | cin>>SAP_ID;
19 | cout<<"Enter the Specialisation of the student"<<endl;
20 | cin>>Specialisation;
21 | }
22 | void show()
23 | {
24 | cout<<"Name of the student is "<<student_name<<endl<<"ROll number of the student is "<<roll_no<<endl<<"SAP ID of the student is "<<SAP_ID<<endl<<"Specialisation of the student is "<<Specialisation<<endl;
25 | }
26 | };
27 | int main()
28 | {
29 | cout<<"Hello User!\nThis is the first programme of Classes"<<endl;
30 | student S;
31 | S.Read_data();
32 | S.show();
33 | return 0;
34 | } 
35 | 
36 | 
37 | 
38 | 
39 | 
40 | 
41 | 
42 | 
43 | 


--------------------------------------------------------------------------------
/class_write_basic.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | using namespace std;
 4 | class nishkarsh
 5 | {
 6 | public:
 7 | int roll; //if these are private data members how will they be accessed in main so that they can be stored inside the file??
 8 | string name;
 9 | void insert(int r,string n)
10 | {
11 | roll=r;
12 | name=n;
13 | }
14 | void show()
15 | {
16 | cout<<"Name is "<<name<<endl<<"Roll number is"<<roll<<endl;
17 | }
18 | };
19 | int main()
20 | {
21 | cout<<"Lets try file handling with C++ classes"<<endl;
22 | nishkarsh n1;
23 | cout<<"Lets write to the file"<<endl;
24 | cout<<"Insert the data as roll number and name"<<endl;
25 | string n;
26 | int r;
27 | cin>>r>>n;
28 | n1.insert(r,n);
29 | n1.show();
30 | cout<<"Class has been created"<<endl;
31 | ///////////////////////////
32 | cout<<"Lets create a text file with the data members filling it"<<endl;
33 | ofstream nish1("Class.txt");
34 | nish1<<n1.name<<" "<<n1.roll<<endl;
35 | nish1.close();
36 | ////////////////////////////
37 | cout<<"Lets create another object with insertion from file "<<endl;
38 | string n2; int r2;
39 | ifstream nish("Class.txt");
40 | nish>>n2>>r2;
41 | nishkarsh o;
42 | o.insert(r2,n2);
43 | o.show();
44 | ///////////////////////////
45 | return 0;
46 | }
47 | 


--------------------------------------------------------------------------------
/constructor.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class nishkarsh
 4 | {
 5 | int sapid;
 6 | string roll;
 7 | public:
 8 | nishkarsh(int sap,string rollnum)
 9 | {
10 | sapid=sap;
11 | roll=rollnum;
12 | }
13 | void show()
14 | {
15 | cout<<"Sapid is "<<sapid<<endl<<"roll number is "<<roll<<endl;
16 | }
17 | };
18 | int main()
19 | {
20 | nishkarsh nish(500060720,"R171217041");
21 | nish.show();
22 | cout<<endl;
23 | return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/copycons (1).cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class nishkarsh
 4 | {
 5 | int sapid;
 6 | public:
 7 | nishkarsh()
 8 | {
 9 | sapid=500060720;
10 | }
11 | nishkarsh(nishkarsh &x)
12 | {
13 | sapid=x.sapid;
14 | }
15 | void show()
16 | {
17 | cout<<sapid<<endl;
18 | }
19 | };
20 | int main()
21 | {
22 | cout<<"Copy Constructor Program"<<endl;
23 | nishkarsh n;
24 | n.show();
25 | nishkarsh x(n);
26 | x.show();
27 | return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/copycons.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class nishkarsh
 4 | {
 5 | int sapid;
 6 | public:
 7 | nishkarsh()
 8 | {
 9 | sapid=500060720;
10 | }
11 | nishkarsh(nishkarsh &x)
12 | {
13 | sapid=x.sapid;
14 | }
15 | void show()
16 | {
17 | cout<<sapid<<endl;
18 | }
19 | };
20 | int main()
21 | {
22 | cout<<"Copy Constructor Program"<<endl;
23 | nishkarsh n;
24 | n.show();
25 | nishkarsh x(n);
26 | x.show();
27 | return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/defaultarg.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | float simple_interest(float p,int t,int rate=5);
 4 | float simple_interest(float p,int t,int rate)
 5 | {
 6 | float SI;
 7 | SI=(p*rate*t)/100;
 8 | return SI;
 9 | }
10 | int main()
11 | {
12 | float principal; int time;
13 | cout<<"Default Arguments program"<<endl;
14 | cout<<"Enter principal and time period in rupees and years respectively"<<endl;
15 | cin>>principal>>time;
16 | float Simple=simple_interest(principal,time);
17 | cout<<"Simple interest is "<<Simple<<endl;
18 | return 0;
19 | }
20 | 
21 | 


--------------------------------------------------------------------------------
/destructor.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class nishkarsh
 4 | {
 5 | public:
 6 | nishkarsh()
 7 | {
 8 | cout<<"I am constructor"<<endl;
 9 | }
10 | ~nishkarsh()
11 | {
12 | cout<<"I am Destructor"<<endl;
13 | }
14 | };
15 | int main()
16 | {
17 | cout<<"Constructor vs Destructor programme"<<endl;
18 | cout<<"I am in main"<<endl;
19 | nishkarsh n1;
20 | {
21 | cout<<"I am in main block 1"<<endl;
22 | nishkarsh n2;
23 | {
24 | cout<<"I am in main block 2"<<endl;
25 | nishkarsh n3;
26 | }
27 | cout<<"I am in main block 1"<<endl;
28 | }
29 | cout<<"I am in main"<<endl;
30 | return 0;
31 | }
32 | 
33 | 


--------------------------------------------------------------------------------
/dynamic.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 | int *p;
 6 | p=new int;
 7 | *p=100;
 8 | cout<<"Value to which p points is "<<*p;
 9 | cout<<endl;
10 | delete(p);
11 | cout<<"Value to which p static points is "<<*p;
12 | cout<<endl;
13 | return 0;
14 | }
15 | 
16 | 
17 | 


--------------------------------------------------------------------------------
/file_write_basic.txt:
--------------------------------------------------------------------------------
1 | Nishkarsh Dehradun
2 | 248007


--------------------------------------------------------------------------------
/friendone.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class ABC
 4 | {
 5 | int a,b;
 6 | public:
 7 | <<<<<<< HEAD
 8 | void setdata(int m,int n)
 9 | {
10 | a=m,b=n;
11 | =======
12 | void setdata()
13 | {
14 | a=10,b=25;
15 | >>>>>>> 068b4e7f2e1cef66939b6df29e22918251c1370b
16 | }
17 | friend float mean(class ABC x);
18 | };
19 | float mean(ABC x)
20 | {
21 | cout<<(x.a+x.b)/2;
22 | }
23 | int main()
24 | {
25 | <<<<<<< HEAD
26 | int m,n;
27 | ABC y;
28 | cout<<"Enter two values whose mean you want"<<endl;
29 | cin>>m>>n;
30 | y.setdata(m,n);
31 | mean(y);
32 | cout<<endl;
33 | =======
34 | ABC y;
35 | y.setdata();
36 | mean(y);
37 | >>>>>>> 068b4e7f2e1cef66939b6df29e22918251c1370b
38 | }
39 | 


--------------------------------------------------------------------------------
/friendtwo.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class endsem; //forward declaration for friendship
 4 | class midsem
 5 | {
 6 | float Chemistry,Maths,EVS,PDS,DevOps,BEE;
 7 | public:
 8 | midsem()
 9 | {
10 | Chemistry=93;
11 | Maths=81;
12 | EVS=74;
13 | PDS=78;
14 | DevOps=67;
15 | BEE=76;
16 | }
17 | friend void result(midsem,endsem);
18 | };
19 | class endsem
20 | {
21 | float Chemistry,Maths,EVS,PDS,DevOps,BEE;
22 | public:
23 | endsem()
24 | {
25 | Chemistry=91;
26 | Maths=82;
27 | EVS=79;
28 | PDS=77;
29 | DevOps=91;
30 | BEE=77;
31 | }
32 | friend void result(midsem,endsem);
33 | };
34 | void result(midsem M,endsem E)
35 | {
36 | float Chem=(M.Chemistry)/5+(E.Chemistry)/2;
37 | float Math=(M.Maths)/5+(E.Maths)/2;
38 | float Basic=(M.BEE)/5+(E.BEE)/2;
39 | float Env=(M.EVS)/5+(E.EVS)/2;
40 | float CS=(M.PDS)/5+(E.PDS)/2;
41 | float DO=(M.DevOps)/5+(E.DevOps)/2;
42 | cout<<"Final marks in Chemistry are "<<Chem<<" out of 70"<<endl;
43 | cout<<"Final marks in Maths are "<<Math<<" out of 70"<<endl;
44 | cout<<"Final marks in DevOps are "<<Basic<<" out of 70"<<endl;
45 | cout<<"Final marks in PDS are "<<Env<<" out of 70"<<endl;
46 | cout<<"Final marks in EVS are "<<CS<<" out of 70"<<endl;
47 | cout<<"Final marks in BEE are "<<DO<<" out of 70"<<endl;
48 | }
49 | int main()
50 | {
51 | cout<<"This is a program for two classes with a friend function depicting Midsem and Endsem marks respectively"<<endl;
52 | cout<<"Semester 1"<<endl;
53 | midsem M;
54 | endsem E;
55 | result(M,E);
56 | cout<<endl;
57 | return 0;
58 | }
59 | 


--------------------------------------------------------------------------------
/functionoverload.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | void show(int a);
 4 | void show(char b);
 5 | //void show(float c);
 6 | void show(int a)
 7 | {
 8 | cout<<"Hey! This is for int"<<endl;
 9 | }
10 | void show(char b)
11 | {
12 | cout<<"Hey! This is for char"<<endl;
13 | }
14 | /*void show(float c)
15 | {
16 | cout<<"Hey this is for float"<<endl;
17 | }*/
18 | int main()
19 | {
20 | cout<<"Function Overloading"<<endl;
21 | show(1);
22 | show('a');
23 | return 0;
24 | }
25 | 
26 | 


--------------------------------------------------------------------------------
/genfunc_twotypes.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | template<typename x,typename y>
 4 | void multiply(x x1,y y1)
 5 | {
 6 | float m;
 7 | m=x1*y1;
 8 | cout<<"Multiplied value is "<<m<<endl;
 9 | }
10 | int main()
11 | {
12 | int x; float y;
13 | cout<<"Enter an integer and then a float value"<<endl;
14 | cin>>x>>y;
15 | multiply(x,y);
16 | return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/graph1.cpp:
--------------------------------------------------------------------------------
  1 | #include<cstdlib>
  2 | #include<iostream>
  3 | using namespace std;
  4 | class student
  5 | {
  6 | public:
  7 | string rollnumber;
  8 | string sapid;
  9 | string name;
 10 | string specialization;
 11 | student *connections[10];
 12 | student()
 13 | {
 14 | rollnumber="R171217041";
 15 | sapid="500060720";
 16 | name="Nishkarsh";
 17 | specialization="DevOps";
 18 | }
 19 | void insert()
 20 | {
 21 | cout<<"Enter the Registered Roll number of the Student"<<endl;
 22 | cin>>rollnumber;
 23 | cout<<"Enter the SAP ID of the student"<<endl;
 24 | cin>>sapid;
 25 | cout<<"Enter the Name(First only) of the Student"<<endl;
 26 | cin>>name;
 27 | cout<<"Enter the Specialization of the Student"<<endl;
 28 | cin>>specialization;
 29 | }
 30 | void show()
 31 | {
 32 | cout<<"Roll Number of the student is "<<rollnumber<<endl;
 33 | cout<<"Name of the Student is "<<name<<endl;
 34 | cout<<"Specialization of the Student is "<<specialization<<endl;
 35 | cout<<"SAP ID of the student is "<<sapid<<endl;
 36 | }
 37 | };
 38 | /////////////////////////////////////////////structure for linked list
 39 | class stud
 40 | {
 41 | public:
 42 | string name;
 43 | stud *next;
 44 | };
 45 | int main()
 46 | {
 47 | int n,i,j;
 48 | char rep;
 49 | cout<<"Hello Everyone!\nThis is the first code of Graph: Unweighted and Undirected Done by Nishkarsh Raj Khare"<<endl;
 50 | cout<<"Enter the number of vertices you want in the graph(Make it less than 10)"<<endl;
 51 | cin>>n;
 52 | int A[10][10]; //Adjancy Matrix
 53 | ////////////////////////////////////////////////////////////////////////Insertion
 54 | if(n<=10)
 55 | {
 56 | student *stu[n];
 57 | for(i=0;i<n;i++)
 58 | {
 59 | cout<<"Lets make insertion for the "<<i+1<<" student"<<endl;
 60 | stu[i]=new student;
 61 | stu[i]->insert();
 62 | for(j=0;j<10;j++)
 63 | stu[i]->connections[j]=NULL;
 64 | }
 65 | //////////////////////////////////////////////////////////////////////Loading
 66 | system("clear");
 67 | for(i=0;i<50000;i++)
 68 | {
 69 | cout<<"Please Wait!!! Loading Boot files of the program into the Active Memory case number "<<i+1<<endl;
 70 | if(i<10000)
 71 | {
 72 | cout<<"Copying files from source location to active memory"<<endl;
 73 | }
 74 | else if((i>=10000)&&(i<40000))
 75 | {
 76 | cout<<"Processing the files and Optimising Disk Space"<<endl;
 77 | }
 78 | else
 79 | {
 80 | cout<<"File is about to be opened! Brace Yourselves"<<endl;
 81 | }
 82 | }
 83 | system("clear");
 84 | //////////////////////////////////////////////////////////////////////Initialize Adjancy Matrix to 2 for general check as 1=true 0=false
 85 | for(i=0;i<10;i++)
 86 | {
 87 | for(j=0;j<10;j++)
 88 | {
 89 | A[i][j]=2;
 90 | }
 91 | }
 92 | //////////////////////////////////////////////////////////////////////Adjancy Matrix
 93 | cout<<"Lets make the adjancy matrix now"<<endl;
 94 | for(i=0;i<n;i++)
 95 | {
 96 | 	for(j=0;j<n;j++)
 97 | 	{
 98 | 		if(A[i][j]!=1)
 99 | 		{
100 | 		cout<<"If there is a graphical connection between "<<stu[i]->name<<" and "<<stu[j]->name<<"?\nIf yes please enter Y"<<endl;
101 | 		cin>>rep; 
102 | 			if((rep=='y')||(rep=='Y'))
103 | 			{
104 | 			A[i][j]=1;
105 | 			A[j][i]=1;
106 | 			}
107 | 			else
108 | 			{
109 | 			A[i][j]=0;
110 | 			}
111 | 		}
112 | 		else
113 | 		{
114 | 		continue;
115 | 		}
116 | 	}//end of for this
117 | }
118 | /////////////////////////////////////////////////////////////creation of adjancy list
119 | stud *node1[10],*p11,*ptr11;
120 | for(i=0;i<n;i++)
121 | {
122 | node1[i]=new stud;
123 | node1[i]->name=stu[i]->name;
124 | node1[i]->next=NULL;
125 | for(j=0;j<n;j++)
126 | {
127 | if((A[i][j]==1)&&(i!=j))
128 | {
129 | p11=new stud;
130 | p11->name=stu[j]->name;
131 | p11->next=NULL;
132 | node1[i]->next=p11;
133 | }
134 | }
135 | }
136 | /////////////////////////////////////////////////////////////creation of connections using adjancy matrix
137 | int k=0;
138 | for(i=0;i<n;i++)
139 | {
140 | for(j=0;j<n;j++)
141 | {
142 | if(A[i][j]==1)
143 | stu[i]->connections[k++]=stu[j];
144 | }
145 | k=0;
146 | }
147 | /////////////////////////////////////////////////////////////Option Menu
148 | int ch,quit=0; 
149 | char rep11;
150 | system("clear");
151 | do
152 | {
153 | cout<<"Option Menu"<<endl;
154 | cout<<"1: Creation of new vertices"<<endl;
155 | cout<<"2: View Adjancy Matrix"<<endl;
156 | cout<<"3: View Adjancy List"<<endl;
157 | cout<<"4: BFS Traversal"<<endl;
158 | cout<<"5: DFS Traversal"<<endl;
159 | cout<<"6: View all the Vertices"<<endl;
160 | cout<<"7: Quit"<<endl;
161 | cout<<"Enter your choice now"<<endl;
162 | cin>>ch;
163 | switch(ch)
164 | {
165 | case 1:
166 | /////////////////////////////////////////////////////////////Insertion
167 | if(n<=10)
168 | {
169 | cout<<"Creation of new vertex"<<endl;
170 | n=n+1;
171 | stu[n]=new student;
172 | stu[n]->insert();
173 | for(i=0;i<10;i++)
174 | {
175 | stu[n]->connections[i]=NULL;
176 | }
177 | //Adjancy Matrix correction
178 | cout<<"Lets make the adjancy matrix now"<<endl;
179 | for(i=0;i<n;i++)
180 | {
181 | cout<<"Is there a relation between "<<stu[n]->name<<" and "<<stu[i]->name<<"?\nIf yes, press Y"<<endl;
182 | cin>>rep11;
183 | if((rep11=='y')||(rep11=='Y'))
184 | {
185 | A[n][i]=1;
186 | A[i][n]=1;
187 | }
188 | else
189 | {
190 | A[n][i]=0;
191 | }
192 | }
193 | //Adjancy List correction
194 | //connections corrections
195 | }
196 | else
197 | {
198 | cout<<"The maximum limit has been reached! I am extremely sorry but no further insertions now."<<endl;
199 | }
200 | /////////////////////////////////////////////////////////////
201 | break;
202 | case 2:
203 | cout<<"Lets see the Adjancy Matrix shall we"<<endl;
204 | cout<<"Here the indexes are for"<<endl;
205 | for(i=0;i<n;i++)
206 | {	
207 | 	cout<<i<<": "<<stu[i]->name<<endl;
208 | }
209 | for(i=0;i<n;i++)
210 | {
211 | for(j=0;j<n;j++)
212 | {
213 | cout<<A[i][j]<<"\t";
214 | }
215 | cout<<endl;
216 | }
217 | break;
218 | case 3: 
219 | cout<<"Lets see the adjancy list now"<<endl;
220 | for(i=0;i<n;i++)
221 | {
222 | cout<<"Adjnacy Linked List for "<<stu[i]->name<<" is "<<endl;
223 | for(ptr11=node1[i];ptr11!=NULL;ptr11=ptr11->next)
224 | {
225 | cout<<ptr11->name<<"\t";
226 | }
227 | cout<<endl;
228 | }
229 | break;
230 | case 4:
231 | break;
232 | case 5:
233 | break;
234 | case 6: cout<<"Lets see all the verices now"<<endl;
235 | for(i=0;i<n;i++)
236 | {
237 | cout<<"The Vertex number "<<i+1<<" is:"<<endl;
238 | stu[i]->show();
239 | }
240 | break;
241 | case 7: quit=1;
242 | break;
243 | default: cout<<"Why are we still here! Only to suffer! Please write a numerical integer value between 1 and 7 you stupid idiot"<<endl;
244 | }
245 | cout<<"\n\n\n\n\n\n\n"<<endl;
246 | cout<<"Enter y to clear screen"<<endl;
247 | cin>>rep11;
248 | if((rep11=='y')||(rep11=='Y'))
249 | system("clear");
250 | }while(quit!=1);
251 | /////////////////////////////////////////////////////////////Code above this only
252 | }
253 | else
254 | {
255 | cout<<"I told you to keep it withing 10! Now Goodbye! You don't deserve me"<<endl;
256 | }
257 | system("clear");
258 | return 0;
259 | }
260 | 


--------------------------------------------------------------------------------
/hybridex.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class grandmother
 4 | {
 5 | protected:
 6 | string name="Maya Rani Khare";
 7 | public:
 8 | void show12()
 9 | {
10 | cout<<"Name of the grandmother is "<<name<<endl;
11 | }
12 | };
13 | class father: virtual public grandmother
14 | {
15 | protected:
16 | string name="Raj Khare";
17 | public:
18 | void show1()
19 | {
20 | cout<<"Name of the father is "<<name<<endl;
21 | }
22 | };
23 | class mother: public virtual grandmother
24 | {
25 | protected:
26 | string name="Shivanee Kanchan";
27 | public:
28 | void show2()
29 | {
30 | cout<<"Name of the mother is "<<name<<endl;
31 | }
32 | };
33 | class child: public mother,public father
34 | {
35 | protected:
36 | string name;
37 | public:
38 | child(string c)
39 | {
40 | name=c;
41 | }
42 | void show()
43 | {
44 | show12();
45 | show1();
46 | show2();
47 | cout<<"Name of the child is "<<name<<endl;
48 | }
49 | };
50 | int main()
51 | {
52 | cout<<"Code for hybrid level"<<endl;
53 | child nish("Nishkarsh Raj");
54 | nish.show();
55 | cout<<"\n\n\n\n";
56 | cout<<sizeof(grandmother)<<endl;
57 | cout<<sizeof(father)<<endl;
58 | cout<<sizeof(mother)<<endl;
59 | cout<<sizeof(child)<<endl;
60 | return 0;
61 | }
62 | 


--------------------------------------------------------------------------------
/hybridvirtual.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std; 
 3 | class A
 4 | {
 5 | int a[10];
 6 | };
 7 | class B1: virtual public A
 8 | {
 9 | };
10 | class B2: virtual public A
11 | {
12 | };
13 | class B3: virtual public A
14 | {
15 | };
16 | class derived: public B1, public B2, public B3
17 | {
18 | };
19 | int main()
20 | {
21 | derived r;
22 | cout<<"Size of A is "<<sizeof(A)<<endl;
23 | cout<<"size of B1 is "<<sizeof(B1)<<endl;
24 | cout<<"Size of derived is "<<sizeof(r)<<endl;
25 | cout<<endl;
26 | return 0;
27 | }
28 | 
29 | 


--------------------------------------------------------------------------------
/independence.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | using namespace std;
 4 | int main()
 5 | {
 6 | ofstream nish("Independence.txt");
 7 | nish<<"Nishkarsh Raj Khare is the best baaybaaay!!!"<<endl;
 8 | cout<<"Text file created"<<endl;
 9 | /*ifstream nish("Independence.txt");
10 | string s;
11 | nish>>s;
12 | cout<<"File had "<<s<<endl; */
13 | nish.open("Independence2.txt");
14 | nish<<"ISSS!!!"<<endl;
15 | cout<<"DID IT HAPPEN"<<endl; /////////////// Nope! The above two lines are ignored by the compiler as is becomes confused how the same logical name can be given in the active memory to two different physical files and thus ignores all next work done with the same logical name. We can correct this by closing the first file thus removing it from active memory.
16 | return 0;
17 | }
18 | 
19 | 
20 | 
21 | /////////////////////////
22 | //we can open in read and write mode same file simultaneously using different logical name
23 | //we cannot open both simultaneously in different modes using same logical name
24 | 


--------------------------------------------------------------------------------
/inheritance.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class A
 4 | {
 5 | int a[10]; int c=2;
 6 | };
 7 | class B: private A
 8 | {
 9 | int b[10],x=2;
10 | public:
11 | void dis()
12 | {
13 | cout<<x+c;
14 | }
15 | };
16 | class C: private B
17 | {
18 | int c[10];
19 | public:
20 | void show(){
21 | cout<<c+x;
22 | }
23 | };
24 | int main()
25 | {
26 | C nish;
27 | nish.show();
28 | B n;
29 | cout<<n.dis();
30 | cout<<sizeof(C)<<endl;
31 | return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/init_nocons.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class Nish
 4 | {
 5 | int sapid=500060720;
 6 | string roll="R171217041";
 7 | public:
 8 | void show()
 9 | {
10 | cout<<"The sapid is "<<sapid<<endl<<"Roll number is "<<roll<<endl;
11 | }
12 | };
13 | int main()
14 | {
15 | Nish n;
16 | n.show();
17 | cout<<endl;
18 | return 0;
19 | }
20 | 
21 | 


--------------------------------------------------------------------------------
/inline.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | void show1();
 4 | inline void show2();
 5 | void show1()
 6 | {
 7 | cout<<"Not inline"<<endl;
 8 | }
 9 | inline void show2()
10 | {
11 | cout<<"Inline"<<endl;
12 | }
13 | int main()
14 | {
15 | cout<<"Lets do inline vs non inline maen"<<endl;
16 | show1();
17 | //show2();
18 | return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/linkedmain.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | using namespace std;
  3 | class student
  4 | {
  5 | 	public:
  6 | string rollno;
  7 | string sapid;
  8 | string name;
  9 | string specialization; //added to commit 2 to make a better platform
 10 | student *next; 
 11 | student()
 12 | {
 13 | rollno="R171217041";
 14 | sapid="500060720";
 15 | name="Nishkarsh Raj Khare";
 16 | specialization="DevOps";	
 17 | }	
 18 | void insert()
 19 | {
 20 | 	cout<<"Enter the name of the person"<<endl;
 21 | 	cin>>name;
 22 | 	cout<<"Enter the sapid of the student"<<endl;
 23 | 	cin>>sapid;
 24 | 	cout<<"Enter the rollno of the student"<<endl;
 25 | 	cin>>rollno;
 26 | 	cout<<"Enter the Specialization of the student"<<endl;
 27 | 	cin>>specialization;
 28 | }
 29 | void show()
 30 | {
 31 | 	cout<<"Name of the student is :"<<name<<endl;
 32 | 	cout<<"Roll Number of the student is :"<<rollno<<endl;
 33 | 	cout<<"Sapid of the student is :"<<sapid<<endl;
 34 | 	cout<<"Specialization of the student is :"<<specialization<<endl;
 35 | }
 36 | };
 37 | int main()
 38 | {
 39 | 	cout<<"Hello! This is a code of Linked List on Student's Data"<<endl;
 40 | 	//Creation of first node
 41 | 	student *node,*ptr,*p,*start;
 42 | 	node=new student;
 43 | 	cout<<"Lets insert the first node data"<<endl;
 44 | 	node->insert();
 45 | 	node->next=NULL;
 46 | 	cout<<"Lets see the details of first node"<<endl;
 47 | 	node->show();
 48 | 	start=node;
 49 | 	string n,n2;
 50 | 	int flag=0;
 51 | 	//creation of menu on commit 3
 52 | 	int quit=0,choice;
 53 | 	do
 54 | 	{
 55 | 	cout<<"\t\t\t\tOption Menu\n\n"<<endl;
 56 | 	cout<<"1) Insertion at Beginning"<<endl;
 57 | 	cout<<"2) Insertion at End"<<endl;
 58 | 	cout<<"3) Insertion at any point"<<endl;
 59 | 	cout<<"4) Deletion at Beginning"<<endl;
 60 | 	cout<<"5) Deleltion at end"<<endl;
 61 | 	cout<<"6) Deletion at any point"<<endl;
 62 | 	cout<<"7) Traversal of nodes"<<endl;
 63 | 	cout<<"8) Quit"<<endl;
 64 | 	cout<<"Enter your choice"<<endl;
 65 | 	cin>>choice;
 66 | 	switch(choice)
 67 | 	{
 68 | 		case 1: cout<<"Insertion at Beginning"<<endl;
 69 | 				ptr=new student;
 70 | 				ptr->insert();
 71 | 				ptr->next=start;
 72 | 				start=ptr;
 73 | 			break;
 74 | 		case 2: cout<<"Insertion at End"<<endl;
 75 | 				node=new student;
 76 | 				node->insert();
 77 | 				node->next=NULL;
 78 | 				for(ptr=start;ptr->next!=NULL;ptr=ptr->next);
 79 | 				ptr->next=node;
 80 | 				break;
 81 | 		case 3: cout<<"Insertion at any point"<<endl;
 82 | 				cout<<"Enter the name of the student after which you want to make the insertion"<<endl;
 83 | 				cin>>n;
 84 | 				for(ptr=start;ptr!=NULL;ptr=ptr->next)
 85 | 				{
 86 | 					if(ptr->name==n)
 87 | 					break;
 88 | 				}
 89 | 				node=new student;
 90 | 				node->insert();
 91 | 				node->next=ptr->next;
 92 | 				ptr->next=node;
 93 | 			break;
 94 | 		case 4: cout<<"Deletion at beginning"<<endl;
 95 | 				ptr=start;
 96 | 				start=ptr->next;
 97 | 				delete ptr;
 98 | 			break;
 99 | 		case 5: cout<<"Deletion at End"<<endl;
100 | 				if(start->next!=NULL)
101 | 				{
102 | 				for(ptr=start;ptr->next!=NULL;p=ptr,ptr=ptr->next);
103 | 				delete ptr;
104 | 				p->next=NULL;
105 | 				}
106 | 				else
107 | 				delete start;
108 | 			break;
109 | 		case 6: cout<<"Deletion anywhere"<<endl;
110 | 				cout<<"Enter name of the student whose record you want to delete"<<endl;
111 | 				cin>>n2;
112 | 				for(ptr=start;ptr->next!=NULL;p=ptr,ptr=ptr->next)
113 | 				{
114 | 					if(ptr->name==n2)
115 | 					{
116 | 					flag=1;
117 | 					break;
118 | 					}
119 | 					if(flag==1)
120 | 					{
121 | 						cout<<"Record Does not exist"<<endl;
122 | 					}
123 | 					else
124 | 					{
125 | 						p->next=ptr->next;
126 | 						delete ptr;
127 | 					}
128 | 				}
129 | 			break;
130 | 		case 7: cout<<"Traversal"<<endl;
131 | 				for(ptr=start;ptr!=NULL;ptr=ptr->next)
132 | 				ptr->show();
133 | 			break;
134 | 		case 8: quit=1;
135 | 			break;
136 | 		default: cout<<"Wrong Choice! Please Try Again"<<endl;
137 | 	}
138 |     }while(quit!=1);  
139 | 	return 0;
140 | }
141 | 


--------------------------------------------------------------------------------
/multilevel.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class student
 4 | {
 5 | protected:
 6 | int rn;
 7 | public:
 8 | void getn(int a)
 9 | {
10 | rn=a;
11 | }
12 | void putn()
13 | {
14 | cout<<"Roll number is "<<rn<<endl;
15 | }
16 | };
17 | class test: public student
18 | {
19 | protected:
20 | float s1,s2;
21 | public:
22 | void getm(float x,float y)
23 | {
24 | s1=x; s2=y;
25 | }
26 | void putm()
27 | {
28 | cout<<"Marks of roll number "<<rn<<endl;
29 | cout<<"Marks in subject 1 are "<<s1<<endl<<"Marks in subject 2 are "<<s2<<endl;
30 | }
31 | };
32 | class result:public test
33 | {
34 | float total;
35 | public:
36 | void display()
37 | {
38 | cout<<"Marks of roll number "<<rn;
39 | total=s1+s2;
40 | putn();
41 | putm();
42 | cout<<"total is "<<total<<endl;
43 | }
44 | };
45 | int main()
46 | {
47 | result r1;
48 | r1.getm(10,20);
49 | r1.getn(41);
50 | r1.display();
51 | return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/multipleambiguity.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class A
 4 | {
 5 | public:
 6 | void show(){cout<<"A"<<endl;}
 7 | };
 8 | class B
 9 | {
10 | public:
11 | void show(){cout<<"B"<<endl;}
12 | };
13 | class C: public A,public B
14 | {
15 | public:
16 | void show(){cout<<"C"<<endl;}
17 | };
18 | int main()
19 | {
20 | C nish;
21 | cout<<"Multiple Level Ambiguity Programme"<<endl;
22 | nish.show();
23 | nish.A::show();
24 | nish.B::show();
25 | nish.C::show();
26 | return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/object_argunment.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | <<<<<<< HEAD
 4 | class time1
 5 | =======
 6 | class time
 7 | >>>>>>> 068b4e7f2e1cef66939b6df29e22918251c1370b
 8 | {
 9 | int hours,minutes,seconds;
10 | public:
11 | void gettime()
12 | {
13 | cout<<"Enter hours,minutes and seconds respectively"<<endl;
14 | cin>>hours>>minutes>>seconds;
15 | <<<<<<< HEAD
16 | cout<<endl;
17 | }
18 | void showtime()
19 | {
20 | cout<<"hours is "<<hours<<endl<<"minutes are "<<minutes<<endl<<"Seconds are "<<seconds<<endl;
21 | }
22 | void sum(time1,time1);
23 | };
24 | void time1::sum(time1 t1,time1 t2)
25 | {
26 | seconds=t1.seconds+t2.seconds;
27 | minutes=t1.minutes+t2.minutes;
28 | if(seconds>=60)
29 | {
30 | minutes=minutes+(seconds/60);
31 | seconds=seconds%60;
32 | }
33 | hours=t1.hours+t2.hours;
34 | if(minutes>=60)
35 | {
36 | hours=hours+(minutes/60);
37 | minutes=minutes%60;
38 | }
39 | }
40 | int main()
41 | {
42 | time1 t1;
43 | t1.gettime();
44 | t1.showtime();
45 | time1 t2;
46 | t2.gettime();
47 | t2.showtime();
48 | time1 t3;
49 | =======
50 | }
51 | void showtime()
52 | {
53 | cout<<"hours is "<<hours<<endl<<"minutes are "<<minutes<<endl<<"Seconds are "<<seconds;
54 | }
55 | void sum(time,time);
56 | };
57 | void time::sum(time t1,time t2)
58 | {
59 | minutes=t1.minutes+t2.minutes;
60 | hours=minutes/60;
61 | minutes=minutes%60;
62 | seconds=t1.seconds+t2.seconds;
63 | }
64 | int main()
65 | {
66 | time t1;
67 | t1.gettime();
68 | t1.showtime();
69 | time t2;
70 | t2.gettime();
71 | t2.showtime();
72 | time t3;
73 | >>>>>>> 068b4e7f2e1cef66939b6df29e22918251c1370b
74 | t3.sum(t1,t2);
75 | t3.showtime();
76 | return 0;
77 | }
78 | 


--------------------------------------------------------------------------------
/pub_pri_call.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class Nish
 4 | {
 5 | int sapid=500060720;
 6 | string roll="R171217041";
 7 | string name="Nishkarsh Raj Khare";
 8 | void show()
 9 | {
10 | cout<<"The sapid is "<<sapid<<endl<<"Roll number is "<<roll<<endl;
11 | }
12 | public:
13 | void nothing();
14 | void display()
15 | {
16 | cout<<"This is a public function maen"<<endl;
17 | show();
18 | }
19 | };
20 | void Nish:: nothing() 
21 | {
22 | cout<<"Resolution baybeeee"<<endl;
23 | }
24 | int main()
25 | {
26 | Nish n;
27 | n.display();
28 | n.nothing();
29 | cout<<endl;
30 | return 0;
31 | }
32 | 
33 | 


--------------------------------------------------------------------------------
/read_file_basic.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | using namespace std;
 4 | int main()
 5 | {
 6 | ifstream nish("file_write_basic.txt");
 7 | string name,city;
 8 | int pin;
 9 | nish>>name>>city>>pin;
10 | cout<<"Lets see what our file had by using a program"<<endl;
11 | cout<<name<<city<<pin;
12 | return 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/read_write_basic.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | using namespace std;
 4 | int main()
 5 | {
 6 | cout<<"Lets write and read from a file in one go maen!!!!!"<<endl;
 7 | ofstream nish("readwrite.txt");
 8 | cout<<"Enter your first name, city and Roll number"<<endl;
 9 | string name,city;
10 | int roll;
11 | cin>>name>>city>>roll;
12 | nish<<name<<" "<<city<<" "<<roll<<endl;
13 | cout<<"Written to the file maen"<<endl;
14 | nish.close(); //close file to repoen for read mode
15 | //ifstream nish;                         //cannot open same file in the same program in different modes with same logical name
16 | //nish.open("readwrite.txt"); 
17 | ifstream nish1("readwrite.txt");
18 | cout<<"File opened in read mode"<<endl;
19 | string n,c; int r;
20 | nish1>>n>>c>>r;
21 | cout<<"Name is "<<n<<endl<<"city is "<<c<<endl<<"roll number is "<<r<<endl;
22 | cout<<"End of the program"<<endl;
23 | return 0;
24 | }
25 | 
26 | 


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


--------------------------------------------------------------------------------
/single_private.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class base 
 4 | {
 5 | int a;
 6 | protected:
 7 | int b;
 8 | public:
 9 | int c;
10 | void set_data(int a1,int b1, int c1)
11 | {
12 | a=a1; b=b1; c=c1;
13 | }
14 | base()
15 | {
16 | a=10; b=15; c=20;
17 | }
18 | };
19 | class derived: private base
20 | {
21 | int a2;
22 | protected:
23 | int b2;
24 | public:
25 | int c2;
26 | derived()
27 | {
28 | a2=5;
29 | b2=6;
30 | c2=10;
31 | }
32 | void show()
33 | {
34 | //cout<<"Protected Member of base "<<b<<endl;
35 | //cout<<"Public Member of base "<<c<<endl;
36 | cout<<"Private Member of Derived "<<a2<<endl;
37 | cout<<"Protected Member of Derived "<<b2<<endl;
38 | cout<<"Public Member of Derived "<<c2<<endl;
39 | cout<<endl;
40 | }
41 | };
42 | int main()
43 | {
44 | cout<<"Single Level Inheritance with private derivation"<<endl;
45 | derived obj;
46 | obj.show();
47 | //obj.set_data(5,14,16);
48 | //obj.show();
49 | return 0;
50 | }
51 | 
52 | 
53 | /* Note that in private derivation all the data members and member functions are inheritable yet all are inaccessible as well. The linux CLI also states that the base is an inaccessible in the child class */
54 | 
55 | 
56 | 
57 | 
58 | 


--------------------------------------------------------------------------------
/single_protected.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class base 
 4 | {
 5 | int a;
 6 | protected:
 7 | int b;
 8 | public:
 9 | int c;
10 | void set_data(int a1,int b1, int c1)
11 | {
12 | a=a1; b=b1; c=c1;
13 | }
14 | base()
15 | {
16 | a=10; b=15; c=20;
17 | }
18 | };
19 | class derived: protected base
20 | {
21 | int a2;
22 | protected:
23 | int b2;
24 | public:
25 | int c2;
26 | derived()
27 | {
28 | a2=5;
29 | b2=6;
30 | c2=10;
31 | }
32 | void show()
33 | {
34 | cout<<"Protected Member of base "<<b<<endl;
35 | cout<<"Public Member of base "<<c<<endl;
36 | cout<<"Private Member of Derived "<<a2<<endl;
37 | cout<<"Protected Member of Derived "<<b2<<endl;
38 | cout<<"Public Member of Derived "<<c2<<endl;
39 | cout<<endl;
40 | }
41 | void show1()
42 | {
43 | set_data(5,6,10);
44 | cout<<"Protected Member of base "<<b<<endl;
45 | cout<<"Public Member of base "<<c<<endl;
46 | cout<<"Private Member of Derived "<<a2<<endl;
47 | cout<<"Protected Member of Derived "<<b2<<endl;
48 | cout<<"Public Member of Derived "<<c2<<endl;
49 | }
50 | };
51 | int main()
52 | {
53 | cout<<"Single Level Inheritance with protected derivation"<<endl;
54 | derived obj;
55 | obj.show();
56 | obj.show1();
57 | return 0;
58 | }
59 | /* Note that in protected derivations public and private members are accessible only as protected. That is they can be accessed within child class but not in main with the object. Thats why here we have called set_data function within the derived class and not in main.
60 | "Protected members are like private for a given class" */
61 | 
62 | 
63 | 
64 | 
65 | 


--------------------------------------------------------------------------------
/single_public.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class base 
 4 | {
 5 | int a;
 6 | protected:
 7 | int b;
 8 | public:
 9 | int c;
10 | void set_data(int a1,int b1, int c1)
11 | {
12 | a=a1; b=b1; c=c1;
13 | }
14 | base()
15 | {
16 | a=10; b=15; c=20;
17 | }
18 | };
19 | class derived: public base
20 | {
21 | int a2;
22 | protected:
23 | int b2;
24 | public:
25 | int c2;
26 | derived()
27 | {
28 | a2=5;
29 | b2=6;
30 | c2=10;
31 | }
32 | void show()
33 | {
34 | cout<<"Protected Member of base "<<b<<endl;
35 | cout<<"Public Member of base "<<c<<endl;
36 | cout<<"Private Member of Derived "<<a2<<endl;
37 | cout<<"Protected Member of Derived "<<b2<<endl;
38 | cout<<"Public Member of Derived "<<c2<<endl;
39 | cout<<endl;
40 | }
41 | };
42 | int main()
43 | {
44 | cout<<"Single Level Inheritance with public derivation"<<endl;
45 | derived obj;
46 | obj.show();
47 | obj.set_data(5,14,16);
48 | obj.show();
49 | return 0;
50 | }
51 | /* Note that in public derivations the constructor of the parent class is invoked without even making the object of parent class if the object of the derived class is made because derived class inherits the constructor publically with its values */
52 | 
53 | 
54 | 
55 | 
56 | 


--------------------------------------------------------------------------------
/static.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | class sample
 4 | {
 5 | int samp;
 6 | 
 7 | public://why??
 8 | static int sam;
 9 | void read()
10 | {
11 | cout<<"Enter the values"<<endl;
12 | cin>>samp>>sam;
13 | }
14 | void sample1()
15 | {
16 | cout<<"Non Static"<<endl<<samp<<endl;
17 | }
18 | static void sample2()
19 | {
20 | cout<<"Static"<<endl<<sam<<endl;
21 | }
22 | };
23 | int sample :: sam; //why?? (2x)
24 | int main()
25 | {
26 | cout<<"Program of static function"<<endl;
27 | sample S;
28 | S.read();
29 | S.sample1();
30 | sample :: sample2();
31 | return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/string.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | using namespace std;
 4 | int main()
 5 | {
 6 | cout<<"Taking an entire string from the text file"<<endl;
 7 | ofstream nish("string.txt");
 8 | nish<<"Nishkarsh Raj Khare is the best in the world."<<endl;
 9 | cout<<"Text file is created!"<<endl;
10 | nish.close();
11 | ifstream nish1("string.txt");
12 | string s1;
13 | char s2[50];
14 | nish1>>s1;
15 | cout<<"Simple string intake "<<s1<<endl;
16 | nish1.get(s2,50);   //get function only works with character array and not with strings :O
17 | cout<<"String using get function "<<s2;
18 | return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/write_file_basic.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream> //both the streams are needed
 3 | using namespace std;
 4 | int main()
 5 | {
 6 | ofstream nish("file_write_basic.txt");  //opening with help of constructor
 7 | cout<<"Program to enter simple texts into the file"<<endl;
 8 | cout<<"Enter your first name, city and pincode "<<endl;
 9 | string name;
10 | string city;
11 | int pincode;
12 | getline(cin,name);
13 | getline(cin,city);
14 | cin>>pincode;
15 | nish<<name<<" "<<city<<endl<<pincode;     //How to give space and how to give linefeed!!
16 | cout<<"Written to the file! Now go and check"<<endl;
17 | return 0;
18 | }
19 | 


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