Merge pull request MicrosoftDocs#310 from MicrosoftDocs/FromPublicMasterBranch

Confirm merge from FromPublicMasterBranch to master to sync with https://github.com/MicrosoftDocs/cpp-docs (branch master)

Author: mikeblome

docs/build/msbuild-visual-cpp-overview.md

@@ -40,7 +40,7 @@ MSBuild is the standard build system for Visual C++ projects. When you build a p
 
 Read the following documents about MSBuild.  
 
-- [MSBuild](/visualstudio/msbuild/msbuild1)  
+- [MSBuild](/visualstudio/msbuild/msbuild)  
  Overview of MSBuild concepts.  
 
 - [MSBuild Reference](/visualstudio/msbuild/msbuild-reference)  
@@ -154,4 +154,4 @@ The following table lists several useful user-oriented targets.
 
 ## See Also  
 
-[MSBuild (Visual C++)](../build/msbuild-visual-cpp.md)
+[MSBuild (Visual C++)](../build/msbuild-visual-cpp.md)

docs/cpp/class-member-overview.md

@@ -36,7 +36,7 @@ translation.priority.ht:
   - "zh-tw"
 ---
 # Class Member Overview
-A class or struct consists of its members. The work that a class does is performed by its member functions. The state that it maintains is stored in its data members. Initialization of members is done by constructors, and cleanup work such as freeing of memory and releasing of resources is done by constructors. In C++11 and later, data members can (and usually should) be initialized at the point of declaration.  
+A class or struct consists of its members. The work that a class does is performed by its member functions. The state that it maintains is stored in its data members. Initialization of members is done by constructors, and cleanup work such as freeing of memory and releasing of resources is done by destructors. In C++11 and later, data members can (and usually should) be initialized at the point of declaration.  
 
 ## Kinds of class members  
  The full list of member categories is as follows:  
@@ -186,4 +186,4 @@ int CanInit2::j = i;
 >  The class name, `CanInit2`, must precede `i` to specify that the `i` being defined is a member of class `CanInit2`.  
   
 ## See Also  
- [Classes and Structs](../cpp/classes-and-structs-cpp.md)
+ [Classes and Structs](../cpp/classes-and-structs-cpp.md)

docs/cpp/noalias.md

@@ -4,24 +4,24 @@ ms.custom: ""
 ms.date: "11/04/2016"
 ms.reviewer: ""
 ms.suite: ""
-ms.technology:  
+ms.technology:
   - "cpp-language"
 ms.tgt_pltfrm: ""
 ms.topic: "language-reference"
-f1_keywords: 
+f1_keywords:
   - "noalias"
   - "noalias_cpp"
-dev_langs: 
+dev_langs:
   - "C++"
-helpviewer_keywords: 
+helpviewer_keywords:
   - "noalias __declspec keyword"
   - "__declspec keyword [C++], noalias"
 ms.assetid: efafa8b0-7f39-4edc-a81e-d287ae882c9b
 caps.latest.revision: 12
 author: "mikeblome"
 ms.author: "mblome"
 manager: "ghogen"
-translation.priority.ht: 
+translation.priority.ht:
   - "cs-cz"
   - "de-de"
   - "es-es"
@@ -37,85 +37,85 @@ translation.priority.ht:
   - "zh-tw"
 ---
 # noalias
-**Microsoft Specific**  
-  
- `noalias` means that a function call does not modify or reference visible global state and only modifies the memory pointed to `directly` by pointer parameters (first-level indirections).  
-  
- If a function is annotated as `noalias`, the optimizer can assume that, in addition to the parameters themselves, only first-level indirections of pointer parameters are referenced or modified inside the function. The visible global state is the set of all data that is not defined or referenced outside of the compilation scope, and their address is not taken. The compilation scope is all source files ([/LTCG (Link-time Code Generation)](../build/reference/ltcg-link-time-code-generation.md) builds) or a single source file (non-**/LTCG** build).  
-  
-## Example  
- The following sample demonstrates using `__declspec(restrict)` and `__declspec(noalias)`. Normally, memory returned from `malloc` is `restrict` and `noalias` because the CRT headers are decorated appropriately.  
-  
- However, in this example, the pointers `mempool` and `memptr` are global so the compiler has no assurance that the memory is not subject to aliasing. Decorating the functions that return pointers with `__declspec(restrict)` tells the compiler that the memory pointed to by the return value is not aliased.  
-  
- Decorating the function in the example that accesses memory with `__declspec(noalias)` tells the compiler that this function does not interfere with the global state except through the pointers in its parameter list.  
-  
-```  
-// declspec_noalias.c   
-#include <stdio.h>  
-#include <stdlib.h>  
-  
-#define M 800  
-#define N 600  
-#define P 700  
-  
-float * mempool, * memptr;  
-  
-__declspec(restrict) float * ma(int size)  
-{  
-    float * retval;  
-    retval = memptr;  
-    memptr += size;  
-    return retval;  
-}  
-  
-__declspec(restrict) float * init(int m, int n)  
-{  
-    float * a;  
-    int i, j;  
-    int k=1;  
-  
-    a = ma(m * n);  
-    if (!a) exit(1);  
-    for (i=0; i<m; i++)  
-        for (j=0; j<n; j++)  
-            a[i*n+j] = 0.1/k++;  
-    return a;  
-}  
-  
-__declspec(noalias) void multiply(float * a, float * b, float * c)  
-{  
-    int i, j, k;  
-  
-    for (j=0; j<P; j++)  
-        for (i=0; i<M; i++)  
-            for (k=0; k<N; k++)  
-                c[i * P + j] =   
-                          a[i * N + k] *   
-                          b[k * P + j];  
-}  
-  
-int main()  
-{  
-    float * a, * b, * c;  
-  
-    mempool = (float *) malloc(sizeof(float) * (M*N + N*P + M*P));  
-  
-    if (!mempool)   
-    {  
-        puts("ERROR: Malloc returned null");  
-        exit(1);  
-    }  
-  
-    memptr = mempool;  
-    a = init(M, N);  
-    b = init(N, P);  
-    c = init(M, P);  
-  
-    multiply(a, b, c);  
-}  
-```  
-  
-## See Also  
- [__declspec](../cpp/declspec.md)   
+**Microsoft Specific**
+
+ `noalias` means that a function call does not modify or reference visible global state and only modifies the memory pointed to *directly* by pointer parameters (first-level indirections).
+
+ If a function is annotated as `noalias`, the optimizer can assume that, in addition to the parameters themselves, only first-level indirections of pointer parameters are referenced or modified inside the function. The visible global state is the set of all data that is not defined or referenced outside of the compilation scope, and their address is not taken. The compilation scope is all source files ([/LTCG (Link-time Code Generation)](../build/reference/ltcg-link-time-code-generation.md) builds) or a single source file (non-**/LTCG** build).
+
+## Example
+ The following sample demonstrates using `__declspec(restrict)` and `__declspec(noalias)`. Normally, memory returned from `malloc` is `restrict` because the CRT headers are decorated appropriately.
+
+ However, in this example, the pointers `mempool` and `memptr` are global so the compiler has no assurance that the memory is not subject to aliasing. Decorating the functions that return pointers with `__declspec(restrict)` tells the compiler that the memory pointed to by the return value is not aliased.
+
+ Decorating the function in the example that accesses memory with `__declspec(noalias)` tells the compiler that this function does not interfere with the global state except through the pointers in its parameter list.
+
+```
+// declspec_noalias.c
+#include <stdio.h>
+#include <stdlib.h>
+
+#define M 800
+#define N 600
+#define P 700
+
+float * mempool, * memptr;
+
+__declspec(restrict) float * ma(int size)
+{
+    float * retval;
+    retval = memptr;
+    memptr += size;
+    return retval;
+}
+
+__declspec(restrict) float * init(int m, int n)
+{
+    float * a;
+    int i, j;
+    int k=1;
+
+    a = ma(m * n);
+    if (!a) exit(1);
+    for (i=0; i<m; i++)
+        for (j=0; j<n; j++)
+            a[i*n+j] = 0.1/k++;
+    return a;
+}
+
+__declspec(noalias) void multiply(float * a, float * b, float * c)
+{
+    int i, j, k;
+
+    for (j=0; j<P; j++)
+        for (i=0; i<M; i++)
+            for (k=0; k<N; k++)
+                c[i * P + j] =
+                          a[i * N + k] *
+                          b[k * P + j];
+}
+
+int main()
+{
+    float * a, * b, * c;
+
+    mempool = (float *) malloc(sizeof(float) * (M*N + N*P + M*P));
+
+    if (!mempool)
+    {
+        puts("ERROR: Malloc returned null");
+        exit(1);
+    }
+
+    memptr = mempool;
+    a = init(M, N);
+    b = init(N, P);
+    c = init(M, P);
+
+    multiply(a, b, c);
+}
+```
+
+## See Also
+ [__declspec](../cpp/declspec.md)
  [Keywords](../cpp/keywords-cpp.md)

