├── LamdaExpression262.cpp
├── FunctionToDisplayHello134.cpp
├── InfiniteLoop72.cpp
├── Auto259.cpp
├── DemoFirstProgram23.cpp
├── ScopingRule151.cpp
├── StaticVariables153.cpp
├── DefaultArguments140.cpp
├── DynamicAllocation110.cpp
├── RecursiveFunction154.cpp
├── ReturnByRefrence148.cpp
├── WritingInAFile245.cpp
├── DemoPointers107.cpp
├── FinalKeyword260.cpp
├── StudentExercise143.cpp
├── AddingAllElementsOfArray90.cpp
├── DemoCompoundAssignment34.cpp
├── DrawingPattern298.cpp
├── FindUserNameFromEmail132.cpp
├── PracticeProblemMultiplicationTable73.cpp
├── FunctionWithArgument134.cpp
├── StringLengthUsingLoop128.cpp
├── FactorsOfANumber76.cpp
├── CompoundConditionYoung52.cpp
├── FactorialOfANumber75.cpp
├── LocalAndGlobalVariables150.cpp
├── PassByAddress143.cpp
├── ReverseANumber82.cpp
├── SomOfNaturalNumbersUsingLoop74.cpp
├── CompoundConditionEligible52.cpp
├── DrawingPattern197.cpp
├── FindingMaxOf2Nos46.cpp
├── GcdOf2Nos85.cpp
├── PreprocessorDirectives236.cpp
├── StringLengthUsingIterator128.cpp
├── SumOfNaturalNumbersUsingWhileLoop74.cpp
├── DrawingPattern399.cpp
├── FIndingMaxElementFromAnArray91.cpp
├── PracticeProblemChangeCasesOfLetters129.cpp
├── FunctionTemplate138.cpp
├── PracticeProblemChangeCasesToUpperCase129.cpp
├── SumOfFactors77.cpp
├── ShortCircuit60.cpp
├── StructVsClass176.cpp
├── PassByReference145.cpp
├── ExceptionHandlingConstruct223.cpp
├── ReturnByAddress147.cpp
├── ProgramToFindGCD85.cpp
├── PassByValue142.cpp
├── Validation48.cpp
├── InclassInitializerAndDelegationOfConstructor265.cpp
├── Namespaces238.cpp
├── ArmstrongNumber81.cpp
├── DemoConditionalStatement47.cpp
├── FunctionToFindMaxOf3Nos134.cpp
├── PrimeNumber78.cpp
├── InnerClasses220.cpp
├── PerfectNumber77.cpp
├── ReadingFromAFile247.cpp
├── FindingMaxOf3Nos54.cpp
├── Ellipses267.cpp
├── FunctionOverloading136.cpp
├── FunctionOverriding204.cpp
├── CheckingPalindrome131.cpp
├── STLClassesUsingVector256.cpp
├── StudentExercise8155.cpp
├── ThrowAndCatchBetweenFunctions225.cpp
├── Demo1VirtualFunction206.cpp
├── ArrayLinearSearch92.cpp
├── DefaultConstructors170.cpp
├── StaticDataMembers216.cpp
├── Demo2VirtualFunction207.cpp
├── DemoFriendFunctionAndClass214.cpp
├── DemoIncrementAndDecrementOperators36.cpp
├── ThisPointer175.cpp
├── DemoDestructor240.cpp
├── Overflow38.cpp
├── ArrayBinarySearch93.cpp
├── Demo1BaseClassPtrDerivedClassObject200.cpp
├── Inheritance187.cpp
├── StaticFunctionOfAClass216.cpp
├── StudentExercise6104.cpp
├── VirtualDestructor242.cpp
├── DemoDynamicDeclarations62.cpp
├── DemoLoops71.cpp
├── AllAboutThrow227.cpp
├── PracticeProblemMatrixOperations103.cpp
├── NatureOfQuadraticRoots55.cpp
├── OperatorOverloadingUsingAdd179.cpp
├── AbstractClass211.cpp
├── Demo2BaseClassPtrDerivedClassObject201.cpp
├── PointerToAnObject163.cpp
├── ClassInC++161.cpp
├── PointerArithmitic112.cpp
├── SwitchUsingMenu66.cpp
├── DemoCompoundCondition52.cpp
├── StudentExercise244.cpp
├── AllAboutCatch229.cpp
├── BitwiseOperators40.cpp
├── STLMapClasses257.cpp
├── StudentExercise4LeapYear68.cpp
├── StudentExercise586.cpp
├── Demo3BaseClassPtrDerivedClassObject202.cpp
├── SmartUniquePointer264.cpp
├── DemoPolymorphism209.cpp
├── SmartSharedPointer264.cpp
├── PracticeStudentExercise367.cpp
├── CountVowelsAndWordsInAString130.cpp
├── ConstructorsInInheritance190.cpp
├── DayNameUsingElseIfLadder58.cpp
├── DayNameUsingSwitchCase65.cpp
├── InsertionOperatorOverloadingUsingStreamOperator183.cpp
├── OperatorOverloadingUsing+Operator179.cpp
├── OperatorOverloadingUsingFriendFunction181.cpp
├── StaticMemberExamples218.cpp
├── AccessorsAndMutators166.cpp
├── DemoAccessorsAndMutators166.cpp
├── DemoWaysOfInheritance196.cpp
├── DemoTemplateClassesOfTypeInt232.cpp
├── StudentExercise13230.cpp
├── DemoTemplateClassesOfTypeFloat232.cpp
├── AccessSpecifiers193.cpp
├── StudentExercise12212.cpp
├── StudentExercise9177.cpp
├── StudentExercise11198.cpp
├── StudentExercise10184.cpp
├── Serialization248.cpp
├── StudentExercise7105.cpp
├── StudentExercise14251.cpp
├── StudentExercise15258.cpp
└── InheritanceExample188.cpp


/LamdaExpression262.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 | 	[](int x,int y)
 7 | 	{
 8 | 	 	cout<<"Sum is "<<x+y<<endl;
 9 | 	}
10 | 	    
11 | 	(10,30);
12 | 	
13 | }
14 |     
15 | 


--------------------------------------------------------------------------------
/FunctionToDisplayHello134.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | void display()
 5 | {
 6 | 	cout<<"Hello";
 7 | }
 8 |     
 9 | int main()
10 | {
11 | 	display();
12 | 	
13 | 	return 0;
14 | 	    
15 | }
16 |     
17 | 


--------------------------------------------------------------------------------
/InfiniteLoop72.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int i=0;
 7 |         
 8 |     for(;;)
 9 |     {
10 |         cout<<" Hello";
11 |         i++;
12 |     }
13 |    	return 0;
14 |     
15 | }
16 | 


--------------------------------------------------------------------------------
/Auto259.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | float fun()
 5 | {
 6 | 	return 2.34f;
 7 | }
 8 |     
 9 | int main()
10 | {
11 | 	double d=12.3f;
12 | 	int i=9;
13 | 	auto x=2*d+i;
14 | 	    
15 | 	cout<<x;
16 | 	return 0;    
17 | }
18 | 


--------------------------------------------------------------------------------
/DemoFirstProgram23.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     string str;
 7 |     cout<<"Enetr your Name";
 8 |     cin>>str;
 9 |         
10 |     cout<<"Welcome "<<str;
11 |         
12 |     return 0;
13 | }
14 |     
15 | 


--------------------------------------------------------------------------------
/ScopingRule151.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int x=10;
 5 | int main()
 6 | {
 7 | 	int x=20;
 8 | 	{
 9 | 		int x=30;
10 | 		cout<<x<<endl;
11 | 	}
12 | 	    
13 | 	cout<<x<<endl;
14 | 	cout<<::x<<endl;
15 | 	    
16 | }
17 |     
18 | 


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


--------------------------------------------------------------------------------
/DefaultArguments140.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int sum(int a,int b,int c=0)
 5 | {
 6 |     return a+b+c;
 7 | }
 8 |     
 9 | int main()
10 | {
11 |     cout<<sum(10,20,3)<<endl;
12 |     
13 |     return 0;
14 |         
15 | } 
16 | 
17 | 


--------------------------------------------------------------------------------
/DynamicAllocation110.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 |     int size;
 7 | 	cout<<"Enter Number of Elements";
 8 | 	cin>>size;
 9 | 	int A[size];
10 | 	    
11 | 	cout<<sizeof A<<endl;
12 | 	
13 |     return 0;
14 |     	
15 | }
16 | 


--------------------------------------------------------------------------------
/RecursiveFunction154.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | void fun(int n)
 5 | {
 6 | 	if(n>0)
 7 | 	{
 8 | 	    cout<<n<<endl;
 9 | 		fun(n-1);
10 | 	}
11 | }
12 |     
13 | int main()
14 | {
15 | 	int x=5;
16 | 	fun(x);
17 | 	    
18 | }
19 |     
20 | 


--------------------------------------------------------------------------------
/ReturnByRefrence148.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int & fun(int &x)
 5 |     {
 6 |     	return x;
 7 |     }
 8 |     
 9 | int main()
10 |     {
11 | 	    int a=10;
12 | 	    fun(a)=25;
13 | 	    
14 | 	    cout<<a<<endl;
15 | 	    
16 |     }
17 | 


--------------------------------------------------------------------------------
/WritingInAFile245.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | using namespace std;
 4 |      
 5 | int main()
 6 | {
 7 | 	ofstream ofs("My.Text",ios::trunc);
 8 | 	ofs<<"john"<<endl;
 9 | 	ofs<<25<<endl;
10 | 	ofs<<"cs"<<endl;
11 | 	ofs.close();
12 | 	    
13 | }
14 |     
15 | 


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


--------------------------------------------------------------------------------
/FinalKeyword260.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class Parent
 5 | {
 6 | 	virtual void show() final
 7 | 	{
 8 | 	        
 9 | 	}
10 | 	
11 | };
12 |     
13 | class Child:Parent
14 | {
15 | 	void show()
16 | 	{
17 | 	        
18 | 	}
19 | 	
20 | };
21 |     
22 |     
23 | 


--------------------------------------------------------------------------------
/StudentExercise143.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     float radius;
 7 |     float area;
 8 | 
 9 |     cout<<"Enrer Radius of a Circle";
10 |     cin>>radius;
11 | 	area=3.1425*radius*radius;
12 | 
13 |     cout<<"Area of a Circle is "<<area<<endl;
14 | 
15 | }
16 | 


--------------------------------------------------------------------------------
/AddingAllElementsOfArray90.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 | 	int a[7]={4,8,6,9,5,2,7};
 7 | 	int n=7,sum=0;
 8 | 	    
 9 | 	for(int i=0;i<7;i++)
10 | 	{
11 | 		sum=sum+a[i];
12 |     }
13 |         
14 | 	cout<<"sum is"<<sum;
15 | 	
16 | 	return 0;
17 | 	    
18 | }
19 | 


--------------------------------------------------------------------------------
/DemoCompoundAssignment34.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int sum=10,x=5;
 7 |     sum+=x;
 8 |     cout<<sum<<endl;
 9 |         
10 |     int fact=10,y=5;
11 |     fact*=y;
12 |     cout<<fact<<endl;
13 |         
14 |     return 0;
15 |     
16 | }
17 |     
18 | 


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


--------------------------------------------------------------------------------
/FindUserNameFromEmail132.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	string email="john123@gmail.com";
 7 | 	int i=(int)email.find('@');
 8 | 	string uname=email.substr(0,i);
 9 | 	    
10 | 	cout<<"User Name is "<<uname<<endl;
11 | 	
12 | 	return 0;
13 | 	    
14 | }
15 |     
16 | 


--------------------------------------------------------------------------------
/PracticeProblemMultiplicationTable73.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	int n,i;
 7 | 	cout<<"Enter a Number";
 8 | 	cin>>n;
 9 | 	    
10 | 	for(i=1;i<=10;i++)
11 | 	{
12 | 	    cout<<n<<" x "<<i<<" = "<<i*n<<endl;
13 | 	}
14 | 	    
15 | 	return 0;
16 | 	
17 | }
18 | 


--------------------------------------------------------------------------------
/FunctionWithArgument134.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | float add(float x,float y)
 5 | {
 6 | 	float z;
 7 | 	z=x+y;
 8 | 	return z;
 9 | }
10 | 
11 | int main()
12 | {
13 | 	float x=2.3,y=7.9,z;
14 | 	z=add(x,y);
15 | 	    
16 | 	cout<<z<<endl;
17 | 	
18 | 	return 0;
19 | 	    
20 | }
21 | 


--------------------------------------------------------------------------------
/StringLengthUsingLoop128.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 | 	string str="welcome";
 7 | 	int count=0;
 8 | 	    
 9 | 	for(int i=0;str[i]!='\0';i++)
10 | 	{
11 | 	    count++;
12 | 	}
13 | 	cout<<"Length is"<<count<<endl;
14 | 	    
15 | 	return 0;
16 | 	    
17 | }
18 |     
19 | 


