RomandevJavaScript
diff --git a/‎docs/cpp/templates-cpp.md‎
Lines changed: 5 additions & 5 deletions b/‎docs/cpp/templates-cpp.md‎
Lines changed: 5 additions & 5 deletions
diff --git a/‎docs/cpp/temporary-objects.md‎
Lines changed: 1 addition & 1 deletion b/‎docs/cpp/temporary-objects.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎docs/cpp/this-pointer.md‎
Lines changed: 9 additions & 9 deletions b/‎docs/cpp/this-pointer.md‎
Lines changed: 9 additions & 9 deletions
diff --git a/‎docs/cpp/tokens-cpp.md‎
Lines changed: 2 additions & 2 deletions b/‎docs/cpp/tokens-cpp.md‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎docs/cpp/transfers-of-control.md‎
Lines changed: 1 addition & 1 deletion b/‎docs/cpp/transfers-of-control.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎docs/cpp/true-cpp.md‎
Lines changed: 2 additions & 2 deletions b/‎docs/cpp/true-cpp.md‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎docs/cpp/try-except-statement.md‎
Lines changed: 1 addition & 1 deletion b/‎docs/cpp/try-except-statement.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎docs/cpp/try-finally-statement.md‎
Lines changed: 1 addition & 1 deletion b/‎docs/cpp/try-finally-statement.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎docs/cpp/try-throw-and-catch-statements-cpp.md‎
Lines changed: 2 additions & 2 deletions b/‎docs/cpp/try-throw-and-catch-statements-cpp.md‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎docs/cpp/typeid-operator.md‎
Lines changed: 5 additions & 7 deletions b/‎docs/cpp/typeid-operator.md‎
Lines changed: 5 additions & 7 deletions
@@ -30,7 +30,7 @@ T minimum(const T& lhs, const T& rhs)
   
  Elsewhere, a user can declare an instance of the template  that is specialized for int. Assume that get_a() and get_b() are functions that return an int:  
   
-```  
+```cpp 
 int a = get_a();  
 int b = get_b();  
 int i = minimum<int>(a, b);  
@@ -44,7 +44,7 @@ int i = minimum(a, b);
 
  When the compiler encounters that last statement, it generates a new function in which every occurrence of *T* in the template is replaced with `int`:  
 
