Uniform initialization is a feature in C++ 11 that allows the usage of a consistent syntax to initialize variables and objects ranging from primitive type to aggregates. In other words, it introduces brace-initialization that uses braces ({}) to enclose initializer values. The syntax is as follows:
type var_name{arg1, arg2, ....arg n}
Following are some of the examples of the different ways of initializing different types:
// uninitialized built-in type int i; // initialized built-in type int j=10; // initialized built-in type int k(10); // Aggregate initialization int a[]={1, 2, 3, 4} // default constructor X x1; // Parametrized constructor X x2(1); // Parametrized constructor with single argument X x3=3; // copy-constructor X x4=x3;
If initialized using brace initialization, the above code can be re-written as:
int i{}; // initialized built-in type, equals to int i{0}; int j{10}; // initialized built-in type int a[]{1, 2, 3, 4} // Aggregate initialization X x1{}; // default constructor X x2{1}; // Parametrized constructor; X x4{x3}; // copy-constructor
Applications of Uniform Initialization
Initialization of dynamically allocated arrays:
CPP
// C++ program to demonstrate initialization // of dynamic array in C++ using uniform initialization #include <bits/stdc++.h> using namespace std; int main() { // declaring a dynamic array // and initializing using braces int * pi = new int [5]{ 1, 2, 3, 4, 5 }; // printing the contents of the array for ( int i = 0; i < 5; i++) cout << *(pi + i) << " " ; } |
1 2 3 4 5
Initialization of an array data member of a class:
CPP
// C++ program to initialize // an array data member of a class // with uniform initialization #include <iostream> using namespace std; class A { int arr[3]; public : // initializing array using // uniform initialization A( int x, int y, int z) : arr{ x, y, z } {}; void show() { // printing the contents of the array for ( int i = 0; i < 3; i++) cout << *(arr + i) << " " ; } }; // Driver Code int main() { // New object created and the numbers // to initialize the array with, are passed // into it as arguments A a(1, 2, 3); a.show(); return 0; } |
1 2 3
Implicitly initialize objects to return:
CPP
// C++ program to implicitly // initialize an object to return #include <iostream> using namespace std; // declaring a class 'A' class A { // a and b are data members int a; int b; // constructor public : A( int x, int y) : a(x) , b(y) { } void show() { cout << a << " " << b; } }; A f( int a, int b) { // The compiler automatically // deduces that the constructor // of the class A needs to be called // and the function parameters of f are // needed to be passed here return { a, b }; } // Driver Code int main() { A x = f(1, 2); x.show(); return 0; } |
1 2
Implicitly initialize function parameter
CPP
// C++ program to demonstrate how to // initialize a function parameter // using Uniform Initialization #include <iostream> using namespace std; // declaring a class 'A' class A { // a and b are data members int a; int b; public : A( int x, int y) : a(x) , b(y) { } void show() { cout << a << " " << b; } }; void f(A x) { x.show(); } // Driver Code int main() { // calling function and initializing it's argument // using brace initialization f({ 1, 2 }); return 0; } |
1 2
Attention reader! Don’t stop learning now. Get hold of all the important C++ Foundation and STL concepts with the C++ Foundation and STL courses at a student-friendly price and become industry ready.