What is Friend Function?

Friend function is a non-member function that can access the private and protected members of a class. “Friend” is a keyword used to indicate that a function is the friend of a class. This allows the compiler to know that the particular function is a friend of the given class. The friend function then should be able to access the private and protected member of a given class. Without the friend keyword, a non-member outside function can only access the public members of a class.

Key Features of Friend Function:

Here are the key features of the friend function:

1. A friend function is not in the scope of the class.
2. The friend function cannot be invoked using an instance of a class.
3. It can access the members using the object and dot operator.

Syntax of Friend Function:

Here is the syntax of the friend function:

Example of Friend Function:

Now, let us look into an example program to understand the concept of the friend function in C++. In the below example program, we have the “Friend_Demo” class. It has three different types of data members, i.e., private, protected, and public.

We have defined another function, i.e., “friendDemo_Func()” outside the scope of the “Friend_Demo” class and tried to access the members (private, protected, and public) of the “Friend_Demo” class.

But, as you can see in the output below when we compile the program, it throws compilation errors. The friend function is going to exactly solve this problem.

In the previous program, we were getting compilation errors while trying to access the private, protected, and public members of a class from a non-member function. This is because a non-member function is not allowed to access the private and protected members of a class from outside the scope of the class.

Now, in this example, we have declared “friendDemo_Func()” function as a friend inside the scope of the class, i.e., “Friend_Demo”:

We have created an object, i.e., “fd” of the “Friend_Demo” class inside the “friendDemo_Func()” function. Now, we can access the private, protected, and public members of the “Friend_Demo” class using the dot operator. We have assigned 10, 15, and 20 to i_private, i_protected, and i_public, respectively.

As you can see in the output below, this program is now compiled and executed without any errors and print the output as expected.

Conclusion:

In this article, I have explained the concept of the friend function in C++. I have also shown two working examples to explain how the friend function behaves in C++. Sometimes, the friend function can be very useful in a complex programming environment. However, a programmer should be cautious about overusing it and compromising its OOP features. ]]> https://linuxhint.com/unique-and-ordered-containers-in-c/ Sun, 14 Feb 2021 18:10:03 +0000 https://linuxhint.com/?p=89978 {6, 10, 2, 8, 4} is a set; {2, 4, 6, 8, 10} is a set of the same integers, arranged in ascending order. In Mathematics, a set has unique elements (distinct elements), and that is, no element occurs more than once. Furthermore, a multiset is a set, where any element can occur more than once. {6, 6, 10, 2, 2, 8, 4, 4, 4} is a multiset. {2, 2, 4, 4, 4, 6, 6, 8, 10} is the same multiset, but with the elements arranged in ascending order. This article does not deal with multiset. It deals with the C++ data structure called, set.

A map in software is like an array, but it is an array with two columns instead of one. The first column has the keys and the second column has the values. Each row is one pair, making a key/value pair. A key is directly related to its value.

An example of a map is {{‘c’,30}, {‘b’,20}, {‘d’,30}, {‘e’,40}, {‘a’,10}}. The first key/value pair inserted here, is {‘c’,3}, where ‘c’ is the key and 30 is the value. This map is not ordered by keys. Ordering this map by keys produces {{‘a’,10}, {‘b’,20}, {‘c’,30}, {‘d’,30}, {‘e’,40}}. Notice that there can be duplicated values, but not duplicated keys. An ordered map is a map ordered by keys.

A multiset is to a set, as a multimap is to a map. This means that there are maps with duplicate keys. An example of a multimap is {{‘a’,10}, {‘b’,20}, {‘b’,20}, {‘c’,30}, {‘c’,30}, {‘d’,30}, {‘e’,40}}. And as stated above, this article does not deal with multimap, rather, it deals with the C++ data structure called, map.

In C++, a data structure is a structure with properties (data members) and methods (member functions). The data of the structure is a list; a set is a list; a map is a list of key/value pairs.

This article discusses the basics of sets and maps in C++, and to better understand this article, the reader should have had a basic knowledge of C++.

Article Content:

• Class and its Objects
• Creating a set or a map
• Iterator Basics
• Element Access for set and map
• Order of Elements in a set or map
• Other Commonly Used Member Functions
• Conclusion

Class and its Objects:

In C++, the set, the map, and other similar structures are called containers. A class is a generalized unit with data members, which are variables, and member functions that are related. When data members are given values, an object is formed. However, an object is formed in a process called, instantiation. As a class can lead to different values for the same data member variables, different objects can then be instantiated from the same class.

In C++, an unusable set is a class, as well as an unusable map. When an object is instantiated from the unusable set or the unusable map, the object becomes the real data structure. With the set and map data structures, the principal data member is a list. Well, the set and the map form a group of containers called, ordered associative containers. Unordered set and the unordered map also exist, but those are unfortunately not addressed in this article.

Creating a set or a map:

Instantiating a set from its set class is creating a set; instantiating a map from its map class is creating a map. The object so created is given a name of the programmer’s choice.

In order to create a set, the program should begin with:

Note the directive “#include <set>”, which includes the set library that has the set class from which set data structures will be instantiated.

In order to create a map, the program should begin with:

Note the directive “#include <map>”, which includes the map library that has the map class from which map data structures will be instantiated.

The syntax to create an empty set is:

Example:

An example to create a set with content is:

The syntax to create an empty map is:

Example:

An example to create a map with content is:

Iterator Basics:

An iterator is an elaborated pointer, which can be used to traverse the list of the data structure from the beginning to the end.

The begin() member Function

The begin() member function returns an iterator that points to the first element of the list. The following example illustrates this for the set:

Note the way begin() has been used with setObj and the dot operator. iter is the returned iterator object. Also, note the way it has been declared. * is the indirection operator. As used with iter, it returns the first element of the set; the first element is 2 instead of 6 – see explanation below.

The following example illustrates the use of the begin() function for the map:

Note the way begin() has been used with mapObj and the dot operator. iter is the returned iterator object. Also, note the way it has been declared. “first”, as used here, refers to the key. “second” refers to the value corresponding to the key. Observe how they have been used with iter to obtain the start element components of the list. The first element is {a,10} instead of {c,30} – see explanation below.

The “begin() const” member Function

The “begin() const” member function returns an iterator that points to the first element of the list when the declaration of the set begins with const (for constant). Under this condition, the value in the list, referred to by the iterator returned, cannot be changed by the iterator. The following example illustrates its use for the set:

Note the way begin() has been used with setObj and the dot operator. No “const” has been typed just after begin(). However, “const” has preceded the declaration. iter here is the returned constant iterator object, which is different from the normal iterator. Also, note the way it has been declared. * is the indirection operator; as used with iter, it returns the first element of the set. The first element is 2 instead of 6 – see explanation below.

The following example illustrates the use of the “begin() const” function for the map:

Note the way begin() has been used with mapObj and the dot operator. No “const” has been typed just after begin(). However, “const” has preceded the declaration. iter here is the returned constant iterator object, which is different from the normal iterator. Also, note the way it has been declared. “first”, as used here, refers to the key; “second”, as used here, refers to the value corresponding to the key. Observe how they have been used with iter to obtain the start element components of the list. The first element is {a,10} instead of {c,30} – see explanation below.

The end() member Function

The end() member function returns an iterator that points just after the end of the list. The following example illustrates this for the set:

Note the way end() has been used with setObj and the dot operator. iter is the returned iterator object. Also, note the way it has been declared. * is the indirection operator; as used with iter, it returns the last+1 element of the set. In the author’s computer, this last+1 element is 5, which is not on the list. So, careful not to use this element.

The following example illustrates the use of the end() function for the map:

Note the way end() has been used with mapObj and the dot operator. iter is the returned iterator object. Also, note the way it has been declared. * is the indirection operator; as used with iter, it returns the last+1 element of the map. In the author’s computer, this last+1 element is {,0}, which is not in the list. So, careful not to use this element.

The “end() const” member Function

The “end() const” member function returns an iterator that points just after the end of the list when the declaration of the set begins with const (for constant). Under this condition, the value in the list, referred to by the iterator returned, cannot be changed by the iterator. The following example illustrates its use for the set:

Note the way end() has been used with setObj and the dot operator. No “const” has been typed just after the end(). However, “const” has preceded the declaration. iter is the returned iterator object. Also, note the way it has been declared. * is the indirection operator; as used with iter, it returns the last+1 element of the set.

The following example illustrates the use of the “end() const” function for the map:

Note the way end() has been used with mapObj and the dot operator. No “const” has been typed just after the end(). However, “const” has preceded the declaration. iter is the returned constant iterator object, which is different from the normal iterator. Also, carefully observe the way it has been declared.

Element Access for set and map:

Set

With the set, the element is read using the indirection operator. The first two elements of a set are read in the following example:

The output is 2, then followed by 4 – see explanation below. To point at the next element of the list, the iterator is incremented.

Note: An element cannot be changed using the indirection operator for the set. For example, “*iter = 9;” is not possible.

map

A map consists of key/value pairs. A value can be read using the corresponding key, and changed using the same key. The following code segment illustrates this:

The output is:

The dot operator has not been used here. Instead, it is the square brackets operator, which takes the key as content, that has been used.

Order of Elements in a set or map:

Elements can be inserted into a set, in any order. However, once inserted, the set rearranges its elements in ascending order. Ascending order is the default order. If descending order is needed, then the set has to be declared as in the following example:

So, after the type, e.g., int, for the template, there is a comma, followed by “greater<type>” in the angle brackets.

Elements can be inserted into a map in any order. However, once inserted, the map rearranges its elements in ascending order by key (only) while maintaining the relationship between each key and its value. Ascending order is the default order; if descending order is needed, then the map has to be declared as in the following example:

So, after the type pair, e.g., “char, int”, for the template, there is a comma, followed by “greater<type>” in the angle brackets.

Traversing a set

The while-loop or for-loop with the iterator can be used to traverse a set. The following example uses a for-loop to traverse a set that has been configured in descending order:

The output is:

Incrementing an iterator points it to the next element.

Traversing a map

The while-loop or for-loop with the iterator can be used to traverse a map. The following example uses a for-loop to traverse a map that has been configured in descending order:

The output is:

Incrementing an iterator points it to the next element. “first”, in the code, refers to the key and “second” refers to the corresponding value. Note how these values have been obtained for the output.

Other Commonly Used Member Functions:

The size() Function

This function returns an integer, which is the number of elements in the list. Set example:

The output is 5.

Map example:

The output is 5.

The insert() Function

set

set does not allow duplicate. So, any duplicate inserted is silently rejected. With the set, the argument to the insert() function is the value to be inserted. The value is fitted into a position, in which the order in the set remains ascending or descending. Example:

The output is:

Note: The insert() member function can be used to populate an empty set.

map

map does not allow duplicate by key. So, any duplicate inserted is silently rejected. With the map, the argument to the insert() function is the key/value pair in braces. The element is fitted into a position by key, in which the order in the map remains ascending or descending. Example:

The output is:

Note: The insert() member function can be used to populate an empty map.

The empty() Function

This function returns true if the list is empty, and false if otherwise. Set example:

The output is 0 for false, meaning the set here is not empty.

Map example:

The output is 0 for false, meaning the map here is not empty.

The erase() Function

set

Consider the following code segment:

The output is:

The erase() function takes an iterator that points to an element as an argument. After erasing the element, the erase() function returns an iterator that points to the next element.

map

Consider the following code segment:

The output is:

The erase() function takes an iterator that points to an element as an argument. After erasing the element, the erase() function returns an iterator that points to the next element.

The clear() Function

The clear() function removes all the elements in the list. Set example:

The output is 0.

map example:

The output is 0.

Conclusion:

A set data structure in C++ is a structure in which the list of elements is stored in ascending order by default, or in descending order by programmer’s choice. All the elements of the set are unique. A map data structure in C++ is a structure in which the list is a hash of key/value pairs, stored in ascending order of keys by default, or in descending order of keys by programmer’s choice. The keys are also unique, and there can be duplicated values. The main data member of either of the structures is the list. Either structure has member functions, some of which are commonly used.

Why Lambda Expression?

Consider the following statement:

Here, myInt is an identifier, an lvalue. 52 is a literal, a prvalue. Today, it is possible to code a function specially and put it in the position of 52. Such a function is called a lambda expression. Consider also the following short program:

Today, it is possible to code a function specially and put it in the position of the argument of 5, of the function call, fn(5). Such a function is called a lambda expression. The lambda expression (function) in that position is a prvalue.

Any literal except the string literal is a prvalue. The lambda expression is a special function design that would fit as a literal in code. It is an anonymous (unnamed) function. This article explains the new C++ primary expression, called the lambda expression. Basic knowledge in C++ is a requirement to understand this article.

Article Content

• Illustration of Lambda Expression
• Parts of Lambda Expression
• Captures
• Classical Callback Function Scheme with Lambda Expression
• The trailing-return-type
• Closure
• Conclusion

Illustration of Lambda Expression

In the following program, a function, which is a lambda expression, is assigned to a variable:

The output is:

Outside the main() function, there is the variable, fn. Its type is auto. Auto in this situation means that the actual type, such as int or float, is determined by the right operand of the assignment operator (=). On the right of the assignment operator is a lambda expression. A lambda expression is a function without the preceding return type. Note the use and position of the square brackets, []. The function returns 5, an int, which will determine the type for fn.

In the main() function, there is the statement:

This means, fn outside main(), ends up as the identifier for a function. Its implicit parameters are those of the lambda expression. The type for variab is auto.

Note that the lambda expression ends with a semicolon, just like the class or struct definition, ends with a semicolon.

