Merge pull request MicrosoftDocs#1053 from msebolt/format-cpp-pr9

format cpp pr9

Author: TrishaMc

docs/cpp/unhook.md

@@ -44,8 +44,8 @@ long  __unhook(
 
 -   Managed events: *SourceClass* is the event source class and *EventMethod* is the event.  
 
- `interface`  
- The interface name being unhooked from `receiver`, only for COM event receivers in which the *layout_dependent* parameter of the [event_receiver](../windows/event-receiver.md) attribute is **true**.  
+ *interface*  
+ The interface name being unhooked from *receiver*, only for COM event receivers in which the *layout_dependent* parameter of the [event_receiver](../windows/event-receiver.md) attribute is **true**.  
 
  *source*  
  A pointer to an instance of the event source. Depending on the code `type` specified in **event_receiver**, *source* can be one of the following:  
@@ -57,34 +57,34 @@ long  __unhook(
 -   A managed object pointer (for managed events).  
 
  **&** *ReceiverClass* `::` `HandlerMethod`  
- A pointer to the event handler method to be unhooked from an event. The handler is specified as a method of a class or a reference to the same; if you do not specify the class name, `__unhook` assumes the class to be that in which it is called.  
+ A pointer to the event handler method to be unhooked from an event. The handler is specified as a method of a class or a reference to the same; if you do not specify the class name, **__unhook** assumes the class to be that in which it is called.  
 
 -   Native C++ events: *ReceiverClass* is the event receiver class and `HandlerMethod` is the handler.  
 
 -   COM events: *ReceiverClass* is the event receiver interface and `HandlerMethod` is one of its handlers.  
 
 -   Managed events: *ReceiverClass* is the event receiver class and `HandlerMethod` is the handler.  
 
- `receiver`(optional)  
- A pointer to an instance of the event receiver class. If you do not specify a receiver, the default is the receiver class or structure in which `__unhook` is called.  
+ *receiver*(optional)  
+ A pointer to an instance of the event receiver class. If you do not specify a receiver, the default is the receiver class or structure in which **__unhook** is called.  
 
 ## Usage  
  Can be use in any function scope, including main, outside the event receiver class.  
 
 ## Remarks  
- Use the intrinsic function `__unhook` in an event receiver to dissociate or "unhook" a handler method from an event method.  
+ Use the intrinsic function **__unhook** in an event receiver to dissociate or "unhook" a handler method from an event method.  
 
- There are three forms of `__unhook`. You can use the first (four-argument) form in most cases. You can use the second (two-argument) form of `__unhook` only for a COM event receiver; this unhooks the entire event interface. You can use the third (one-argument) form to unhook all delegates from the specified source.  
+ There are three forms of **__unhook**. You can use the first (four-argument) form in most cases. You can use the second (two-argument) form of **__unhook** only for a COM event receiver; this unhooks the entire event interface. You can use the third (one-argument) form to unhook all delegates from the specified source.  
 
  A nonzero return value indicates that an error has occurred (managed events will throw an exception).  
 
- If you call `__unhook` on an event and event handler that are not already hooked, it will have no effect.  
+ If you call **__unhook** on an event and event handler that are not already hooked, it will have no effect.  
 
  At compile time, the compiler verifies that the event exists and does parameter type checking with the specified handler.  
 
- With the exception of COM events, `__hook` and `__unhook` can be called outside the event receiver.  
+ With the exception of COM events, **__hook** and **__unhook** can be called outside the event receiver.  
 
- An alternative to using `__unhook` is to use the -= operator.  
+ An alternative to using **__unhook** is to use the -= operator.  
 
  For information on coding managed events in the new syntax, see [event](../windows/event-cpp-component-extensions.md).  
 

docs/cpp/uniform-initialization-and-delegating-constructors.md

@@ -82,7 +82,7 @@ int main()
 }  
 ```  
   
- You can use brace initialization anywhere you would typically do initialization—for example, as a function parameter or a return value, or with the `new` keyword:  
+ You can use brace initialization anywhere you would typically do initialization—for example, as a function parameter or a return value, or with the **new** keyword:  
   
 ```cpp  
 class_d* cf = new class_d{4.5};  

docs/cpp/unions.md

@@ -13,7 +13,7 @@ ms.author: "mblome"
 ms.workload: ["cplusplus"]
 ---
 # Unions
-A `union` is a user-defined type in which all members share the same memory location. This means that at any given time a union can contain no more than one object from its list of members. It also means that no matter how many members a union has, it always uses only enough memory to store the largest member.  
+A **union** is a user-defined type in which all members share the same memory location. This means that at any given time a union can contain no more than one object from its list of members. It also means that no matter how many members a union has, it always uses only enough memory to store the largest member.  
 
  Unions can be useful for conserving memory when you have lots of objects and/or limited memory. However they require extra care to use correctly because you are responsible for ensuring that you always access the last member that was written to. If any member types have a non-trivial constructor, then you must write additional code to explicitly construct and destroy that member. Before using a union, consider whether the problem you are trying to solve could be better expressed by using a base class and derived classes.  
 
@@ -24,16 +24,16 @@ union [name]  { member-list };
 ```  
   
 #### Parameters  
- `name`  
+ *name*  
  The type name given to the union.  
   
- `member-list`  
+ *member-list*  
  Members that the union can contain. See Remarks.  
   
 ## Remarks  
   
 ## Declaring a Union  
- Begin the declaration of a union with the `union` keyword, and enclose the member list in curly braces:  
+ Begin the declaration of a union with the **union** keyword, and enclose the member list in curly braces:  
   
 ```cpp  
 // declaring_a_union.cpp  

docs/cpp/user-defined-literals-cpp.md

@@ -94,7 +94,7 @@ int main(int argc, char* argv[])
 }  
 ```  
   
- Note that the literal number must use a decimal, otherwise the number would be interpreted as an integer and the type would not be compatible with the operator. Also note that for floating point input, the type must be `long double`, and for integral types it must be `long long`.  
+ Note that the literal number must use a decimal, otherwise the number would be interpreted as an integer and the type would not be compatible with the operator. Also note that for floating point input, the type must be **long double**, and for integral types it must be **long long**.  
   
 ## Raw literals  
  In a raw user-defined literal, the operator that you define accepts the literal as a sequence of char values and it is up to you to interpret that sequence as a number or string or other type. In the list of operators shown earlier in this page, `_r` and `_t` can be used to define raw literals: