admin, Author at SimpleTechTalks

std::move explained with simple example

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:

From C++11 onwards:

template< class T >
typename std::remove_reference<T>::type&& move( T&& t );

From C++14 onwards:

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…)

Move Constructors explained with simple example

by admin

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.

(more…)

Rvalue References

by admin

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.

(more…)

Introduction to C++11

by admin

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.

Why C++11 ?

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.

Aims of C++11

Compatibility and Stability MUST be maintained for old code written in C++98,C++03 and in C.
Extension of core language preferably be done via standard library.
System and library design method is preferred compared to introducing new features which is useful only for specific applications.
Focus to improve type safety by providing safer methods to earlier unsafe methods.
Improve performance and better interaction with hardware to ensure better,safe and high performance embedded system programming.
Make C++ easier to teach and learn through increased uniformity, stronger guarantees, and facilities better libraries for beginners. Expert programmers can use other efficient features.

(more…)

Command Design Pattern Explained With Simple Example: Behavioural Design Pattern Category

by admin

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

(more…)

Flyweight Design Pattern Explained With Simple Example: Structural Design Pattern Category

by admin

The flyweight design pattern allows to greatly reduce memory footprint of any product by dividing an object into basically two parts. If multiple objects have some internal part as common then all these objects can share these memory to reduce memory consumption. The other part which varies from object to object will still be part of final object. The common part of various object is stored and shared via a “Flyweight” object. For Design patterns basic explanation see (Design Patterns Simplified Version).

(more…)

Decorator Design Pattern Explained With Simple Example: Structural Design Pattern Category

by admin

The Decorator design pattern allows behavior addition to an object either statically or dynamically without affecting the core behavior of other objects from the same class. This design pattern allows us to change the behavior of any specific object which is achieved by a wrapper class to the original class known as Decorator class. The original class is divided into two parts, one is with the essential basic features of the original class while the other one is the decorator base class which implements the same interface as the original class but allows to create several concrete decorator class having their own additional methods. For Design patterns basic explanation see (Design Patterns Simplified Version)

(more…)

Singleton Design Pattern Explained With Simple Example: Creational Design Pattern Category

by admin

The singleton design pattern ensures that at any point of time a class has one and only one instance which can be accessed globally. This design pattern is useful in cases where exactly one instance is needed to co-ordinate between different modules of a software. Singleton design pattern can be used as a logger class or memory/thread pool classes for which only one instance of object is needed. For Design patterns basic explanation see (Design Patterns Simplified Version)

(more…)

Prototype Design Pattern Explained With Simple Example: Creational Design Pattern Category

by admin

The Prototype design pattern is used when the objects which needs to be created is of similar types and can be cloned to produce new objects. The main aim of this pattern is to minimize the required cost of creating new object. This design pattern declares an abstract base class which exposes pure virtual clone() member function which is called by the client to get the required object instead of calling “new”. The idea behind this design pattern is to create first object of all prototype classes by the usual method and then for other objects use clone method which will create the new objects by copying the prototype objects. For Design patterns basic explanation see (Design Patterns Simplified Version)

(more…)

Abstract Factory Design Pattern Explained With Simple Example: Creational Design Pattern Category

by admin

The Abstract Factory pattern serves encapsulation to a group of individual factories without exposing the concrete classes. In this model, a generic interface of an abstract factory class is used to create the required concrete object separating the details of implementation of objects from their usage and composition. This design pattern is widely used in GUI applications where similar kind of GUI components needs to be created. For Design patterns basic explanation see (Design Patterns Simplified Version)

(more…)