In the following program, a function, which is a lambda expression returning the value of 5, is an argument to another function:

The output is :

There are two functions here, the lambda expression and the otherfn() function. The lambda expression is the second argument of the otherfn(), called in main(). Note that the lambda function (expression) does not end with a semicolon in this call because, here, it is an argument (not a stand-alone function).

The lambda function parameter in the definition of the otherfn() function is a pointer to a function. The pointer has the name, ptr. The name, ptr, is used in the otherfn() definition to call the lambda function.

The statement,

In the otherfn() definition, it calls the lambda function with an argument of 2. The return value of the call, "(*ptr)(2)" from the lambda function, is assigned to no2.

The above program also shows how the lambda function can be used in the C++ callback function scheme.

Parts of Lambda Expression

The parts of a typical lambda function is as follows:

• [] is the capture clause. It can have items.
• () is for the parameter list.
• {} is for the function body. If the function is standing alone, then it should end with a semicolon.

Captures

The lambda function definition can be assigned to a variable or used as the argument to a different function call. The definition for such a function call should have as a parameter, a pointer to a function, corresponding to the lambda function definition.

The lambda function definition is different from the normal function definition. It can be assigned to a variable in the global scope; this function-assigned-to-variable can also be coded inside another function. When assigned to a global scope variable, its body can see other variables in the global scope. When assigned to a variable inside a normal function definition, its body can see other variables in the function scope only with the capture clause’s help, [].

The capture clause [], also known as the lambda-introducer, allows variables to be sent from the surrounding (function) scope into the lambda expression’s function body. The lambda expression’s function body is said to capture the variable when it receives the object. Without the capture clause [], a variable cannot be sent from the surrounding scope into the lambda expression’s function body. The following program illustrates this, with the main() function scope, as the surrounding scope:

The output is 5. Without the name, id, inside [], the lambda expression would not have seen the variable id of the main() function scope.

Capturing by Reference

The above example use of the capture clause is capturing by value (see details below). In capturing by reference, the location (storage) of the variable, e.g., id above, of the surrounding scope, is made available inside the lambda function body. So, changing the value of the variable inside the lambda function body will change the value of that same variable in the surrounding scope. Each variable repeated in the capture clause is preceded by the ampersand (&) to achieve this. The following program illustrates this:

The output is:

Confirming that the variable names inside the lambda expression’s function body are for the same variables outside the lambda expression.

Capturing by Value

In capturing by value, a copy of the variable’s location, of the surrounding scope, is made available inside the lambda function body. Though the variable inside the lambda function body is a copy, its value cannot be changed inside the body as of now. To achieve capturing by value, each variable repeated in the capture clause is not preceded by anything. The following program illustrates this:

The output is:

If the comment indicator is removed, the program will not compile. The compiler will issue an error message that the variables inside the function body’s definition of the lambda expression cannot be changed. Though the variables cannot be changed inside the lambda function, they can be changed outside the lambda function, as the above program’s output shows.

Mixing Captures

Capturing by reference and capturing by value can be mixed, as the following program shows:

The output is:

When all captured, are by reference:

If all variables to be captured are captured by reference, then just one & will suffice in the capture clause. The following program illustrates this:

The output is:

If some variables are to be captured by reference and others by value, then one & will represent all the references, and the rest will each not be preceded by anything, as the following program shows:

The output is:

Note that & alone (i.e., & not followed by an identifier) has to be the first character in the capture clause.

When all captured, are by value:

If all variables to be captured are to be captured by value, then just one = will suffice in the capture clause. The following program illustrates this:

The output is:

Note: = is read-only, as of now.

If some variables are to be captured by value and others by reference, then one = will represent all the read-only copied variables, and the rest will each have &, as the following program shows:

The output is:

Note that = alone has to be the first character in the capture clause.

Classical Callback Function Scheme with Lambda Expression

The following program shows how a classical callback function scheme can be done with the lambda expression:

The output is:

Recall that when a lambda expression definition is assigned to a variable in the global scope, its function body can see global variables without employing the capture clause.

The trailing-return-type

The return type of a lambda expression is auto, meaning the compiler determines the return type from the return expression (if present). If the programmer really wants to indicate the return type, then he will do it as in the following program:

The output is 5. After the parameter list, the arrow operator is typed. This is followed by the return type (int in this case).

Closure

Consider the following code segment:

Here, Cla is the name of the struct class.  Obj1 and obj2 are two objects that will be instantiated from the struct class. Lambda expression is similar in implementation. The lambda function definition is a kind of class. When the lambda function is called (invoked), an object is instantiated from its definition. This object is called a closure. It is the closure that does the work the lambda is expected to do.

However, coding the lambda expression like the struct above will have obj1 and obj2 replaced by the corresponding parameters’ arguments. The following program illustrates this:

The output is 5. The arguments are 2 and 3 in parentheses. Note that the lambda expression function call, fn, does not take any argument since the arguments have already been coded at the end of the lambda function definition.

Conclusion

The lambda expression is an anonymous function. It is in two parts: class and object. Its definition is a kind of class. When the expression is called, an object is formed from the definition. This object is called a closure. It is the closure that does the work the lambda is expected to do.

For the lambda expression to receive a variable from an outer function scope, it needs a non-empty capture clause into its function body.

Arithmetic operators are typically used for arithmetic operations. Is it not nice to have the +, join two strings? Enabling that is said to be overloading the arithmetic addition operator, for strings.

The increment operator, ++ adds 1 to an int or a float. When dealing with pointers, it does not add 1 to the pointer. It makes the pointer point to the next consecutive object in memory. An iterator points to the next object in a linked-list, but the linked-list objects are in different places in memory (not in consecutive regions). Would it not be nice to overload the increment operator for an iterator, to increment but point to the following element, in the linked-list?

This article explains overloading in C++. It is divided into two parts: function overloading and operator overloading. Having already basic knowledge in C++ is necessary to understand the rest of the article.

Article Content

• Function Overloading
• Operator Overloading
• Example String Class Operator Overloading
• Iterator Operator Overloading
• Conclusion

Function Overloading

The following function adds two ints and returns an int:

How does the compiler differentiate which function to call, since two or more functions have the same name? The compiler uses the number of arguments and argument types to determine which function to call. The parameter list of overloaded functions should differ in their number and/or parameter types. So, the function call,

would call the integer function, while the function call,

would call the float function. Note: there are situations where the compiler will reject an overloaded function when the number of arguments is the same but of different types! – Reason: – see later.

The following program puts the above code segments into action:

The output is:
5
7.7

Operator Overloading

Arithmetic operators are used to overload operations in class types. An iterator is a class type. The increment and decrement operators are used to overload operations for an iterator.

Example String Class Operator Overloading

This section provides an example, where + is overloaded for a simply designed string class, called a spring class. + concatenates the literals of two string objects, returning a new object with the concatenated literals. Concatenating two literals means joining the second literal to the end of the first literal.

