Skip to main content

C++11 - Uniform initialization

C++11 standard provides new form of objects initialization which makes such initialization uniform for different structs and classes and simplify objects construction and initialization process. Thanks to the new process we can initialize many different classes using the same syntax.

Please take a look on the example below: Output of this example is: In point I we are initializing class of two different objects using C++11 uniform initialization mechanism. On object is created based on struct type (pure struct type without any method - look point II). The second one is created based on MyClass class constructor.

As you can see, despite that we are creating objects of two totally different types, those objects can be created the same way (uniform way). This is just uniform unitialization featuere provided in C++11 standard.

Below we are initializating MyStruct object using external function getMyStruct(). You can take a look to the body of that function (point IV). As you can see we are implicitly using uniform initialization form of struct MyStruct inside getMyStruct() function to create object.

However you need to be careful with using uniform initialization for classes having initializer_list constructor. In such case, initializer list constructor has higher priority than uniform initialization and constructor will be used instead of uniform initialization. So be aware of it and enjoy your C++11 programming :)

Code of this article's example you can find on our GitHub account here: https://github.com/xmementoit/CppAdventureExamples/tree/master/cpp11/uniformInitialization

Comments

Popular posts from this blog

GDB Automatic Deadlock Detector

Have you ever had a problem with detection deadlock between threads in your C/C++ application? Would you like to do that automatically? Try this GDB Automatic Deadlock Detector from my github: GDB Automatic Deadlock Detector Picture source: http://csunplugged.org/wp-content/uploads/2015/03/deadlock.jpg1286488735

STL - count and count_if algorithms

One of the basic and most useful STL algorithms is algorithm which can be used to count number of elements within selected container according to specified criteria. In order to do that we can use std::count or std::count_if algorithm. std::count (firstElementIterator, lastElementIterator, elementForSearch) - is function which will go through container using firstElementIterator and lastElementIterator and return number of container elements which value is equal elementForSearch std::count_if (firstElementIterator, lastElementIterator, UnaryPredicateFunction) - is function which examine range from firstElementIterator to lastElementIterator and return number of container elements which fulfill UnaryPredicateFunction criteria. UnaryPredicateFunction is function having following signature: bool functionName(const Type& a) . So, count_if returns number of elements where UnaryPredicateFunction returns true for. For better understanding let's take a

Advanced C++ - Stack unwinding

Stack unwinding is normally a concept of removing function entries from call stack (also known as Execution stack, Control stack, Function stack or Run-time stack). Call Stack is a stack data structure that stores active functions' addresses and helps in supporting function call/return mechanism. Every time when a function is called, an entry is made into Call stack which contains the return address of the calling function where the control needs to return after the execution of called function. This entry is called by various names like stack frame , activation frame or activation record. With respect to exception handling , stack Unwinding is a process of linearly searching function call stack to reach exception handler. When an exception occurs, if it is not handled in current function where it is thrown, the function Call Stack is unwound until the control reaches try block and then passes to catch block at the end of try block to handle exception. Also, in this proc