C++ Programming Code Examples

List is a popularly used sequence container. Container is an object that holds data of same type. List container is implemented as doubly linked-list, hence it provides bidirectional sequential access to it's data. List doesn't provide fast random access, it only supports sequential access in both directions. List allows insertion and deletion operation anywhere within a sequence in constant time. Elements of list can be scattered in different chunks of memory. Container stores necessary information to allow sequential access to it's data. Lists can shrink or expand as needed from both ends at run time. The storage requirement is fulfilled automatically by internal allocator. Zero sized lists are also valid. In that case list.begin() and list.end() points to same location. But behavior of calling front() or back() is undefined. To define the std::list, we have to import the <list> header file. Defines the type of element contained. You can substitute T by any data type, even user-defined types. Defines the type of the allocator object. This uses the allocator class template by default. It's value-dependent and uses a simple memory allocation model. • List is a contiguous container while vector is a non-contiguous container i.e list stores the elements on a contiguous memory and vector stores on a non-contiguous memory. • Insertion and deletion in the middle of the vector is very costly as it takes lot of time in shifting all the elements. Linklist overcome this problem and it is implemented using list container. • List supports a bidirectional and provides an efficient way for insertion and deletion operations. • Traversal is slow in list as list elements are accessed sequentially while vector supports a random access. Following member types can be used as parameters or return type by member functions: • value_type T (First parameter of the template) • allocator_type Alloc (Second parameter of the template) • reference value_type& • const_reference const value_type& • pointer value_type* • const_pointer const value_type* • iterator a random access iterator to value_type • const_iterator a random access iterator to const value_type • reverse_iterator std::reverse_iterator <iterator> • const_reverse_iterator std::reverse_iterator <const_iterator> • size_type size_t • difference_type ptrdiff_t C++ List Member Functions • insert(): It inserts the new element before the position pointed by the iterator. • push_back(): It adds a new element at the end of the vector. • push_front(): It adds a new element to the front. • pop_back(): It deletes the last element. • pop_front(): It deletes the first element. • empty(): It checks whether the list is empty or not. • size(): It finds the number of elements present in the list. • max_size(): It finds the maximum size of the list. • front(): It returns the first element of the list. • back(): It returns the last element of the list. • swap(): It swaps two list when the type of both the list are same. • reverse(): It reverses the elements of the list. • sort(): It sorts the elements of the list in an increasing order. • merge(): It merges the two sorted list. • splice(): It inserts a new list into the invoking list. • unique(): It removes all the duplicate elements from the list. • resize(): It changes the size of the list container. • assign(): It assigns a new element to the list container. • emplace(): It inserts a new element at a specified position. • emplace_back(): It inserts a new element at the end of the vector. • emplace_front(): It inserts a new element at the beginning of the list. Non-member overloaded functions operator== Tests whether two lists are equal or not. 2 operator!= Tests whether two lists are equal or not. 3 operator< Tests whether first list is less than other or not. 4 operator<= Tests whether first list is less than or equal to other or not. 5 operator> Tests whether first list is greater than other or not. 6 operator>= Tests whether first list is greater than or equal to other or not. 7 swap Exchanges the contents of two list.

A program shall contain a global function named main, which is the designated start of the program in hosted environment. main() function is the entry point of any C++ program. It is the point at which execution of program is started. When a C++ program is executed, the execution control goes directly to the main() function. Every C++ program have a main() function. void is a keyword in C++ language, void means nothing, whenever we use void as a function return type then that function nothing return. here main() function no return any value. main is a name of function which is predefined function in C++ library. In place of void we can also use int return type of main() function, at that time main() return integer type value. 1) It cannot be used anywhere in the program a) in particular, it cannot be called recursively b) its address cannot be taken 2) It cannot be predefined and cannot be overloaded: effectively, the name main in the global namespace is reserved for functions (although it can be used to name classes, namespaces, enumerations, and any entity in a non-global namespace, except that a function called "main" cannot be declared with C language linkage in any namespace). 3) It cannot be defined as deleted or (since C++11) declared with C language linkage, constexpr (since C++11), consteval (since C++20), inline, or static. 4) The body of the main function does not need to contain the return statement: if control reaches the end of main without encountering a return statement, the effect is that of executing return 0;. 5) Execution of the return (or the implicit return upon reaching the end of main) is equivalent to first leaving the function normally (which destroys the objects with automatic storage duration) and then calling std::exit with the same argument as the argument of the return. (std::exit then destroys static objects and terminates the program). 6) (since C++14) The return type of the main function cannot be deduced (auto main() {... is not allowed). 7) (since C++20) The main function cannot be a coroutine.

