Merge branch 'master' into cr-started

Author: Colin Robertson

docs/atl-mfc-shared/atl-mfc-shared-classes.md

@@ -63,9 +63,6 @@ Beginning with Visual C++ .NET 2002, several existing MFC utility classes were r
  [Microsoft Foundation Class Library (MFC) Reference](../mfc/mfc-desktop-applications.md)  
  Provides reference material for the MFC Library, a set of classes in that constitute an application framework, which is the framework of an application written for the Windows API.  
 
- [NIB: Samples Included in Visual C++](http://msdn.microsoft.com/en-us/c9ec56b3-2bbd-49b4-8a4c-9ed4b78b7a84)  
- Provides links to sample code showing the capabilities of Visual C++ and the libraries and technologies it supports.  
-  
  [Visual C++ Libraries](http://msdn.microsoft.com/en-us/fec23c40-10c0-4857-9cdc-33a3b99b30ae)  
  Provides links to the various libraries provided with Visual C++, including ATL, MFC, OLE DB Templates, the C run-time library, and the C++ Standard Library.  
 

docs/build/building-c-cpp-programs.md

@@ -65,8 +65,5 @@ You can build Visual C++ projects either in Visual Studio or on the command line
  Describes how to set the Platform Toolset to target Windows XP development.  
 
 ## Related Sections  
- [NIB: Samples Included in Visual C++](http://msdn.microsoft.com/en-us/c9ec56b3-2bbd-49b4-8a4c-9ed4b78b7a84)  
- Provides links to sample code that shows the capabilities of Visual C++ and the libraries and technologies it supports.  
-  
  [Compiling and Building](/visualstudio/ide/compiling-and-building-in-visual-studio)  
  Describes the Visual Studio build system and tools.

docs/build/reference/clr-common-language-runtime-compilation.md

@@ -74,8 +74,7 @@ Enables applications and components to use features from the common language run
  **/clr:safe**  
  Produces an MSIL-only (no native executable code), verifiable output file. **/clr:safe** enables verification diagnostics ([PEVerify Tool (Peverify.exe)](http://msdn.microsoft.com/Library/f4f46f9e-8d08-4e66-a94b-0c69c9b0bbfa)).  
 
- For more information, see [NIB: Writing Verifiably Type-Safe Code](http://msdn.microsoft.com/en-us/d18f10ef-3b48-4f47-8726-96714021547b).  
-  
+
  /clr:safe is deprecated. A future version of the compiler may not support this option. We recommend that you port code that must be pure, verifiable MSIL to C#.  
 
  **/clr:noAssembly**  

docs/c-language/typedef-declarations.md

@@ -178,4 +178,5 @@ void box( int, int );
 ```  
 
 ## See Also  
- [(NOTINBUILD)typedef Specifier](http://msdn.microsoft.com/en-us/cc96cf26-ba93-4179-951e-695d1f5fdcf1)
+
+

docs/cpp-conformance-improvements-2017.md

@@ -355,12 +355,12 @@ In previous versions of Visual Studio, the compiler in some cases would fail to
 ```cpp
 template<typename T> 
 struct S { 
-template<typename U> static int f() = delete; 
+   template<typename U> static int f() = delete; 
 }; 
 
 void g() 
 { 
-decltype(S<int>::f<int>()) i; // this should fail 
+   decltype(S<int>::f<int>()) i; // this should fail 
 }
 ```
 To fix the error, declare i as `int`.
@@ -385,16 +385,16 @@ Now the compiler will emit a warning if it can know at compile time that a nativ
 class A 
 { 
 public: 
-A() : p_(new int) {} 
-~A() { delete p_; } 
+   A() : p_(new int) {} 
+   ~A() { delete p_; } 
 
-A(A const &) = delete; 
-A(A &&rhs) { 
-p_ = rhs.p_; 
+   A(A const &) = delete; 
+   A(A &&rhs) { 
+   p_ = rhs.p_; 
 } 
 
 private: 
-int *p_; 
+   int *p_; 
 }; 
 
 #pragma unmanaged 
@@ -559,7 +559,7 @@ void h()
    g(42); 
 }
 ```
-### Unitialized const variables
+### Uninitialized const variables
 Visual Studio 2017 RTW release had a regression in which the C++ compiler would not issue a diagnostic if a 'const' variable was not initialized. This regression has been fixed in Visual Studio 2017 Update 1. The following code now produces "warning C4132: 'Value': const object should be initialized":
 
 ```cpp

docs/cpp/storage-classes-cpp.md

@@ -37,13 +37,15 @@ translation.priority.ht:
   - "zh-tw"
 ---
 # Storage classes (C++)
-A *storage class* in the context of C++ variable declarations is a type specifier that governs the lifetime, linkage, and memory location of objects and. A given object can have only one storage class. Variables defined within a block have automatic storage unless otherwise specified using the `extern`, `static`, or `thread_local` specifiers. Automatic objects and variables have no linkage; they are not visible to code outside the block.  
+A *storage class* in the context of C++ variable declarations is a type specifier that governs the lifetime, linkage, and memory location of objects. A given object can have only one storage class. Variables defined within a block have automatic storage unless otherwise specified using the `extern`, `static`, or `thread_local` specifiers. Automatic objects and variables have no linkage; they are not visible to code outside the block.  
 
  **Notes**  
 
 1.  The [mutable](../cpp/mutable-data-members-cpp.md) keyword may be considered a storage class specifier. However, it is only available in the member list of a class definition.  
 
 2.  Starting with [!INCLUDE[cpp_dev10_long](../build/includes/cpp_dev10_long_md.md)], the `auto` keyword is no longer a C++ storage-class specifier, and the `register` keyword is deprecated.  
+
+## In this section:
 
 -   [static](#static)  
 
@@ -60,7 +62,7 @@ A *storage class* in the context of C++ variable declarations is a type specifie
 
 2.  When you declare a variable in a function, the `static` keyword specifies that the variable retains its state between calls to that function.  
 
-3.  When you declare a data member in a class declaration, the `static` keyword specifies that one copy of the member is shared by all instances of the class. A static data member must be defined at file scope. An integral data member that you declare as `const``static` can have an initializer.  
+3.  When you declare a data member in a class declaration, the `static` keyword specifies that one copy of the member is shared by all instances of the class. A static data member must be defined at file scope. An integral data member that you declare as `const static` can have an initializer.  
 
 4.  When you declare a member function in a class declaration, the `static` keyword specifies that the function is shared by all instances of the class. A static member function cannot access an instance member because the function does not have an implicit `this` pointer. To access an instance member, declare the function with a parameter that is an instance pointer or reference.  
 
@@ -199,29 +201,31 @@ int main() {
  A variable declared with the `thread_local` specifier is accessible only on the thread on which it is created. The variable is created when the thread is created, and destroyed when the thread is destroyed. Each thread has its own copy of the variable. On Windows, `thread_local` is functionally equivalent to the Microsoft-specific [__declspec( thread )](../cpp/thread.md) attribute.  
 
 ```  
-thread_local float f = 42.0; //global namespace  
+thread_local float f = 42.0; // Global namespace. Not implicitly static.
   
 struct C // cannot be applied to type definition  
 {  
-thread_local int i; //local  
-thread_local static char buf[10]; // local and static  
+    thread_local int i; // Illegal. The member must be static.  
+    thread_local static char buf[10]; // OK 
 };  
   
 void DoSomething()  
 {  
-thread_local C my_struct; // Apply  thread_local to a variable  
+   // Apply thread_local to a local variable.
+   // Implicitly “thread_local static C my_struct”.
+   thread_local C my_struct;  
 }  
 ```  
 
 1.  The thread_local specifier may be combined with `static` or `extern`.  
 
-2.  You can apply `thread_local` only to data declarations and definitions; **thread_local** cannot be used on function declarations or definitions.  
+2.  You can apply `thread_local` only to data declarations and definitions; `thread_local` cannot be used on function declarations or definitions.  
 
-3.  The use of `thread_local` may interfere with [delay loading](../build/reference/linker-support-for-delay-loaded-dlls.md) of DLL imports**.**  
+3.  The use of `thread_local` may interfere with [delay loading](../build/reference/linker-support-for-delay-loaded-dlls.md) of DLL imports. 
 
 4.  On XP systems, `thread_local` may not function correctly if a DLL uses `thread_local` data and it is loaded dynamically via LoadLibrary.  
 
-5.  You can specify `thread_local` only on data items with static storage duration. This includes global data objects (both **static** and `extern`), local static objects, and static data members of classes. You cannot declare automatic data objects with **thread_local**.  
+5.  You can specify `thread_local` only on data items with static storage duration. This includes global data objects (both `static` and `extern`), local static objects, and static data members of classes. Any local variable declared `thread_local` will be implicitly static if no other storage class is provided; in other words, at block scope `thread_local` is equivalent to `thread_local static`. 
 
 6.  You must specify `thread_local` for both the declaration and the definition of a thread local object, whether the declaration and definition occur in the same file or separate files.  
 

docs/cppcx/dlls-c-cx.md

@@ -66,4 +66,5 @@ You can use Visual Studio to create either a standard Win32 DLL or a [!INCLUDE[w
 3.  In your source code files, add a `#include` statement for the DLL header file, as needed.  
 
 ## See Also  
- [(NOTINBUILD) Advanced Topics](http://msdn.microsoft.com/en-us/1ccff0cf-a6cc-47ef-a05f-eba6307b3ced)
+
+