Fixes for feedback issues.

Author: Colin Robertson

docs/build/how-to-modify-the-target-framework-and-platform-toolset.md

@@ -39,7 +39,7 @@ translation.priority.mt:
 You can change [!INCLUDE[vcprvc](../build/includes/vcprvc_md.md)] project settings to target different versions of the .NET Framework and to use different platform toolsets. By default, the project system uses the .NET Framework version and the toolset version that correspond to the version of Visual Studio that you use to create the project. You can change the target platform toolset by modifying the project properties. You can change the target Framework by modifying the project (.vcxproj) file. You do not have to maintain a separate code base for every compilation target.  
 
 > [!IMPORTANT]
->  Some editions might not support modified target Frameworks or platform toolsets. For compatibility information, see [Porting, Migrating, and Upgrading Visual Studio Projects](/visualstudio/porting/porting-migrating-and-upgrading-visual-studio-projects).  
+>  Some editions might not support modified target Frameworks or platform toolsets. For compatibility information, see [Port, Migrate, and Upgrade Visual Studio Projects](/visualstudio/porting/port-migrate-and-upgrade-visual-studio-projects).  
   
  When you change the target Framework, also change the platform toolset to a version that supports that Framework. For example, to target the .NET Framework 4.5, you must use a compatible platform toolset such as Visual Studio 2015 (v140), Visual Studio 2013 (v120) or Visual Studio 2012 (v110). You can use the **Windows7.1SDK** platform toolset to target the .NET Framework 2.0, 3.0, 3.5, and 4, and the x86, Itanium, and x64 platforms.  
 

docs/cpp/special-member-functions.md

@@ -39,16 +39,18 @@ translation.priority.ht:
 ---
 # Special member functions  
 