-```  
+```cpp 
 
       int minimum(const int& lhs, const int& rhs)  
 {  
@@ -66,7 +66,7 @@ template <typename T, typename U, typename V> class Foo{};
 
  The keyword `class` is equivalent to `typename` in this context. You can express the previous example as:  
 
-```  
+```cpp 
 template <class T, class U, class V> class Foo{};   
 ```  
   
@@ -103,7 +103,7 @@ int main()
 
  There is no inherent requirement that the type arguments for any particular template all belong to the same object hierarchy, although you can define a template that enforces such a restriction. You can combine object-oriented techniques with templates; for example, you can store a Derived* in a vector\<Base\*>.    Note that the arguments must be pointers  
 
-```  
+```cpp 
 vector<MyClass*> vec;  
    MyDerived d(3, L"back again", time(0));  
    vec.push_back(&d);  
@@ -118,7 +118,7 @@ vector<MyClass*> vec;
 ## Non-type parameters  
  Unlike generic types in other languages such as C# and Java, C++ templates support non-type parameters, also called value parameters. For example, you can provide a constant integral value to specify the length of an array, as with this example that is similar to the std::array class in the Standard Library:  
   
-```  
+```cpp 
 template<typename T, size_t L>  
 class MyArray  
 {  
 
@@ -18,7 +18,7 @@ In some cases, it is necessary for the compiler to create temporary objects. The
 
 -   To store the return value of a function that returns a user-defined type. These temporaries are created only if your program does not copy the return value to an object. For example:  
 
-    ```  
+    ```cpp 
     UDT Func1();    //  Declare a function that returns a user-defined  
                     //   type.  
 
 
@@ -19,26 +19,26 @@ The **this** pointer is a pointer accessible only within the nonstatic member fu
 
 ```  
   
-      this   
+this   
 this->member-identifier  
 ```  
 
 ## Remarks  
  An object's **this** pointer is not part of the object itself; it is not reflected in the result of a `sizeof` statement on the object. Instead, when a nonstatic member function is called for an object, the address of the object is passed by the compiler as a hidden argument to the function. For example, the following function call:  
 
-```  
+```cpp 
 myDate.setMonth( 3 );  
 ```  
 
  can be interpreted this way:  
 
-```  
+```cpp 
 setMonth( &myDate, 3 );  
 ```  
   
  The object's address is available from within the member function as the **this** pointer. Most uses of **this** are implicit. It is legal, though unnecessary, to explicitly use **this** when referring to members of the class. For example:  
   
-```  
+```cpp 
 void Date::setMonth( int mn )  
 {  
    month = mn;            // These three statements  
@@ -49,13 +49,13 @@ void Date::setMonth( int mn )
 
  The expression `*this` is commonly used to return the current object from a member function:  
 
-```  
+```cpp 
 return *this;  
 ```  
 
  The **this** pointer is also used to guard against self-reference:  
 
-```  
+```cpp 
 if (&Object != this) {  
 // do not execute in cases of self-reference  
 ```  
@@ -67,7 +67,7 @@ if (&Object != this) {
   
 ## Example  
   
-```  
+```cpp 
 // this_pointer.cpp  
 // compile with: /EHsc  
   
@@ -140,7 +140,7 @@ your buffer
 
  Consider this example:  
 
-```  
+```cpp 
 // type_of_this_pointer1.cpp  
 class Point  
 {  
@@ -153,7 +153,7 @@ int main()
 
  The preceding code declares a member function, `X`, in which the **this** pointer is treated as a **const** pointer to a **const** object. Combinations of *cv-mod-list* options can be used, but they always modify the object pointed to by **this**, not the **this** pointer itself. Therefore, the following declaration declares function `X`; the **this** pointer is a **const** pointer to a **const** object:  
 
-```  
+```cpp 
 // type_of_this_pointer2.cpp  
 class Point  
 {  
 
@@ -32,13 +32,13 @@ A token is the smallest element of a C++ program that is meaningful to the compi
 
  The parser separates tokens from the input stream by creating the longest token possible using the input characters in a left-to-right scan. Consider this code fragment:  
 
-```  
+```cpp 
 a = i+++j;  
 ```  
 
  The programmer who wrote the code might have intended either of these two statements:  
 
-```  
+```cpp 
 a = i + (++j)  
 
 a = (i++) + j  
 
@@ -16,7 +16,7 @@ You can use the `goto` statement or a **case** label in a `switch` statement to
 
  The following example shows a loop that declares and initializes the objects `total`, `ch`, and `i`. There is also an erroneous `goto` statement that transfers control past an initializer.  
 
-```  
+```cpp 
 // transfers_of_control.cpp  
 // compile with: /W1  
 // Read input until a nonnumeric character is entered.  
 
@@ -17,7 +17,7 @@ ms.workload: ["cplusplus"]
 
 ```  
   
-      bool-identifier = true ;  
+bool-identifier = true ;  
 bool-expression logical-operator true ;  
 ```  
 
@@ -26,7 +26,7 @@ bool-expression logical-operator true ;
 
 ## Example  
 
-```  
+```cpp 
 // bool_true.cpp  
 #include <stdio.h>  
 int main()  
 
@@ -148,7 +148,7 @@ int main()
 
 ## Output  
 
-```  
+```Output 
 hello  
 in try  
 in try  
 
@@ -17,7 +17,7 @@ ms.workload: ["cplusplus"]
 
  The following syntax describes the `try-finally` statement:  
 
-```  
+```cpp 
 __try {  
    // guarded code  
 }  
 
@@ -25,7 +25,7 @@ To implement exception handling in C++, you use `try`, `throw`, and `catch` expr
 
 ## Example  
 
-```  
+```cpp 
 
 MyData md;  
 try {  
@@ -63,7 +63,7 @@ MyData GetNetworkResource()
 
  A `throw` expression that has no operand re-throws the exception currently being handled. We recommend this form when re-throwing the exception, because this preserves the original exception’s polymorphic type information. Such an expression should only be used in a `catch` handler or in a function that's called from a `catch` handler. The re-thrown exception object is the original exception object, not a copy.  
 
-```  
+```cpp 
 try {  
    throw CSomeOtherException();  
 }  
 
@@ -16,10 +16,8 @@ ms.workload: ["cplusplus"]
 
 ```  
   
-      typeid(   
-      type-id  
-       )  
-typeid( expression )  
+typeid(type-id)  
+typeid(expression)  
 ```  
 
 ## Remarks  
@@ -39,7 +37,7 @@ typeid( expression )
 
  If the *expression* points to a base class type, yet the object is actually of a type derived from that base class, a **type_info** reference for the derived class is the result. The *expression* must point to a polymorphic type (a class with virtual functions). Otherwise, the result is the **type_info** for the static class referred to in the *expression*. Further, the pointer must be dereferenced so that the object it points to is used. Without dereferencing the pointer, the result will be the **type_info** for the pointer, not what it points to. For example:  
 
-```  
+```cpp 
 // expre_typeid_Operator.cpp  
 // compile with: /GR /EHsc  
 #include <iostream>  
@@ -68,7 +66,7 @@ int main() {
   
  If the *expression* is neither a pointer nor a reference to a base class of the object, the result is a **type_info** reference representing the static type of the *expression*. The *static type* of an expression refers to the type of an expression as it is known at compile time. Execution semantics are ignored when evaluating the static type of an expression. Furthermore, references are ignored when possible when determining the static type of an expression:  
   
-```  
+```cpp 
 // expre_typeid_Operator_2.cpp  
 #include <typeinfo>  
   
@@ -80,7 +78,7 @@ int main()
 
  **typeid** can also be used in templates to determine the type of a template parameter:  
 
-```  
+```cpp 
 // expre_typeid_Operator_3.cpp  
 // compile with: /c  
 #include <typeinfo>
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ ms.workload: ["cplusplus"]`
`17`	`17`
`18`	`18`	The following syntax describes the `try-finally` statement:
`19`	`19`
`20`		-```
	`20`	+```cpp
`21`	`21`	`__try {`
`22`	`22`	`// guarded code`
`23`	`23`	`}`