--------------------------------------------------------------------------------
/FactorsOfANumber76.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	int i,n;
 7 | 	cout<<"Enter the Number";
 8 | 	cin>>n;
 9 | 	    
10 | 	for(i=1;i<=n;i++)
11 | 	{
12 | 	    if(n%i==0)
13 | 	    {
14 | 		    cout<<i<<endl;
15 | 	    }
16 | 	}
17 | 	    
18 | 	return 0;
19 | 	
20 | }
21 | 


--------------------------------------------------------------------------------
/CompoundConditionYoung52.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main() 			
 4 | {
 5 | 	int age;
 6 | 	cout<<"Enter Age";
 7 | 	cin>>age;
 8 | 	    
 9 | 	if(age>=12&&age<=50)
10 | 	{
11 | 		cout<<"Young";
12 | 	}
13 | 	else
14 |     {
15 | 		cout<<"Not Young";
16 | 	}
17 | 	    
18 | 	return 0;
19 | 	
20 | }
21 | 


--------------------------------------------------------------------------------
/FactorialOfANumber75.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 | 	int n,i=1,fact=1;
 7 | 	cout<<"Enter the Number";
 8 | 	cin>>n;
 9 | 	    
10 | 	for(i=1;i<=n;i++)
11 | 	{
12 | 		fact=fact*i;
13 | 	}
14 | 	cout<<"Factorial of"<<n<<"is"<<fact<<endl;
15 | 	    
16 | 	return 0;
17 | 	    
18 | }
19 | 


--------------------------------------------------------------------------------
/LocalAndGlobalVariables150.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int g=5;
 5 | void fun()
 6 | {
 7 | 	int a=10;
 8 | 	a++;
 9 |     g++;
10 |     	
11 | 	cout<<a<<" "<<g<<endl;
12 | }
13 |     
14 | int main()
15 | {
16 |     cout<<g<<endl;
17 | 	fun();
18 | 	    
19 | 	cout<<g<<endl;
20 | 	    
21 | }
22 | 


--------------------------------------------------------------------------------
/PassByAddress143.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | void swap(int *a,int *b)
 5 | {
 6 | 	int temp;
 7 | 	temp=*a;
 8 | 	*a=*b;
 9 | 	*b=temp;
10 | }
11 |     
12 | int main()
13 | {
14 | 	int x=10,y=20;
15 | 	swap(&x,&y);
16 | 	cout<<x<<" "<<y<<endl;
17 | 	
18 | 	return 0;
19 | 	    
20 | }
21 |     
22 | 


--------------------------------------------------------------------------------
/ReverseANumber82.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	int n,r,rev=0;
 7 | 	cout<<"Enter the Number";
 8 | 	cin>>n;
 9 | 	    
10 | 	while(n>0)
11 | 	{
12 | 		r=n%10;
13 | 	    n=n/10;
14 | 		rev=rev*10+r;
15 | 	}
16 | 	cout<<"Reverse Number is"<<rev;
17 | 	    
18 | 	return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/SomOfNaturalNumbersUsingLoop74.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	int n,i,sum=0;
 7 | 	cout<<"Enter the Number";
 8 | 	cin>>n;
 9 | 	    
10 | 	for(i=1;i<=n;i++)
11 | 	{
12 | 	    sum=sum+i;
13 | 	}
14 | 	cout<<"Sum of Natural no is"<<sum<<endl;
15 | 	    
16 | 	return 0;
17 | 	    
18 | }
19 | 


--------------------------------------------------------------------------------
/CompoundConditionEligible52.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main() 			
 5 | {
 6 | 	int age;
 7 | 	cout<<"Enter Age";
 8 | 	cin>>age;
 9 | 	    
10 | 	if(age<=12||age>=50)
11 | 	{
12 | 		cout<<"Eligible";
13 | 	}
14 | 	else
15 | 	{
16 | 		cout<<"Not Eligible";
17 | 	}
18 | 	    
19 | 	return 0;
20 | 	
21 |     }
22 | 


--------------------------------------------------------------------------------
/DrawingPattern197.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	int count=1;
 7 | 	    
 8 | 	for(int i=0;i<4;i++)
 9 | 	{
10 | 	    for(int j=0;j<4;j++)
11 | 		{
12 | 		    cout<<count<<" ";
13 | 		    count++;
14 | 	    }
15 | 	    	
16 | 		cout<<endl;
17 | 	}
18 | 	    
19 | 	return 0;
20 | 	
21 | }
22 | 


--------------------------------------------------------------------------------
/FindingMaxOf2Nos46.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main() 			
 5 | {
 6 | 	int x,y;
 7 | 	cout<<"Enter 2 nos";
 8 | 	cin>>x>>y;
 9 | 	    
10 | 	if(x>y)
11 | 	{
12 | 		cout<<"Maximum is"<<x;
13 |     }
14 |     else
15 | 	{
16 | 		cout<<"Maximum is"<<y;
17 | 	}
18 | 	        
19 | 	return 0;
20 | 	    
21 | }
22 | 


--------------------------------------------------------------------------------
/GcdOf2Nos85.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 | 	int m,n;
 7 | 	cout<<"Enter two Numbers";
 8 | 	cin>>m>>n;
 9 | 	    
10 | 	while(m!=n)
11 |     {
12 | 	if(m>n)
13 | 	  	m=m-n;
14 | 	else if(n>m)
15 | 	  	n=n-m;
16 |     }	
17 | 	cout<<"GCD of 2nos "<<m;
18 | 	    
19 | 	return 0;
20 | 	    
21 | }
22 | 


--------------------------------------------------------------------------------
/PreprocessorDirectives236.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | #define max(x,y) (x>y?x:y)
 5 | #define msg(x) #x
 6 | #define pI 3.1425
 7 | 
 8 | #ifndef pI
 9 |       #define pI 3
10 | #endif
11 | 
12 | int main()
13 | {
14 | 	cout<<pI<<endl;
15 | 	cout<<max(10,12)<<endl;
16 | 	cout<<msg(hello)<<endl;
17 | 	    
18 | }
19 |     
20 | 


--------------------------------------------------------------------------------
/StringLengthUsingIterator128.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	string str="welcome";
 7 | 	string::iterator it;
 8 | 	int count=0;
 9 | 	    
10 | 	for(it=str.begin();it!=str.end();it++)
11 | 	{
12 | 		count++;
13 | 	}
14 | 	cout<<"length is"<<count<<endl;
15 | 	    
16 | 	return 0;
17 | 	    
18 | }
19 | 


--------------------------------------------------------------------------------
/SumOfNaturalNumbersUsingWhileLoop74.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 | 	int n,i=1,sum=0;
 7 | 	cout<<"Enter the Number";
 8 | 	cin>>n;
 9 | 	    
10 | 	while(i<=n)
11 | 	{
12 | 	    sum=sum+i;
13 | 	    i++;
14 | 	}
15 | 	cout<<"Sum of Natural no is"<<sum<<endl;
16 | 	    
17 |     return 0;
18 |     	
19 | }
20 | 


--------------------------------------------------------------------------------
/DrawingPattern399.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	for(int i=0;i<4;i++)
 7 | 	{
 8 | 	    for(int j=0;j<4;j++)
 9 | 	    {
10 | 		    if(i+j>4-1)
11 | 		        cout<<"*";
12 | 		    else
13 | 		        cout<<" ";
14 | 	    }
15 | 	        
16 | 	    cout<<endl;
17 | 	}
18 | 	    
19 | 	return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/FIndingMaxElementFromAnArray91.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	int A[7]={4,8,6,9,5,2,7};
 7 | 	int n=7,max;
 8 | 	max=A[0];
 9 | 	
10 | 	for(int i=0;i<7;i++)
11 | 	{
12 | 		if(A[i]>max)
13 | 		{
14 | 		    max=A[i];
15 | 		}
16 | 	}	
17 | 	cout<<"Maxmium no is"<<max;
18 | 	
19 | 	return 0;
20 | 	
21 | }
22 | 


--------------------------------------------------------------------------------
/PracticeProblemChangeCasesOfLetters129.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	string str="WeLcOMe";
 7 | 	    
 8 | 	for(int i=0;str[i]!='\0';i++)
 9 | 	{
10 | 		if(str[i]>=65 && str[i]<=90)
11 | 		{
12 | 		    str[i]=str[i]+32;
13 | 		}
14 | 	}
15 | 	cout<<str<<endl;
16 | 	    
17 | 	return 0;
18 | 	    
19 | }
20 | 


--------------------------------------------------------------------------------
/FunctionTemplate138.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | template<class T>
 5 | T maxim(T a,T b)
 6 |     {
 7 |        return a>b?a:b;
 8 |     }
 9 |     
10 | int main()
11 | {
12 | 	cout<<maxim(12,14)<<endl;
13 | 	cout<<maxim(2.3,1.4)<<endl;
14 | 	cout<<maxim(2.3f,5.6f)<<endl;
15 | 	
16 | 	return 0;
17 | 	    
18 | }
19 |     
20 | 	 
21 | 


--------------------------------------------------------------------------------
/PracticeProblemChangeCasesToUpperCase129.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	string str="wELcoMe7";
 7 | 	    
 8 | 	for(int i=0;str[i]!='\0';i++)
 9 | 	{
10 | 		if(str[i]>=97 && str[i]<=122)
11 | 		{
12 | 		    str[i]=str[i]-32;
13 | 		}
14 | 	}
15 | 	cout<<str<<endl;
16 | 	    
17 | 	return 0;
18 | 	    
19 | }
20 | 


--------------------------------------------------------------------------------
/SumOfFactors77.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 | 	int i,n,sum=0;
 7 | 	cout<<"Enter the Number";
 8 | 	cin>>n;
 9 | 	    
10 | 	for(i=1;i<=n;i++)
11 | 	{
12 | 	    if(n%i==0)
13 | 	    {
14 | 		    sum=sum+i;
15 | 	    }
16 | 	}  
17 | 	cout<<"Sum of Factors"<<sum<<endl;   
18 | 		  
19 | 	return 0;
20 | 	    
21 | }
22 | 


--------------------------------------------------------------------------------
/ShortCircuit60.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 | 	int a=10,b=5,i=5;
 7 |         
 8 |     if(a>b && ++i<=b)
 9 |     {
10 |                 
11 |     }
12 |     cout<<i<<endl;
13 |     if(a<b || ++i<=b)
14 |     {
15 |                 
16 |     }
17 |     cout<<i<<endl;
18 |         
19 |     return 0;
20 |         
21 | }
22 | 


--------------------------------------------------------------------------------
/StructVsClass176.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Demo
 5 | {
 6 |     public:
 7 | 	int x;
 8 | 	int y;
 9 | 	    
10 |     void display()
11 |  	{
12 | 		cout<<x<<" "<<y<<endl;
13 | 	}
14 | 	
15 | };
16 |     
17 | int main()
18 | {
19 | 	Demo d;
20 | 	d.x=10;
21 | 	d.y=20;
22 | 	d.display();
23 | 	    
24 | }
25 |     
26 |     
27 | 


--------------------------------------------------------------------------------
/PassByReference145.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | void swap(int &a,int &b)
 5 | {
 6 |     cout<<&a<<" "<<&b<<endl;
 7 | 	int temp;
 8 | 	temp=a;
 9 | 	a=b;
10 | 	b=temp;
11 | }
12 |     
13 | int main()
14 | {
15 | 	int x=10,y=20;
16 | 	swap(x,y);
17 | 	cout<<&x<<" "<<&y<<endl;
18 | 	cout<<x<<" "<<y;
19 | 	    
20 | 	return 0;
21 | 	    
22 | }
23 | 


--------------------------------------------------------------------------------
/ExceptionHandlingConstruct223.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	int x=10,y=0,z;
 7 | 	    
 8 | 	try
 9 | 	{
10 | 		if(y==0)
11 | 			throw 1;
12 | 		z=x/y;
13 | 		cout<<z<<endl;
14 | 	}
15 | 	    
16 | 	catch(int e)
17 | 	{
18 | 		cout<<"Division by Zero"<<e<<endl;
19 | 	}
20 | 	        
21 | 	cout<<"Bye"<<endl;
22 | 	    
23 | }
24 | 


--------------------------------------------------------------------------------
/ReturnByAddress147.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int * fun()
 5 | {
 6 | 	int *p=new int[5];
 7 | 	for(int i=0;i<5;i++)
 8 | 	{
 9 | 		p[i]=5*i;
10 | 	}
11 | 	    
12 | 	cout<<p<<endl;
13 | 	return p;
14 | }
15 |     
16 | int main()
17 | {
18 | 	int *q=fun();
19 | 	cout<<q<<endl;
20 | 	for(int i=0;i<5;i++)
21 | 	cout<<q[i]<<endl;
22 | 		
23 | }
24 |     
25 | 


--------------------------------------------------------------------------------
/ProgramToFindGCD85.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int m,n;
 7 |     cout<<"Enter 2 Numbers "<<endl;
 8 |     cin>>m>>n;
 9 |         
