C++ Programming Code Examples

/* Binary search tree with all the three recursive and non recursive traversals */ #include<iostream.h> #include<conio.h> #include<stdlib.h> class binarynode { public: int data; binarynode *left; binarynode *right; }; class binsrctree { private: binarynode *root; void inorder_rec(binarynode *); void inorder_non_rec(binarynode *); void preorder_rec(binarynode *); void preorder_non_rec(binarynode *); void postorder_rec(binarynode *); void postorder_non_rec(binarynode *); public: binsrctree() { root=NULL; } void insert(int ); void print_inorder_rec(); void print_inorder_non_rec(); void print_preorder_rec(); void print_preorder_non_rec(); void print_postorder_rec(); void print_postorder_non_rec(); }; class stack { int top; binarynode *stackel[20]; public: stack() { top=-1; } void push(binarynode *); binarynode* pop(); int empty() { if(top==-1) return(1); return(0); } }; void stack::push(binarynode *node) { stackel[++top]=node; } binarynode *stack::pop() { return(stackel[top--]); } class stack_int { int top; int stack_int[20]; public: stack_int() { top=-1; } void push(int flag); int pop(); int empty_int() { if(top==-1) return(1); return(0); } }; void stack_int::push(int flag) { stack_int[++top]=flag; } int stack_int::pop() { return(stack_int[top--]); } /*---------------------------------------------------------------------*/ /* FUNCTION TO INSERT A NODE IN THE TREE */ /*---------------------------------------------------------------------*/ void binsrctree::insert(int val) { binarynode *temp,*prev,*curr; temp=new binarynode; temp->data=val; temp->left=temp->right=NULL; if(root==NULL) { root=temp; } else { curr=root; while(curr!=NULL) { prev=curr; if(temp->data<curr->data) curr=curr->left; else curr=curr->right; } if(temp->data<prev->data) prev->left=temp; else prev->right=temp; } } /* ------------------------------------------------*/ /*INORDER RECURSIVE TRAVERSAL*/ /*-------------------------------------------------*/ void binsrctree::inorder_rec(binarynode *root) { if(root!=NULL) { inorder_rec(root->left); cout<<root->data<<" "; inorder_rec(root->right); } } /*--------------------------------------------------*/ /*INORDER NON RECURSIVE TRAVERSAL*/ /*--------------------------------------------------*/ void binsrctree::inorder_non_rec(binarynode *root) { stack stk; binarynode *temp; if(root!=NULL) { temp=root; do { while(temp!=NULL) { stk.push(temp); temp=temp->left; }/*end while*/ if(!stk.empty()) { temp=stk.pop(); cout<<temp->data<<" "; temp=temp->right; }/*end if*/ else break; }while(1); /*end do while*/ }/* end if */ else cout<<" Empty tree"; } /*end function */ /*--------------------------------------------------*/ /*PREORDER RECURSIVE TRAVERSAL */ /*---------------------------------------------------*/ void binsrctree::preorder_rec(binarynode *root) { if(root!=NULL) { cout<<root->data<<" "; preorder_rec(root->left); preorder_rec(root->right); } } /*--------------------------------------------------*/ /*PREORDER NON RECURSIVE TRAVERSAL */ /*---------------------------------------------------*/ void binsrctree::preorder_non_rec(binarynode *root) { stack stk; binarynode *temp=root; stk.push(temp); while(!stk.empty()) { temp=stk.pop(); if(temp!=NULL) { cout<<temp->data<<" "; stk.push(temp->right); stk.push(temp->left); } } } /*--------------------------------------------------*/ /*POSTRDER RECURSIVE TRAVERSAL */ /*---------------------------------------------------*/ void binsrctree::postorder_rec(binarynode *root) { if(root!=NULL) { postorder_rec(root->left); postorder_rec(root->right); cout<<root->data<<" "; } } /*--------------------------------------------------*/ /*POSTORDER NON RECURSIVE TRAVERSAL */ /*---------------------------------------------------*/ void binsrctree::postorder_non_rec(binarynode *root) { stack stk; stack_int stk1; int flag; binarynode *temp=root; do { if(temp!=NULL) { stk.push(temp); stk1.push(1); temp=temp->left; } else { if(stk.empty()) break; temp=stk.pop(); flag=stk1.pop(); if(flag==2) { cout<<temp->data; temp=NULL; } /*end if */ else { stk.push(temp); stk1.push(2); temp=temp->right; } /* end else */ } /* end if */ }while(1);/*end do while*/ }/*end function*/ /*--------------------------------------------------*/ /*FUNCTION TO PRINT INORDER RECURSIVE TRAVERSAL */ /*---------------------------------------------------*/ void binsrctree::print_inorder_rec() { cout<<" "; inorder_rec(root); cout<<" "; } /*--------------------------------------------------*/ /*FUNCTION TO PRINT INORDER NON RECURSIVE TRAVERSAL */ /*---------------------------------------------------*/ void binsrctree::print_inorder_non_rec() { cout<<" "; inorder_non_rec(root); cout<<" "; } /*--------------------------------------------------*/ /*FUNCTION TO PRINT PREORDER RECURSIVE TRAVERSAL */ /*---------------------------------------------------*/ void binsrctree::print_preorder_rec() { cout<<" "; preorder_rec(root); cout<<" "; } /*--------------------------------------------------*/ /*FUNCTION TO PRINT PREORDER NON RECURSIVE TRAVERSAL */ /*---------------------------------------------------*/ void binsrctree::print_preorder_non_rec() { cout<<" "; preorder_non_rec(root); cout<<" "; } /*--------------------------------------------------*/ /*FUNCTION TO PRINT POSTORDER RECURSIVE TRAVERSAL */ /*---------------------------------------------------*/ void binsrctree::print_postorder_rec() { cout<<" "; postorder_rec(root); cout<<" "; } /*--------------------------------------------------*/ /*FUNCTION TO PRINT POSTORDER NON RECURSIVE TRAVERSAL */ /*---------------------------------------------------*/ void binsrctree::print_postorder_non_rec() { cout<<" "; postorder_non_rec(root); cout<<" "; } /*--------------------------------------------------*/ /* MAIN FUNCTION */ /*---------------------------------------------------*/ void main() { binsrctree BST; int ch,element; clrscr(); do { cout<<" 1.Insert a node in binary tree"; cout<<" 2.Recursive Inorder traversal"; cout<<" 3.Non Recursive Inorder traversal"; cout<<" 4.Recursive preorder traversal"; cout<<" 5.Non recursive preorder traversal"; cout<<" 6.Recursive postorder traversal"; cout<<" 7.Non recursive postorder traversal"; cout<<" 8.Exit"; cout<<" Enter your choice"; cin>>ch; switch(ch) { case 1: cout<<" Enter the element you wnat to insert"; cin>>element; BST.insert(element); break; case 2: cout<<" Recursive Inorder traversal "; BST.print_inorder_rec(); break; case 3: cout<<" NonRecursive Inorder traversal "; BST.print_inorder_non_rec(); break; case 4: cout<<" Recursive preorder traversal "; BST.print_preorder_rec(); break; case 5: cout<<" Non recursive preorder traversal "; BST.print_preorder_non_rec(); break; case 6: cout<<" Recursive postorder traversal"; BST.print_postorder_rec(); break; case 7: cout<<" Non recursive postorder traversal "; BST.print_postorder_non_rec(); break; case 8: exit(1); } }while(ch<8); }

