Remove extraneous tabs, fix other space issues

Author: Colin Robertson

docs/cpp/function-overloading.md

@@ -97,10 +97,10 @@ int print(double dvalue, int prec)
     const int iPowZero = 6;
 
     // If precision out of range, just print the number.
-	if (prec < -6 || prec > 7)
-	{
-		return print(dvalue);
-	}
+    if (prec < -6 || prec > 7)
+    {
+        return print(dvalue);
+    }
     // Scale, truncate, then rescale.
     dvalue = floor(dvalue / rgPow10[iPowZero - prec]) *
         rgPow10[iPowZero - prec];

docs/cpp/if-else-statement-cpp.md

@@ -15,14 +15,15 @@ ms.workload: ["cplusplus"]
 # if-else Statement (C++)
 
 Controls conditional branching. Statements in the *if-block* are executed only if the *if-expression* evaluates to a non-zero value (or TRUE). If the value of *expression* is nonzero, *statement1* and any other statements in the block are executed and the else-block, if present, is skipped. If the value of *expression* is zero, then the if-block is skipped and the else-block, if present, is executed. Expressions that evaluate to non-zero are
+
 - TRUE
 - a non-null pointer,
 - any non-zero arithmetic value, or
 - a class type that defines an unambiguous conversion to an arithmetic, boolean or pointer type. (For information about conversions, see [Standard Conversions](../cpp/standard-conversions.md).)
 
 ## Syntax
 