10 |     while(m!=n)
11 |     {
12 |     if(m>n)
13 |         m=m-n;
14 |     else
15 |         n=n-m;
16 |     }
17 |         
18 |     cout<<"GCD is "<<m;
19 |     
20 |     return 0;
21 |         
22 | }
23 | 


--------------------------------------------------------------------------------
/PassByValue142.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | void swap(int a,int b)
 5 | {
 6 | 	cout<<a<<" "<<b<<endl;
 7 | 	int temp;
 8 | 	temp=a;
 9 | 	a=b;
10 | 	b=temp;
11 | 	    
12 | 	cout<<a<<" "<<b<<endl;
13 | }
14 |     
15 | int main()
16 | {    
17 | 	int x=10,y=20;
18 | 	swap(x,y);
19 | 	    
20 | 	cout<<x<<" "<<y<<endl;
21 | 	
22 | 	return 0;
23 | 	    
24 | }
25 |     
26 | 


--------------------------------------------------------------------------------
/Validation48.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int a,b,c;
 7 |     cout<<"Enter Two Numbers: "<<endl;
 8 |     cin>>a>>b;
 9 |         
10 |     if(b==0)
11 |     {
12 |         cout<<"Division By Zero"<<endl;
13 |     }
14 |     else
15 |     {
16 |         c=a/b;
17 |         cout<<c<<endl;
18 |     }
19 |     
20 |     return 0;
21 |         
22 | }
23 | 


--------------------------------------------------------------------------------
/InclassInitializerAndDelegationOfConstructor265.cpp:
--------------------------------------------------------------------------------
 1 | # include<iostream>
 2 | # include<memory>
 3 | using namespace std;
 4 |     
 5 | class Test
 6 | {
 7 | 	int x=10;
 8 |     int y=13;
 9 |     public:
10 | 	Test(int a,int b)
11 | 	{
12 | 		x=a;
13 | 	    y=b;
14 | 	}
15 |     Test():Test(1,1)
16 | 	{
17 | 	            
18 | 	}
19 | 	
20 | };
21 |     
22 | int main()
23 | {
24 |         
25 | }
26 |     
27 | 


--------------------------------------------------------------------------------
/Namespaces238.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | namespace First
 5 | {
 6 | 	void fun()
 7 | 	{
 8 | 	    cout<<"First"<<endl;
 9 | 	}
10 | 	
11 | };
12 |     
13 | namespace Second
14 | {
15 | 	void fun()
16 | 	{
17 | 		cout<<"Second"<<endl;
18 | 	}
19 | 	
20 | };
21 |     
22 | using namespace First;
23 | int main()
24 | {
25 | 	Second::fun();
26 | 	std::cout<<"kkk"<<endl;
27 | 	    
28 | }
29 | 


--------------------------------------------------------------------------------
/ArmstrongNumber81.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	int n,r,sum=0,m;
 7 | 	cout<<"Enter the Number";
 8 | 	cin>>n;
 9 | 	m=n;
10 | 	    
11 | 	while(n>0)
12 | 	{
13 | 		r=n%10;
14 | 	    n=n/10;
15 | 		sum=sum+r*r*r;
16 | 	}
17 | 	    
18 | 	if(sum==m)
19 | 	    cout<<"Armstrong Number";
20 | 	else
21 | 		cout<<"Not a Armstrong Number";
22 | 		
23 | 	return 0;
24 | 	    
25 | }
26 | 


--------------------------------------------------------------------------------
/DemoConditionalStatement47.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int roll;
 7 |     cout<<"Enter your Roll Number."<<endl;
 8 |     cin>>roll;
 9 |         
10 |     if(roll<1)
11 |     {
12 |         cout<<"Invalid Roll Number."<<endl;
13 |     }
14 |     else
15 |     {
16 |         cout<<"Valid Roll Number."<<endl;
17 |     }
18 |             
19 |     return 0;
20 |         
21 | }
22 | 


--------------------------------------------------------------------------------
/FunctionToFindMaxOf3Nos134.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int maxim(int a,int b,int c)
 5 | {
 6 | 	if(a>b && a>c)
 7 | 		return a;
 8 | 	else if(b>c)
 9 | 		return b;
10 | 	else
11 | 	return c;
12 |     }
13 |     
14 | int main()
15 | {
16 | 	int a,b,c,d;
17 | 	cout<<"Enter 3nos";
18 | 	cin>>a>>b>>c;
19 | 	d=maxim(a,b,c);
20 | 	    
21 | 	cout<<"Maximum no is"<<d;
22 | 	return 0;
23 | 	    
24 | }
25 | 


--------------------------------------------------------------------------------
/PrimeNumber78.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	int i,n,count=0;
 7 | 	cout<<"Enter the Number";
 8 | 	cin>>n;
 9 | 	    
10 | 	for(i=1;i<=n;i++)
11 | 	{
12 | 	    if(n%i==0)
13 | 	    {
14 | 		    count++;
15 | 	    }
16 |     } 
17 |     	
18 | 	if(count==2)
19 | 		cout<<"Prime Number";
20 | 	else
21 | 		cout<<"Not a Prime Number"; 
22 | 			    
23 | 	return 0;
24 | 	    
25 | }
26 | 


--------------------------------------------------------------------------------
/InnerClasses220.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Outer
 5 | {
 6 | 	class Inner
 7 |     {
 8 | 	public:
 9 | 	void display()
10 | 	{
11 | 	cout<<"Display of Inner"<<endl;
12 | 	}
13 | 	
14 | };
15 | 
16 |     public:
17 | 	void fun()
18 | 	{
19 | 		i.display();
20 | 	}
21 | 	                
22 |     Inner i;
23 |     
24 | };
25 |     
26 | int main()
27 | {
28 | 	Outer::Inner i;
29 | }
30 |     
31 | 


--------------------------------------------------------------------------------
/PerfectNumber77.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	int i,n,sum=0;
 7 | 	cout<<"Enter the Number";
 8 | 	cin>>n;
 9 | 	    
10 | 	for(i=1;i<=n;i++)
11 | 	{
12 | 	    if(n%i==0)
13 | 	    {
14 | 		    sum=sum+i;
15 | 	    }
16 | 	}
17 | 	    
18 |     if(2*n==sum)
19 | 		cout<<"Perfect Number";
20 |     else
21 | 		cout<<"Not a Perfect Number";	 
22 | 			    
23 | 	return 0;
24 | 	    
25 | }
26 | 


--------------------------------------------------------------------------------
/ReadingFromAFile247.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | using namespace std;
 4 |      
 5 | int main()
 6 | {
 7 | 	ifstream ifs;
 8 | 	ifs.open("My.txt");
 9 | 	
10 | 	cout<<"file is opened"<<endl;
11 | 	string name;
12 | 	int roll;
13 | 	string branch;
14 | 	ifs>>name>>roll>>branch;
15 | 	ifs.close();
16 | 	    
17 | 	cout<<"name"<<name<<endl;
18 | 	cout<<"roll"<<roll<<endl;
19 | 	cout<<"branch"<<branch<<endl;
20 | 	    
21 | }
22 | 


--------------------------------------------------------------------------------
/FindingMaxOf3Nos54.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int a,b,c;
 7 |     cout<<"Enter 3 no.s"<<endl;
 8 |     cin>>a>>b>>c;
 9 |         
10 |     if(a>b && a>c)
11 |     {
12 |         cout<<a<<endl;
13 |     }
14 |     else if(b>c)
15 |     {
16 |         cout<<b<<endl;
17 |     }
18 |     else
19 |     {
20 |         cout<<c<<endl;
21 |     }
22 |             
23 |     return 0;
24 | 
25 | }
26 | 


--------------------------------------------------------------------------------
/Ellipses267.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstdarg>
 3 | using namespace std;
 4 |     
 5 | int sum(int n,...)
 6 | {
 7 | 	va_list list;
 8 | 	va_start(list,n);
 9 | 	int x;
10 | 	int s=0;
11 | 	    
12 | 	for(int i=0;i<n;i++)
13 | 	{
14 | 		x=va_arg(list,int);
15 | 	    s+=x;
16 | 	}
17 | 	        
18 | 	return s;
19 | }
20 |     
21 | int main()
22 | {
23 | 	cout<<sum(3,10,20,30)<<endl;
24 | 	cout<<sum(5,1,2,3,4,5)<<endl;
25 | 	    
26 | }
27 | 


--------------------------------------------------------------------------------
/FunctionOverloading136.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int sum(int a,int b)
 5 | {
 6 | 	return a+b;
 7 | }
 8 | 
 9 | float sum(float a,float b)
10 | {
11 | 	return a+b;
12 | }
13 | 
14 | int sum(int a,int b,int c)
15 | {
16 | 	return a+b+c;
17 | }
18 | 
19 | int main()
20 | {
21 | 	cout<<sum(10,5)<<endl;
22 | 	cout<<sum(12.5f,3.4f)<<endl;
23 | 	cout<<sum(10,20,3)<<endl;
24 | 	    
25 | 	return 0;
26 | 	    
27 | }
28 |     
29 |     
30 | 


--------------------------------------------------------------------------------
/FunctionOverriding204.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Base
 5 | {
 6 |     public:
 7 | 	void display()
 8 | 	{
 9 | 		cout<<"Display of Base"<<endl;
10 | 	}
11 | 	
12 | };
13 |     
14 | class Derived:public Base
15 | {
16 |     public:
17 | 	void display()
18 | 	{
19 | 		cout<<"Display of Derived"<<endl;
20 | 	}
21 | 	
22 | };    
23 |  				   
24 | int main()
25 | {
26 | 	Derived d;
27 | 	d.display();
28 | 	    
29 | }
30 |     
31 | 


--------------------------------------------------------------------------------
/CheckingPalindrome131.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	string str="MADAM";
 7 | 	string rev="";
 8 | 	int len=(int)str.length();
 9 | 	rev.resize(len);
10 | 	    
11 | 	for(int i=0,j=len-1;i<len;i++,j--)
12 | 	{
13 | 		rev[i]=str[j];
14 | 	}
15 | 	rev[len]='\0';
16 | 			
17 | 	if(str.compare(rev)==0)
18 | 		cout<<"Palindrome"<<endl;
19 | 	else
20 | 		cout<<"Not a Pallindrome"<<endl;
21 | 		    
22 | 	return 0;
23 | 	    
24 | }
25 | 


--------------------------------------------------------------------------------
/STLClassesUsingVector256.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | using namespace std;
 4 |     
 5 | int main()
 6 | {
 7 | 	vector<int> v={2,4,6,8,10};
 8 | 	v.push_back(20);
 9 | 	v.push_back(30);
10 | 	vector<int>::iterator itr;
11 | 	cout<<"Using Iterator"<<endl;
12 | 	    
13 | 	for(itr=v.begin();itr!=v.end();itr++)
14 | 		cout<<++*itr<<endl;
15 | 	    cout<<"Using For Each Loop"<<endl;
16 | 	        
17 | 	for(int x:v)
18 | 		cout<<x<<endl;
19 | 		    
20 | }
21 |     
22 | 


--------------------------------------------------------------------------------
/StudentExercise8155.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int Search(int A[],int n,int key)
 5 | {
 6 | 	for(int i=0;i<n;i++)
 7 |     	if(key==A[i])
 8 |         return i;
 9 |     return 0;
10 | }
11 |     
12 | int main()
13 | {
14 | 	int A[]={2,4,5,7,10,9,13};
15 |     int k;
16 |     cout<<"Enter an Element to be Searched:";
17 |     cin>>k;
18 |     int index=Search(A,7,k);
19 | 
20 |     cout<<"Element found at index :"<<index<<endl;
21 | 
22 | }
23 |     
24 | 


--------------------------------------------------------------------------------
/ThrowAndCatchBetweenFunctions225.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int division(int a,int b)
 5 | {
 6 | 	if(b==0)
 7 | 		throw 1;
 8 | 	return a/b;
 9 | }
10 |     
11 | int main()
12 | {
13 | 	int x=10,y=2,z;
14 | 	try
15 | 	{
16 | 	    if(y==0)
17 | 			throw 1;
18 | 		z=x/y;
19 | 		cout<<z<<endl;
20 | 	}
21 | 	        
22 | 	catch(int e)
23 | 	{
24 | 		cout<<"Division by Zero"<<e<<endl;
25 | 	}
26 | 	cout<<"Bye"<<endl;
27 | 	    
28 | }
29 |     
30 | 


--------------------------------------------------------------------------------
/Demo1VirtualFunction206.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class Base
 5 | {
 6 |     public:
 7 | 	virtual void fun()
 8 | 	{
 9 | 		cout<<"fun of Base"<<endl;
10 | 	}
11 | 	
12 | };
13 |     
14 | class Derived:public Base
15 | {
16 |     public:
17 | 	void fun()
18 | 	{
19 | 		cout<<"fun of Derived"<<endl;
20 | 	}
21 | 	
22 | };
23 |     
24 | int main()
25 | {
26 | 	Derived d;
27 | 	d.fun();
28 | 	Base *ptr=&d;
29 | 	ptr->fun();
30 | 	    
31 | }
32 |     
33 | 