Add element at the end. Adds a new element at the end of the list container, after its current last element. The content of val is copied (or moved) to the new element. This effectively increases the container size by one. The list:push_back() function in C++ STL is used to add a new element to an existing list container. It takes the element to be added as a parameter and adds it to the list container. Value to be copied (or moved) to the new element. Member type value_type is the type of the elements in the container, defined in list as an alias of its first template parameter (T). This function accepts a single parameter which is mandatory value. This refers to the element needed to be added to the list, list_name. This function does not return any value. The storage for the new elements is allocated using the container's allocator, which may throw exceptions on failure (for the default allocator, bad_alloc is thrown if the allocation request does not succeed). Constant No changes The container is modified. No existing contained elements are accessed: concurrently accessing or modifying them is safe. Strong guarantee: if an exception is thrown, there are no changes in the container. If allocator_traits::construct is not supported with val as argument, it causes undefined behavior.

Return iterator to beginning. Returns an iterator pointing to the first element in the list container. Notice that, unlike member list::front, which returns a reference to the first element, this function returns a bidirectional iterator pointing to it. If the container is empty, the returned iterator value shall not be dereferenced. begin() function is used to return an iterator pointing to the first element of the list container. It is different from the front() function because the front function returns a reference to the first element of the container but begin() function returns a bidirectional iterator to the first element of the container. This function does not accept any parameter. Function returns an iterator to the beginning of the sequence container. If the list object is const-qualified, the function returns a const_iterator. Otherwise, it returns an iterator. Member types iterator and const_iterator are bidirectional iterator types (pointing to an element and to a const element, respectively). If list object is constant qualified then method returns constant random access iterator otherwise non constant random access iterator. Constant No changes The container is accessed (neither the const nor the non-const versions modify the container). No contained elements are accessed by the call, but the iterator returned can be used to access or modify elements. Concurrently accessing or modifying different elements is safe. No-throw guarantee: this member function never throws exceptions. The copy construction or assignment of the returned iterator is also guaranteed to never throw.

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. • 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.

Relational operators for string. Performs the appropriate comparison operation between the string objects lhs and rhs. The functions use string::compare for the comparison. These operators are overloaded in header <string>. If strings are compared using relational operators then, their characters are compared lexicographically according to the current character traits, means it starts comparison character by character starting from the first character until the characters in both strings are equal or a NULL character is encountered. Arguments to the left- and right-hand side of the operator, respectively. If of type char*, it shall point to a null-terminated character sequence. • lhs < rhs : A string lhs is smaller than rhs string, if either, length of lhs is shorter than rhs or first mismatched character is smaller. • lhs > rhs : A string lhs is greater than rhs string, if either, length of lhs is longer than rhs or first mismatched character is larger. • <= and >= have almost same implementation with additional feature of being equal as well. • If after comparing lexicographically, both strings are found same, then they are said to be equal. • If any of the points from 1 to 3 follows up then, strings are said to be unequal. Function returns true if the condition holds, and false otherwise. Unspecified, but generally up to linear in both lhs and rhs's lengths. No changes Both objects, lhs and rhs, are accessed. If an argument of type char* does not point to null-terminated character sequence, it causes undefined behavior. For operations between string objects, exceptions are never thrown (no-throw guarantee). For other cases, if an exception is thrown, there are no changes in the string (strong guarantee).

Consider a situation, when we have two persons with the same name, jhon, in the same class. Whenever we need to differentiate them definitely we would have to use some additional information along with their name, like either the area, if they live in different area or their mother's or father's name, etc. Same situation can arise in your C++ applications. For example, you might be writing some code that has a function called xyz() and there is another library available which is also having same function xyz(). Now the compiler has no way of knowing which version of xyz() function you are referring to within your code. A namespace is designed to overcome this difficulty and is used as additional information to differentiate similar functions, classes, variables etc. with the same name available in different libraries. Using namespace, you can define the context in which names are defined. In essence, a namespace defines a scope. A namespace definition begins with the keyword namespace followed by the namespace name as follows: To call the namespace-enabled version of either function or variable, prepend (::) the namespace name as follows: You can also avoid prepending of namespaces with the using namespace directive. This directive tells the compiler that the subsequent code is making use of names in the specified namespace. A namespace can be defined in several parts and so a namespace is made up of the sum of its separately defined parts. The separate parts of a namespace can be spread over multiple files. So, if one part of the namespace requires a name defined in another file, that name must still be declared. Writing a following namespace definition either defines a new namespace or adds new elements to an existing one: Namespaces can be nested where you can define one namespace inside another name space as follows: • Namespace is a feature added in C++ and not present in C. • A namespace is a declarative region that provides a scope to the identifiers (names of the types, function, variables etc) inside it. • Multiple namespace blocks with the same name are allowed. All declarations within those blocks are declared in the named scope. • Namespace declarations appear only at global scope. • Namespace declarations can be nested within another namespace. • Namespace declarations don't have access specifiers. (Public or private) • No need to give semicolon after the closing brace of definition of namespace. • We can split the definition of namespace over several units.

