C++ Programming Code Examples

/* Program to Construct an Expression Tree for an Infix Expression This is a C++ Program to construct an Expression tree for an Infix Expression. A binary expression tree is a specific application of a binary tree to evaluate certain expressions. Two common types of expressions that a binary expression tree can represent are algebraic[1] and boolean. These trees can represent expressions that contain both unary and binary operators.In general, expression trees are a special kind of binary tree. A binary tree is a tree in which all nodes contain zero, one or two children. This restricted structure simplifies the programmatic processing of Expression trees */ #include <cstdlib> #include <iostream> #include <sstream> #include <string> #include <stack> #include <exception> using namespace std; class ExpressionElementNode { public: virtual double value() = 0; // Return the value of this node. }; class NumericElementNode: public ExpressionElementNode { private: double number; NumericElementNode(const NumericElementNode& n); NumericElementNode(); NumericElementNode&operator=(const NumericElementNode& n); public: NumericElementNode(double val); virtual double value(); }; inline NumericElementNode::NumericElementNode(double val) : number(val) { } inline double NumericElementNode::value() { return number; } class BinaryOperationNode: public ExpressionElementNode { private: char binary_op; ExpressionElementNode *left; ExpressionElementNode *right; BinaryOperationNode(const BinaryOperationNode& n); BinaryOperationNode(); BinaryOperationNode &operator=(const BinaryOperationNode& n); public: BinaryOperationNode(char op, ExpressionElementNode *l, ExpressionElementNode *r); virtual double value(); }; inline BinaryOperationNode::BinaryOperationNode(char op, ExpressionElementNode *l, ExpressionElementNode *r) : binary_op(op), left(l), right(r) { } double BinaryOperationNode::value() { // To get the value, compute the value of the left and // right operands, and combine them with the operator. double leftVal = left->value(); double rightVal = right->value(); double result; switch (binary_op) { case '+': result = leftVal + rightVal; break; case '-': result = leftVal - rightVal; break; case '*': result = leftVal * rightVal; break; case '/': result = leftVal / rightVal; break; } return result; } class ExpressionElementNode; class BinaryOperationNode; class BinaryExpressionBuilder { private: // holds either (, +, -, /, or * std::stack<char> operatorStack; // operandStack is made up of BinaryOperationNodes and NumericElementNode std::stack<ExpressionElementNode *> operandStack; void processOperator(char op); void processRightParenthesis(); void doBinary(char op); int precedence(char op); public: class NotWellFormed: public std::exception { public: virtual const char* what() const throw () { return "The expression is not valid"; } }; BinaryOperationNode *parse(std::string& istr) throw (NotWellFormed); }; int BinaryExpressionBuilder::precedence(char op) { enum { lowest, mid, highest }; switch (op) { case '+': case '-': return mid; case '/': case '*': return highest; default: return lowest; } } // Input: +, -, /, or * // creates BinaryOperationNode's from all preceding BinaryOperationNode *BinaryExpressionBuilder::parse(std::string& str) throw (NotWellFormed) { istringstream istr(str); char token; while (istr >> token) { switch (token) { case '+': case '-': case '*': case '/': processOperator(token); break; case ')': processRightParenthesis(); break; case '(': operatorStack.push(token); break; default: // If it is not an operator, it must be a number. // Since token is only a char in width, we put it back, // and get the complete number as a double. istr.putback(token); double number; istr >> number; NumericElementNode *newNode = new NumericElementNode(number); operandStack.push(newNode); continue; } // end switch } // end while while (!operatorStack.empty()) { doBinary(operatorStack.top()); operatorStack.pop(); } // Invariant: At this point the operandStack should have only one element // operandStack.size() == 1 // otherwise, the expression is not well formed. if (operandStack.size() != 1) { throw NotWellFormed(); } ExpressionElementNode *p = operandStack.top(); return static_cast<BinaryOperationNode *> (p); } void BinaryExpressionBuilder::processOperator(char op) { // pop operators with higher precedence and create their BinaryOperationNode int opPrecedence = precedence(op); while ((!operatorStack.empty()) && (opPrecedence <= precedence( operatorStack.top()))) { doBinary(operatorStack.top()); operatorStack.pop(); } // lastly push the operator passed onto the operatorStack operatorStack.push(op); } void BinaryExpressionBuilder::processRightParenthesis() { while (!operatorStack.empty() && operatorStack.top() != '(') { doBinary(operatorStack.top()); operatorStack.pop(); } operatorStack.pop(); // remove '(' } // Creates a BinaryOperationNode from the top two operands on operandStack // These top two operands are removed (poped), and the new BinaryOperation // takes their place on the top of the stack. void BinaryExpressionBuilder::doBinary(char op) { ExpressionElementNode *right = operandStack.top(); operandStack.pop(); ExpressionElementNode *left = operandStack.top(); operandStack.pop(); BinaryOperationNode *p = new BinaryOperationNode(operatorStack.top(), left, right); operandStack.push(p); } int main(int argc, char** argv) { NumericElementNode num1(10); NumericElementNode num2(20); BinaryOperationNode n('+', &num1, &num2); BinaryExpressionBuilder b; cout << "Enter expression" << endl; string expression; getline(cin, expression); BinaryOperationNode *root = b.parse(expression); cout << " result = " << root->value(); return 0; }

