proofread pass

Michael Blome · Michael Blome · commit 074026221b14 · 2018-06-05T14:56:02.000-07:00
diff --git a/docs/cpp/aliases-and-typedefs-cpp.md b/docs/cpp/aliases-and-typedefs-cpp.md
@@ -263,11 +263,11 @@ int main()
     ms.f = 0.99;  
     printf_s("%d   %f\n", ms.i, ms.f);  
 }  
-```cpp 
+``` 
   
 ```Output  
 10   0.990000  
-```cpp 
+``` 
   
 ### Re-declaration of typedefs  
  The `typedef` declaration can be used to redeclare the same name to refer to the same type. For example:  
@@ -282,7 +282,7 @@ typedef char CHAR;
 // PROG.CPP  
 #include "file1.h"  
 #include "file2.h"   // OK  
-```cpp 
+``` 
   
  The program PROG.CPP includes two header files, both of which contain `typedef` declarations for the name `CHAR`. As long as both declarations refer to the same type, such redeclaration is acceptable.  
   
@@ -291,7 +291,7 @@ typedef char CHAR;
 ```cpp  
 // FILE2.H  
 typedef int CHAR;     // Error  
-```cpp 
+``` 
   
  the compiler issues an error because of the attempt to redeclare the name `CHAR` to refer to a different type. This extends to constructs such as:  
   
@@ -304,7 +304,7 @@ typedef union REGS      // OK: name REGS redeclared
     struct wordregs x;  //  same meaning.  
     struct byteregs h;  
 } REGS;  
-```cpp 
+``` 
   
 ### typedefs in C++ vs. C  
  Use of the `typedef` specifier with class types is supported largely because of the ANSI C practice of declaring unnamed structures in `typedef` declarations. For example, many C programmers use the following:  
@@ -317,13 +317,13 @@ typedef struct {   // Declare an unnamed structure and give it the
    unsigned x;  
    unsigned y;  
 } POINT;  
-```cpp 
+``` 
   
  The advantage of such a declaration is that it enables declarations like:  
   
-```  
+```cpp  
 POINT ptOrigin;  
-```cpp 
+``` 
   
  instead of:  
   
diff --git a/docs/cpp/assignment.md b/docs/cpp/assignment.md
@@ -22,7 +22,7 @@ The assignment operator (**=**) is, strictly speaking, a binary operator. Its de
   
  The following example illustrates how to declare an assignment operator:  
   