--------------------------------------------------------------------------------
/ArrayLinearSearch92.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |  	int A[10],n=10;
 7 | 	int key;
 8 | 	cout<<"Enter Numbers";
 9 | 	    
10 | 	for(int i=0;i<n;i++)
11 | 	{
12 | 		cin>>A[i];
13 | 	}
14 | 	cout<<"Enter Key";
15 | 	cin>>key;
16 | 	    
17 | 	for(int i=0;i<n;i++)
18 | 	{
19 | 		if(key==A[i])
20 | 		{
21 | 			cout<<"Found at"<<i;
22 | 			return 0;
23 | 		}
24 | 	}
25 | 	    
26 | 	cout<<"Not Found";
27 | 	
28 | 	return 0;
29 | 	    
30 | }		
31 | 


--------------------------------------------------------------------------------
/DefaultConstructors170.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Rectangle
 5 | {
 6 |     private:
 7 | 	int length;
 8 | 	int breadth;
 9 | 	    
10 |     public:
11 | 	Rectangle()
12 | 	{
13 | 			
14 | 		length=1;
15 | 		breadth=1;
16 | 	}
17 | 	        
18 | int area()
19 | 	{
20 | 		return length*breadth;
21 | 	}
22 | 	
23 | };
24 |     
25 | int main()
26 | {
27 | 	Rectangle r1;
28 | 	cout<<r1.area()<<endl;
29 | 	
30 | 	return 0;
31 | 	    
32 | }
33 |     
34 | 


--------------------------------------------------------------------------------
/StaticDataMembers216.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Test
 5 | {
 6 |     public:
 7 |     int a;
 8 |     static int count;
 9 |     Test()
10 |     {
11 | 	    a=10;
12 |         count++;
13 |     }
14 |     
15 | };
16 |     
17 | int Test::count=0;
18 | 
19 | int main()
20 | {
21 | 	Test t1,t2;
22 | 	cout<<t1.count<<endl;
23 | 	cout<<t2.count<<endl;
24 | 	t1.count=25;
25 | 	cout<<t2.count<<endl;
26 | 	cout<<Test::count<<endl;
27 | 	    
28 | }
29 |     
30 | 


--------------------------------------------------------------------------------
/Demo2VirtualFunction207.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class BasicCar
 5 | {
 6 |     public:
 7 | 	virtual void start()
 8 | 	{
 9 | 		cout<<"BasicCar Started"<<endl;
10 | 	}
11 | 	
12 | };
13 |     
14 | class AdvanceCar:public BasicCar
15 | {
16 |     public:
17 | 	void start()
18 | 	{
19 | 		cout<<"AdvanceCar Started"<<endl;
20 | 	}
21 | 	
22 | };
23 |     
24 | int main()
25 | {
26 | 	BasicCar *ptr=new AdvanceCar();
27 | 	ptr->start();
28 | 	    
29 | }
30 |     
31 | 


--------------------------------------------------------------------------------
/DemoFriendFunctionAndClass214.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Your;
 5 | class My
 6 | {
 7 |     private:
 8 | 	int a;
 9 |     protected:
10 | 	int b;
11 |     public:
12 | 	int c;
13 | 	friend Your;
14 | };
15 | 
16 | class Your
17 | {
18 |     public:
19 | 	My m;
20 | 	void fun()
21 | 	{
22 | 	    m.a=10;
23 | 	    m.b=10;
24 | 	    m.c=10;
25 | 	}
26 | 	
27 | };
28 |     
29 | int main()
30 | {
31 |     	
32 | }
33 |     
34 |     
35 |     
36 | 
37 | 
38 | 


--------------------------------------------------------------------------------
/DemoIncrementAndDecrementOperators36.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int i=5,j;
 7 |     j=i++;
 8 |     cout<<j<<" "<<i<<endl;
 9 |         
10 |     int k=5,l;
11 |     l=++k;
12 |     cout<<l<<" "<<k<<endl;
13 |         
14 |     int a=5,b;
15 |     b=2*++a + 2*a++;
16 |     cout<<b<<" "<<a<<endl;;
17 |         
18 |     int c=5,d;
19 |     d=2*c++ + 2*c++;
20 |     cout<<d<<" "<<c<<endl;
21 |         
22 |     return 0;
23 |     
24 | }
25 |     
26 | 


--------------------------------------------------------------------------------
/ThisPointer175.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Rectangle
 5 | {
 6 |     private:
 7 | 	int length;
 8 | 	int breadth;
 9 | 	    
10 |     public:
11 | 	Rectangle(int length,int breadth)
12 | 	{
13 |     	this->length=length;
14 | 		this->breadth=breadth;
15 | 	}
16 | 	    
17 | 	int area()
18 | 	{
19 | 		return length*breadth;
20 | 	}
21 | 	
22 | };
23 |     
24 | int main()
25 | {
26 | 	Rectangle r1(10,5);
27 | 	cout<<r1.area()<<endl;
28 |     	
29 | }
30 |     
31 | 


--------------------------------------------------------------------------------
/DemoDestructor240.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Demo
 5 | {
 6 | 	int *p;
 7 |     public:
 8 | 	Demo()
 9 | 	{
10 | 		p=new int[10];
11 | 	    cout<<"Constructor of Demo"<<endl;
12 | 	}
13 | 	        
14 |     ~Demo()
15 | 	{
16 | 		delete[]p;
17 | 	   	cout<<"Destructor of Demo"<<endl;
18 | 	}
19 | 	
20 | };
21 |     
22 | void fun()
23 | {
24 | 	Demo *p=new Demo();
25 | 	delete p;
26 | }
27 |     
28 | int main()
29 | {
30 | 	fun();
31 | }
32 |     
33 |     
34 | 


--------------------------------------------------------------------------------
/Overflow38.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     char a=128;
 7 |     cout<<(int)a<<endl;
 8 |         
 9 |     char b=127;
10 |     b++;
11 |     cout<<(int)b<<endl;
12 |         
13 |     char c=129;
14 |     cout<<(int)c<<endl;
15 |         
16 |     char d=-128;
17 |     d--;
18 |     cout<<(int)d<<endl;
19 |         
20 |     int e=32767; // maximum integer value.
21 |     e++;
22 |     cout<<(int)e<<endl;
23 |         
24 |     return 0;
25 |     
26 | }
27 |     
28 | 


--------------------------------------------------------------------------------
/ArrayBinarySearch93.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 |     int A[10]={6,8,13,17,20,22,25,28,30,35};
 7 |  	int l=0,h=9,key,mid;
 8 | 	cout<<"Enter the Key";
 9 | 	cin>>key;
10 | 	    
11 | 	while(l<=h)
12 | 	{
13 | 		mid=(l+h)/2;
14 | 		if(key==A[mid])
15 | 		{
16 | 			cout<<"Found at"<<mid;
17 | 			return 0;
18 | 		}
19 | 		else if(key<A[mid])
20 | 			h=mid-l;
21 | 		else
22 | 			l=mid+l;
23 | 	}
24 | 	    
25 | 	cout<<"Not Found";
26 | 	
27 | 	return 0;
28 | 	    
29 | }
30 | 


--------------------------------------------------------------------------------
/Demo1BaseClassPtrDerivedClassObject200.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Base
 5 | {
 6 |     public:
 7 | 	void fun1()
 8 | 	{
 9 | 	    cout<<"fun1 of Base"<<endl;
10 | 	}
11 | 	
12 | };
13 |     
14 | class Derived:public Base
15 | {
16 |     public:
17 | 	void fun2()
18 | 	{
19 | 		cout<<"fun2 of Derived"<<endl;
20 | 	}
21 | 	
22 | };
23 |     
24 | int main()
25 | {
26 | 	Derived d;
27 | 	Base *ptr=&d;
28 | 	ptr->fun1();
29 | 	ptr->fun2();
30 | 	
31 | 	return 0;
32 | 	    
33 | }
34 | 


--------------------------------------------------------------------------------
/Inheritance187.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Base
 5 | {
 6 |     public:
 7 | 	int a;
 8 |     void display()
 9 |     {   
10 | 	 	cout<<"Display of Base "<<a<<endl;
11 | 	}
12 | 	
13 | };
14 |     
15 | class Derived:public Base
16 | {
17 |     public:
18 |     void show()
19 | 	{
20 | 	   	cout<<"Show of Derived"<<endl;
21 |     }
22 |     
23 | };
24 |     
25 | int main()
26 | {
27 |     Derived d;
28 | 	d.a=100;
29 | 	d.display();
30 |     d.show();
31 |     	
32 | }
33 |     	
34 | 


--------------------------------------------------------------------------------
/StaticFunctionOfAClass216.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Test
 5 | {
 6 |     public:
 7 |     int a;
 8 |     static int count;
 9 |     Test()
10 |     {
11 | 	    a=10;
12 |         count++;
13 |     }
14 |             
15 |     static int getCount()
16 |     {
17 | 	    return count;
18 |     }
19 |     
20 | };
21 |     
22 | int Test::count=0;
23 | int main()
24 | {
25 | 	Test t1,t2;
26 | 	cout<<Test::getCount()<<endl;
27 | 	cout<<t1.getCount()<<endl;
28 | 	    
29 | }
30 |     
31 | 


--------------------------------------------------------------------------------
/StudentExercise6104.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int n, i;
 7 |     float num[100], sum=0.0, average;
 8 | 
 9 |     cout << "Enter the Numbers of Element: ";
10 |     cin >> n;
11 | 
12 |     for(i = 0; i < n; ++i)
13 |     {
14 |         cout << i + 1 << ". Enter number: ";
15 |         cin >> num[i];
16 |         sum += num[i];
17 |     }
18 | 
19 |     average = sum / n;
20 |     cout << "Average = " << average;
21 | 
22 |     return 0;
23 |         
24 | } 
25 |     
26 | 


--------------------------------------------------------------------------------
/VirtualDestructor242.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Base
 5 | {
 6 |     public:
 7 | 	virtual ~Base()
 8 | 	{
 9 | 	    cout<<"Destructor of Base"<<endl;
10 | 	}
11 | 	
12 | };
13 |     
14 | class Derived:public Base
15 | {
16 |     public:
17 | 	~Derived()
18 | 	{
19 | 		cout<<"Destructor of Derived"<<endl;
20 | 	}
21 |     };
22 |     
23 |     
24 | void fun()
25 | {
26 | 	Base *p=new Derived();
27 | 	delete p;
28 | }
29 |     
30 | int main()
31 | {
32 | 	fun();
33 | }
34 |     
35 | 


--------------------------------------------------------------------------------
/DemoDynamicDeclarations62.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int a=10,b=5;
 7 |         
 8 |     if(true)
 9 |     {
10 |         int c=a+b;
11 |         cout<<c<<endl;
12 |     }
13 |     {
14 |         int d=a-b;
15 |         
16 |         if(true)
17 |         {
18 |             cout<<d<<endl;
19 |         }
20 |     }
21 |     
22 |         if(int e=a*b)
23 |         {
24 |             cout<<e<<endl;
25 |         }
26 |             
27 |     return 0;
28 |         
29 | }
30 | 


--------------------------------------------------------------------------------
/DemoLoops71.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int a=0;
 7 |         
 8 |     while(a<10)
 9 |     {
10 |         cout<<a<<"Hello\n;"
11 |         a++;
12 |     }
13 |     
14 |     int b=0;
15 |         
16 |     do
17 |     {
18 |         cout<<b<<"Hello\n";
19 |         b++;
20 |     }
21 |     while(b<10);
22 |         
23 |     for(int i=0;i<10;i++)
24 |     {
25 |         cout<<i<<"Hello\n";
26 |     }
27 |         
28 |     return 0;
29 |     
30 | }
31 |     
32 |     
33 | 


--------------------------------------------------------------------------------
/AllAboutThrow227.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class MyException: exception
 5 | {
 6 |         
 7 | };
 8 |     
 9 | int division(int a,int b)throw(MyException)
10 | {
11 | 	if(b==0)
12 | 	throw MyException();
13 | 	return a/b;
14 | }
15 |     
16 | int main()
17 | {
18 | 	int x=10,y=2,z;
19 | 	try
20 | 	{
21 | 		z=division(x,y);
22 | 		cout<<z<<endl;
23 | 	}
24 | 	catch(MyException e)
25 | 	{
26 | 	    cout<<"Division by Zero"<<endl;
27 | 	}
28 | 	        
29 | 	cout<<"Bye"<<endl;
30 | 	    
31 | }
32 |     
33 | 


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