/* continue statement skips the execution of further statements in the block and continues with the next iteration. */ // program to calculate positive numbers till 50 only // if the user enters a negative number, // that number is skipped from the calculation // negative number -> loop terminate // numbers above 50 -> skip iteration #include <iostream> using namespace std; int main() { int sum = 0; int number = 0; while (number >= 0) { // add all positive numbers sum += number; // take input from the user cout << "Enter a number: "; cin >> number; // continue condition if (number > 50) { cout << "The number is greater than 50 and won't be calculated." << endl; number = 0; // the value of number is made 0 again continue; } } // display the sum cout << "The sum is " << sum << endl; return 0; }

/* A Cast operator is an unary operator which forces one data type to be converted into another data type. */ /* static_cast converts between types using a combination of implicit and user-defined conversions. */ #include <iostream> #include <string> using namespace std; class Int { int x; public: Int(int x_in = 0) : x{ x_in } { cout << "Conversion Ctor called" << endl; } operator string() { cout << "Conversion Operator" << endl; return to_string(x); } }; int main() { Int obj(3); string str = obj; obj = 20; string str2 = static_cast<string>(obj); obj = static_cast<Int>(30); 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; }

/* get string identifying exception by exception::what function code example */ #include <iostream> #include <exception> using namespace std; struct MyException : public exception { const char * what () const throw () { return "C++ Exception"; } }; int main() { try { throw MyException(); } catch(MyException& e) { std::cout << "MyException caught" << std::endl; std::cout << e.what() << std::endl; } catch(std::exception& e) { //Other errors } }

/* Structure is a collection of variables of different data types under a single name. It is similar to a class in that, both holds a collecion of data of different data types. */ #include <iostream> using namespace std; struct Person { char name[50]; int age; float salary; }; int main() { Person p1; cout << "Enter Full name: "; cin.get(p1.name, 50); cout << "Enter age: "; cin >> p1.age; cout << "Enter salary: "; cin >> p1.salary; cout << "\nDisplaying Information." << endl; cout << "Name: " << p1.name << endl; cout <<"Age: " << p1.age << endl; cout << "Salary: " << p1.salary; return 0; }

/* 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; }

/* get and set string object whose content is present in the stream by str() function code example. */ #include <sstream> #include <iostream> int main() { int n; std::istringstream in; // could also use in("1 2") in.str("1 2"); in >> n; std::cout << "after reading the first int from \"1 2\", the int is " << n << ", str() = \"" << in.str() << "\"\n"; std::ostringstream out("1 2"); out << 3; std::cout << "after writing the int '3' to output stream \"1 2\"" << ", str() = \"" << out.str() << "\"\n"; std::ostringstream ate("1 2", std::ios_base::ate); ate << 3; std::cout << "after writing the int '3' to append stream \"1 2\"" << ", str() = \"" << ate.str() << "\"\n"; }

/* namespaces in C++ language */ // A C++ code to demonstrate that we can define // methods outside namespace. #include <iostream> using namespace std; // Creating a namespace namespace ns { void display(); class happy { public: void display(); }; } // Defining methods of namespace void ns::happy::display() { cout << "ns::happy::display()\n"; } void ns::display() { cout << "ns::display()\n"; } // Driver code int main() { ns::happy obj; ns::display(); obj.display(); return 0; }

