To make technologies simpler
by A tree is an abstract data type which stores data hierarchically. The top element is known as “Root”. Each node in a tree has a parent node and zero or more children nodes except that Root node which has only children nodes but no parent node.
For eg: a tree can be shown as follows:
by In C++11(Introduction to C++11), constexpr is added which improves the run-time performance of the code as it allows the compiler to compute the associated code at compile time if possible. constexpr specifier can be used with both variables and functions where only constant expressions are used which can be evaluated at compile time.
by In C++11 (Introduction to C++11) , move assignment operator are added which can improve any code’s performance drastically. Typically a move assignment operator is same as copy/move constructor but before reusing the memory blocks from passed object, it releases all the memory which is owned by this object. Since, memory reallocation is avoided in case of move assignment operators. Thus it gives better performance.
However while implementing move assignment operators we need to take care of one important point to ensure that the original object can be correctly destroyed.
Let’s take an example to see how this memory reallocation is avoided in case of move assignment.
by std::move is a C++11(Introduction to C++11) utility function which is used to convert an lvalue to rvalue expression to forcefully call the move constructor or move assignment operator which will improve the program’s performance drastically. This utility function is only change lvalue into rvalue expression that’s it. This function doesn’t do any kind of memory movement.
Implementation of this function is as follows:
template< class T >
typename std::remove_reference<T>::type&& move( T&& t );
template< class T >
constexpr typename std::remove_reference<T>::type&& move( T&& t );
Let’s take an example of usage of this move function:
(more…)by
In C++11 (Introduction to C++11) , move constructors are added which can improve any code’s performance drastically. Typically a move constructor is same as copy constructor which will create a new instance based on the passed object. But, the idea behind move constructor is to avoid memory reallocation and use as many memory from the passed original object because the original object is about to be deleted as it has been provided as a temporary object.
Since, in move constructors we avoid memory reallocation while creating new instance while will improve the code’s performance as we know memory allocation is quite costly.
While implementing move constructors we need to take care of one important point to ensure that the original object can be correctly destroyed.
Let’s take an example to see how this memory reallocation is avoided in case of move constructor.
by
Before understanding about this new feature “Rvalue references” of C++11(Introduction to C++11), we should first understand what is lvalue and rvalue in C++.
Typically Lvalue is an expression which returns a permanent memory address which can be assigned to any variables. For ex:
int x = 10; int y; y = 20;
Here both x and y are lvalues. In some cases, we can have functions also as lvalue as shown in below example:
int x; // global variable
// Returning reference to global variable x
int& getXRef()
{
return x;
}
getXRef() = 30;
Now this function can act as lvalue too as shown above.
by In August 2011, a new C++ version which is known as C++11 is approved by ISO which adds a lot of new set of features to existing C++ programming language. All official documents related to these changes can be found at ISO C++ committee website.
C++11 significantly improved the core C++ language by making several additions to its standard libraries. Major areas where C++11 is improved from its predecessor includes multithreading support, uniform initialization, generic programming support and performance.
by The Command design pattern allows to encapsulate an action or trigger inside an object which will be used later to trigger an event. Since in this design pattern, commands are encapsulated inside objects, hence we can use additional actions on this commands for example- Queuing of various commands, undo/redo actions etc. This design pattern is very useful in case of GUI actions (button, menu actions etc), transactional behaviour, progress bars etc. For Design patterns basic explanation see (Design Patterns Simplified Version).
by The Chain-of-Responsibility design pattern basically consists of a source of command objects and a hierarchical series of processing objects. Every processing unit will process only typical kind of commands and it will pass rest of the command to next processing unit, thus creating a chain of processing units and that’s why the name of this design pattern is Chain-of-Responsibility pattern. This pattern provides the idea of one of the best programming practice which is “loose coupling”. For Design patterns basic explanation see (Design Patterns Simplified Version).
by The Proxy design pattern allows to define a “proxy” class which will act as a wrapper object which will be called by the client to access the product object without exposing the details. This proxy class can also be used to add extra functionality without changing the product behavior. This design pattern can be used in cases to provide additional security access to an existing product or providing an interface for remote resources. For Design patterns basic explanation see (Design Patterns Simplified Version).