Transfer elements from list to list. Transfers elements from x into the container, inserting them at position. The list::splice() is a built-in function in C++ STL which is used to transfer elements from one list to another. This effectively inserts those elements into the container and removes them from x, altering the sizes of both containers. The operation does not involve the construction or destruction of any element. They are transferred, no matter whether x is an lvalue or an rvalue, or whether the value_type supports move-construction or not. The first version (1) transfers all the elements of x into the container. The second version (2) transfers only the element pointed by i from x into the container. The third version (3) transfers the range [first,last) from x into the container. Position within the container where the elements of x are inserted. Member types iterator and const_iterator are bidirectional iterator types that point to elements. A list object of the same type (i.e., with the same template parameters, T and Alloc). This parameter may be *this if position points to an element not actually being spliced (for the first version, this is never the case, but for the other versions this is possible). Iterator to an element in x. Only this single element is transferred. iterator is a member type, defined as a bidirectional iterator type. Member types iterator and const_iterator are bidirectional iterator types that point to elements. Iterators specifying a range of elements in x. Transfers the elements in the range [first,last) to position. Notice that the range includes all the elements between first and last, including the element pointed by first but not the one pointed by last. Member types iterator and const_iterator are bidirectional iterator types that point to elements. This function does not return any value. Constant for (1) and (2). Up to linear in the number of elements transferred for (3). No changes on the iterators, pointers and references related to the container before the call. The iterators, pointers and references that referred to transferred elements keep referring to those same elements, but iterators now iterate into the container the elements have been transferred to. Both the container and x are modified. Concurrently accessing or modifying their elements is safe, although iterating x or ranges that include position is not. If the allocators in both containers do not compare equal, if any of the iterators or ranges specified is not valid, or if x is *this in (1), or if position is in the range [first,last) in (3), it causes undefined behavior. Otherwise, the function never throws exceptions (no-throw guarantee).

In while loop, condition is evaluated first and if it returns true then the statements inside while loop execute, this happens repeatedly until the condition returns false. When condition returns false, the control comes out of loop and jumps to the next statement in the program after while loop. The important point to note when using while loop is that we need to use increment or decrement statement inside while loop so that the loop variable gets changed on each iteration, and at some point condition returns false. This way we can end the execution of while loop otherwise the loop would execute indefinitely. A while loop that never stops is said to be the infinite while loop, when we give the condition in such a way so that it never returns false, then the loops becomes infinite and repeats itself indefinitely. • A while loop evaluates the condition • If the condition evaluates to true, the code inside the while loop is executed. • The condition is evaluated again. • This process continues until the condition is false. • When the condition evaluates to false, the loop terminates. Do not forget to increase the variable used in the condition, otherwise the loop will never end!