/* standard output stream (cout) in C++ language */ #include <iostream> using namespace std; int main() { string str = "Do not interrupt me"; char ch = 'm'; // use cout with write() cout.write(str,6); cout << endl; // use cout with put() cout.put(ch); return 0; }

/* demonstrate the use of the push() function of the stack by insertion of simple integer values */ #include <iostream> #include <stack> int main() { std::stack<int> newstack; newstack.push(11); newstack.push(22); newstack.push(33); newstack.push(44); std::cout << "Popping out elements?"; newstack.pop(); newstack.pop(); while (!newstack.empty () ) { std::cout << " " << newstack.top(); newstack.pop(); } std:: cout<<'\n'; return 0; }

/* terminate the process normally, performing the regular cleanup for terminating programs by exit() function code example */ #include<iostream> using namespace std; int main() { int i; cout<<"Enter a non-zero value: "; //user input cin>>i; if(i) // checks whether the user input is non-zero or not { cout<<"Valid input.\n"; } else { cout<<"ERROR!"; //the program exists if the value is 0 exit(0); } cout<<"The input was : "<<i; }

/* using public and private in C++ Class */ // Program to illustrate the working of // public and private in C++ Class #include <iostream> using namespace std; class Room { private: double length; double breadth; double height; public: // function to initialize private variables void initData(double len, double brth, double hgt) { length = len; breadth = brth; height = hgt; } double calculateArea() { return length * breadth; } double calculateVolume() { return length * breadth * height; } }; int main() { // create object of Room class Room room1; // pass the values of private variables as arguments room1.initData(42.5, 30.8, 19.2); cout << "Area of Room = " << room1.calculateArea() << endl; cout << "Volume of Room = " << room1.calculateVolume() << endl; return 0; }