--------------------------------------------------------------------------------
/NatureOfQuadraticRoots55.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cmath>
 3 | using namespace std;
 4 | 
 5 | int main() 			
 6 | {
 7 | 	float a,b,c,d,r1,r2;
 8 | 	cout<<"Enter a,b,c";
 9 | 	cin>>a>>b>>c;
10 | 	d=b*b-4*a*c;
11 | 
12 | 	if(d==0)
13 | 	{
14 | 		cout<<"Roots are Real and Equal"<<endl;
15 | 		cout<<(-b/(2*a));
16 | 	}
17 | 	else if(d>0)
18 | 	{
19 | 		cout<<"Roots are Real and Unequal"<<endl;
20 | 		cout<<(-b+sqrt(d)/(2*a));
21 | 		cout<<(-b-sqrt(d)/(2*a));
22 | 	}
23 | 	else
24 | 		cout<<"Imaginery";
25 | 		    	
26 | 	return 0;
27 | 
28 | }
29 |     
30 | 


--------------------------------------------------------------------------------
/OperatorOverloadingUsingAdd179.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Complex
 5 | {
 6 |     public:
 7 | 	int real;
 8 | 	int img;
 9 | 	        
10 | 	Complex add(Complex c)
11 | 	{
12 | 		Complex temp;
13 | 		temp.real=real+c.real;
14 | 		temp.img=img+c.img;
15 | 		return temp;
16 | 	}
17 | 	
18 | };
19 |     
20 | int main()
21 | {
22 | 	Complex c1,c2,c3;
23 | 	c1.real=5;
24 | 	c1.img=3;
25 | 	c2.real=10;
26 | 	c2.img=5;
27 | 	c3=c1.add(c2);
28 | 	    
29 | 	cout<<c3.real<<"+i"<<c3.img<<endl;
30 | 	    
31 | }
32 |     
33 | 


--------------------------------------------------------------------------------
/AbstractClass211.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class Base
 5 | {
 6 |     public:
 7 |     virtual void fun1()=0;
 8 |     virtual void fun2()=0;
 9 | };
10 |     
11 | class Derived :public Base
12 | {
13 |     public:
14 |     void fun1()
15 |     {
16 |         cout<<"fun1 of Derived"<<endl;
17 |     }  
18 |                 
19 |     void fun2()
20 |     {
21 |         cout<<"fun2 of Derived"<<endl;
22 |     }
23 | 
24 | };
25 |     
26 | int main()
27 | {
28 |     Derived d;
29 |     d.fun1();
30 |     d.fun2();
31 | 
32 | } 
33 |     
34 | 


--------------------------------------------------------------------------------
/Demo2BaseClassPtrDerivedClassObject201.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class Rectangle
 5 | {
 6 |     public:
 7 | 	void area()
 8 | 	{
 9 | 		cout<<"Area of Rectangle"<<endl;
10 | 	}
11 | 	
12 | };
13 |     
14 | class Cuboid:public Rectangle
15 | {
16 |     public:
17 | 	void volume()
18 | 	{
19 | 		cout<<"Cuboid Volume"<<endl;
20 | 	}
21 | 	
22 | };
23 |     
24 | int main()
25 | {
26 | 	Cuboid c;
27 | 	Rectangle *p=&c;
28 | 	p->area();
29 | 	p->volume(); // this function cannot be call	
30 | 		      
31 | 	return 0;
32 | 	    
33 | }
34 |     
35 | 


--------------------------------------------------------------------------------
/PointerToAnObject163.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class Rectangle
 5 | {
 6 |     public:
 7 | 	int length;
 8 | 	int breadth;
 9 | 	    
10 | 	int area()
11 | 	{
12 | 		return length*breadth;
13 | 	}
14 | 	        
15 | 	int perimeter()
16 |     {
17 | 		return 2*(length+breadth);
18 | 	}
19 | 	
20 | };
21 |     
22 | int main()
23 | {	
24 | 	Rectangle r1;
25 |     Rectangle *ptr;
26 | 	ptr=&r1;
27 | 	ptr->length=10;
28 | 	ptr->breadth=5;
29 | 	    
30 | 	cout<<ptr->area()<<endl;
31 | 	cout<<ptr->perimeter()<<endl;  
32 | 	    
33 | }
34 |     
35 | 


--------------------------------------------------------------------------------
/ClassInC++161.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Rectangle
 5 | {
 6 |     public:
 7 | 	int length;
 8 | 	int breadth;
 9 | 	    
10 | 	int area()
11 | 	{
12 | 		return length*breadth;
13 | 	}
14 | 	        
15 | 	int perimeter()
16 |     {
17 | 		return 2*(length+breadth);
18 | 	}
19 | };
20 |     
21 | int main()
22 | {
23 | 	Rectangle r1;
24 | 	r1.length=10;
25 | 	r1.breadth=5;
26 | 	    
27 |     cout<<"Area is "<<r1.area()<<endl;
28 |     cout<<"Perimeter is "<<r1.perimeter()<<endl;
29 |     
30 |     return 0;
31 |     	
32 | }
33 |     
34 | 


--------------------------------------------------------------------------------
/PointerArithmitic112.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int A[5]={2,4,6,8,10};
 7 |     int *p=A,*q=&A[4];
 8 |     cout<<*p<<endl;
 9 |     cout<<endl;
10 |         
11 |     p++;
12 |     cout<<*p<<endl;
13 |     cout<<endl;
14 |         
15 |     p--;
16 |     cout<<*p<<endl;
17 |     cout<<endl;
18 |     cout<<p<<endl;
19 |     cout<<p+2<<endl;
20 |     cout<<endl;
21 |     cout<<*p<<endl;
22 |     cout<<*(p+2)<<endl;
23 |     cout<<endl;
24 |     cout<<q-p<<endl;
25 |     cout<<p-q<<endl;
26 |     
27 |     return 0;
28 |         
29 | }
30 |     
31 | 


--------------------------------------------------------------------------------
/SwitchUsingMenu66.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 | 	cout<<"Menu\n";
 7 | 	cout<<"1. add\n"<<"2. sub\n"<<"3. multi\n"<<"4. div\n";
 8 | 	int option;
 9 | 	cout<<"Enter Your Choice";
10 | 	cin>>option;
11 | 	int a,b,c; 
12 | 	cout<<"Enter 2 Numbers";
13 | 	cin>>a>>b;
14 | 		
15 | 	switch(option)
16 |     {
17 | 	    case 1:c=a+b;
18 |       		break;
19 | 		case 2:c=a-b;
20 | 		    break;
21 | 	    case 3:c=a*b;
22 | 		    break;
23 | 		case 4:c=a/b;
24 | 		    break;
25 | 	    }
26 | 	    cout<<"result is"<<c<<endl;
27 | 		
28 | 	return 0;
29 | 		
30 | }
31 | 


--------------------------------------------------------------------------------
/DemoCompoundCondition52.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int age;
 7 |     cout<<"Enter your age: "<<endl;
 8 |     cin>>age;
 9 |         
10 |     if(age>=12 && age<=50)
11 |     {
12 |         cout<<"Young"<<endl;
13 |     }
14 |     else
15 |     {
16 |         cout<<"Not Young"<<endl;
17 | 	}
18 | 			
19 |     if(age<12 || age>50)
20 |     {
21 |         cout<<"Eligible for the offer"<<endl;
22 |     }
23 |     else
24 |     {
25 |         cout<<"Not eligible for the offer"<<endl;
26 |     }
27 |             
28 |     return 0;
29 |         
30 | }
31 | 


--------------------------------------------------------------------------------
/StudentExercise244.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     float basic;
 7 |     float percentAllow;
 8 |     float percentDeduct;
 9 |     float netSalary;
10 | 
11 |     cout<<"Enter Basic Salary:";
12 |     cin>>basic;
13 |     cout<<"Enter percent of Allowences:";
14 |     cin>>percentAllow;
15 |     cout<<"Enter percent of Deductions:";
16 |     cin>>percentDeduct;
17 | 
18 |     netSalary=basic+basic*percentAllow/100-
19 |     basic*percentDeduct/100;
20 | 
21 |     cout<<"Net Salary is:"<<netSalary<<endl;
22 |         
23 |     return 0;
24 | 
25 | }
26 |     
27 | 


--------------------------------------------------------------------------------
/AllAboutCatch229.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class MyException1: exception
 5 | {
 6 |         
 7 | };
 8 |     
 9 | class MyException2:public MyException1
10 | {
11 |         
12 | };
13 |     
14 | int main()
15 | {
16 | 	try
17 | 	{
18 | 		throw MyException1();
19 | 	}
20 | 	        
21 | 	catch(MyException2 e)
22 | 	{
23 | 		cout<<"Int Catch"<<endl;
24 |     }
25 |         	
26 | 	catch(MyException1 e)
27 | 	{
28 | 	    cout<<"Double Catch"<<endl;
29 | 	}
30 | 	        
31 | 	catch(...)
32 | 	{
33 | 		cout<<"All Catch"<<endl;
34 | 	}
35 | 	        
36 | }
37 |     
38 | 


--------------------------------------------------------------------------------
/BitwiseOperators40.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int a=11,b=7,c;
 7 |     c=a&b;
 8 |     cout<<c<<endl;
 9 |         
10 |     int d=11,e=7,f;
11 |     f=d|e;
12 |     cout<<f<<endl;
13 |         
14 |     int g=11,h=7,i;
15 |     i=g^h;
16 |     cout<<i<<endl;
17 |         
18 |     char j=5,k;
19 |     k=j<<1;
20 |     cout<<(int)k<<endl;
21 |         
22 |     char l=20,m;
23 |     m=l>>1;
24 |     cout<<(int)m<<endl;
25 |         
26 |     char x=5,y;
27 |     y= ~ x;
28 |     cout<<(int)y<<endl;
29 |         
30 |     return 0;
31 |         
32 | }
33 | 


--------------------------------------------------------------------------------
/STLMapClasses257.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<map>
 3 | using namespace std;
 4 |     
 5 | int main()
 6 | {
 7 | 	map<int,string> m;
 8 | 	m.insert(pair<int,string>(1,"john"));
 9 | 	m.insert(pair<int,string>(2,"ravi"));
10 | 	m.insert(pair<int,string>(3,"khan"));
11 | 	map<int,string>::iterator itr;
12 | 	    
13 | 	for(itr=m.begin();itr!=m.end();itr++)
14 | 	{
15 | 	    cout<<itr->first<<" "<<itr->second<<endl;
16 | 	}
17 | 	map<int,string>::iterator itr1;
18 | 		itr1=m.find(2);
19 | 	        
20 | 	cout<<"Value Found is"<<endl;
21 | 	cout<<itr1->first<<" "<<itr1->second<<endl;
22 | 	    
23 | }
24 |     
25 | 


--------------------------------------------------------------------------------
/StudentExercise4LeapYear68.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int year;
 7 | 
 8 |     cout << "Enter a year: ";
 9 |     cin >> year;
10 | 
11 |     if (year % 4 == 0)
12 |     {
13 |         if (year % 100 == 0)
14 |         {
15 |         if (year % 400 == 0)
16 |         	cout << year << " is a leap year.";
17 |         else
18 |         	cout << year << " is not a leap year.";
19 |         }
20 |     else
21 |         cout << year << " is a leap year.";
22 |     }
23 |     else
24 |          cout << year << " is not a leap year.";
25 | 
26 |     return 0;
27 |         
28 | }
29 | 


--------------------------------------------------------------------------------
/StudentExercise586.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int n, num, digit, rev = 0;
 7 | 
 8 |     cout << "Enter a Positive Number: ";
 9 |     cin >> num;
10 |     n = num;
11 | 
12 |     do
13 |     {
14 |         digit = num % 10;
15 |         rev = (rev * 10) + digit;
16 |         num = num / 10;
17 |     } while (num != 0);
18 | 
19 |     cout << " The Reverse of the Number is: " << rev << endl;
20 | 
21 |     if (n == rev)
22 |         cout << " The Number is a Palindrome";
23 |     else
24 |         cout << " The Number is Not a Palindrome";
25 | 
26 |     return 0;
27 |         
28 | }
29 | 


--------------------------------------------------------------------------------
/Demo3BaseClassPtrDerivedClassObject202.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class BasicCar
 5 | {
 6 |     public:
 7 | 	void start()
 8 | 	{
 9 | 		cout<<"Car Started"<<endl;
10 | 	}
11 | 	
12 | };
13 |     
14 | class AdvanceCar:public BasicCar
15 | {
16 |     public:
17 | 	void playmusic()
18 | 	{
19 | 		cout<<"Playing Music"<<endl;
20 | 	}
21 | 	
22 | };
23 |     
24 | int main()
25 | {
26 | 	BasicCar b;
27 | 	AdvanceCar *q=&b;
28 | 	AdvanceCar a;
29 | 	a.start();
30 | 	a.playmusic();
31 | 	BasicCar *ptr=&a;
32 | 	ptr->start();
33 | 	ptr->playmusic(); // this function cannot be called.
34 | 	    
35 | }
36 |     
37 | 