Now, C++ has a special member function for all classes, called the operator. The programmer can use this special function to overload operators, such as +. The following program shows the overloading of the + operator for two strings.

The value of str1 is "I hate you! ". The value of str2 is "But she loves you!". The value of str3, which is, str1 + str2, is the output:

"I hate you! But she loves you!"

which is the concatenation of the two string literals. The strings themselves are instantiated objects.

The definition of the operator function is inside the description(definition) of the string class. It begins with the return type, "spring" for "string". The special name, "operator, follow this". After that, there is the symbol of the operator (to be overloaded). Then there is the parameter list, which is actually the operand list. + is a binary operator: meaning it takes a left and a right operand. However, by the C++ specification, the parameter list here has only the right parameter. Then there is the body of the operator function, which mimics the ordinary operator behaviour.

By the C++ specification, the + operator definition takes only the right operand parameter, because the rest of the class description is the left operand parameter.

In the above code, only the operator+() function definition, is concerned with the + overloading. The rest of the code for the class is normal coding. Inside this definition, the two string literals are concatenated into the array, newStr[]. After that, a new string object is actually created (instantiated), using an argument, newStr[]. At the end of the operator+() function definition, the newly created object, having the concatenated string, is returned.

In the main() function, the addition is done by the statement:

Where str1, str2 and str3 are string objects that have already been created in main(). The expression, “str1 + str2” with its +, calls the operator+() member function in the str1 object. The operator+() member function in the str1 object uses str2 as its argument and returns the new object with (developed) the concatenated string. The assignment operator (=) of the complete statement, replaces the content (values of variables) of the str3 object, with those of the returned object. In the main() function, after addition, the value of the data member str3.val is no longer "one"; it is the concatenated (addition) string, "I hate you! But she loves you!". The operator+() member function in the str1 object, uses its own object's string literal, and the string literal of its argument, str2 to come up with a joined string literal.

Iterator Operator Overloading

When dealing with the iterator, at least two objects are involved: a linked-list and the iterator itself. In fact, at least two classes are involved: a class from which a linked-list is instantiated, and a class from which an iterator is instantiated.

Linked-list

A diagram for a doubly linked-list object is:

This list has three elements, but there can be more. The three elements here are elements of integers. The first one has the value, 14; the next one has the value, 88; and the last one has the value, 47. Each element here consists of three consecutive locations.

This is unlike the array, where each element is one location, and all the array elements are in consecutive locations. Here, the different elements are in different places in the memory series, but each element consists of three consecutive locations.

For each element, the middle location holds the value. The right location has the pointer to the next element. The left location has the pointer to the previous element. For the last element, the right location points to a theoretical end of the list. For the first element, the left location points to a theoretical start of the list.

With the array, the increment operator (++), increments the pointer to point to the physically next location. With the list, the elements are not in consecutive regions in memory. So, the increment operator can be overloaded, move the iterator (pointer) from one element to the logically next element. The same projection applies to the decrement operator (–).

A forward iterator is an iterator that when engaged, points to the next element. A reverse iterator is an iterator, that when engaged, points to the previous element.

Overloading ++ ad —

Overloading of these operators is done in the class description (definition) of the iterator.

The syntax for the prototype of the increment operator overloading, prefix, is

The syntax for the prototype of the increment operator overloading, postfix, is

The syntax for the prototype of the decrement operator overloading, prefix, is

The syntax for the prototype of the increment operator overloading, postfix, is

Conclusion

Overloading means giving a different meaning to a function or an operator. Functions are overloaded in the same scope. What differentiates overloaded functions are the number and/or types of parameters in their parameter lists. In some cases, where the number of the parameters is the same, but with different types, the compiler rejects the overloading – see later. Many ordinary operators can be overloaded in classes from which objects are instantiated. This is done by giving a return type, parameter list, and body, to the special function named, operator, in the class description.

CV stands for Constant-Volatile. The declaration of an object that is not preceded by const and/or volatile is a cv-unqualified type. On the other hand, the declaration of an object that is preceded by const and/or volatile is a cv-qualified type. If an object is declared const, the value in its location cannot be changed. A volatile variable is a variable whose value is under the influence of the programmer, and hence cannot be changed by the compiler.Storage Class Specifiers refer to the life, place, and way in which a type exists. Storage class specifiers are static, mutable, thread_local, and extern.

This article explains C++ Qualifiers and Storage Class Specifiers. Thus, some preliminary knowledge in C++ comes in handy to really appreciate the article.

Article Content:

• Qualifiers
• Storage Class Specifiers
• Conclusion

Qualifiers:

const

An object declared constant is an object the storage (location) of whose value cannot be changed. For example, in the statement:

The value of 5 in the storage for theInt cannot be changed.

volatile

Consider the following statement:

Compilers sometimes interfere with the value of a variable with the hope of optimizing the program. The compiler may maintain the value of a variable as constant when it is not supposed to be constant. Object values that have to do with memory-mapped IO ports, or Interrupt Service Routines of peripheral devices, can be interfered with by the compiler. To prevent such interference, make the variable volatile, like:

Combining const and volatile:

const and volatile may occur in one statement as follows:

cv-qualifiers

A variable preceded with const and/or volatile is a cv-qualified type. A variable not preceded with either const or volatile or both is a cv-unqualified type.

Ordering:

One type can be more cv-qualified than another:

• No cv-qualifier is less than a const qualifier
• No cv-qualifier is also less than a volatile qualifier
• No cv-qualifier is less than a const-volatile qualifier
• const qualifier is less than a const-volatile qualifier
• volatile qualifier is less than a const-volatile qualifier

It has not yet been concluded if const and volatile are of the same rank.

Array and Instantiated Object:

When an array is declared constant, as in the following statement, it means that the value of each element of the array cannot be changed:

Whether it’s an ‘a’, ‘b’, ‘c’, or ‘d’, it still can’t be changed to some other value (character).

A similar situation is applies to an instantiated object of a class. Consider the following program:

Due to the statement “const Cla obj;” with const in the main() function, neither ‘a’ nor ‘b’ nor ‘c’ nor ‘d’ can be changed to some other value.

Storage Class Specifiers:

Storage class specifiers are static, mutable, thread_local, and extern.

The static Storage Class Specifier

The static storage class specifier allows the variable to live after its scope has gone through, but it cannot be accessed directly.

The following program illustrates this, with a recursive function:

The output is:

If a static variable is not initialized at its first declaration, it assumes the default value for its type.

The static specifier can also be used with members of a class; the use here is different. Here, it allows the member to be accessed without instantiation for the object.

The following program illustrates this for a data member:

The output is:

The static data member has to be constant. Note that the use of the scope resolution operator to access the static variable outside its scope (in the main function).

The following program illustrates the use of “static” for a member function:

The output is:

Of static member function!

