Happy Codings - Programming Code Examples
Html Css Web Design Sample Codes CPlusPlus Programming Sample Codes JavaScript Programming Sample Codes C Programming Sample Codes CSharp Programming Sample Codes Java Programming Sample Codes Php Programming Sample Codes Visual Basic Programming Sample Codes


C++ Programming Code Examples

C++ > Data Structures and Algorithm Analysis in C++ Code Examples

Simple exception classes

1 2 3 4 5 6 7 8 9 10 11
/* Simple exception classes */ #ifndef DSEXCEPTIONS_H_ #define DSEXCEPTIONS_H_ class Underflow { }; class Overflow { }; class OutOfMemory { }; class BadIterator { }; #endif
#define Directive in C++
In the C++ Programming Language, the #define directive allows the definition of macros within your source code. These macro definitions allow constant values to be declared for use throughout your code. Macro definitions are not variables and cannot be changed by your program code like variables. You generally use this syntax when creating constants that represent numbers, strings or expressions. The syntax for creating a constant using #define in the C++ is: #define token value
Syntax for #define Directive in C++
#define macro-name replacement-text
• Using #define to create Macros Macros also follow the same structure as Symbolic Constants; however, Macros allow arguments to be included in the identifier:
#define SQUARE_AREA(l) ((l) * (l))
Unlike in functions, the argument here is enclosed in parenthesis in the identifier and does not have a type associated with it. Before compilation, the compiler will replace every instance of SQUARE_AREA(l) by ((l) * (l)), where l can be any expression. • Conditional Compilation There are several directives, which can be used to compile selective portions of your program's source code. This process is called conditional compilation. The conditional preprocessor construct is much like the 'if' selection structure. Consider the following preprocessor code:
#ifndef NULL #define NULL 0 #endif
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/* #define directive in C++ language */ #include <bits/stdc++.h> using namespace std; void func1(); void func2(); #pragma startup func1 #pragma exit func2 void func1() { cout << "Inside func1()\n"; } void func2() { cout << "Inside func2()\n"; } int main() { void func1(); void func2(); cout << "Inside main()\n"; return 0; }
Iterators in C++ Language
Iterators are just like pointers used to access the container elements. Iterators are one of the four pillars of the Standard Template Library or STL in C++. An iterator is used to point to the memory address of the STL container classes. For better understanding, you can relate them with a pointer, to some extent. Iterators act as a bridge that connects algorithms to STL containers and allows the modifications of the data present inside the container. They allow you to iterate over the container, access and assign the values, and run different operators over them, to get the desired result.
Syntax for Iterators in C++
<ContainerType> :: iterator; <ContainerType> :: const_iterator;
• Iterators are used to traverse from one element to another element, a process is known as iterating through the container. • The main advantage of an iterator is to provide a common interface for all the containers type. • Iterators make the algorithm independent of the type of the container used. • Iterators provide a generic approach to navigate through the elements of a container. Operator (*) : The '*' operator returns the element of the current position pointed by the iterator. Operator (++) : The '++' operator increments the iterator by one. Therefore, an iterator points to the next element of the container. Operator (==) and Operator (!=) : Both these operators determine whether the two iterators point to the same position or not. Operator (=) : The '=' operator assigns the iterator. Iterators can be smart pointers which allow to iterate over the complex data structures. A Container provides its iterator type. Therefore, we can say that the iterators have the common interface with different container type. The container classes provide two basic member functions that allow to iterate or move through the elements of a container: begin(): The begin() function returns an iterator pointing to the first element of the container. end(): The end() function returns an iterator pointing to the past-the-last element of the container. Input Iterator: An input iterator is an iterator used to access the elements from the container, but it does not modify the value of a container. Operators used for an input iterator are: Increment operator(++), Equal operator(==), Not equal operator(!=), Dereference operator(*). Output Iterator: An output iterator is an iterator used to modify the value of a container, but it does not read the value from a container. Therefore, we can say that an output iterator is a write-only iterator. Operators used for an output iterator are: Increment operator(++), Assignment operator(=). Forward Iterator: A forward iterator is an iterator used to read and write to a container. It is a multi-pass iterator. Operators used for a Forward iterator are: Increment operator(++), Assignment operator(=), Equal operator(=), Not equal operator(!=). Bidirectional iterator: A bidirectional iterator is an iterator supports all the features of a forward iterator plus it adds one more feature, i.e., decrement operator(--). We can move backward by decrementing an iterator. Operators used for a Bidirectional iterator are: Increment operator(++), Assignment operator(=), Equal operator(=), Not equal operator(!=), Decrement operator(--). Random Access Iterator: A Random Access iterator is an iterator provides random access of an element at an arbitrary location. It has all the features of a bidirectional iterator plus it adds one more feature, i.e., pointer addition and pointer subtraction to provide random access to an element. Following are the disadvantages of an iterator: • If we want to move from one data structure to another at the same time, iterators won't work. • If we want to update the structure which is being iterated, an iterator won?t allow us to do because of the way it stores the position. • If we want to backtrack while processing through a list, the iterator will not work in this case. Following are the advantages of an iterator: • Ease in programming: It is convenient to use iterators rather than using a subscript operator[] to access the elements of a container. If we use subscript operator[] to access the elements, then we need to keep the track of the number of elements added at the runtime, but this would not happen in the case of an iterator. • Code Reusability: A code can be reused if we use iterators. In the above example, if we replace vector with the list, and then the subscript operator[] would not work to access the elements as the list does not support the random access. However, we use iterators to access the elements, then we can also access the list elements. • Dynamic Processing: C++ iterators provide the facility to add or delete the data dynamically.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
/* Iterators in C++ language */ // C++ code to demonstrate the working of next() and prev() #include<iostream> #include<iterator> // for iterators #include<vector> // for vectors using namespace std; int main() { vector<int> ar = { 1, 2, 3, 4, 5 }; // Declaring iterators to a vector vector<int>::iterator ptr = ar.begin(); vector<int>::iterator ftr = ar.end(); // Using next() to return new iterator // points to 4 auto it = next(ptr, 3); // Using prev() to return new iterator // points to 3 auto it1 = prev(ftr, 3); // Displaying iterator position cout << "The position of new iterator using next() is : "; cout << *it << " "; cout << endl; // Displaying iterator position cout << "The position of new iterator using prev() is : "; cout << *it1 << " "; cout << endl; return 0; }
Comments in C++
The C++ comments are statements that are not executed by the compiler. The comments in C++ programming can be used to provide explanation of the code, variable, method or class. If we write comments on our code, it will be easier for us to understand the code in the future. Also, it will be easier for your fellow developers to understand the code. By the help of comments, you can hide the program code also. There are two types of comments in C++: • Single Line comment • Multi Line comment
Syntax for Single Line Comment in C++
/* This is a comment */
The single line comment starts with // (double slash).
Syntax for Multi Line Comment in C++
/* C++ comments can also * span multiple lines */
C++ multi line comment is used to comment multiple lines of code. It is surrounded by slash and asterisk (/* ..... */). Comments shouldn't be the substitute for a way to explain poorly written code in English. We should always write well-structured and self-explanatory code. And, then use comments.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/* program to illustrate use comments in C++ language */ #include <ostream> using namespace std; int main() { int x = 11; // x is a variable cout<<x<<"\n"; /* declare and print variable in C++ */ int x = 35; cout<<x<<"\n"; // This is a comment cout << "Hello World!"; /* Multi-line Comments in C++ */ }
#ifndef Directive in C++
The #ifndef directive of the C++ Programming Language helps in allowing the conditional compilation. The C++ Programming Language's preprocessor helps in determining only if the macro provided is not at all existed before including the specific subsequent code in the C++ compilation process. The #ifndef preprocessor only checks If the specific macro is not at all defined with the help of the #define directive. If the condition is TRUE then it will be helpful in executing the code otherwise the else code of the #ifndef will be compiled or executed only if present.
Syntax for #ifndef Directive in C++
#ifndef MACRO //Code Statements #else //Code Statements which are used to include if the specific token is defined #endif
#ifndef MACRO
The #ifndef works for the opposite condition of the #ifdef directive of the C Programming Language. The "MACRO" definition should not be defined for the specific preprocessor which is used to include the C Programming Source Code into the specific compiled application. The #ifndef must be ended with the #endif directive of the C Programming Language.
#else directive
If the #ifndef does not accept then else code statements will be printed which are actually used in including the specific which is defined.
#endif directive
The #endif directive of the C Programming Language helps in closing the #ifndef directive of the C Programming Language. It is must and should end only with the #endif C Source code directive. The $ifndef directive usually checks/helps in seeing the specific identifier is currently not defined or not. The #ifndef preprocessor of the C Programming Language helps in allowing the conditional compilations. The preprocessor directive helps in determining whether the macro is existed or not before the subsequent code in the compilation process/ procedure. The #ifndef directive and #if !defined identifier are equivalent directives of the C Programming Language. The #ifndef directive helps in checking the opposite condition of the #ifdef directive of the C Programming Language. If the specified identifier is not even defined or definition is removed with the help of the #undef then the condition is TRUE for nonzero value or else the condition will be FALSE.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
/* #ifndef Directive in C++ language */ #define Module101 #define MyVersion 1.1 #include<iostream> usingnamespace std; int main(void) { cout<<"Sample using #define, #ifdef, #ifndef"<<endl; cout<<" #undef, #else and #endif..."<<endl; cout<<"-------------------------------------"<<endl; #ifdef Module102 cout<<"\nModule102 is defined."<<endl; #else cout<<"\nModule102 is not defined."<<endl; #endif #ifndef MyVersion cout<<"\nMyVersion is not defined"<<endl; #else cout<<"\nMyVersion is "<<MyVersion<<endl; #endif #ifdef MyRevision cout<<"\nMy Revision is defined\n"<<endl; #else cout<<"\nMyRevision is not defined!"<<endl<<endl; #endif #undef MyVersion #ifndef MyVersion cout<<"MyVersion is not defined"<<endl<<endl; #else cout<<"MyVersion is "<<MyVersion<<endl; #endif return 0; }


C++ program opens a file named filename.txt to read the content present inside this file, if there is an error in opening a file then puts a message on the screen for the "error", and if
Construct Binary Search tree for the unsorted data array. 'Search the element' starting from the Root of the Tree. Proceed with the search by comparing an element to the data of node
Shellsort, using Shell's (poor) increments. An Internal method for heapsort. i is the index of an item in the heap. Returns the index of the left child. Internal method for heapsort that is
To get the IP address of your computer in c++ programming, use the function system() and place the command 'ipconfig' after providing the full path of 'System32' i.e., C:\\Windows\\
This is a C++ Program to perform Fast Fourier Transform. A 'Fast Fourier transform' (FFT) is an algorithm to compute the discrete Fourier transform (DFT) & its inverse. Fourier analysis