Use uniform initializer where it's reasonable.

Author: tuncatunc

docs/cpp/codesnippet/CPP/how-to-create-and-use-unique-ptr-instances_2.cpp

@@ -1,13 +1,13 @@
 void SongVector()
 {
-    vector<unique_ptr<Song>> songs;
-
     // Create a few new unique_ptr<Song> instances
     // and add them to vector using implicit move semantics.
-    songs.push_back(make_unique<Song>(L"B'z", L"Juice"));
-    songs.push_back(make_unique<Song>(L"Namie Amuro", L"Funky Town"));
-    songs.push_back(make_unique<Song>(L"Kome Kome Club", L"Kimi ga Iru Dake de"));
-    songs.push_back(make_unique<Song>(L"Ayumi Hamasaki", L"Poker Face"));
+    vector<unique_ptr<Song>> songs {
+      make_unique<Song>(L"B'z", L"Juice"),
+      make_unique<Song>(L"Namie Amuro", L"Funky Town"),
+      make_unique<Song>(L"Kome Kome Club", L"Kimi ga Iru Dake de"),
+      make_unique<Song>(L"Ayumi Hamasaki", L"Poker Face")
+    };
 
     // Pass by const reference when possible to avoid copying.
     for (const auto& song : songs)

docs/cpp/codesnippet/CPP/how-to-create-and-use-weak-ptr-instances_1.cpp

@@ -44,13 +44,13 @@ class Controller
 
 void RunTest()
 {
-    vector<shared_ptr<Controller>> v;
-
-    v.push_back(shared_ptr<Controller>(new Controller(0)));
-    v.push_back(shared_ptr<Controller>(new Controller(1)));
-    v.push_back(shared_ptr<Controller>(new Controller(2)));
-    v.push_back(shared_ptr<Controller>(new Controller(3)));
-    v.push_back(shared_ptr<Controller>(new Controller(4)));
+    vector<shared_ptr<Controller>> v {
+      make_shared<Controller>(0),
+      make_shared<Controller>(1),
+      make_shared<Controller>(2),
+      make_shared<Controller>(3),
+      make_shared<Controller>(4),
+    };
 
     // Each controller depends on all others not being deleted. 
     // Give each controller a pointer to all the others. 

docs/parallel/concrt/codesnippet/CPP/how-to-perform-map-and-reduce-operations-in-parallel_1.cpp

@@ -46,24 +46,24 @@ struct ReduceFunc : binary_function<unordered_map<wstring, size_t>,
 int wmain()
 { 
     // File 1 
-    vector<wstring> v1;
-    v1.push_back(L"word1"); //1 
-    v1.push_back(L"word1"); //2 
-    v1.push_back(L"word2"); 
-    v1.push_back(L"word3"); 
-    v1.push_back(L"word4"); 
+    vector<wstring> v1 {
+      L"word1", // 1
+      L"word1", // 1
+      L"word2",
+      L"word3",
+      L"word4"
+    };
 
     // File 2 
-    vector<wstring> v2; 
-    v2.push_back(L"word5"); 
-    v2.push_back(L"word6"); 
-    v2.push_back(L"word7"); 
-    v2.push_back(L"word8"); 
-    v2.push_back(L"word1"); //3 
+    vector<wstring> v2 {
+      L"word5",
+      L"word6",
+      L"word7",
+      L"word8",
+      L"word1" // 3
+    };
 
-    vector<vector<wstring>> v;
-    v.push_back(v1);
-    v.push_back(v2);
+    vector<vector<wstring>> v { v1, v2 };
 
     vector<unordered_map<wstring, size_t>> map(v.size()); 
 

docs/parallel/concrt/codesnippet/CPP/how-to-perform-map-and-reduce-operations-in-parallel_2.cpp

@@ -1,22 +1,22 @@
     // File 1 
-    vector<wstring> v1;
-    v1.push_back(L"word1"); //1 
-    v1.push_back(L"word1"); //2 
-    v1.push_back(L"word2"); 
-    v1.push_back(L"word3"); 
-    v1.push_back(L"word4"); 
+    vector<wstring> v1 {
+      L"word1", // 1
+      L"word1", // 2
+      L"word2",
+      L"word3",
+      L"word4",
+    };
 
     // File 2 
-    vector<wstring> v2; 
-    v2.push_back(L"word5"); 
-    v2.push_back(L"word6"); 
-    v2.push_back(L"word7"); 
-    v2.push_back(L"word8"); 
-    v2.push_back(L"word1"); //3 
+    vector<wstring> v2 {
+      L"word5",
+      L"word6",
+      L"word7",
+      L"word8",
+      L"word1", // 3
+    }; 
 
-    vector<vector<wstring>> v;
-    v.push_back(v1);
-    v.push_back(v2);
+    vector<vector<wstring>> v { v1, v2 };
 
     concurrent_unordered_map<wstring, size_t> result;
     for_each(begin(v), end(v), [&result](const vector<wstring>& words) {

docs/parallel/concrt/codesnippet/CPP/parallel-algorithms_6.cpp

@@ -2,27 +2,27 @@
 // compile with: /EHsc
 #include <ppl.h>
 #include <iostream>
-#include <string> 
+#include <string>
 #include <vector>
 
 using namespace concurrency;
 using namespace std;
 
 int wmain()
 {
-    // Create a vector of strings.
-    vector<wstring> words;
-    words.push_back(L"Lorem ");
-    words.push_back(L"ipsum ");
-    words.push_back(L"dolor ");
-    words.push_back(L"sit ");
-    words.push_back(L"amet, ");
-    words.push_back(L"consectetur ");
-    words.push_back(L"adipiscing ");
-    words.push_back(L"elit.");
-
-    // Reduce the vector to one string in parallel.
-    wcout << parallel_reduce(begin(words), end(words), wstring()) << endl;
+  // Create a vector of strings.
+  vector<wstring> words{
+      L"Lorem ",
+      L"ipsum ",
+      L"dolor ",
+      L"sit ",
+      L"amet, ",
+      L"consectetur ",
+      L"adipiscing ",
+      L"elit."};
+      
+  // Reduce the vector to one string in parallel.
+  wcout << parallel_reduce(begin(words), end(words), wstring()) << endl;
 }
 
 /* Output: