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; // Parameterized constructor X x2(1); // Parameterized 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}; // Parameterized constructor; X x4{x3}; // copy-constructor
Applications of Uniform Initialization
Initialization of dynamically allocated arrays:
// 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
Time Complexity: O(1)
Auxiliary Space: O(1)
Initialization of an array data member of a class:
// 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
Time Complexity: O(1)
Auxiliary Space: O(1)
Implicitly initialize objects to return:
// 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
Time Complexity: O(1)
Auxiliary Space: O(1)
Implicitly initialize function parameter
// 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
Time Complexity: O(1)
Auxiliary Space: O(1)