--------------------------------------------------------------------------------
/SmartUniquePointer264.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<memory>
 3 | using namespace std;
 4 | 
 5 | class Rectangle
 6 | {
 7 | 	int length;
 8 |     int breadth;
 9 |     public:
10 | 	Rectangle(int l,int b)
11 | 	{
12 | 		length=l;
13 | 	    breadth=b;
14 | 	}
15 | 	    
16 |     int area()
17 | 	{
18 | 	    return length*breadth;
19 | 	}
20 | 	
21 | };
22 | 
23 | int main()
24 | {
25 | 	unique_ptr<Rectangle> ptr(new Rectangle(10,5));
26 | 	cout<<ptr->area()<<endl;
27 | 	unique_ptr<Rectangle> ptr2;
28 | 	ptr2=move(ptr);
29 | 	    
30 | 	cout<<ptr2->area();
31 | 	//cout<<ptr->area(); // this ptr cannot be called.
32 | 	    
33 | }
34 |     
35 | 


--------------------------------------------------------------------------------
/DemoPolymorphism209.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Car
 5 | {
 6 |     public:
 7 | 	virtual void start()
 8 | 	{
 9 | 		cout<<"Car Started"<<endl;
10 | 	}
11 | 	
12 | };
13 |     
14 | class Innova:public Car
15 | {
16 |     public:
17 | 	void start()
18 | 	{
19 | 		cout<<"Innova Started"<<endl;
20 | 	}
21 | 	
22 | };
23 |     
24 | class Swift:public Car
25 | {
26 |     public:
27 | 	void start()
28 |     {
29 | 		cout<<"Swift Started"<<endl;
30 | 	}
31 | 	
32 | };
33 |     
34 | int main()
35 | {
36 | 	Car *ptr=new Innova();
37 | 	ptr->start();
38 | 	ptr=new Swift();
39 | 	ptr->start();
40 | 	    
41 | }
42 |     
43 | 


--------------------------------------------------------------------------------
/SmartSharedPointer264.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<memory>
 3 | using namespace std;
 4 | 
 5 | class Rectangle
 6 | {
 7 | 	int length;
 8 |     int breadth;
 9 |     public:
10 | 	Rectangle(int l,int b)
11 | 	{
12 | 		length=l;
13 | 	    breadth=b;
14 | 	}
15 | 	    
16 |     int area()
17 | 	{
18 | 		return length*breadth;
19 | 	}
20 | 	
21 | };
22 |     
23 | int main()
24 | {
25 | 	shared_ptr<Rectangle> ptr(new Rectangle(10,5));
26 | 	cout<<ptr->area()<<endl;
27 | 	shared_ptr<Rectangle> ptr2;
28 | 	ptr2=ptr;
29 | 	    
30 | 	cout<<"ptr2 "<<ptr2->area()<<endl;
31 | 	cout<<"ptr "<<ptr->area()<<endl;
32 | 	cout<<ptr.use_count()<<endl;
33 | 	
34 | }
35 |     
36 | 


--------------------------------------------------------------------------------
/PracticeStudentExercise367.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     float billAmount;
 7 |     float discount=0.0;
 8 | 
 9 |     cout<<"Enter Bill Amount:";
10 |     cin>>billAmount;
11 |         
12 |     if(billAmount>=500)
13 |         
14 |     	discount=billAmount*20/100;
15 |         
16 |     else if(billAmount>=100 && billAmount<500)
17 |         
18 |         discount=billAmount*10/100;
19 |         billAmount=billAmount-discount;
20 | 
21 |     cout<<"Bill Amount is:"<<billAmount<<endl;
22 |     cout<<"Discount is :"<<discount<<endl;
23 |     cout<<"Discounted Amount is:"<<billAmount<<endl;
24 |         
25 |     return 0;
26 |         
27 | }
28 | 


--------------------------------------------------------------------------------
/CountVowelsAndWordsInAString130.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main()
 5 | {
 6 | 	string str="How Many Words";
 7 | 	int vowels=0,consonant=0,space=0;
 8 | 	    
 9 | 	for(int i=0;str[i]!='\0';i++)
10 | 	{
11 | 		if(str[i]=='A' || str[i]=='E' || str[i]=='I' || str[i]=='O' || str[i]=='U' || str[i]=='a' || str[i]=='e' || str[i]=='i' || str[i]=='o' || str[i]=='u')
12 | 		
13 | 		    vowels++;
14 | 		else if(str[i]==' ')
15 | 		
16 | 		    space++;
17 | 		    
18 | 		else
19 | 		    consonant++;
20 | 	}
21 | 	
22 | 	cout<<"vowels "<<vowels<<endl;
23 | 	cout<<"consonant "<<consonant<<endl;
24 | 	cout<<"words "<<space+1<<endl;
25 | 	    
26 | 	return 0;
27 | 	    
28 | }
29 |     
30 | 


--------------------------------------------------------------------------------
/ConstructorsInInheritance190.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class Base
 5 | {
 6 |     public:
 7 |     Base()
 8 | 	{
 9 | 	  	cout<<"Non-Param Base"<<endl;
10 |     }
11 |                 
12 |    	Base(int x)
13 | 	{
14 | 	 	cout<<"Param of Base"<<x<<endl;
15 | 	}
16 | 	
17 | };
18 |     
19 | class Derived:public Base
20 | {
21 |     public:
22 | 	Derived()
23 | 	{
24 | 		cout<<"Non-Param Derived"<<endl;
25 | 	}
26 | 	Derived(int y)
27 | 	{
28 | 		cout<<"Param of Derived"<<y<<endl;
29 | 	}
30 | 	Derived(int x,int y):Base(x)
31 |     {
32 | 		cout<<"Param of Derived"<<y<<endl;
33 | 	}
34 | 	
35 | };
36 |     
37 | int main()
38 | {
39 | 	Derived(5,10);
40 | 	
41 | }
42 |     
43 | 
44 | 


--------------------------------------------------------------------------------
/DayNameUsingElseIfLadder58.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | int main() 			
 5 | {
 6 |     int day;
 7 |     cout<<"Enter the Day Number";
 8 |     cin>>day;
 9 |         
10 |     if(day==1)
11 |         cout<<"Monday"<<endl;
12 |     else if(day==2)
13 |         cout<<"Tuesday"<<endl;
14 |     else if(day==3)
15 |         cout<<"Wednesday"<<endl;
16 |     else if(day==4)
17 |         cout<<"Thursday"<<endl;
18 |     else if(day==5)
19 | 	    cout<<"Friday"<<endl;
20 |     else if(day==6)
21 |         cout<<"Saturday"<<endl;
22 |     else if(day==7)
23 |         cout<<"Sunday"<<endl;
24 |     else
25 |         cout<<"Invalid Day No"<<endl;
26 |              
27 |     return 0;
28 |         
29 | }
30 | 


--------------------------------------------------------------------------------
/DayNameUsingSwitchCase65.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 | 	int day;
 7 | 	cout<<"Enter Day Number";
 8 | 	cin>>day;
 9 | 	    
10 |     switch(day)
11 |     {
12 |         case 1: cout<<"Monday"<<endl;
13 |         	break;
14 | 	   	case 2: cout<<"Tuesday"<<endl;
15 | 	  		break;
16 |         case 3: cout<<"Wednesday"<<endl;
17 |   	    	break;
18 | 	    case 4: cout<<"Thursday"<<endl;
19 | 	    	break;
20 | 	    case 5: cout<<"Friday"<<endl;
21 | 	    	break;
22 | 	    case 6: cout<<"Saturday"<<endl;
23 |         	break;
24 | 	    case 7: cout<<"Sunday"<<endl;
25 |         	break;
26 | 	    default: cout<<"Invalid Day Number"<<endl;
27 | 	}
28 | 	        
29 | 	return 0;
30 | 	
31 | }
32 | 


--------------------------------------------------------------------------------
/InsertionOperatorOverloadingUsingStreamOperator183.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class Complex
 5 | {
 6 |     private:
 7 | 	int real;
 8 | 	int img;
 9 | 	        
10 | 	public:
11 | 	Complex(int r=0,int i=0)
12 | 	{
13 | 	    real=r;
14 | 	    img=i;
15 | 	}
16 | 	void display()
17 | 	{
18 | 	    cout<<real<<"+i"<<img<<endl;
19 | 	}
20 | 	
21 | 	friend ostream & operator<<(ostream &out,Complex &c);
22 | 	
23 | };
24 |     
25 |     ostream & operator<<(ostream &out,Complex &c)
26 |     {
27 | 	    out<<c.real<<"+i"<<c.img<<endl;
28 | 	    return out;
29 |     }
30 |                 
31 | int main()
32 | {
33 | 	Complex c(10,5);
34 | 	    
35 | 	cout<<c<<endl;;
36 | 	    
37 | 	operator<<(cout,c);
38 | 	    
39 | }
40 |     
41 | 


--------------------------------------------------------------------------------
/OperatorOverloadingUsing+Operator179.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class Complex
 5 | {
 6 |     private:
 7 |     int real;
 8 |     int img;
 9 |             
10 |     public:
11 |     Complex(int r=0,int i=0)
12 |     {
13 |         real=r;
14 |         img=i;
15 |     }
16 |                 
17 |     void display()
18 |     {
19 |         cout<<real<<"+i"<<img<<endl;
20 |     }
21 |                 
22 |     Complex operator+(Complex c)
23 |     {
24 |         Complex temp;
25 |         temp.real=real+c.real;
26 |         temp.img=img+c.img;
27 |         return temp;
28 |     }
29 |     
30 | };
31 | 
32 | int main()
33 | {
34 | 	Complex c1(5,3),c2(10,5),c3;
35 | 
36 |     c3=c1+c2;
37 | 
38 |     c3.display();
39 |         
40 | }
41 |     
42 | 


--------------------------------------------------------------------------------
/OperatorOverloadingUsingFriendFunction181.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Complex
 5 | {
 6 |     private:
 7 | 	int real;
 8 | 	int img;
 9 | 	        
10 |     public:
11 | 	Complex(int r=0,int i=0)
12 | 	{
13 | 		real=r;
14 | 	    img=i;
15 | 	}
16 | 	            
17 | 	void display()
18 | 	{
19 | 		cout<<real<<"+i"<<img;
20 | 	}
21 | 	            
22 | 	friend Complex operator+(Complex c1,Complex c2);
23 | 	
24 | };
25 |     
26 |     Complex operator+(Complex c1,Complex c2)
27 |     {
28 | 	    Complex temp;
29 | 	    temp.real=c1.real+c2.real;
30 | 	    temp.img=c1.img+c2.img;
31 | 	    return temp;
32 |     }
33 | 
34 | int main()
35 | {
36 | 	Complex c1(5,3),c2(10,5),c3;
37 | 	c3=c1+c2;
38 | 	    
39 |     c3.display();
40 |     	
41 | }
42 |     
43 | 


--------------------------------------------------------------------------------
/StaticMemberExamples218.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class Student
 5 | {
 6 | 	public:
 7 |     int roll;
 8 |     string name;
 9 |             
10 |     static int addNo;
11 |             
12 |     Student(string n)
13 |     {
14 |         addNo++;
15 |         roll=addNo;
16 |         name=n;
17 |     }
18 |             
19 |     void display()
20 |     {
21 |         cout<<"Name "<<name<<endl<<"Roll "<<roll<<endl;
22 |     }
23 |     
24 | };
25 |     
26 | int Student::addNo=0;
27 | int main()
28 | {
29 |     Student s1("John");
30 |     Student s2("Ravi");
31 |     Student s3("Khan");
32 |     Student s4("Khan");
33 |     Student s5("Khan");
34 |     Student s6("Khan");
35 | 
36 | 	s1.display();
37 |     s6.display();
38 |         
39 |     cout<<"Number Admission "<<Student::addNo<<endl;
40 |         
41 | } 
42 | 


--------------------------------------------------------------------------------
/AccessorsAndMutators166.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Rectangle
 5 | {
 6 |     private:
 7 | 	int length;
 8 | 	int breadth;
 9 | 	
10 |     public:
11 | 	void setLength(int l)
12 | 	{
13 | 		length=l;
14 |     }
15 | 	
16 | 	void setBreadth(int b)
17 | 	{
18 | 	    breadth=b;
19 | 	}
20 | 	
21 |  	int getLength()
22 |     {
23 | 	    return length;
24 | 	}
25 | 	        
26 | 	int getBreadth()
27 | 	{
28 | 		return breadth;
29 | 	}
30 | 	    
31 | 	int area()
32 | 	{
33 | 	 	return length*breadth;
34 | 	}
35 | 	    
36 | 	int perimeter()
37 | 	{
38 | 		return 2*(length+breadth);
39 | 	}
40 | };
41 |     
42 | int main()
43 | {
44 | 	Rectangle r1;
45 | 	r1.setLength(10);
46 | 	r1.setBreadth(5);
47 | 	    
48 |  	cout<<r1.area()<<endl;
49 | 	cout<<r1.perimeter()<<endl;
50 | 	cout<<r1.getLength()<<endl;
51 | 	
52 | }
53 |     
54 | 