-The special member functions are class (or struct) member functions that, in certain cases, the compiler automatically generates for you. These functions are the [default constructor](constructors-cpp.md#default_constructors), the [destructor](destructors-cpp.md), the [copy constructor and copy assignment operator](copy-constructors-and-copy-assignment-operators-cpp.md), and the [move constructor and move assignment operator](move-constructors-and-move-assignment-operators-cpp.md). If your class does not define one or more of the special member functions, then the compiler may implicitly declare and define the functions that are used. The compiler does not generate functions if they are not needed.  
+The *special member functions* are class (or struct) member functions that, in certain cases, the compiler automatically generates for you. These functions are the [default constructor](constructors-cpp.md#default_constructors), the [destructor](destructors-cpp.md), the [copy constructor and copy assignment operator](copy-constructors-and-copy-assignment-operators-cpp.md), and the [move constructor and move assignment operator](move-constructors-and-move-assignment-operators-cpp.md). If your class does not define one or more of the special member functions, then the compiler may implicitly declare and define the functions that are used. The compiler-generated implementations are called the *default* special member functions. The compiler does not generate functions if they are not needed.  
 
-The compiler does generates a default constructor 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.  
+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.  
+  
+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.  
 
 The default destructor performs member-wise destruction of the object. It is virtual only if a base class destructor is virtual.  
 
 The default copy and move construction and assignment operations perform member-wise bit-pattern copies or moves of non-static data members. Move operations are only generated when no destructor or move or copy operations are declared. A default copy constructor is only generated when no copy constructor is declared. It is implicitly deleted if a move operation is declared. A default copy assignment operator is generated only when no copy assignment operator is explicitly declared. It is implicitly deleted if a move operation is declared.  
 
-You can explicitly declare a default special member function by using the `= default` keyword. This causes the compiler to define the function if needed, in the same way as if the function was not declared at all. To prevent automatic generation of a special member function, you can explicitly declare it as deleted by using the `= deleted` keyword.  
-  
 ## See Also  
 [C++ Language Reference](cpp-language-reference.md)  
 

docs/error-messages/compiler-errors-1/compiler-error-c2065.md

@@ -37,46 +37,139 @@ translation.priority.ht:
 # Compiler Error C2065
 'identifier' : undeclared identifier  
 
- A variable's type must be specified in a declaration before it can be used. The parameters that a function uses must be specified in a declaration, or prototype, before the function can be used.  
+The compiler can't find the declaration for an identifier. If the identifier is a variable, you must specify the type of the variable in a declaration before it can be used. If the identifier is a function name, the parameters that the function uses must be specified in a declaration before the function can be used. If the identifier is the tag for a user-defined type, for example, a `class` or `struct`, the type of the tag must be declared before it can be used. If the identifier is a type alias, the type must be declared by using a `using` declaration or `typedef` before the type can be used.  
 
- Possible causes:  
+There are many possible causes for this error. Here are some of the most common issues:
 
-1.  Identifier name is misspelled.  
+## Example: misspelled identifier  
 
-2.  Identifier uses the wrong uppercase and lowercase letters.  
+This error commonly occurs when the identifier name is misspelled, or the identifier uses the wrong uppercase and lowercase letters. The name in the declaration must exactly match the name you use.  
 
-3.  Missing closing quote after a string constant.  
-  
-4.  You are compiling with a debug version of the C runtime, declaring a C++ Standard Library iterator variable in a `for` loop, and then trying to use that iterator variable outside the scope of the `for` loop. Compiling C++ Standard Library code with a debug version of the C runtime implies [/Zc:forScope](../../build/reference/zc-forscope-force-conformance-in-for-loop-scope.md).  See [Debug Iterator Support](../../standard-library/debug-iterator-support.md) for more information.  
+```cpp  
+// C2065_spell.cpp  
+// compile with: cl /EHsc C2065_spell.cpp 
+#include <iostream> 
+using namespace std; 
+int main() { 
+    int someIdentifier = 42; 
+    cout << "Some Identifier: " << SomeIdentifier << endl;   
+    // C2065: 'SomeIdentifier': undeclared identifier 
+    // To fix, correct the spelling:  
+    // cout << "Some Identifier: " << someIdentifier << endl;   
+}  
+```
+  
+## Example: missing header file  
+  
+You have not included the header file that declares the identifier. Make sure the file that contains the declaration for the identifier is included in every source file that uses it.  
+  
+```cpp  
+// C2065_header.cpp  
+// compile with: cl /EHsc C2065_spell.cpp 
+
+//#include <stdio.h> 
+int main() { 
+    fpos_t file_position = 42; // C2065: 'fpos_t': undeclared identifier 
+    // To fix, uncomment the #include <stdio.h> line
+    // to include the header where fpos_t is defined  
+} 
+```  
 
-5.  You may be calling a function in an SDK header file that is currently not supported in your build environment.  
+You may see this error in Windows Desktop app source files if you define `VC_EXTRALEAN`, `WIN32_LEAN_AND_MEAN`, or `WIN32_EXTRA_LEAN`. These preprocessor macros exclude some header files from windows.h and afxv\_w32.h to speed compiles. Look in windows.h and afxv_w32.h for an up-to-date description of what's excluded.  
 
-6.  Omitting necessary include files, especially if you define `VC_EXTRALEAN`, `WIN32_LEAN_AND_MEAN`, or `WIN32_EXTRA_LEAN`. These symbols exclude some header files from windows.h and afxv_w32.h to speed compiles. (Look in windows.h and afxv_w32.h for an up-to-date description of what's excluded.)  
+## Eample: missing closing quote  
 
-7.  Improper namespace scope. For example, to resolve C++ Standard Library functions and operators that are not fully qualified, you must specify the `std` namespace with the `using` directive. The following example fails to compile because the `using` directive is commented out and `cout` is defined in the `std` namespace:  
+This error can occur if you are missing a closing quote after a string constant. This is an easy way to confuse the compiler. 
 
-## Example  
- The following sample generates C2065 and shows how to fix it.  
+```cpp  
+// C2065_quote.cpp  
+// compile with: cl /EHsc C2065_quote.cpp 
+#include <iostream>  
+
+int main() { 
+    // Fix this issue by adding the closing quote to "Aaaa"
+    char * first = "Aaaa, * last = "Zeee"; 
+    std::cout << "Name: " << first 
+        << " " << last << std::endl; // C2065: 'last': undeclared identifier 
+} 
+```  
 
+## Example: use iterator outside for loop scope  
+  
+This error can occur if you declare an iterator variable in a `for` loop, and then you try to use that iterator variable outside the scope of the `for` loop. The compiler enables the [/Zc:forScope](../../build/reference/zc-forscope-force-conformance-in-for-loop-scope.md) compiler option by default. See [Debug Iterator Support](../../standard-library/debug-iterator-support.md) for more information.  
+  
+```cpp  
+// C2065_iter.cpp  
+// compile with: cl /EHsc C2065_iter.cpp 
+#include <iostream> 
+#include <string> 
+
+int main() {
+    // char last = '!'; 
+    std::string letters{ "ABCDEFGHIJKLMNOPQRSTUVWXYZ" }; 
+    for (const char& c : letters) {
+        if ('Q' == c) {
+            std::cout << "Found Q!" << std::endl;
+        }
+        // last = c;
+    }
+    std::cout << "Last letter was " << c << std::endl; // C2065
+    // Fix by using a variable declared in an outer scope.
+    // Uncomment the lines that declare and use 'last' for an example.
+    // std::cout << "Last letter was " << last << std::endl; // C2065
+} 
 ```  
-// C2065.cpp  
-// compile with: /EHsc  
+  
+## Example: preprocessor removed declaration  
+  
+This error can occur if you refer to a function or variable that is in conditionally compiled code that is not compiled for your current configuration. This can also occur if you call a function in a header file that is currently not supported in your build environment. If certain variables or functions are only available when a particular preprocessor macro is defined, make sure the code that calls those functions can only be compiled when the same preprocessor macro is defined. This issue is easy to spot in the IDE, because the declaration for the function is greyed out if the required preprocessor macros are not defined for the current build configuration.  
+  
+This is an example of code that works when you build in Debug, but not Retail:  
+  
+```cpp  
+// C2065_defined.cpp
+// Compile with: cl /EHsc /W4 /MT C2065_defined.cpp
+#include <iostream>
+#include <crtdbg.h>
+#ifdef _DEBUG
+    _CrtMemState oldstate;
+#endif
+int main() {
+    _CrtMemDumpStatistics(&oldstate); 
+    std::cout << "Total count " << oldstate.lTotalCount; // C2065
+    // Fix by guarding references the same way as the declaration:
+    // #ifdef _DEBUG
+    //    std::cout << "Total count " << oldstate.lTotalCount;
+    // #endif
+}
+```
+  
+## Example: use an unscoped identifier  
+  
+This error can occur if your identifier is not properly scoped. For example, when C++ Standard Library functions and operators are not fully qualified by namespace, or you have not brought the `std` namespace into the current scope by using a `using` directive, the compiler can't find them. To fix this issue, you must either fully qualify the identifier names, or specify the namespace with the `using` directive.  
+  
+This example fails to compile because `cout` and `endl` are defined in the `std` namespace:  
+  
+```cpp  
+// C2065_scope.cpp  
+// compile with: cl /EHsc C2065_scope.cpp 
 // using namespace std;   // Uncomment this line to fix  
 #include <iostream>  
 int main() {  
-   cout << "Hello" << endl;   // C2065  
-  
-   // Or try the following line instead  
-   std::cout << "Hello" << std::endl;  
-}  
+    cout << "Hello" << endl;   // C2065 'cout': undeclared identifier 
+                               // C2065 'endl': undeclared identifier
+    // Or try the following line instead  
+    std::cout << "Hello" << std::endl;  
+}
 ```  
 
-## Example  
- When calling a generic function, if the intended type argument cannot be deduced from the parameters used, the compiler will report an error. For more information, see [Generic Functions (C++/CLI)](../../windows/generic-functions-cpp-cli.md).  
+Identifiers that are declared inside of `class`, `struct`, or `enum class` types, must also be qualified by the name of the enclosing scope.
 
- The following sample generates C2065 and shows how to fix it.  
+## Example: C++/CLI type deduction failure  
 
-```  
+This error can occur when calling a generic function, if the intended type argument cannot be deduced from the parameters used. For more information, see [Generic Functions (C++/CLI)](../../windows/generic-functions-cpp-cli.md).  
+  
+```cpp  
 // C2065_b.cpp  
 // compile with: /clr  
 generic <typename ItemType>  
@@ -89,14 +182,13 @@ int main() {
 }  
 ```  
   
-## Example  
- This error can also be generated as a result of compiler conformance work that was done for Visual C++ 2005: parameter checking for Visual C++ attributes.  
+## Example: C++/CLI attribute parameters  
   
- The following sample generates C2065 and shows how to fix it.  
+This error can also be generated as a result of compiler conformance work that was done for Visual C++ 2005: parameter checking for Visual C++ attributes.  
   
-```  
-// C2065_c.cpp  
-// compile with: /c  
+```cpp  
+// C2065_attributes.cpp  
+// compile with: cl /c /clr C2065_attributes.cpp  
 [module(DLL, name=MyLibrary)];   // C2065  
 // try the following line instead  
 // [module(dll, name="MyLibrary")];  
@@ -105,4 +197,4 @@ int main() {
 struct MyStruct {  
    int i;  
 };  
-```
+```