-```
+```cpp
 if ( expression )
 {
    statement1;
@@ -70,49 +71,49 @@ using namespace std;
 class C
 {
     public:
-    void do_somthing(){}
+    void do_something(){}
 };
 void init(C){}
 bool is_true() { return true; }
 int x = 10;
 
 int main()
 {
-	if (is_true())
-	{
-		cout << "b is true!\n";  // executed
-	}
-	else
-	{
-		cout << "b is false!\n";
-	}
-
-  // no else statement
-	if (x == 10)
-	{
-		x = 0;
-	}
-	
-
-	C* c;
-  init(c);
-	if (c)
-	{
-		c->do_something();
-	}
-	else
-	{
-		cout << "c is null!\n";
-	}
+    if (is_true())
+    {
+        cout << "b is true!\n";  // executed
+    }
+    else
+    {
+        cout << "b is false!\n";
+    }
+
+    // no else statement
+    if (x == 10)
+    {
+        x = 0;
+    }
+
+    C* c;
+    init(c);
+    if (c)
+    {
+        c->do_something();
+    }
+    else
+    {
+        cout << "c is null!\n";
+    }
 }
 ```
+
 ## <a name="if_with_init"></a> if statement with an initializer
 
 **Visual Studio 2017 version 15.3 and later** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): An **if** statement may also contain an expression that declares and initializes a named variable. Use this form of the if-statement when the variable is only needed within the scope of the if-block.
 
-```cpp
 ## Example
 
+```cpp
 #include <iostream>
 #include <mutex>
 #include <map>
@@ -129,28 +130,28 @@ void unsafe_operation() {}
 int main()
 {
 
-	if (auto it = m.find(10); it != m.end())
-	{
-		cout << it->second;
-		return 0;
-	}
+    if (auto it = m.find(10); it != m.end())
+    {
+        cout << it->second;
+        return 0;
+    }
 
-	if (char buf[10]; fgets(buf, 10, stdin))
-	{
-		m[0] += buf;
-	}
+    if (char buf[10]; fgets(buf, 10, stdin))
+    {
+        m[0] += buf;
+    }
 
-	if (lock_guard<mutex> lock(mx); shared_flag)
-	{
-		unsafe_operation();
-		shared_flag = false;
-	}
+    if (lock_guard<mutex> lock(mx); shared_flag)
+    {
+        unsafe_operation();
+        shared_flag = false;
+    }
 
-	string s{ "if" };
+    string s{ "if" };
     if (auto keywords = { "if", "for", "while" }; any_of(keywords.begin(), keywords.end(), [&s](const char* kw) { return s == kw; }))
-	{
-		cout << "Error! Token must not be a keyword\n";
-	}
+    {
+        cout << "Error! Token must not be a keyword\n";
+    }
 }
 ```
 
@@ -166,18 +167,18 @@ The **else** clause of an `if...else` statement is associated with the closest p
 template <class T, class... Rest>
 void f(T&& t, Rest&&... r)
 {
-// handle t
-   do_something(t);
-
-   // handle r conditionally
-   if constexpr (sizeof...(r))
-   {
-      f(r...);
-   }
-   else
-   {
-       g(r...);
-   }
+    // handle t
+    do_something(t);
+
+    // handle r conditionally
+    if constexpr (sizeof...(r))
+    {
+        f(r...);
+    }
+    else
+    {
+        g(r...);
+    }
 }
 ```
 

docs/cpp/lambda-expressions-constexpr.md

@@ -17,35 +17,38 @@ ms.workload: ["cplusplus"]
 
 ```cpp
     int y = 32;
-	auto answer = [y]() constexpr
-	{
-		int x = 10;
-		return y + x;
-	};
+    auto answer = [y]() constexpr
+    {
+        int x = 10;
+        return y + x;
+    };
 
     constexpr int Increment(int n)
     {
-	    return [n] { return n + 1; }();
+        return [n] { return n + 1; }();
     }
 ```
+
 A lambda is implicitly **constexpr** if its result satisfies the requirements of a **constexpr** function:
+
 ```cpp
-	auto answer = [](int n)
-	{
-		return 32 + n;
-	};
+    auto answer = [](int n)
+    {
+        return 32 + n;
+    };
 
-	constexpr int response = answer(10);
+    constexpr int response = answer(10);
 ```
+
 If a lambda is implicitly or explicitly **constexpr**, and you convert it to a function pointer, the resulting function is also **constexpr**:
 
 ```cpp
-	auto Increment = [](int n)
-	{
-		return n + 1;
-	};
+    auto Increment = [](int n)
+    {
+        return n + 1;
+    };
 
-	constexpr int(*inc)(int) = Increment;
+    constexpr int(*inc)(int) = Increment;
 ```
 
 ## See also

docs/cpp/lambda-expressions-in-cpp.md

@@ -326,35 +326,38 @@ For more information, see [generate_n](../standard-library/algorithm-functions.m
 
 ```cpp
     int y = 32;
-	auto answer = [y]() constexpr
-	{
-		int x = 10;
-		return y + x;
-	};
+    auto answer = [y]() constexpr
+    {
+        int x = 10;
+        return y + x;
+    };
 
     constexpr int Increment(int n)
     {
-	    return [n] { return n + 1; }();
+        return [n] { return n + 1; }();
     }
 ```
+
 A lambda is implicitly `constexpr` if its result satisfies the requirements of a `constexpr` function:
+
 ```cpp
-	auto answer = [](int n)
-	{
-		return 32 + n;
-	};
+    auto answer = [](int n)
+    {
+        return 32 + n;
+    };
 
-	constexpr int response = answer(10);
+    constexpr int response = answer(10);
 ```
+
 If a lambda is implicitly or explicitly `constexpr`, conversion to a function pointer produces a `constexpr` function:
 
 ```cpp
-	auto Increment = [](int n)
-	{
-		return n + 1;
-	};
+    auto Increment = [](int n)
+    {
+        return n + 1;
+    };
 
-	constexpr int(*inc)(int) = Increment;
+    constexpr int(*inc)(int) = Increment;
 ```
 
 ## Microsoft-Specific

docs/cpp/member-access-control-cpp.md

@@ -35,7 +35,7 @@ protected:      // Declare protected function for derived classes only.
 
 The default access is **private** in a class, and **public** in a struct or union. Access specifiers in a class can be used any number of times in any order. The allocation of storage for objects of class types is implementation dependent, but members are guaranteed to be assigned successively higher memory addresses between access specifiers.
 
-### Member-Access Control
+## Member-Access Control
 
 |Type of Access|Meaning|
 |--------------------|-------------|
@@ -73,40 +73,40 @@ The following example illustrates this:
 class BaseClass
 {
 public:
-	int PublicFunc(); // Declare a public member.
+    int PublicFunc(); // Declare a public member.
 protected:
-	int ProtectedFunc(); // Declare a protected member.
+    int ProtectedFunc(); // Declare a protected member.
 private:
-	int PrivateFunc(); // Declare a private member.
+    int PrivateFunc(); // Declare a private member.
 };
 
 // Declare two classes derived from BaseClass.
 class DerivedClass1 : public BaseClass
 {
-	void foo()
-	{
-		PublicFunc();
-		ProtectedFunc();
-		PrivateFunc(); // function is inaccessible
-	}
+    void foo()
+    {
+        PublicFunc();
+        ProtectedFunc();
+        PrivateFunc(); // function is inaccessible
+    }
 };
 
 class DerivedClass2 : private BaseClass
 {
-	void foo()
-	{
-		PublicFunc();
-		ProtectedFunc();
-		PrivateFunc(); // function is inaccessible
-	}
+    void foo()
+    {
+        PublicFunc();
+        ProtectedFunc();
+        PrivateFunc(); // function is inaccessible
+    }
 };
 
 int main()
 {
-	DerivedClass1 derived_class1;
-	DerivedClass2 derived_class2;
-	derived_class1.PublicFunc();
-	derived_class2.PublicFunc(); // function is inaccessible
+    DerivedClass1 derived_class1;
+    DerivedClass2 derived_class2;
+    derived_class1.PublicFunc();
+    derived_class2.PublicFunc(); // function is inaccessible
 }
 ```