-```  
+```cpp 
 // assignment.cpp  
 class Point  
 {  
@@ -47,7 +47,7 @@ int main()
   
  Note that the supplied argument is the right side of the expression. The operator returns the object to preserve the behavior of the assignment operator, which returns the value of the left side after the assignment is complete. This allows writing statements such as:  
   
-```  
+```cpp 
 pt1 = pt2 = pt3;  
 ```  
   
diff --git a/docs/cpp/bitwise-and-operator-amp.md b/docs/cpp/bitwise-and-operator-amp.md
@@ -13,15 +13,14 @@ ms.author: "mblome"
 ms.workload: ["cplusplus"]
 ---
 # Bitwise AND Operator: &amp;
+
 ## Syntax  
   
-```  
-  
-expression   
-&  
- expression  
-  
-```  
+```
+
+expression & expression  
+
+```
   
 ## Remarks  
  The expressions may be other and-expressions, or (subject to the type restrictions mentioned below) equality expressions, relational expressions, additive expressions, multiplicative expressions, pointer to member expressions, cast expressions, unary expressions, postfix expressions, or primary expressions.  
diff --git a/docs/cpp/bitwise-inclusive-or-operator-pipe.md b/docs/cpp/bitwise-inclusive-or-operator-pipe.md
@@ -17,9 +17,7 @@ ms.workload: ["cplusplus"]
   
 ```  
   
-expression   
-|  
- expression  
+expression | expression  
   
 ```  
   
diff --git a/docs/cpp/explicit-type-conversion-operator-parens.md b/docs/cpp/explicit-type-conversion-operator-parens.md
@@ -93,13 +93,16 @@ d = float( i );
   
  Explicit type conversions can also be specified using the "cast" syntax. The previous example, rewritten using the cast syntax, is:  
   
-```cpp 
+```cpp
+
 d = (float)i;  
+
 ```  
   
  Both cast and function-style conversions have the same results when converting from single values. However, in the function-style syntax, you can specify more than one argument for conversion. This difference is important for user-defined types. Consider a `Point` class and its conversions:  
   
-```cpp 
+```cpp
+
 struct Point  
 {  
     Point( short x, short y ) { _x = x; _y = y; }  
@@ -108,7 +111,8 @@ struct Point
 };  
 ...  
 Point pt = Point( 3, 10 );  
-```cpp 
+
+```
   
  The preceding example, which uses function-style conversion, shows how to convert two values (one for *x* and one for *y*) to the user-defined type `Point`.  
   
diff --git a/docs/cpp/if-else-statement-cpp.md b/docs/cpp/if-else-statement-cpp.md
@@ -58,8 +58,10 @@ else  // optional
    ...
 } 
 ```  
+
 ## Example  
-```  
+
+```cpp  
 // if_else_statement.cpp  
 #include <iostream>
 
diff --git a/docs/cpp/increment-and-decrement-operator-overloading-cpp.md b/docs/cpp/increment-and-decrement-operator-overloading-cpp.md
@@ -25,7 +25,7 @@ The increment and decrement operators fall into a special category because there
   
  The following example shows how to define prefix and postfix increment and decrement operators for the `Point` class:  
   
-```  
+```cpp  
 // increment_and_decrement1.cpp  
 class Point  
 {  
@@ -86,7 +86,7 @@ int main()
   
  The same operators can be defined in file scope (globally) using the following function heads:  
   
-```  
+```cpp  
 friend Point& operator++( Point& )      // Prefix increment  
 friend Point& operator++( Point&, int ) // Postfix increment  
 friend Point& operator--( Point& )      // Prefix decrement  
@@ -95,7 +95,7 @@ friend Point& operator--( Point&, int ) // Postfix decrement
   
  The argument of type `int` that denotes the postfix form of the increment or decrement operator is not commonly used to pass arguments. It usually contains the value 0. However, it can be used as follows:  
   
-```  
+```cpp  
 // increment_and_decrement2.cpp  
 class Int  
 {  
diff --git a/docs/cpp/move-constructors-and-move-assignment-operators-cpp.md b/docs/cpp/move-constructors-and-move-assignment-operators-cpp.md
@@ -293,7 +293,8 @@ In ~MemoryBlock(). length = 75. Deleting resource.
   
  If you provide both a move constructor and a move assignment operator for your class, you can eliminate redundant code by writing the move constructor to call the move assignment operator. The following example shows a revised version of the move constructor that calls the move assignment operator:  
   
-```  
+```cpp
+  
 // Move constructor.  
 MemoryBlock(MemoryBlock&& other)  
    : _data(nullptr)  
diff --git a/docs/cpp/overview-of-declarators.md b/docs/cpp/overview-of-declarators.md
@@ -159,7 +159,7 @@ int a, *b, c[5], **d, &e=a;
   - qualified-name   
   - declarator ( argument-list ) [cv-qualfiers] [exception-spec]  
   - declarator [ [ constant-expression ] ]
-  - pointer-operatordeclarator   
+  - pointer-operator declarator   
   - ( declarator )  
 
   
diff --git a/docs/cpp/primary-expressions.md b/docs/cpp/primary-expressions.md
@@ -16,9 +16,10 @@ Primary expressions are the building blocks of more complex expressions. They ar
   
 ```  
   
-      literal  
-      this  
-      :: namename( expression )  
+literal  
+this
+name  
+::name ( expression )  
 ```  
   
  A *literal* is a constant primary expression. Its type depends on the form of its specification. See [Literals](../cpp/numeric-boolean-and-pointer-literals-cpp.md) for complete information about specifying literals.  