/* A constructor is a special type of member function that is called automatically when an object is created. In C++, a constructor has the same name as that of the class and it does not have a return type. */ #include <iostream> using namespace std; // declare a class class Wall { private: double length; double height; public: // initialize variables with parameterized constructor Wall(double len, double hgt) { length = len; height = hgt; } // copy constructor with a Wall object as parameter // copies data of the obj parameter Wall(Wall &obj) { length = obj.length; height = obj.height; } double calculateArea() { return length * height; } }; int main() { // create an object of Wall class Wall wall1(10.5, 8.6); // copy contents of wall1 to wall2 Wall wall2 = wall1; // print areas of wall1 and wall2 cout << "Area of Wall 1: " << wall1.calculateArea() << endl; cout << "Area of Wall 2: " << wall2.calculateArea(); return 0; }

/* simple code example by main() function in C++ */ #include <iostream> using namespace std; int main() { int day = 4; switch (day) { case 1: cout << "Monday"; break; case 2: cout << "Tuesday"; break; case 3: cout << "Wednesday"; break; case 4: cout << "Thursday"; break; case 5: cout << "Friday"; break; case 6: cout << "Saturday"; break; case 7: cout << "Sunday"; break; } return 0; }

/* If Else Statement in C++ Language */ #include <iostream> using namespace std; int main () { // local variable declaration: int a = 100; // check the boolean condition if( a < 20 ) { // if condition is true then print the following cout << "a is less than 20;" << endl; } else { // if condition is false then print the following cout << "a is not less than 20;" << endl; } cout << "value of a is : " << a << endl; return 0; }

/* Stack in C++ language */ #include <iostream> #include <stack> using namespace std; void newstack(stack <int> ss) { stack <int> sg = ss; while (!sg.empty()) { cout << '\t' << sg.top(); sg.pop(); } cout << '\n'; } int main () { stack <int> newst; newst.push(55); newst.push(44); newst.push(33); newst.push(22); newst.push(11); cout << "The stack newst is : "; newstack(newst); cout << "\n newst.size() : " << newst.size(); cout << "\n newst.top() : " << newst.top(); cout << "\n newst.pop() : "; newst.pop(); newstack(newst); return 0; }

/* clrscr() function is also a non-standard function defined in "conio.h" header. This function is used to clear the console screen. It is often used at the beginning of the program (mostly after variable declaration but not necessarily) so that the console is clear for our output.*/ #include<iostream.h> #include<conio.h> void main() { int a=10, b=20; int sum=0; clrscr(); // use clrscr() after variable declaration sum=a+b; cout<<"Sum: "<<sum; //clear the console screen clrscr(); getch(); }

/* write a C program which demonstrate use of if-else-if ladder statement */ /* Program to Print Day Names using Else If Ladder in C++*/ #include <iostream> using namespace std; int main() { int day; cout << "Enter Day Number: "; cin >> day; cout << "Day is "; if (day == 1) cout << "Sunday" << endl; else if (day == 2) cout << "Monday" << endl; else if (day == 3) cout << "Tuesday" << endl; else if (day == 4) cout << "Wednesday" << endl; else if (day == 5) cout << "Thursday" << endl; else if (day == 6) cout << "Friday" << endl; else cout << "Saturday" << endl; return 0; }

/* the switch statement helps in testing the equality of a variable against a set of values */ #include <iostream> using namespace std; int main () { // local variable declaration: char grade = 'D'; switch(grade) { case 'A' : cout << "Excellent!" << endl; break; case 'B' : case 'C' : cout << "Well done" << endl; break; case 'D' : cout << "You passed" << endl; break; case 'F' : cout << "Better try again" << endl; break; default : cout << "Invalid grade" << endl; } cout << "Your grade is " << grade << endl; return 0; }