Note that the use of the scope resolution operator to access the static member function outside its scope (in the main function).

The mutable Specifier

Remember, from above, that if an instantiated object begins with const, the value of any of its normal data members cannot be changed. And for any such data member to be changed, it has to be declared, mutable.

The following program illustrates this:

The output is:

The thread_local Specifier

In the normal running of a program, one code segment is executed, then the next code segment, followed by another code segment after that, and so on. That is one thread; the main thread. If two code segments execute at the same time (same duration), then a second thread is needed. The result of the second thread may even be ready before the main thread.

The main() function is like the main thread. A program may have more than two threads for such an asynchronous behavior.

The second thread needs a scope (block scope) in order to operate. This is typically provided by the function scope, a function. A variable in an outer scope that can be seen in the scope of the second thread.

The following short program illustrates the use of the thread_local specifier:

The output is:

The variable, inter, preceded by thread_local, means that inter has a separate instance in each thread. And that it can be modified in different threads to have different values. In this program, it is assigned the value, 1 in the main thread, and modified to the value, 2 in the second thread.

A thread needs a special object in order to operate. For this program, the library included by “#include <thread>” has a class called a thread, from which the object thr has been instantiated. The constructor for this object takes a reference to the thread function as an argument. The name of the thread function in this program is thread_function().

The join() member function for the special object, at its position employed, makes the main thread wait for the second thread to finish executing before it continues to execute, otherwise, the main() function may exit without the (second) thread having yielded its result.

The extern Specifier

In simple terms, for a declaration, memory is not allocated for the variable or function, while for a definition, memory is allocated. The extern reserved word allows a global variable or function to be declared in one file but defined in another. Such files are called translation units for the complete C++ application.

Type the following program and save it with the file-name, mainFile:

The variable, myInt, the constant variable, ch, and the function, myFn(), have been declared without being defined.

Type the following program with the definitions, and save it with the file-name, otherFile, in the same directory:

Try to compile the application at the terminal (DOS command prompt) with the following command, and notice that it may not compile:

Now, precede the three declarations in mainFile with the word “extern”, as follows:

Re-save mainFile. Compile the application with:

(This is how separate files for the same application are compiled in C++)

And it should compile. Now, run the application, complete.exe, and the output should be:

Note that with the use of “extern”, a constant variable can be declared in one file but defined in another. When dealing with function declaration and definition in different files, the use of extern is optional.

When to use extern? Use it when you do not have header files with global declarations.

“extern” is also used with template declarations – see later.

Conclusion:

A variable preceded with const and/or volatile is a cv-qualified type. A variable, not preceded with either const or volatile or both, is a cv-unqualified type.

Storage class specifiers are static, mutable, thread_local, and extern. These affect the life span (duration), place, and way of employment of variables in an application.

Syntax Errors

A wrongly typed expression, statement, or construction is a syntax error.

Consider the following two statements:

They are definitions of the same array. The first one is correct. The second one is missing [], and that is a syntax error. A program with a syntax error does not succeed to compile. The compilation fails with an error message indicating the syntax error. Good thing is that a syntax error can always be fixed if the programmer knows what he is doing.

Logic Error

A logic error is an error committed by the programmer when some wrong logical coding is made. It may be the result of ignorance from the programmer to the programming language features or a misunderstanding of what the program should do.

In this situation, the program is compiled successfully. The program works fine, but it produces wrong results. Such an error may be because of making a loop iterate 5 times when it is made to iterate 10 times. It may also be that a loop is unconsciously made to iterate infinitely. The only way to solve this kind of error is to do careful programming and test the program thoroughly before handing it over to the customer.

Runtime Errors

Wrong or exceptional inputs cause runtime errors. In this case, the program was compiled successfully and works well in many situations. In certain situations, the program crashes (and stops).

Imagine that in a program code segment, 8 has to be divided by a number of denominators. So if the numerator 8 is divided by the denominator 4, the answer (quotient) would be 2. However, if the user inputs 0 as the denominator, the program would crash. Division by 0 is not allowed in Mathematics, and it is also not allowed in computing. Division-by-zero should be prevented in programming. Exception handling handles runtime errors, like division-by-zero. The following program shows how to handle the division-by-zero problem without using the exception feature in C++:

The output is 4. If the denominator was 0, the output would have been:

“Division by zero is not permitted!”

The main code here is an if-else construct. If the denominator is not 0, the division will take place; if it is 0, the division will not take place. An error message will be sent to the user, and the program continues to run without crashing. Runtime errors are usually handled by avoiding the execution of a code segment and sending an error message to the user.

The exception feature in C++ uses a try-block for the if-block and a catch-block for the else-block to handle the error, just as follows:

Note that the try header does not have an argument. Also note that the catch-block, which is like a function definition, has a parameter. The type of parameter must be the same as the operand (argument) of the throw-expression. The throw-expression is in the try-block. It throws an argument of the programmer’s choice that is related to the error, and the catch-block catches it. In that way, the code in the try-block is not executed. Then, the catch-block displays the error message.

This article explains exception handling in C++. Basic knowledge in C++ is a prerequisite for the reader to understand this article.

Article Content:

• Function Throwing an Exception
• More than One Catch-Blocks for One Try-block
• Nested try/catch Blocks
• noexcept-specifier
• The Special std::terminate() Function
• Conclusion

Function Throwing an Exception:

A function can also throw an exception just like what the try-block does. The throwing takes place within the definition of the function. The following program illustrates this:

Notice that this time, the try block has just the function call. It is the function called that has the throw operation. The catch block catches the exception, and the output is:

“Person's name cannot begin in lowercase!”

This time, the type thrown and caught is a char.

More than One Catch-Blocks for One Try-block:

There can be more than one catch-block for one try-block. Imagine the situation where an input can be any of the characters of the keyboard, but not a digit and not an alphabet. In this case, there must be two catch-blocks: one for an integer to check the digit and one for a char to check the alphabet. The following code illustrates this:

There is no output. If the value of input were a digit, e.g., ‘1’, the output would have been:

"Digit input is forbidden!"

If the value of input were an alphabet, e.g., ‘a’, the output would have been:

"Character input is forbidden!"

Note that in the parameter list of the two catch-blocks, there is no identifier name. Also note that in the definition of the two catch-blocks, the particular arguments thrown have not been verified whether their values are exact or not.

What matters for a catch is the type; a catch must match the type of operand thrown. The particular value of the argument (operand) thrown can be used for further verification if needed.

More than one Handler for the Same Type

It is possible to have two handlers of the same type. When an exception is thrown, control is transferred to the nearest handler with a matching type. The following program illustrates this:

The output is:

Nested try/catch Blocks:

try/catch blocks can be nested. The above program for the input of non-alphanumeric characters from the keyboard is repeated here, but with the alphabetic error code nested:

The error alphabetic try/catch-block is nested in the try-block of the digit code. The operation of this program and the previous operation from which it is copied are the same.

