Add special member function, fix links (MicrosoftDocs#110)

Colin Robertson · web-flow · commit aab08b0d79ff · 2016-12-06T22:15:53.000-08:00
* Links and Special Member Functions

* fix typo

* fix typo
diff --git a/docs/c-language/c-language-reference.md b/docs/c-language/c-language-reference.md
@@ -39,18 +39,17 @@ translation.priority.ht:
   - "zh-tw"
 ---
 # C Language Reference
-The *C Language Reference* describes the C programming language as implemented in Microsoft C. The book's organization is based on the ANSI C standard with additional material on the Microsoft extensions to the ANSI C standard.  
+The *C Language Reference* describes the C programming language as implemented in Microsoft C. The book's organization is based on the ANSI C standard (sometimes referred to as C89) with additional material on the Microsoft extensions to the ANSI C standard.  
   
 -   [Organization of the C Language Reference](../c-language/organization-of-the-c-language-reference.md)  
   
- For additional reference material on C++ and the preprocessor, see:  
+For additional reference material on C++ and the preprocessor, see:  
   
 -   [C++ Language Reference](../cpp/cpp-language-reference.md)  
   
 -   [Preprocessor Reference](../preprocessor/c-cpp-preprocessor-reference.md)  
   
- Compiler and linker options are documented in the [C/C++ Building Reference](../build/reference/c-cpp-building-reference.md).  
+Compiler and linker options are documented in the [C/C++ Building Reference](../build/reference/c-cpp-building-reference.md).  
   
 ## See Also  
- [C/C++ Languages](../misc/c-cpp-languages.md)   
- [Visual C++ Libraries Reference](http://msdn.microsoft.com/en-us/fec23c40-10c0-4857-9cdc-33a3b99b30ae)
+[C/C++ Language and Standard Libraries](../cpp/c-cpp-language-and-standard-libraries.md)   
diff --git a/docs/c-language/sizeof-operator-c.md b/docs/c-language/sizeof-operator-c.md
@@ -41,37 +41,37 @@ The `sizeof` operator gives the amount of storage, in bytes, required to store a
 ## Syntax  
   
 ```  
-  
-      sizeof unary-expression  
+sizeof unary-expression  
 sizeof ( type-name )  
 ```  
   
 ## Remarks  
- The operand is either an identifier that is a *unary-expression*, or a type-cast expression (that is, a type specifier enclosed in parentheses). The *unary-expression* cannot represent a bit-field object, an incomplete type, or a function designator. The result is an unsigned integral constant. The standard header STDDEF.H defines this type as **size_t**.  
+The operand is either an identifier that is a *unary-expression*, or a type-cast expression (that is, a type specifier enclosed in parentheses). The *unary-expression* cannot represent a bit-field object, an incomplete type, or a function designator. The result is an unsigned integral constant. The standard header STDDEF.H defines this type as **size_t**.  
   
- When you apply the `sizeof` operator to an array identifier, the result is the size of the entire array rather than the size of the pointer represented by the array identifier.  
+When you apply the `sizeof` operator to an array identifier, the result is the size of the entire array rather than the size of the pointer represented by the array identifier.  
   
- When you apply the `sizeof` operator to a structure or union type name, or to an identifier of structure or union type, the result is the number of bytes in the structure or union, including internal and trailing padding. This size may include internal and trailing padding used to align the members of the structure or union on memory boundaries. Thus, the result may not correspond to the size calculated by adding up the storage requirements of the individual members.  
+When you apply the `sizeof` operator to a structure or union type name, or to an identifier of structure or union type, the result is the number of bytes in the structure or union, including internal and trailing padding. This size may include internal and trailing padding used to align the members of the structure or union on memory boundaries. Thus, the result may not correspond to the size calculated by adding up the storage requirements of the individual members.  
   
- If an unsized array is the last element of a structure, the `sizeof` operator returns the size of the structure without the array.  
+If an unsized array is the last element of a structure, the `sizeof` operator returns the size of the structure without the array.  
   
 ```  
 buffer = calloc(100, sizeof (int) );  
 ```  
   
- This example uses the `sizeof` operator to pass the size of an `int`, which varies among machines, as an argument to a run-time function named `calloc`. The value returned by the function is stored in `buffer`.  
+This example uses the `sizeof` operator to pass the size of an `int`, which varies among machines, as an argument to a run-time function named `calloc`. The value returned by the function is stored in `buffer`.  
   
 ```  
-static char *strings[] ={  
-          "this is string one",  
-          "this is string two",  
-          "this is string three",  
-         };  
+static char *strings[] = {  
+      "this is string one",  
+      "this is string two",  
+      "this is string three",  
+   };  
 const int string_no = ( sizeof strings ) / ( sizeof strings[0] );   
 ```  
   
- In this example, `strings` is an array of pointers to `char`. The number of pointers is the number of elements in the array, but is not specified. It is easy to determine the number of pointers by using the `sizeof` operator to calculate the number of elements in the array. The **const** integer value `string_no` is initialized to this number. Because it is a **const** value, `string_no` cannot be modified.  
+In this example, `strings` is an array of pointers to `char`. The number of pointers is the number of elements in the array, but is not specified. It is easy to determine the number of pointers by using the `sizeof` operator to calculate the number of elements in the array. The **const** integer value `string_no` is initialized to this number. Because it is a **const** value, `string_no` cannot be modified.  
   
 ## See Also  
- [C++ Built-in Operators, Precedence and Associativity](../cpp/cpp-built-in-operators-precedence-and-associativity)
-
+[C Operators](c-operators.md)  
+[C++ Built-in Operators, Precedence and Associativity](../cpp/cpp-built-in-operators-precedence-and-associativity.md)  
+  
diff --git a/docs/c-language/static-storage-class-specifier.md b/docs/c-language/static-storage-class-specifier.md
@@ -39,7 +39,8 @@ translation.priority.ht:
 A variable declared at the internal level with the **static** storage-class specifier has a global lifetime but is visible only within the block in which it is declared. For constant strings, using **static** is useful because it alleviates the overhead of frequent initialization in often-called functions.  
   
 ## Remarks  
- If you do not explicitly initialize a **static** variable, it is initialized to 0 by default. Inside a function, **static** causes storage to be allocated and serves as a definition. Internal static variables provide private, permanent storage visible to only a single function.  
+If you do not explicitly initialize a **static** variable, it is initialized to 0 by default. Inside a function, **static** causes storage to be allocated and serves as a definition. Internal static variables provide private, permanent storage visible to only a single function.  
   
 ## See Also  
- [Static](../misc/static-cpp.md)
+[C Storage Classes](c-storage-classes.md)  
+[Storage classes (C++)](../cpp/storage-classes-cpp.md)  
diff --git a/docs/cpp/TOC.md b/docs/cpp/TOC.md
@@ -199,6 +199,7 @@
 #### [virtual (C++)](virtual-cpp.md)
 #### [__super](super.md)
 #### [__interface](interface.md)
+### [Special Member Functions](special-member-functions.md)
 ### [Static Members (C++)](static-members-cpp.md)
 ### [User-Defined Type Conversions (C++)](user-defined-type-conversions-cpp.md)
 ### [Mutable Data Members (C++)](mutable-data-members-cpp.md)
diff --git a/docs/cpp/aliases-and-typedefs-cpp.md b/docs/cpp/aliases-and-typedefs-cpp.md
@@ -38,7 +38,6 @@ You can use an *alias declaration* to declare a name to use as a synonym for a p
 ## Syntax  
   
 ```  
-  
 using identifier = type;  
 ```  
   
diff --git a/docs/cpp/auto-cpp.md b/docs/cpp/auto-cpp.md
@@ -141,7 +141,6 @@ int main()
 |[C3531](../error-messages/compiler-errors-2/compiler-error-c3531.md)|A symbol that is declared with the `auto` keyword must have an initializer.|  
 |[C3532](../error-messages/compiler-errors-2/compiler-error-c3532.md)|You incorrectly used the `auto` keyword to declare a type. For example, you declared a method return type or an array.|  
 |[C3533](../error-messages/compiler-errors-2/compiler-error-c3533.md), [C3539](../error-messages/compiler-errors-2/compiler-error-c3539.md)|A parameter or template argument cannot be declared with the `auto` keyword.|  
-|[C3534](../error-messages/compiler-errors-2/compiler-error-c3534.md)|A symbol that is declared with the `auto` keyword in a `new` expression must have an initializer. For more information, see [operator new](new-operator-cpp.md).|  
 |[C3535](../error-messages/compiler-errors-2/compiler-error-c3535.md)|A method or template parameter cannot be declared with the `auto` keyword.|  
 |[C3536](../error-messages/compiler-errors-2/compiler-error-c3536.md)|A symbol cannot be used before it is initialized. In practice, this means that a variable cannot be used to initialize itself.|  
 |[C3537](../error-messages/compiler-errors-2/compiler-error-c3537.md)|You cannot cast to a type that is declared with the `auto` keyword.|  
diff --git a/docs/cpp/bitwise-exclusive-or-operator-hat.md b/docs/cpp/bitwise-exclusive-or-operator-hat.md
@@ -46,16 +46,16 @@ expression ^ expression
 ```  
   
 ## Remarks  
- The bitwise exclusive OR operator (**^**) compares each bit of its first operand to the corresponding bit of its second operand. If one bit is 0 and the other bit is 1, the corresponding result bit is set to 1. Otherwise, the corresponding result bit is set to 0.  
+The bitwise exclusive OR operator (**^**) compares each bit of its first operand to the corresponding bit of its second operand. If one bit is 0 and the other bit is 1, the corresponding result bit is set to 1. Otherwise, the corresponding result bit is set to 0.  
   
- Both operands to the bitwise exclusive OR operator must be of integral types. The usual arithmetic conversions covered in [Standard Conversions](standard-conversions.md) are applied to the operands.  
+Both operands to the bitwise exclusive OR operator must be of integral types. The usual arithmetic conversions covered in [Standard Conversions](standard-conversions.md) are applied to the operands.  
   
 ## Operator Keyword for ^  
- The **xor** operator is the text equivalent of **^**. There are two ways to access the **xor** operator in your programs: include the header file `iso646.h`, or compile with the [/Za](../build/reference/za-ze-disable-language-extensions.md) (Disable language extensions) compiler option.  
+The **xor** operator is the text equivalent of **^**. There are two ways to access the **xor** operator in your programs: include the header file `iso646.h`, or compile with the [/Za](../build/reference/za-ze-disable-language-extensions.md) (Disable language extensions) compiler option.  
   
 ## Example  
   
-```  
+```cpp  
 // expre_Bitwise_Exclusive_OR_Operator.cpp  
 // compile with: /EHsc  
 // Demonstrate bitwise exclusive OR  
@@ -70,7 +70,6 @@ int main() {
 ```  
   
 ## See Also  
- [C++ Bitwise Operators](../misc/cpp-bitwise-operators.md)   
  [C++ Built-in Operators, Precedence and Associativity](../cpp/cpp-built-in-operators-precedence-and-associativity.md)   
 
 
diff --git a/docs/cpp/c-cpp-language-and-standard-libraries.md b/docs/cpp/c-cpp-language-and-standard-libraries.md
@@ -1,5 +1,5 @@
 ---
-title: "C-C++ Language and Standard Libraries | Microsoft Docs"
+title: "C/C++ Language and Standard Libraries | Microsoft Docs"
 ms.custom: ""
 ms.date: "11/04/2016"
 ms.reviewer: ""
@@ -30,8 +30,8 @@ translation.priority.ht:
   - "zh-cn"
   - "zh-tw"
 ---
-# C/C++ Language Reference
-This section of the documentation includes guidelines and reference content for the Microsoft implementation of the ISO standard for C++.  
+# C/C++ Language and Standard Libraries
+This section of the documentation includes guidelines and reference content for the Microsoft implementation of the ISO standards for C and C++.  
   
 ## Related Articles  
   
diff --git a/docs/cpp/class-member-overview.md b/docs/cpp/class-member-overview.md
@@ -41,7 +41,7 @@ A class or struct consists of its members. The work that a class does is perform
 ## Kinds of class members  
  The full list of member categories is as follows:  
   
--   Special Member functions.  
+-   [Special Member Functions](special-member-functions.md).  
   
 -   [Overview of Member Functions](overview-of-member-functions.md).  
   
@@ -129,6 +129,8 @@ int TestRun::_instances{ 0 };
   
 6.  Destructor  
   
+For more information, see [Special Member Functions](../cpp/special-member-functions.md).
+  
 ## Memberwise initialization  
  In C++11 and later, non-static member declarators can contain initializers.  
   
diff --git a/docs/cpp/compiler-limits.md b/docs/cpp/compiler-limits.md
@@ -35,23 +35,23 @@ translation.priority.ht:
 # Compiler Limits
 The C++ standard recommends limits for various language constructs. The following is a list of cases where the Visual C++ compiler does not implement the recommended limits. The first number is the limit that is established in the ISO C++ 11 standard (INCITS/ISO/IEC 14882-2011[2012], Annex B) and the second number is the limit implemented by Visual C++:  
   
--   Nesting levels of compound statements, iteration control structures, and selection control structures [C++ standard: 256] (Visual C++ compiler: depends on the combination of statements that are nested, but generally between 100 and 110).  
+-   Nesting levels of compound statements, iteration control structures, and selection control structures - C++ standard: 256, Visual C++ compiler: depends on the combination of statements that are nested, but generally between 100 and 110.  
   
--   Parameters in one macro definition [C++ standard: 256] (Visual C++ compiler: 127).  
+-   Parameters in one macro definition - C++ standard: 256, Visual C++ compiler: 127.  
   
--   Arguments in one macro invocation [C++ standard: 256] (Visual C++ compiler 127).  
+-   Arguments in one macro invocation - C++ standard: 256, Visual C++ compiler 127.  
   
--   Characters in a character string literal or wide string literal (after concatenation) [C++ standard: 65536] (Visual C++ compiler: 65535 single-byte characters, including the `null` terminator, and 32767 double-byte characters, including the `null` terminator).  
+-   Characters in a character string literal or wide string literal (after concatenation) - C++ standard: 65536, Visual C++ compiler: 65535 single-byte characters, including the `null` terminator, and 32767 double-byte characters, including the `null` terminator.  
   
--   Levels of nested class, structure, or union definitions in a single `struct-declaration-list` [C++ standard: 256] (Visual C++ compiler: 16).  
+-   Levels of nested class, structure, or union definitions in a single `struct-declaration-list` - C++ standard: 256, Visual C++ compiler: 16.  
   
--   Member initializers in a constructor definition [C++ standard: 6144] (Visual C++ compiler: at least 6144).  
+-   Member initializers in a constructor definition - C++ standard: 6144, Visual C++ compiler: at least 6144.  
   
--   Scope qualifications of one identifier [C++ standard: 256] (Visual C++ compiler: 127).  
+-   Scope qualifications of one identifier - C++ standard: 256, Visual C++ compiler: 127.  
   
--   Nested `extern` specifications [C++ standard: 1024] (Visual C++ compiler: 9 (not counting the implicit `extern` specification in global scope, or 10, if you count the implicit `extern` specification in global scope.).  
+-   Nested `extern` specifications - C++ standard: 1024, Visual C++ compiler: 9 (not counting the implicit `extern` specification in global scope, or 10, if you count the implicit `extern` specification in global scope..  
   
--   Template arguments in a template declaration [C++ standard: 1024] (Visual C++ compiler: 2046).  
+-   Template arguments in a template declaration - C++ standard: 1024, Visual C++ compiler: 2046.  
   
 ## See Also  
  [Nonstandard Behavior](../cpp/nonstandard-behavior.md)
diff --git a/docs/cpp/constructors-cpp.md b/docs/cpp/constructors-cpp.md
@@ -63,8 +63,6 @@ A constructor is a kind of member function that initializes an instance of its c
   
 -   [Rules for Declaring Constructors](#rules_for_declaring_constructors)  
   
--   Default and Copy Constructors  
-  
 -   [Explicitly invoking constructors](#explicitly_invoking_constructors)  
   
 ##  <a name="order_of_construction"></a> Order of Construction  
@@ -280,10 +278,10 @@ Box boxes[3]{ { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
 ```  
   
 ##  <a name="copy_and_move_constructors"></a> Copy and Move Constructors  
- A *copy constructor* is a special member function that takes as input a reference to an object of the same type, and makes a copy of it. For more information, see [Copy Constructors and Copy Assignment Operators (C++)](../cpp/copy-constructors-and-copy-assignment-operators-cpp.md). A move is also a special member function constructor moves ownership of an existing object to a new variable without copying the original data. For more information, see  [Move Constructors and Move Assignment Operators (C++)](http://msdn.microsoft.com/en-us/1442de5f-37a5-42a1-83a6-ec9cfe0414db) and  [Move Constructors and Move Assignment Operators (C++)](../cpp/move-constructors-and-move-assignment-operators-cpp.md).  
+ A *copy constructor* is a special member function that takes as input a reference to an object of the same type, and makes a copy of it. For more information, see [Copy Constructors and Copy Assignment Operators (C++)](../cpp/copy-constructors-and-copy-assignment-operators-cpp.md). A *move constructor* is also a special member function that moves ownership of an existing object's data to a new variable without copying the original data. For more information, see [Move Constructors and Move Assignment Operators (C++)](../cpp/move-constructors-and-move-assignment-operators-cpp.md).  
   
 ##  <a name="explicitly_defaulted_and_deleted_constructors"></a> Explicitly Defaulted and Deleted Constructors  
- You can explicitly default copy constructors, default constructors, move constructors, copy assignment operators, move assignment operators, and destructors. You can explicitly delete all of the special member functions. For more information, see [Explicitly Defaulted and Deleted Functions](../cpp/explicitly-defaulted-and-deleted-functions.md).  
+ You can explicitly *default* copy constructors, default constructors, move constructors, copy assignment operators, move assignment operators, and destructors. You can explicitly *delete* all of the special member functions. For more information, see [Explicitly Defaulted and Deleted Functions](../cpp/explicitly-defaulted-and-deleted-functions.md).  
   
 ##  <a name="constructors_in_derived_classes"></a> Constructors in Derived Classes  
  A derived class constructor always calls a base class constructor, so that it can rely on completely constructed base classes before any extra work is done. The base class constructors are called in order of derivation—for example, if ClassA is derived from ClassB, which is derived from ClassC, the ClassC constructor is called first, then the ClassB constructor, then the ClassA constructor.  
diff --git a/docs/cpp/cpp-language-reference.md b/docs/cpp/cpp-language-reference.md
@@ -78,17 +78,14 @@ For an overview of Modern C++ programming practices, see [Welcome Back to C++](w
  The portion of a declaration statement that names an object, type, or function. Abstract declarators, type names, initializers, function declarations and definitions, arrays, references.  
   
  [Classes, Structures, and Unions](../cpp/classes-and-structs-cpp.md)  
- Introduction to classes, structures, and unions. Also, member functions, data members, bit fields, this pointer, nested classes.  
+ Introduction to classes, structures, and unions. Also, member functions, special member functions, data members, bit fields, this pointer, nested classes.  
   
  [Derived Classes](../cpp/inheritance-cpp.md)  
  Single and multiple inheritance, virtual functions, multiple base classes, abstract classes, scope rules. Also, the __super and \__interface keywords.  
   
  [Member-Access Control](../cpp/member-access-control-cpp.md)  
  Controlling access to class members: public, private, and protected keywords. Friend functions and classes.  
   
- [Special Member Functions](../misc/special-member-functions-cpp.md)  
- Special functions unique to class types: constructors, destructors, conversion functions, assignment operator, operator new and operator delete functions.  
-  
  [Overloading](operator-overloading.md)  
  Overloaded operators, rules for operator overloading.  
   
diff --git a/docs/cpp/initializers.md b/docs/cpp/initializers.md
diff --git a/docs/cpp/keywords-cpp.md b/docs/cpp/keywords-cpp.md
diff --git a/docs/cpp/special-member-functions.md b/docs/cpp/special-member-functions.md
diff --git a/docs/cpp/using-declaration.md b/docs/cpp/using-declaration.md
diff --git a/docs/porting/visual-cpp-change-history-2003-2015.md b/docs/porting/visual-cpp-change-history-2003-2015.md
diff --git a/docs/preprocessor/hash-using-directive-cpp.md b/docs/preprocessor/hash-using-directive-cpp.md