docs/cpp/special-member-functions.md

@@ -43,7 +43,7 @@ The *special member functions* are class (or struct) member functions that, in c
 
 You can explicitly declare a default special member function by using the `= default` keyword. This causes the compiler to define the function only if needed, in the same way as if the function was not declared at all. 
 
-In some cases, the compiler may generate *deleted* special member functions, which are not defined and therefore not callable. This can happen in cases where a call to a particular special member function on a class doesn't make sense, given other properties of the class. To explicitly prevent automatic generation of a special member function, you can declare it as deleted by using the `= deleted` keyword.  
+In some cases, the compiler may generate *deleted* special member functions, which are not defined and therefore not callable. This can happen in cases where a call to a particular special member function on a class doesn't make sense, given other properties of the class. To explicitly prevent automatic generation of a special member function, you can declare it as deleted by using the `= delete` keyword.  
 
 The compiler generates a *default constructor*, a constructor that takes no arguments, only when you have not declared any other constructor. If you have declared only a constructor that takes parameters, code that attempts to call a default constructor causes the compiler to produce an error message. The compiler-generated default constructor performs simple member-wise [default initialization](initializers.md#default_initialization) of the object. Default initialization leaves all member variables in an indeterminate state.  
 

docs/cpp/template-specialization-cpp.md

@@ -89,7 +89,7 @@ PTS<int S::*>::IsPointer == 0 PTS<int S::*>::IsPointerToDataMember == 1
 ```  
 
 ## Example  
- If you have a template collection class that takes any type **T**, you can create a partial specialization that takes any pointer type **T\***. The following code demonstrates a collection class template `Bag` and a partial specialization for pointer types in which the collection dereferences the pointer types before copying them to the array. The collection then stores the values that are pointed to. With the original template, only the pointers themselves would have been stored in the collection, leaving the data vulnerable to deletion or modification. In this special pointer version of the collection, code to check for a null pointer in the `add` method is added.  
+ If you have a template collection class that takes any type **T**, you can create a partial specialization that takes any pointer type **T***. The following code demonstrates a collection class template `Bag` and a partial specialization for pointer types in which the collection dereferences the pointer types before copying them to the array. The collection then stores the values that are pointed to. With the original template, only the pointers themselves would have been stored in the collection, leaving the data vulnerable to deletion or modification. In this special pointer version of the collection, code to check for a null pointer in the `add` method is added.  
 
 ```  
 // partial_specialization_of_class_templates2.cpp  

docs/preprocessor/hash-import-directive-cpp.md

@@ -194,7 +194,7 @@ using namespace MyLib;
   
  You must determine which of the dependency comments are not otherwise provided for by system headers and then provide an `#import` directive at some point before the `#import` directive of the dependent type library to resolve the errors.  
   
- For more information, see the Knowledge Base article "#import Wrapper Methods May Cause Access Violation" (Q242527) or "Compiler Errors When You Use #import with XML" (Q269194). You can find Knowledge Base articles on the MSDN Library media or at [http://support.microsoft.com/support/](http://support.microsoft.com/support/).  
+ For more information, see the Knowledge Base article "#import Wrapper Methods May Cause Access Violation" (Q242527) or "Compiler Errors When You Use #import with XML" (Q269194). You can find Knowledge Base articles on the MSDN Library media or at [Microsoft Support](https://support.microsoft.com/).  
   
 ##  <a name="_predir_the_23import_directive_import_attributes"></a> #import Attributes  
  `#import` can optionally include one or more attributes. These attributes tell the compiler to modify the contents of the type-library headers. A backslash (**\\**) symbol can be used to include additional lines in a single `#import` statement. For example:  
@@ -210,4 +210,4 @@ using namespace MyLib;
   
 ## See Also  
  [Preprocessor Directives](../preprocessor/preprocessor-directives.md)   
- [Compiler COM Support](../cpp/compiler-com-support.md)
+ [Compiler COM Support](../cpp/compiler-com-support.md)

docs/windows/desktop-applications-visual-cpp.md

@@ -65,4 +65,4 @@ A *desktop application* in C++ is a native application that can access the full
 |[Visual C++](../visual-cpp-in-visual-studio.md)|Describes key features of Visual C++ in Visual Studio and links to the rest of the Visual C++ documentation.|  
 
 ## See Also  
- [Visual C++](../visual-cpp-in-visual-studio.md)
+ [Visual C++](../visual-cpp-in-visual-studio.md)