noexcept-specifier

Consider the following function:

Notice the specifier ‘noexcept’ just after the right parenthesis of the function parameter list. This means that the function should not throw an exception. If the function throws an exception, as in this case, it will compile with a warning message but will not run. An attempt to run the program will call the special function std::terminate(), which should halt the program gracefully instead of just allowing it to literally crash.

The noexcept specifier is in different forms. These are as follows:

true or false in the parentheses can be replaced by an expression that results in true or false.

The Special std::terminate() Function:

If an exception cannot be handled, it should be re-thrown. In this case, the thrown expression may or may not have an operand. The special function std::terminate() will be called at runtime, which should halt the program gracefully instead of just allowing it to literally crash.

Type, compile, and run the following program:

After a successful compilation, the program terminated without running, and the error message from the author’s computer is:

“terminate called after throwing an instance of ‘int’

Aborted (core dumped)”

Conclusion:

The exception feature in C++ prevents a code segment from executing based on some kind of input. The program continues to execute as necessary. The exception (error prevention) construct consists of a try-block and a catch-block. The try-block has the code segment of interest, which may be bypassed, depending on some input condition. The try-block has the throw expression, which throws an operand. This operand is also called the exception. If the operand type and the type for the parameter of the catch block are the same, then the exception is caught (handled). If the exception is not caught, the program will be terminated, but still, be safe since the code segment that was to be executed to give the wrong result has not been executed. Typical exception handling means bypassing the code segment and sending an error message to the user. The code segment is executed for normal input but bypassed for wrong inputs.

The word access means to read or change the value of a variable, and it also means to use a function. C++ access specifiers are the words, “private,” “protected,” and “public.” They decide whether a member can access other members of its class, or if a function or operator outside the class and not belonging to the class can access any member of the class. They also decide whether a member of a derived (child) class can access a member of a parent class.

Basic knowledge of C++ is required to understand this article and to test the code provided.

Article Content

• The Public and Private Specifiers
• The Protected Specifier
• Derived Class Specifiers and Member Specifiers
• Conclusion

The Public and Private Specifiers

Class
Any member of a class can access any other member of that same class, independent of which is labeled “public” or “private.” Consider the following program:

The output is 10. The private members are num1 and num2. The public members are TheCla() and  method(). Note that TheCla() is the constructor function that initializes variables of interest. The region of an access specifier begins from its label to the end of the class description (definition) or to the start of another access specifier.

In the main() function, the first statement is the instantiation involving the constructor function, which initializes num1 and num2. The next statement calls the public member, method(), of the class.

Now, in the class description (definition), the public member function, TheCla(), accesses the private members, num1 and num2. Also, the public member function, method(), accesses the private member,  num1. Any member within a class description can access any other member within the same class description; it does not matter which member is private or public.

However, a function or operator not declared in the class description and outside the class description can access only public members of the class. The main() function, for example, is a function declared outside the class description. It has been able to access only the method() and the TheCla() public members. Inside the main() function, the TheCla() function is obj(10, 20).

An outside function or outside operator, such as the main() function, cannot access any of the private members of the class, such as num1 or num2. Remove the comment indicator, //, from the last-but-one statement in main(). If you attempt to compile the program, note that the program will not compile, giving an error message.

Default Specifier
The default specifier for a class is “private.” So, the above class description is the same as the following description, private, but without the specifier:

Note: the access specifier label begins with the specifier, and is then followed by a colon.

The Protected Specifier

Within a class description, and from an outside function or outside operator, the protected specifier is the same as the private specifier. Now, replace the private specifier in the above program with the specifier, protect, and remove the comment indicator, //, from the last-but-one statement in the main() function. If you attempt to compile the program, note that the program will not compile, giving an error message.

The issue of the protected specifier comes up when members of the derived (inherited) class must access members of the base (parent) class.

Public Derived Class with Public Members
Consider the following program:

In the base class, num1 is public, num2 is protected, and num3 is private. In the derived class, all the member functions are public. The first function, method1(), accesses the public data member, num1. The second function, method2(), accesses the protected data member, num2. The third function, method3(), though currently commented out, should access the private data member, num3.

A derived class is not declared without an access specifier (public, protected, or private). Above, the derived class is declared with the public specifier, that is:

Now un-comment the third member function definition in the derived class. If you attempt to compile the program, note that it will not compile, giving an error message.

Note: When the whole derived class is declared public, its members cannot access the private members of the base class. Its members can, however, access the public and protected members of the base class. The above program illustrates this.

However, note that a public member of the public derived class can access a protected member of the base class.

Derived Class Specifiers and Member Specifiers

Protected Derived Class with Public Members
Replace the “public” specifier with “protected” in the declaration of the derived class above, as follows:

Compile and run the program and note that the result is the same as before.

So, when the whole derived class is declared protected, its members cannot access the private members of the base class. Its members can, however, access the public and protected members of the base class. This is the same as when the derived class is declared public.

Note: a protected member of the public derived class can access a protected member of the base class.

Private Derived Class with Public Members
Replace the “protected” specifier with “private” in the declaration of the derived class above, as follows:

Compile and run the program and note that the result is the same as before.

So, when the whole derived class is declared private, its members cannot access the private members of the base class. Its members can, however, access the public and protected members of the base class. This is the same as when the derived class is declared protected or public.

Public Derived Class with Protected Members
Type, compile, and run the following program, in which the whole derived class is protected, and its members are also protected. Some code segments are as follows:

The program works as it is. There is no output, and there is not supposed to be any output, based on how the program has been typed.

Now, un-comment the function definition, method3(), in the derived class. If you attempt to compile the program, note that it will not compile, giving an error message. This means that a private member cannot be accessed from an outside function, outside operator, or derived class. This is the same conclusion as was concluded above, concerning access to a private member.

Note: a protected member of the protected derived class can access a protected member of the base class.

Now, put the comments back in the derived class and un-comment the first code segment in the main() function. If you attempt to compile the program, note that the program will not compile because of the first code segment in the main() function. This effect is not new. Apart from the derived class, outside functions, and outside operators, the protected and private members of a (base or derived) class are of the same specifier, private. The main() function sees the protected member of any class, whether base or derived, as of the same specifier, private, and is forbidden from accessing it.

If the second code segment of the main() function is un-commented, the same explanation will apply. That is, the main() function will not be able to access a protected or private member of the derived class or of the base class. This is independent of whether a protected member of the derived class could access a protected member of the base class.

Protected Derived Class with Protected Members
Replace the “public” specifier with “protected” in the declaration of the derived class above, as follows:

Put the comment of the code segments back into the main() function, if this has not already been done. Compile and run the program and note that the result is as before.

Private Derived Class with Protected Members
Replace the “protected” specifier with “private” in the declaration of the derived class above, as follows:

Compile and run the program and note that the result will be as before.

Public Derived Class with Private Members
Replace the “private” specifier with “public” in the declaration of the derived class above, as follows:

Make the members of the derived class private. Compile and run the program. The result is not different from the “Public Derived Class with Protected Members” case.

Protected Derived Class with Private Members
Replace the “public” specifier with “protected” in the declaration of the derived class above, as follows:

Compile and run the program. This result is no different from the “Protected Derived Class with Protected Members” case.

Private Derived Class with Private Members
Replace the “protected” specifier with “private” in the declaration of the derived class above, as follows:

Compile and run the program. This result is no different from the “Private Derived Class with Protected Members” case.

Conclusion

C++ access specifiers are the words “private,” “protected,” and “public.” They decide access for members of a class. The region of an access specifier begins from its label, to the end of the class description (definition), or to the start of another access specifier. Any member of a class can access any other member of that same class. A private member of a class cannot be accessed by any outside function, any outside operator, or a derived class.

The member of the base class must be made protected so that a private member of the base class can be accessed by a member of the derived class. This protected member of the base class is seen as a private member of the base class by an outside function or an outside operator.

A public member of a class can be accessed by any outside function, any outside operator, or a derived class.

In the absence of any access specifier in a class, the private specifier is assumed. That is, the default access specifier is private.

References Used in This Work

• Alireza Ebrahimi, INHERITANCE: REUSABILITY AND EXTENDABILITY
• S. Malik, Data Structures Using C++ 2nd Edition

In order to use the C++ priority_queue, the program should begin with code like:

It includes the queue library into the program.

In order to continue reading, the reader should have had a basic knowledge of C++.

Article Content

• Introduction – see above
• Basic Construction
• Important Member Functions
• Other Priority Queue Functions
• String Data
• Other Priority Queue Constructions
• Conclusion

Basic Construction

The data structure has to be constructed first before it can be used. Construction here means instantiating an object from the queue class of the library. The queue object must then have a name given to it by the programmer. The simplest syntax to create a priority queue is:

With this syntax, the greatest value is removed first. An example of the instantiation is:

or

The vector and the deque are two data structures in C++. A priority_queue can be created with either of them. The syntax to create a priority queue from the vector structure is:

An example of this instantiation is:

Notice the gap between > and > at the end of the declaration. This is to prevent confusion with >>. The default compare code is “less<int>”, meaning the greatest, and not necessarily the first value, would be removed first. So, the creation statement can simply be written as:

If the least value is to be removed first, then the statement has to be:

Important Member Functions

The push() Function
This function pushes a value, which is its argument, into the priority_queue. It returns void. The following code illustrates this:

This priority_queue has received 5 integer values in the order of 10, 30, 20, 50, 40. If all these elements are to be popped out of the priority queue, then they will come out in the order of 50, 40, 30, 20, 10.

The pop() Function
This function removes from the priority_queue the value with the highest priority. If the compare code is “greater<int>”, then it will remove the element with the smallest value. If called again, it removes the next element with the smallest value of the rest; called again, it removes the next smallest value present, and so on. It returns void. The following code illustrates this:

Note that in order to call a member function, the name of the object has to be followed by a dot, and then the function.

The top() Function
The pop() function removes the next value of highest priority, but does not return it, as pop() is a void function. Use the top() function in order to know the value of highest priority that has to be removed next. The top() function returns a copy of the value of highest priority in the priority_queue. The following code, where the next value of highest priority is the least value, illustrates this

The output is ‘a’ ‘b’ ‘c’ ‘d’ ‘e’.

The empty() Function
If a programmer uses the top() function on an empty priority_queue, after the successful compilation, he would receive an error message such as:

So, always check if the priority queue is not empty before using the top() function. The empty() member function returns a bool, true, if the queue is empty, and false if the queue is not empty. The following code illustrates this:

Other Priority Queue Functions

The size() Function
This function returns the length of the priority queue, as the following code illustrates:

The output is 5.

The swap() Function
If two priority_queues are of the same type and size, then they can be swapped by this function, as the following code shows:

The output is:

 5  4  3  2  1
 50  40  30  20  10

The emplace() Fuction
The emplace() function is similar to the push function. The following code illustrates this:

The output is:

50 40 30 20 10

String Data

When comparing strings, the string class should be used and not the direct use of the string literals because it would compare pointers and not the actual strings. The following code shows how the string class is used:

The output is:

 text book  ruler  pencil  pen  exercise book

Other Priority Queue Constructions

Explicit Creation from a Vector
A priority queue can be created explicitly from a vector as the following code shows:

The output is: 50 40 30 20 10. This time, the vector header also has to be included. The arguments for the constructor function take the start and end pointers of the vector. The data type for the vector and the data type for the priority_queue must be the same.

In order to make the least value the priority, the declaration for the constructor would be:

Explicit Creation from an Array
A priority queue can be created explicitly from an array as the following code shows:

The output is: 50 40 30 20 10. The arguments for the constructor function take the start and end pointers of the array. arr returns the start pointer, “arr+5” returns the pointer just past the array, and 5 is the size of the array. The data type for the array and the data type for the priority_queue must be the same.

In order to make the least value the priority, the declaration for the constructor would be:

Note: In C++, the priority_queue is actually called an adaptor, not just a container.

Custom Compare Code

Having all values in the priority queue ascending or all descending is not the only option for the priority queue. For example, a list of 11 integers for a maximum heap is:

88, 86, 87, 84, 82, 79,74, 80, 81, , , 64, 69

The highest value is 88. This is followed by two numbers: 86 and 87, which are less than 88. The rest of the numbers are less than these three numbers, but not really in order. There are two empty cells in the list. The numbers 84 and 82 are less than 86. The numbers 79 and 74 are less than 87. The numbers 80 and 81 are less than 84. The numbers 64 and 69 are less than 79.

The placement of the numbers follow the max-heap criteria – see later. In order to provide such a scheme for the priority_queue, the programmer has to provide his own compare code – see later.

Conclusion

A C++ priority_queue is a first-in-first-out queue. The member function, push(), adds a new value into the queue. The member function, top(), reads the top value in the queue. The member function, pop(), removes without returning the top value of the queue. The member function, empty(), checks if the queue is empty. However, the priority_queue differs from the queue, in that, it follows some priority algorithm. It can be greatest, from first to last, or least, from first to last. The criteria (algorithm) can also be programmer-defined. ]]> https://linuxhint.com/callback-function-in-c/ Tue, 19 Jan 2021 19:06:41 +0000 https://linuxhint.com/?p=86494

A callback function is a function, which is an argument, not a parameter, in another function. The other function can be called the principal function. So two functions are involved: the principal function and the callback function itself. In the parameter list of the principal function, the declaration of the callback function without its definition is present, just as object declarations without assignment are present. The principal function is called with arguments (in main()). One of the arguments in the principal function call is the effective definition of the callback function. In C++, this argument is a reference to the definition of the callback function; it is not the actual definition. The callback function itself is actually called within the definition of the principal function.