C++ find() function is part of the standard library function which tries to find the first occurrence of the specified range of element where the range starts with first range to last range and that iterator encounters the first element, compares for the value which must be equal after all possible comparisons and if no element is found it returns the last element. For making all the comparisons it makes use of the operator = for comparison. If find() function performs any unnecessary action it throws exceptions that are not required by the programmer. Find value in range. Returns an iterator to the first element in the range [first,last) that compares equal to val. If no such element is found, the function returns last. The function uses operator== to compare the individual elements to val. Input iterator to the initial position. Input iterator to the final position. Input iterators to the initial and final positions in a sequence. The range searched is [first,last), which contains all the elements between first and last, including the element pointed by first but not the element pointed by last. Value to compare the elements. Value to search for in the range. T shall be a type supporting comparisons with the elements pointed by InputIterator using operator== (with the elements as left-hand side operands, and val as right-hand side). Function returns an iterator to the first element in the range that compares equal to val. If no elements match, the function returns last. If element found it returns an iterator pointing to the first occurrence of the element otherwise returns last. Throws exception if either element comparison or an operation on an iterator throws exception. Please note that invalid parameters cause undefined behavior. Any find() function defined should have a proper standard library for inclusion otherwise it will throw an unwanted exception saying that this member or method is not present with the designated standard library for the function which means incompatibility of function with the standard library. Advantages of C++ algorithm library find() function: • find() function as part of the standard library can be used by the programmers for searching elements at the time of comparison with the first and last element within a specified range. • The iterator pointing to the first or the last element can enhance or manipulate the entire traversal process as all the elements present are with the index were retrieving the value is important for comparisons and other operations. • It enhances the reusability of the code base as it not important to design and define a function again and again wherever required we can call the find function and the task becomes simplified as it will be already present within the standard library. • Testing of individual functions becomes easy as the scope for re-writing function becomes simplified. • The division of the program makes the view of the codebase clear and understandable by the programmers to write a new and enhanced form of code. Up to linear in the distance between first and last: Compares elements until a match is found. Some (or all) of the objects in the range [first,last) are accessed (once at most). Throws if either an element comparison or an operation on an iterator throws. Note that invalid arguments cause undefined behavior.

#include is a way of including a standard or user-defined file in the program and is mostly written at the beginning of any C/C++ program. This directive is read by the preprocessor and orders it to insert the content of a user-defined or system header file into the following program. These files are mainly imported from an outside source into the current program. The process of importing such files that might be system-defined or user-defined is known as File Inclusion. This type of preprocessor directive tells the compiler to include a file in the source code program. Including using " ": When using the double quotes(" "), the preprocessor access the current directory in which the source "header_file" is located. This type is mainly used to access any header files of the user's program or user-defined files. Including using <>: While importing file using angular brackets(<>), the the preprocessor uses a predetermined directory path to access the file. It is mainly used to access system header files located in the standard system directories. Header File or Standard files: This is a file which contains C/C++ function declarations and macro definitions to be shared between several source files. Functions like the printf(), scanf(), cout, cin and various other input-output or other standard functions are contained within different header files. So to utilise those functions, the users need to import a few header files which define the required functions. User-defined files: These files resembles the header files, except for the fact that they are written and defined by the user itself. This saves the user from writing a particular function multiple times. Once a user-defined file is written, it can be imported anywhere in the program using the #include preprocessor. • In #include directive, comments are not recognized. So in case of #include <a//b>, a//b is treated as filename. • In #include directive, backslash is considered as normal text not escape sequence. So in case of #include <a\nb>, a\nb is treated as filename. • You can use only comment after filename otherwise it will give error.

Return iterator to end. Returns an iterator referring to the past-the-end element in the list container. The past-the-end element is the theoretical element that would follow the last element in the list container. It does not point to any element, and thus shall not be dereferenced. Because the ranges used by functions of the standard library do not include the element pointed by their closing iterator, this function is often used in combination with list::begin to specify a range including all the elements in the container. If the container is empty, this function returns the same as list::begin. This function does not accept any parameter. Function returns an iterator to the element past the end of the sequence. If the list object is const-qualified, the function returns a const_iterator. Otherwise, it returns an iterator. Member types iterator and const_iterator are bidirectional iterator types (pointing to an element and to a const element, respectively). The list::end() is a built-in function in C++ STL which is used to get an iterator to past the last element. By past the last element it is meant that the iterator returned by the end() function return an iterator to an element which follows the last element in the list container. It can not be used to modify the element or the list container. Constant No changes The container is accessed (neither the const nor the non-const versions modify the container). No contained elements are accessed by the call, but the iterator returned can be used to access or modify elements. Concurrently accessing or modifying different elements is safe. No-throw guarantee: this member function never throws exceptions. The copy construction or assignment of the returned iterator is also guaranteed to never throw.

In computer programming, loops are used to repeat a block of code. For example, when you are displaying number from 1 to 100 you may want set the value of a variable to 1 and display it 100 times, increasing its value by 1 on each loop iteration. When you know exactly how many times you want to loop through a block of code, use the for loop instead of a while loop. A for loop is a repetition control structure that allows you to efficiently write a loop that needs to execute a specific number of times. initializes variables and is executed only once. if true, the body of for loop is executed, if false, the for loop is terminated. updates the value of initialized variables and again checks the condition. A new range-based for loop was introduced to work with collections such as arrays and vectors.