/* C++ Stack empty() function is used for testing whether the container is empty or not. In many cases, before extracting the actual elements from the stack, programmers give preference to check whether the stack does have some elements or not. Doing so is advantageous regarding memory and cost. */ /* Test the stack is empty or not by stack empty() function code example. */ #include <bits/stdc++.h> using namespace std; int main(){ cout<<"...use of empty function...\n"; int count=0; stack<int> st; //declare the stack st.push(4); //pushed 4 st.push(5); //pushed 5 st.push(6); cout<<"stack elements are:\n"; while(!st.empty()){//stack not empty cout<<"top element is:"<<st.top()<<endl;//print top element st.pop(); count++; } if(st.empty()) //to check for empty stack cout<<"stack empty\n"; cout<<count<<" pop operation performed total to make stack empty\n"; return 0; }

/* break statement with while loop code example */ // program to find the sum of positive numbers // if the user enters a negative numbers, break ends the loop // the negative number entered is not added to sum #include <iostream> using namespace std; int main() { int number; int sum = 0; while (true) { // take input from the user cout << "Enter a number: "; cin >> number; // break condition if (number < 0) { break; } // add all positive numbers sum += number; } // display the sum cout << "The sum is " << sum << endl; return 0; }

/* While Loop Statement in C++ language */ // program to find the sum of positive numbers // if the user enters a negative number, the loop ends // the negative number entered is not added to the sum #include <iostream> using namespace std; int main() { int number; int sum = 0; // take input from the user cout << "Enter a number: "; cin >> number; while (number >= 0) { // add all positive numbers sum += number; // take input again if the number is positive cout << "Enter a number: "; cin >> number; } // display the sum cout << "\nThe sum is " << sum << endl; return 0; }

/* C++ allows us to allocate the memory of a variable or an array in run time. This is known as dynamic memory allocation. The new operator denotes a request for memory allocation on the Free Store. If sufficient memory is available, new operator initializes the memory and returns the address of the newly allocated and initialized memory to the pointer variable. */ /* Allocate storage space by operator new */ // C++ program code example to illustrate dynamic allocation and deallocation of memory using new and delete #include <iostream> using namespace std; int main () { // Pointer initialization to null int* p = NULL; // Request memory for the variable // using new operator p = new(nothrow) int; if (!p) cout << "allocation of memory failed\n"; else { // Store value at allocated address *p = 29; cout << "Value of p: " << *p << endl; } // Request block of memory // using new operator float *r = new float(75.25); cout << "Value of r: " << *r << endl; // Request block of memory of size n int n = 5; int *q = new(nothrow) int[n]; if (!q) cout << "allocation of memory failed\n"; else { for (int i = 0; i < n; i++) q[i] = i+1; cout << "Value store in block of memory: "; for (int i = 0; i < n; i++) cout << q[i] << " "; } // freed the allocated memory delete p; delete r; // freed the block of allocated memory delete[] q; return 0; }

/* Standard Input Stream (cin) in C++ language */ // cin with Member Functions #include <iostream> using namespace std; int main() { char name[20], address[20]; cout << "Name: "; // use cin with getline() cin.getline(name, 20); cout << "Address: "; cin.getline(address, 20); cout << endl << "You entered " << endl; cout << "Name = " << name << endl; cout << "Address = " << address; return 0; }

/* pop() function is used to remove or 'pop' an element from the top of the stack(newest or the topmost element in the stack). This is an inbuilt function from C++ Standard Template Library(STL). This function belongs to the <stack> header file. The element is removed from the stack container and the size of the stack is decreased by 1. */ /* removing the topmost element of the stack by Stack pop() function code example. */ #include <iostream> #include <stack> using namespace std; int main (){ stack<int> MyStack; MyStack.push(10); MyStack.push(20); MyStack.push(30); MyStack.push(40); MyStack.push(50); cout<<"The top element of the stack is: "<<MyStack.top(); //deletes top element of the stack MyStack.pop(); cout<<"\nNow, the top element of the stack is: "<<MyStack.top(); //deletes next top element of the stack MyStack.pop(); cout<<"\nNow, the top element of the stack is: "<<MyStack.top(); return 0; }

/* using #include directive in C language */ #include <stdio.h> int main() { /* * C standard library printf function * defined in the stdio.h header file */ printf("I love you Clementine"); printf("I love you so much"); printf("HappyCodings"); return 0; }