The basic callback function in C++ does not guarantee asynchronous behavior in a program.  Asynchronous behavior is the real benefit of the callback function scheme. In the asynchronous callback function scheme, the result of the principal function should be obtained for the program before the result of the callback function is obtained. It is possible to do this in C++; however, C++ has a library called future to guarantee the behavior of the asynchronous callback function scheme.

This article explains the basic callback function scheme. A lot of it is with pure C++. As far as the callback is concerned, the basic behavior of the future library is also explained. Basic knowledge of C++ and its pointers is necessary for the understanding of this article.

Article Content

• Basic Callback Function Scheme
• Synchronous Behavior with Callback Function
• Asynchronous Behavior with Callback Function
• Basic use of the future Library
• Conclusion

Basic Callback Function Scheme

A callback function scheme needs a principal function, and the callback function itself. The declaration of the callback function is part of the parameter list of the principal function. The definition of the callback function is indicated in the function call of the principal function. The callback function is actually called within the definition of the principal function. The following program illustrates this:

The output is:

The principal function is identified by principalFn(). The callback function is identified by cb(). The callback function is defined outside the principal function but actually called within the principal function.

Note the declaration of the callback function as a parameter in the parameter list of the principal function declaration. The declaration of the callback function is “int (*ptr)(int)”. Note the callback function expression, like a function call, in the definition of the principal function; any argument for the callback function call is passed there. The statement for this function call is:

Where id2 is an argument. ptr is part of the parameter, a pointer, that will be linked to the reference of the callback function in the main() function.

Note the expression:

In the main() function, which links the declaration (without definition) of the callback function to the name of the definition of the same callback function.

The principal function is called, in the main() function, as:

Where cha is a string and cb is the name of the callback function without any of its argument.

Synchronous Behavior of Callback Function

Consider the following program:

The output is:

There is a new function here. All the new function does, is to display the output, “seen”. In the main() function, the principal function is called, then the new function, fn() is called. The output shows that the code for the principal function was executed, then that for the callback function was executed, and finally that for the fn() function was executed. This is synchronous (single-threaded) behavior.

If it were asynchronous behavior, when three code segments are called in order, the first code segment may be executed, followed instead by the execution of the third code segment, before the second code segment is executed.

Well, the function, fn() can be called from within the definition of the principal function, instead of from within the main() function, as follows:

The output is:

This is an imitation of asynchronous behavior. It is not asynchronous behavior. It is still synchronous behavior.

Also, the order of execution of the code segment of the principal function and the code segment of the callback function can be swapped in the definition of the principal function. The following program illustrates this:

The output is now,

This is also an imitation of asynchronous behavior. It is not asynchronous behavior. It is still synchronous behavior. True asynchronous behavior can be obtained as explained in the next section or with the library, future.

Asynchronous Behavior with Callback Function

The pseudo-code for the basic asynchronous callback function scheme is:

Note the positions of the input and output data in the different places of the pseudo-code. The input of the callback function is its output. The parameters of the principal function are the input parameter for the general code and the parameter for the callback function. With this scheme, a third function can be executed (called) in the main() function before the output of the callback function is read (still in the main() function). The following code illustrates this:

The program output is:

In this particular code, the output and input datum happens to be the same datum. The result of the third function call in the main() function has been displayed before the result of the callback function. The callback function executed, finished, and assigned its result (value) to the variable, output, allowing the program to continue without its interference. In the main() function, the output of the callback function was used (read and displayed) when it was needed, leading to asynchronous behavior for the whole scheme.

This is the single-threaded way to obtain callback function asynchronous behavior with pure C++.

Basic use of the future Library

The idea of the asynchronous callback function scheme is that the principal function returns before the callback function returns. This was done indirectly, effectively, in the above code.

Note from the above code that the callback function receives the main input for the code and produces the main output for the code. The C++ library, future, has a function called sync(). The first argument to this function is the callback function reference; the second argument is the input to the callback function. The sync() function returns without waiting for the execution of the callback function to complete but allows the callback function to complete. This provides asynchronous behavior. While the callback function continues to execute, since the sync() function has already returned, the statements below it continue to execute. This is like ideal asynchronous behavior.

The above program has been rewritten below, taking into consideration, the future library and its sync() function:

The sync() function finally stores the output of the callback function into the future object. The expected output can be obtained in the main() function, using the get() member function of the future object.

Conclusion

A callback function is a function, which is an argument, not a parameter, in another function. A callback function scheme needs a principal function, and the callback function itself. The declaration of the callback function is part of the parameter list of the principal function. The definition of the callback function is indicated in the function call of the principal function (in main()). The callback function is actually called within the definition of the principal function.

A callback function scheme is not necessarily asynchronous. To be sure that the callback function scheme is asynchronous, make the main input to the code, the input to the callback function; make the main output of the code, the output of the callback function; store the output of the callback function in a variable or data structure. In the main() function, after calling the principal function, execute other statements of the application. When the output of the callback function is needed, in the main() function, use (read and display) it there and then.

What is Operator?

An operator is a symbol that indicates to the compiler to perform a particular operation. For example, there are various types of operators in C++, such as Arithmetic Operators, Logical Operators, Relational Operators, Assignment Operators, Bitwise Operators, and more.

What is Operator Overloading?

The C++ language allows programmers to give special meanings to operators. This means that you can redefine the operator for user-defined data types in C++. For example, “+” is used to add built-in data types, such as int, float, etc. To add two types of user-defined data, it is necessary to overload the “+” operator.

Syntax for Operator Overloading

C++ provides a special function called “operator” for operator overloading. The following is the syntax for operator overloading:

Here, “operator” is a keyword, and “symbol” is the operator that we want to overload.

Examples

Now that you understand the overall concept of operator overloading, let us go through a couple of working example programs for you to understand this idea more concretely. We will cover the following examples:

1. Example 1: Unary Operator Overloading (1)
2. Example 2: Unary Operator Overloading (2)
3. Example 3: Binary Operator Overloading
4. Example 4: Relational Operator Overloading

Example 1: Unary Operator Overloading (1)

In this example, we will demonstrate how a unary operator can be overloaded in C++. We have defined the class, “Square_Box,” and the public functions, “operator ++ ()” and “operator ++ (int),” to overload both the prefix and the postfix increment operators. In the “main()” function, we have created the object, “mySquare_Box1.” We have then applied the prefix and postfix increment operators to the “mySquare_Box1” object to demonstrate the unary operator overloading.

Example 2: Unary Operator Overloading (2)

This is another example in which we will demonstrate how a unary operator can be overloaded in C++. We have defined the class, “Square_Box,” and the public functions, “operator — ()” and “operator — (int),” to overload both the prefix and postfix decrement operators. In the “main()” function, we have created the “mySquare_Box1” object. We have then applied the prefix and postfix decrement operators to the “mySquare_Box1” object.