/* If make a function as inline, then the compiler replaces the function calling location with the definition of the inline function at compile time. Any changes made to an inline function will require the inline function to be recompiled again because the compiler would need to replace all the code with a new code; otherwise, it will execute the old functionality. */ #include <iostream> using namespace std; class operation { int a,b,add,sub,mul; float div; public: void get(); void sum(); void difference(); void product(); void division(); }; inline void operation :: get() { cout << "Enter first value:"; cin >> a; cout << "Enter second value:"; cin >> b; } inline void operation :: sum() { add = a+b; cout << "Addition of two numbers: " << a+b << "\n"; } inline void operation :: difference() { sub = a-b; cout << "Difference of two numbers: " << a-b << "\n"; } inline void operation :: product() { mul = a*b; cout << "Product of two numbers: " << a*b << "\n"; } inline void operation ::division() { div=a/b; cout<<"Division of two numbers: "<<a/b<<"\n" ; } int main() { cout << "Program using inline function\n"; operation s; s.get(); s.sum(); s.difference(); s.product(); s.division(); return 0; }

/* Type casting of the variables in the C++ programming language. Type casting refers to the conversion of one data type to another in a program. Typecasting can be done in two ways: automatically by the compiler and manually by the programmer or user. Type Casting is also known as Type Conversion. */ /* code example to demonstrate the casting of one variable to another using the implicit type casting in C++. */ #include <iostream> using namespace std; int main () { short x = 200; int y; y = x; cout << " Implicit Type Casting " << endl; cout << " The value of x: " << x << endl; cout << " The value of y: " << y << endl; int num = 20; char ch = 'a'; int res = 20 + 'a'; cout << " Type casting char to int data type ('a' to 20): " << res << endl; float val = num + 'A'; cout << " Type casting from int data to float type: " << val << 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; }

/* 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; }

/* 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; }

/* The basic_istream::putback() used to put the character back in the input string. This function is present in the iostream header file. */ /* Put character back by putback() function code example */ #include <iostream> #include <string> int main () { std::cout << "Please, enter a number or a word: "; char c = std::cin.get(); if ( (c >= '0') && (c <= '9') ) { int n; std::cin.putback (c); std::cin >> n; std::cout << "You entered a number: " << n << '\n'; } else { std::string str; std::cin.putback (c); getline (std::cin,str); std::cout << "You entered a word: " << str << '\n'; } 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; }

/* 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; }

/* get line from stream into string by getline() function code example */ // C++ program to demonstrate anomaly of delimitation of getline() function #include <iostream> #include <string> using namespace std; int main() { string name; int id; // Taking id as input cout << "Please enter your id: \n"; cin >> id; // Takes the empty character as input cout << "Please enter your name: \n"; getline(cin, name); // Prints id cout << "Your id : " << id << "\n"; // Prints nothing in name field // as "\n" is considered a valid string cout << "Hello, " << name << " welcome to world !\n"; // Again Taking string as input getline(cin, name); // This actually prints the name cout << "Hello, " << name << " welcome to world !\n"; 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; }

// C++ program to demonstrate the use of virtual function // CPP program to illustrate concept of Virtual Functions #include<iostream> using namespace std; class base { public: virtual void print() { cout << "print base class\n"; } void show() { cout << "show base class\n"; } }; class derived : public base { public: void print() { cout << "print derived class\n"; } void show() { cout << "show derived class\n"; } }; int main() { base *bptr; derived d; bptr = &d; // Virtual function, binded at runtime bptr->print(); // Non-virtual function, binded at compile time bptr->show(); 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; }

/* 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; }

/* C++ Stack size() function returns the number of stack elements. The number of stack elements is referred to the size of the stack. The size of the stack element is very important information as based on it we can deduce many other things such as the space required, etc. */ /* Find out the total number of elements in the stack by stack::size 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<<"Stack size is: "<<MyStack.size()<<"\n"; cout<<"Three elements are added in the Stack.\n"; MyStack.push(60); MyStack.push(70); MyStack.push(80); cout<<"Now, Stack size is: "<<MyStack.size()<<"\n"; 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; }

/* C++ Stack top() function returns the value of the top element in the stack. The top element is the one which was recently added on the stack. The last added element is the top element. Of all the elements that are present in a stack the top element stands out and is more significant as all the major operations on the stack are performed at the top element. Be it push, pop or anything all the operations are done at the top most position. */ /* get the reference of the element at the top of the stack by stack top() 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 MyStack is: "; cout<<MyStack.top()<<endl; cout<<"Delete the top element of MyStack.\n"; MyStack.pop(); cout<<"Now, The top element of MyStack is: "; cout<<MyStack.top(); return 0; }