merged with master and added new file

mikeblome · mikeblome · commit 03dca83565a4 · 2019-11-19T12:12:06.000-08:00
diff --git a/docs/cpp/delegating-constructors.md b/docs/cpp/delegating-constructors.md
@@ -0,0 +1,111 @@
+---
+title: "Delegating constructors (C++)"
+description: "Use delegating constructors in C++ to invoke other constructors and reduce code repetition."
+ms.date: "11/19/2019"
+---
+
+# Delegating constructors
+
+Many classes have multiple constructors that do similar things—for example, validate parameters:
+
+```cpp
+class class_c {
+public:
+    int max;
+    int min;
+    int middle;
+
+    class_c() {}
+    class_c(int my_max) {
+        max = my_max > 0 ? my_max : 10;
+    }
+    class_c(int my_max, int my_min) {
+        max = my_max > 0 ? my_max : 10;
+        min = my_min > 0 && my_min < max ? my_min : 1;
+    }
+    class_c(int my_max, int my_min, int my_middle) {
+        max = my_max > 0 ? my_max : 10;
+        min = my_min > 0 && my_min < max ? my_min : 1;
+        middle = my_middle < max && my_middle > min ? my_middle : 5;
+    }
+};
+```
+
+You could reduce the repetitive code by adding a function that does all of the validation, but the code for `class_c` would be easier to understand and maintain if one constructor could delegate some of the work to another one. To add delegating constructors, use the `constructor (. . .) : constructor (. . .)` syntax:
+
+```cpp
+class class_c {
+public:
+    int max;
+    int min;
+    int middle;
+
+    class_c(int my_max) {
+        max = my_max > 0 ? my_max : 10;
+    }
+    class_c(int my_max, int my_min) : class_c(my_max) {
+        min = my_min > 0 && my_min < max ? my_min : 1;
+    }
+    class_c(int my_max, int my_min, int my_middle) : class_c (my_max, my_min){
+        middle = my_middle < max && my_middle > min ? my_middle : 5;
+}
+};
+int main() {
+
+    class_c c1{ 1, 3, 2 };
+}
+```
+
+As you step through the previous example, notice that the constructor `class_c(int, int, int)` first calls the constructor `class_c(int, int)`, which in turn calls `class_c(int)`. Each of the constructors performs only the work that is not performed by the other constructors.
+
+The first constructor that's called initializes the object so that all of its members are initialized at that point. You can’t do member initialization in a constructor that delegates to another constructor, as shown here:
+
+```cpp
+class class_a {
+public:
+    class_a() {}
+    // member initialization here, no delegate
+    class_a(string str) : m_string{ str } {}
+
+    //can’t do member initialization here
+    // error C3511: a call to a delegating constructor shall be the only member-initializer
+    class_a(string str, double dbl) : class_a(str) , m_double{ dbl } {}
+
+    // only member assignment
+    class_a(string str, double dbl) : class_a(str) { m_double = dbl; }
+    double m_double{ 1.0 };
+    string m_string;
+};
+```
+
+The next example shows the use of non-static data-member initializers. Notice that if a constructor also initializes a given data member, the member initializer is overridden:
+
+```cpp
+class class_a {
+public:
+    class_a() {}
+    class_a(string str) : m_string{ str } {}
+    class_a(string str, double dbl) : class_a(str) { m_double = dbl; }
+    double m_double{ 1.0 };
+    string m_string{ m_double < 10.0 ? "alpha" : "beta" };
+};
+
+int main() {
+    class_a a{ "hello", 2.0 };  //expect a.m_double == 2.0, a.m_string == "hello"
+    int y = 4;
+}
+```
+
+The constructor delegation syntax doesn't prevent the accidental creation of constructor recursion—Constructor1 calls Constructor2 which calls Constructor1—and no errors are thrown until there is a stack overflow. It's your responsibility to avoid cycles.
+
+```cpp
+class class_f{
+public:
+    int max;
+    int min;
+
+    // don't do this
+    class_f() : class_f(6, 3){ }
+    class_f(int my_max, int my_min) : class_f() { }
+};
+```