--------------------------------------------------------------------------------
/DemoAccessorsAndMutators166.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Rectangle
 5 | {
 6 |     private:
 7 | 	int length;
 8 | 	int breadth;
 9 | 	
10 |     public:
11 | 	void setLength(int l)
12 | 	{
13 | 		length=l;
14 |     }
15 | 	
16 | 	void setBreadth(int b)
17 | 	{
18 | 	    breadth=b;
19 | 	}
20 | 	
21 |  	int getLength()
22 |     {
23 | 	    return length;
24 | 	}
25 | 	        
26 | 	int getBreadth()
27 | 	{
28 | 		return breadth;
29 | 	}
30 | 	    
31 | 	int area()
32 | 	{
33 | 	 	return length*breadth;
34 | 	}
35 | 	    
36 | 	int perimeter()
37 | 	{
38 | 		return 2*(length+breadth);
39 | 	}
40 | 	
41 | };
42 |     
43 | int main()
44 | {
45 | 	Rectangle r1;
46 | 	r1.setLength(10);
47 | 	r1.setBreadth(5);
48 | 	    
49 |  	cout<<r1.area()<<endl;
50 | 	cout<<r1.perimeter()<<endl;
51 | 	cout<<r1.getLength()<<endl;
52 | 	
53 | }
54 |     
55 | 


--------------------------------------------------------------------------------
/DemoWaysOfInheritance196.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class Parent
 5 | {
 6 |     private: int a;
 7 |     protected: int b;    
 8 |     public: int c;
 9 | 
10 |     void funParent()
11 |     {
12 |         a=10;
13 |         b=5;
14 |         c=15;
15 |     }
16 |     
17 | };
18 |     
19 | class Child: private Parent
20 | {
21 |     private:
22 |     protected:
23 |     public:
24 | 
25 |     void funChild()
26 |     {
27 |         //a=10;
28 |         b=5;
29 |         c=15;
30 |     } 
31 | 	     
32 | };
33 |     
34 | class GrandChild : public Child
35 | {
36 |     public:
37 |     void funGrandChild()
38 |     {
39 |         //a=10;
40 |         //b=5;
41 |         //c=20;
42 |     }
43 |     
44 | };
45 |     
46 | int main()
47 | {
48 |     // Child c;
49 |     //c.a=10;
50 |     //c.b=5;
51 |     //c.c=20;
52 |         
53 | }
54 |     
55 | 


--------------------------------------------------------------------------------
/DemoTemplateClassesOfTypeInt232.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | template<class T>
 5 | class Stack
 6 | {
 7 |     private:
 8 | 	T *stk;
 9 |     int top;
10 |     int size;
11 |     public:
12 | 	Stack(int z)
13 |     {
14 |         size=z;
15 | 		top=-1;
16 | 		stk=new int[size];
17 |     }
18 | 	void push(T x);
19 | 	T pop();
20 | };
21 |     
22 | template<class T>
23 | void Stack<T>::push(T x)
24 | {
25 | 	if(top==size-1)
26 | 		cout<<"Stack is Full";
27 | 	else
28 | 	{
29 | 		top++;
30 | 	    stk[top]=x;
31 | 	}
32 | }
33 |     
34 | template<class T>
35 | T Stack<T>::pop()
36 | {
37 | 	T x=0;
38 | 	        
39 | 	if(top==-1)
40 | 		cout<<"Stack is Empty"<<endl;
41 | 	else
42 | 	{
43 | 		x=stk[top];
44 | 		top--;
45 | 	}
46 | 	return x;
47 | }
48 |         
49 | int main()
50 | {
51 | 	Stack<int> s(10);
52 | 	s.push(10);
53 | 	s.push(23);
54 | 	s.push(33);
55 | 	    
56 | }
57 |     
58 | 


--------------------------------------------------------------------------------
/StudentExercise13230.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class StackOverFlow:exception{};
 5 | class StackUnderFlow:exception{};
 6 | 
 7 | class Stack
 8 | {
 9 |     private:
10 |     int *stk;
11 |     int top=-1;
12 |     int size;
13 |     public:
14 |     Stack(int sz)
15 |     {
16 |         size=sz;
17 |         stk=new int[size];
18 |     }
19 |     
20 |     void push(int x)
21 |     {
22 |         if(top==size-1)
23 |             throw StackOverFlow();
24 |             top++;
25 |             stk[top]=x;
26 |     }
27 |             
28 |     int pop()
29 |     {
30 |         if(top==-1)
31 |             throw StackUnderFlow();
32 |             return stk[top--];
33 |     }
34 |     
35 | };
36 |     
37 | int main()
38 | {
39 |     Stack s(5);
40 |  
41 |     s.push(2);
42 |     s.push(3);
43 |     s.push(4);
44 |     s.push(10);
45 |     s.push(9);
46 |     s.push(8);
47 | 
48 | }
49 |     
50 | 


--------------------------------------------------------------------------------
/DemoTemplateClassesOfTypeFloat232.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | template<class T>
 5 | class Stack
 6 | {
 7 | 	private:
 8 |     T *stk;
 9 |     int top;
10 |     int size;
11 |     public:
12 |     Stack(int sz)
13 |     {
14 |         size=sz;
15 |         top=-1;
16 |         stk=new T[size];
17 |     }
18 |     void push(T x);
19 |     T pop();
20 |     
21 | };
22 |     
23 | template<class T>
24 | void Stack<T>::push(T x)
25 | {
26 |     if(top==size-1)
27 |         cout<<"Stack is Full";
28 |     else
29 |     {
30 |         top++;
31 |         stk[top]=x;
32 |     }
33 | }
34 |         
35 | template<class T>
36 | T Stack<T>::pop()
37 | {
38 |     T x=0;
39 |             
40 |     if(top==-1)
41 |         cout<<"Stack is Empty"<<endl;
42 |     else
43 |     {
44 |         x=stk[top];
45 |         top--;
46 |     }
47 |     return x;
48 | }
49 |         
50 | int main()
51 | {
52 |     Stack<float> s(10);
53 |     s.push(10);
54 |     s.push(23);
55 |     s.push(33);
56 |         
57 | }
58 |     
59 | 


--------------------------------------------------------------------------------
/AccessSpecifiers193.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 |     
 4 | class Rectangle
 5 | {
 6 |     private:
 7 | 	int length;
 8 | 	int breadth;
 9 | 	        
10 | 	public:
11 | 	void setLength(int l)
12 | 	{
13 | 	if(l>0)
14 | 		length=l;
15 | 	else
16 | 		length=0;
17 | 	}
18 | 	            
19 | 	void setBreadth( int b)
20 | 	{
21 | 	if(b>0)
22 | 		breadth=b;
23 | 	else
24 | 		breadth=0;
25 | 	}
26 | 	            
27 | 	int getLength()
28 | 	{
29 | 		return length;
30 | 	}
31 | 	            
32 | 	int getBreadth()
33 | 	{
34 | 		return breadth;
35 | 	}
36 | 	            
37 | 	int area()
38 | 	{
39 | 		return length*breadth;
40 | 	}
41 | 	            
42 | 	int perimeter()
43 | 	{
44 | 		return 2*(length+breadth);
45 | 	}
46 | };
47 |     
48 | int main()
49 | {
50 | 	Rectangle r1;
51 | 	r1.setLength(10);
52 | 	r1.setBreadth(5);
53 | 	    
54 | 	cout<<r1.area()<<endl;    
55 | 	cout<<r1.perimeter()<<endl;
56 | 	cout<<"Length"<<r1.getLength()<<endl;    
57 | 	cout<<"Breadth"<<r1.getBreadth()<<endl;
58 | 	    
59 | 	return 0;
60 | 	    
61 | }
62 |     
63 | 


--------------------------------------------------------------------------------
/StudentExercise12212.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class Shape
 5 | {
 6 |     public:
 7 |     virtual float area()=0;
 8 |     virtual float perimeter()=0;
 9 |     
10 | };
11 |     
12 | class Rectangle:public Shape
13 | {
14 |     private:
15 |     float length;
16 |     float breadth;
17 |     public:
18 |     Rectangle(int l=1,int b=1){length=1;breadth=b;}
19 | 
20 |     float area(){ return length*breadth;}
21 |     float perimeter(){return 2*(length+breadth);}
22 | 
23 | };
24 |     
25 | class Circle:public Shape
26 | {
27 |     private:
28 |     float radius;
29 |     public:
30 |     Circle(float r){radius=r;}
31 |     float area(){return 3.1425*radius*radius;}
32 |     float perimeter(){return 2*3.1425*radius;}
33 |     
34 | };
35 |     
36 | int main()
37 | {
38 |     Shape *s=new Rectangle(10,5);
39 |         
40 |     cout<<"Area of Rectangle "<<s->area()<<endl;
41 |     cout<<"Perimeter of Rectangle "<<s->perimeter()<<endl;
42 | 
43 |     s=new Circle(10);
44 |         
45 |     cout<<"Area of Circle "<<s->area()<<endl;
46 |     cout<<"Perimeter of Circle "<<s->perimeter()<<endl;
47 | 
48 | }
49 | 
50 |     
51 | 


--------------------------------------------------------------------------------
/StudentExercise9177.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class Student
 5 | {
 6 |     private:
 7 |     int roll;
 8 |     string name;
 9 |     int mathMarks;
10 |     int phyMarks;
11 |     int chemMarks;
12 |     
13 |     public:
14 |     Student(int r,string n,int m,int p,int c)
15 |     {
16 |         roll=r;
17 |         name=n;
18 |         mathMarks=m;
19 |         phyMarks=p;
20 |         chemMarks=c;
21 |     }
22 |         
23 |     int total()
24 |     {
25 |         return mathMarks+phyMarks+chemMarks;
26 |     }
27 |         
28 |     char grade()
29 |     {
30 |         float average=total()/3;
31 |         
32 |         if(average > 60)
33 |             return 'A';
34 |         else if(average>=40 && average<=60)
35 |             return 'B';
36 |         else
37 |             return 'C';
38 |     }
39 |     
40 | };
41 |     
42 | int main()
43 | {
44 |     int roll;
45 |     string name;
46 |     int m,p,c;
47 |     cout<<"Enter Roll Number of a Student: ";
48 |     cin>>roll;
49 |     cout<<"Enter Name of a Student:";
50 |     cin>>name;
51 |     cout<<"Enter Marks in 3 Subjects";
52 |     cin>>m>>p>>c;
53 |     Student s(roll,name,m,p,c);
54 |         
55 |     cout<<"Total Marks:"<<s.total()<<endl;
56 |     cout<<"Grade of Student:"<<s.grade()<<endl;
57 | 
58 | }
59 |     
60 | 


--------------------------------------------------------------------------------
/StudentExercise11198.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class Employee
 5 | {
 6 |     private:
 7 |     int eid;
 8 |     string name;
 9 |             
10 |     public:
11 |     Employee(int e,string n)
12 |     {
13 |         eid=e;
14 |         name=n;
15 |     }
16 |                 
17 |     int getEmployeeID(){return eid;}
18 |         
19 |     string getName(){return name;}
20 |     
21 | };
22 |     
23 | class FulltimeEmployee:public Employee
24 | {
25 |     private:
26 |     int salary;
27 |             
28 |     public:
29 |     FulltimeEmployee(int e,string n,int sal):Employee(e,n)
30 |     {
31 |         salary=sal;
32 |     }
33 |                 
34 |     int getSalary(){return salary;}
35 |     
36 | };
37 |     
38 | class ParttimeEmployee: public Employee
39 | {
40 |     private:
41 |     int wage;
42 |              
43 |     public:
44 |     ParttimeEmployee(int e,string n,int w):Employee(e,n)
45 |     {
46 |         wage=w;
47 |     }
48 |                 
49 |     int getWage(){return wage;}
50 |     
51 | };
52 |     
53 | int main()
54 | {
55 |     ParttimeEmployee p1(1,"John",300);
56 |     FulltimeEmployee p2(2,"Raj",5000);
57 | 
58 |     cout<<"Salary of "<<p2.getName()<<" is "<<p2.getSalary()<<endl;
59 | 	cout<<"Daily wage of "<<p1.getName()<<" is "<<p1.getWage()<<endl;
60 |  
61 | }
62 |     
63 | 


--------------------------------------------------------------------------------
/StudentExercise10184.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | class Rational
 5 | {
 6 |     private:
 7 |     int p;
 8 |     int q;
 9 |             
10 |     public:
11 |     Rational()
12 |     {
13 |         p=1;
14 |         q=1;
15 |     }
16 |                 
17 |     Rational(int p,int q)
18 |     {
19 |         this->p=p;
20 |         this->q=q;
21 |     }
22 |                 
23 |     Rational(Rational &r)
24 |     {
25 |         this->p=r.p;
26 |         this->q=r.q;
27 |     }
28 |                 
29 |     int getP(){return p;}
30 |             
31 |     int getQ(){return q;}
32 |             
33 |     void setP(int p)
34 |     {
35 |         this->p=p;
36 |     }
37 |                 
38 |     void setQ(int q)
39 |     {
40 |         this->q=q;
41 |     }
42 |                 
43 |     Rational operator+(Rational r)
44 |     {
45 |     Rational t;
46 |     t.p=this->p*r.q+this->q*r.p;
47 |     t.q=this->q*r.q;
48 |     return t;
49 |     }
50 |     friend ostream & operator<<(ostream &os,Rational &r);
51 |     
52 | };
53 |     
54 |     ostream & operator<<(ostream &os,Rational &r)
55 |     {
56 |         os<<r.p<<"/"<<r.q;
57 |         return os;
58 |     }
59 |                 
60 | int main()
61 | {
62 |     Rational r1(3,4),r2(2,5),r3;
63 |     r3=r1+r2;
64 |     cout<<"Sum of "<<r1<<" and "<<r2<<" is "<<r3<<endl;
65 | 
66 | }
67 |     
68 | 


--------------------------------------------------------------------------------
/Serialization248.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | using namespace std;
 4 | 
 5 | class Student
 6 | {
 7 |     private:
 8 |     string name;
 9 |     int roll;
10 |     string branch;
11 |             
12 | 	public:
13 |     Student(){}
14 |             
15 |     Student(string n,int r,string b)
16 |     {
17 |         name=n;
18 |         roll=r;
19 |         branch=b;
20 |     }
21 |                 
22 |     friend ofstream & operator<<(ofstream &ofs,Student s);
23 |     friend ifstream & operator>>(ifstream &ifs,Student &s);
24 |     friend ostream & operator<<(ostream &os,Student &s);
25 |     
26 | };
27 |     
28 | ofstream & operator<<(ofstream &ofs,Student s)
29 | {
30 |     ofs<<s.name<<endl;
31 |     ofs<<s.roll<<endl;
32 |     ofs<<s.branch<<endl;
33 |     return ofs;
34 | }
35 |     
36 | ifstream & operator>>(ifstream &ifs,Student &s)
37 | {
38 |     ifs>>s.name;
39 |     ifs>>s.roll;
40 |     ifs>>s.branch;
41 |     return ifs;
42 | }
43 |     
44 | ostream & operator<<(ostream &os,Student &s)
45 | {
46 |     os<<"Name "<<s.name<<endl;
47 |     os<<"Roll "<<s.roll<<endl;
48 |     os<<"Branch "<<s.branch<<endl;
49 |     return os;
50 | }
51 |     
52 | int main()
53 | {
54 |     ofstream ofs("Test.txt");
55 |     Student s1("John",10,"CS");
56 |     ofs<<s1;
57 |     ofs.close();
58 |     Student s2;
59 |     ifstream ifs("Test.txt");
60 |     ifs>>s1;
61 |         
62 |     cout<<s1;
63 | 
64 | } 
65 | 
66 |     
67 | 


--------------------------------------------------------------------------------
/StudentExercise7105.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int A[10][10], B[10][10], Mult[10][10], r1, c1, r2, c2, i, j, k;
 7 | 
 8 |     cout << "Enter Rows and Columns for First Matrix: ";
 9 |     cin >> r1 >> c1;
10 |     cout << "Enter Rows and Columns for Second Matrix: ";
11 |     cin >> r2 >> c2;
12 | 
13 |     if (c1!=r2)
14 |     {
15 |         cout<<"Cant be Multiplied";
16 |         return 0;
17 |     }
18 | 
19 |     // Storing Elements of First Matrix.
20 |     cout << endl << "Enter Elements of Matrix 1:" << endl;
21 |     
22 |     for(i = 0; i < r1; ++i)
23 |         for(j = 0; j < c1; ++j)
24 |         {
25 |             cout << "Enter Element A" << i + 1 << j + 1 << " : ";
26 |             cin >> A[i][j];
27 |         }
28 | 
29 |     // Storing Elements of Second Matrix.
30 |     cout << endl << "Enter Elements of Matrix 2:" << endl;
31 |         
32 |     for(i = 0; i < r2; ++i)
33 |         for(j = 0; j < c2; ++j)
34 |         {
35 |             cout << "Enter Element B" << i + 1 << j + 1 << " : ";
36 |             cin >> B[i][j];
37 |         }
38 |         
39 | 	// Multiplying Matrix A and B and Storing in Array Mult.
40 |     for(i = 0; i < r1; ++i)
41 |         for(j = 0; j < c2; ++j)
42 |         {
43 |             Mult[i][j]=0;
44 |             
45 |             for(k = 0; k < c1; ++k)
46 |             {
47 |                 Mult[i][j] += A[i][k] * B[k][j];
48 |             }
49 |         }
50 | 
51 |     // Displaying the Multiplication of Two Matrix.
52 |     cout << endl << "Output Matrix: " << endl;
53 |         
54 |     for(i = 0; i < r1; ++i)
55 |         for(j = 0; j < c2; ++j)
56 |         {
57 |             cout << " " << Mult[i][j];
58 |             
59 |         	if(j == c2-1)
60 |         	cout << endl;
61 |         }
62 | 
63 |     return 0;
64 | }
65 | 
66 |     
67 | 


--------------------------------------------------------------------------------
/StudentExercise14251.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | using namespace std;
 4 | 
 5 | class Item
 6 | {
 7 |     private:
 8 |     string name;
 9 |     float price;
10 |     int qty;
11 |             
12 |     public:
13 |     Item(){}
14 |     Item(string n,float p,int q);
15 |     
16 |     friend ifstream & operator>>(ifstream &fis,Item &i);
17 |     friend ofstream & operator<<(ofstream &fos,Item &i);
18 |     friend ostream & operator<<(ostream &os,Item &i);
19 | 
20 | };
21 |     
22 | int main()
23 | {
24 |     int n;
25 |     string name;
26 |     float price;
27 |     int qty;
28 |         
29 |     cout<<"Enter number of Item:";
30 |     cin>>n;
31 |     Item *list[n];
32 |     cout<<"Enter All Item "<<endl;
33 |         
34 |     for(int i=0;i<n;i++)
35 |     {
36 |         cout<<"Enter "<<i+1<<" Item Name , price and quantity";
37 |         cin>>name;
38 |         cin>>price;
39 |         cin>>qty;
40 |         list[i]=new Item(name,price,qty);
41 | 
42 |     }
43 | 
44 |     ofstream fos("Items.txt");
45 |         
46 |     for(int i=0;i<n;i++)
47 |     {
48 |         fos<<*list[i];
49 |     }
50 |     Item item;
51 |     ifstream fis("Items.txt");
52 |         
53 |     for(int i=0;i<3;i++)
54 |     {
55 |         fis>>item;
56 |         cout<<"Item "<<i<<item<<endl;
57 |     }
58 |     
59 | }
60 |     
61 | Item::Item(string n,float p,int q)
62 | {
63 |     name=n;
64 |     price=p;
65 |     qty=q;
66 | }
67 |     
68 | ofstream & operator<<(ofstream &fos,Item &i)
69 | {
70 |     fos<<i.name<<endl<<i.price<<endl<<i.qty<<endl;
71 |     return fos;
72 | }
73 |     
74 | ifstream & operator>>(ifstream &fis,Item &i)
75 | {
76 |     fis>>i.name>>i.price>>i.qty;
77 |     return fis;
78 | }
79 |     
80 | ostream & operator<<(ostream &os,Item &i)
81 | {
82 |     os<<i.name<<endl<<i.price<<endl<<i.qty<<endl;
83 |     return os;
84 |         
85 | }
86 | 


--------------------------------------------------------------------------------
/StudentExercise15258.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | #include<vector>
 4 | using namespace std;
 5 | 
 6 | class Item
 7 | {
 8 |     private:
 9 |     string name;
10 |     float price;
11 |     int qty;
12 |             
13 |     public:
14 |     Item(){}
15 |     Item(string n,float p,int q);
16 |     
17 |     friend ifstream & operator>>(ifstream &fis,Item &i);
18 |     friend ofstream & operator<<(ofstream &fos,Item &i);
19 |     friend ostream & operator<<(ostream &os,Item &i);
20 | 
21 | };
22 |     
23 | int main()
24 | {
25 |     int n;
26 |     string name;
27 |     float price;
28 |     int qty;
29 |     cout<<"Enter number of Item:";
30 |     cin>>n;
31 | 
32 |     vector<Item *> list;
33 |     cout<<"Enter All Item "<<endl;
34 |         
35 |     for(int i=0;i<n;i++)
36 |     {
37 |         cout<<"Enter "<<i+1<<" Item Name , price and quantity";
38 |         cin>>name;
39 |         cin>>price;
40 |         cin>>qty;
41 |         list.push_back(new Item(name,price,qty));
42 | 
43 |     }
44 | 
45 |     ofstream fos("Items.txt");
46 |     vector<Item *>::iterator itr;
47 | 
48 |     for(itr=list.begin();itr!=list.end();itr++)
49 |     {
50 |         fos<<**itr;
51 |     }
52 |         
53 |     Item item;
54 |     ifstream fis("Items.txt");
55 |     
56 |     for(int i=0;i<3;i++)
57 |     {
58 |         fis>>item;
59 |         cout<<"Item "<<i<<endl<<item<<endl;
60 |     }
61 | 
62 | }
63 | 
64 | Item::Item(string n,float p,int q)
65 | {
66 |     name=n;
67 |     price=p;
68 |     qty=q;
69 | }
70 | 
71 | ofstream & operator<<(ofstream &fos,Item &i)
72 | {
73 |     fos<<i.name<<endl<<i.price<<endl<<i.qty<<endl;
74 |     return fos;
75 | }
76 | 
77 | ifstream & operator>>(ifstream &fis,Item &i)
78 | {
79 |     fis>>i.name>>i.price>>i.qty;
80 |     return fis;
81 | }
82 | 
83 | ostream & operator<<(ostream &os,Item &i)
84 | {
85 |     os<<i.name<<endl<<i.price<<endl<<i.qty<<endl;
86 |     return os;
87 | }
88 | 
89 |     
90 | 


--------------------------------------------------------------------------------
/InheritanceExample188.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | using namespace std;
  3 | 
  4 | class Rectangle
  5 | {
  6 |     private:
  7 |     int length;
  8 |     int breadth;
  9 |             
 10 |     public:
 11 |     Rectangle();
 12 |     Rectangle(int l,int b);
 13 |     Rectangle(Rectangle &r);
 14 |     int getLength(){return length;}
 15 |     int getBreadth(){return breadth;}
 16 |             
 17 |     void setLength(int l);        
 18 |     void setBreadth(int b);
 19 |     int area();        
 20 |     int perimeter();        
 21 |     bool isSquare();        
 22 |     ~Rectangle();
 23 |     
 24 | };
 25 |     
 26 | class Cuboid:public Rectangle
 27 | {
 28 |     private:
 29 |     int height;
 30 |             
 31 | 	public:
 32 |     Cuboid(int h)
 33 |     {
 34 |         height=h;
 35 |     }
 36 |                 
 37 |     int getHeight(){return height;}
 38 |             
 39 |     void setHeight(int h){height=h;}
 40 |             
 41 |     int volume(){return getLength()*getBreadth()*height;}
 42 |     
 43 | };
 44 |     
 45 | int main()
 46 | {
 47 |     Cuboid c(5);
 48 |     c.setLength(10);
 49 |     c.setBreadth(7);
 50 |         
 51 |     cout<<"Volume is "<<c.volume()<<endl;
 52 |         
 53 | }
 54 |     
 55 | Rectangle::Rectangle()
 56 | {
 57 |     length=1;
 58 |     breadth=1;
 59 | }
 60 |     
 61 | Rectangle::Rectangle(int l,int b)
 62 | {
 63 |     length=l;
 64 |     breadth=b;
 65 | }
 66 |     
 67 | Rectangle::Rectangle(Rectangle &r)
 68 | {
 69 |     length=r.length;
 70 |     breadth=r.breadth;
 71 | }
 72 |     
 73 | void Rectangle::setLength(int l)
 74 | {
 75 |     length=l;
 76 | }
 77 |     
 78 | void Rectangle::setBreadth(int b)
 79 | {
 80 |     breadth=b;
 81 | }
 82 |     
 83 | int Rectangle::area()
 84 | {
 85 |     return length*breadth;
 86 | }
 87 |     
 88 | int Rectangle::perimeter()
 89 | {
 90 |     return 2*(length+breadth);
 91 | }
 92 |     
 93 | bool Rectangle::isSquare()
 94 | {
 95 |     return length==breadth;
 96 | }
 97 |     
 98 | Rectangle::~Rectangle()
 99 | {
100 |     // cout<<"Rectangle Destroyed";
101 | } 
102 | 
103 | 


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