@@ -57,7 +57,7 @@ In addition to the above restrictions, when using the [/clr (Common Language Run
 |-------------|---------------------|
 |**_malloca**|\<malloc.h>|
 
-## Example: malloca simple
+## Example: malloca
 
 ```C
 // crt_malloca_simple.c
 
@@ -134,7 +134,7 @@ Output:
 character count = 79
 ```
 
-## Example: _swprintf_p returns error code
+## Example: Error code handling
 
 ```C
 // crt_swprintf_p.c
 
@@ -147,7 +147,7 @@ Output:
 character count = 79
 ```
 
-## Example: swprintf_s returns error code
+## Example: Error code handling
 
 ```C
 // crt_swprintf_s.c
 
@@ -152,7 +152,7 @@ Output:
 character count = 79
 ```
 
-## Example: swprintf returns error code
+## Example: Error code handling
 
 ```C
 // crt_swprintf.c
 
@@ -63,7 +63,7 @@ Specifies type to be allocated; it can be either a built-in or user-defined type
 *initializer*<br/>
 Provides a value for the initialized object. Initializers cannot be specified for arrays. The **`new`** operator will create arrays of objects only if the class has a default constructor.
 
-## Example: Allocates character array and object
+## Example: Allocate character array and object
 
 The following code example allocates a character array and an object of class `CName` and then frees them.
 
@@ -108,7 +108,7 @@ int main() {
 }
 ```
 
-## Example: new operator
+## Example: `new` operator
 
 If you use the placement new form of the **`new`** operator, the form with arguments in addition to the size of the allocation, the compiler does not support a placement form of the **`delete`** operator if the constructor throws an exception. For example:
 
 
@@ -28,7 +28,7 @@ A global data item can normally be initialized only once in an EXE or DLL projec
 > [!NOTE]
 > **`selectany`** can only be applied to the actual initialization of global data items that are externally visible.
 
-## Example: selectany attribute
+## Example: `selectany` attribute
 
 This code shows how to use the **`selectany`** attribute:
 
@@ -62,7 +62,7 @@ int i;
 __declspec(selectany) X x(1);
 ```
 
-## Example: Use selectany attribute to ensure data COMDAT folding
+## Example: Use `selectany` attribute to ensure data COMDAT folding
 
 This code shows how to use the **`selectany`** attribute to ensure data COMDAT folding when you also use the [`/OPT:ICF`](../build/reference/opt-optimizations.md) linker option. Note that data must be marked with **`selectany`** and placed in a **`const`** (readonly) section. You must explicitly specify the read-only section.
 
 
@@ -39,7 +39,7 @@ You can use the **`static_assert`** keyword at namespace, class, or block scope.
 
 In the following example, the **`static_assert`** declaration has namespace scope. Because the compiler knows the size of type `void *`, the expression is evaluated immediately.
 
-## Example: static_assert with namespace scope
+## Example: `static_assert` with namespace scope
 
 ```cpp
 static_assert(sizeof(void *) == 4, "64-bit code generation is not supported.");
@@ -49,7 +49,7 @@ static_assert(sizeof(void *) == 4, "64-bit code generation is not supported.");
 
 In the following example, the **`static_assert`** declaration has class scope. The **`static_assert`** verifies that a template parameter is a *plain old data* (POD) type. The compiler examines the **`static_assert`** declaration when it is declared, but does not evaluate the *constant-expression* parameter until the `basic_string` class template is instantiated in `main()`.
 
-## Example: static_assert with class scope
+## Example: `static_assert` with class scope
 
 ```cpp
 #include <type_traits>
@@ -74,11 +74,11 @@ int main()
 }
 ```
 
-## Description of static_assert with block scope
+## Description of `static_assert` with block scope
 
 In the following example, the **`static_assert`** declaration has block scope. The **`static_assert`** verifies that the size of the VMPage structure is equal to the virtual memory pagesize of the system.
 
-## Example: static_assert with block scope
+## Example: `static_assert` with block scope
 
 ```cpp
 #include <sys/param.h> // defines PAGESIZE
 
@@ -171,7 +171,7 @@ Null pointer!
 3 87 8 100
 ```
 
-## Example: Define partial specialization so one type is in
+## Example: Define partial specialization so one type is `int`
 
 The following example defines a template class that takes pairs of any two types and then defines a partial specialization of that template class specialized so that one of the types is **`int`**. The specialization defines an additional sort method that implements a simple bubble sort based on the integer.
 
 
@@ -30,7 +30,7 @@ using declarator-list ;
 
 A using declaration introduces an unqualified name as a synonym for an entity declared elsewhere. It allows a single name from a specific namespace to be used without explicit qualification in the declaration region in which it appears. This is in contrast to the [using directive](../cpp/namespaces-cpp.md#using_directives), which allows *all* the names in a namespace to be used without qualification. The **`using`** keyword is also used for [type aliases](../cpp/aliases-and-typedefs-cpp.md).
 
-## Example: using declaration in class field
+## Example: `using` declaration in class field
 
 A using declaration can be used in a class definition.
 
@@ -76,7 +76,7 @@ In B::f()
 In B::g()
 ```
 
-## Example: using declaration to declare a member
+## Example: `using` declaration to declare a member
 
 When used to declare a member, a using declaration must refer to a member of a base class.
 
@@ -185,7 +185,7 @@ void b() {
 }
 ```
 
-## Example: Local declarations and using declarations
+## Example: Local declarations and `using` declarations
 
 With respect to functions in namespaces, if a set of local declarations and using declarations for a single name are given in a declarative region, they must all refer to the same entity, or they must all refer to functions.
 
@@ -208,7 +208,7 @@ void g() {
 
 In the example above, the `using B::i` statement causes a second `int i` to be declared in the `g()` function. The `using B::f` statement does not conflict with the `f(char)` function because the function names introduced by `B::f` have different parameter types.
 
-## Example: Local function declarations and using declarations
+## Example: Local function declarations and `using` declarations
 
 A local function declaration cannot have the same name and type as a function introduced by using declaration. For example:
 
@@ -235,7 +235,7 @@ void h() {
 }
 ```
 
-## Example: using declaration and inheritance
+## Example: `using` declaration and inheritance
 
 With respect to inheritance, when a using declaration introduces a name from a base class into a derived class scope, member functions in the derived class override virtual member functions with the same name and argument types in the base class.
 
@@ -293,7 +293,7 @@ In B::g
 In D::g(char)
 ```
 
-## Example: using declaration accessibility
+## Example: `using` declaration accessibility
 
 All instances of a name mentioned in a using declaration must be accessible. In particular, if a derived class uses a using declaration to access a member of a base class, the member name must be accessible. If the name is that of an overloaded member function, then all functions named must be accessible.
 
 
@@ -14,7 +14,7 @@ The [DynamicConsumer](https://github.com/Microsoft/VCSamples/tree/master/VC2008S
 
 [CDynamicAccessor](../../data/oledb/cdynamicaccessor-class.md) allows you to access a data source when you have no knowledge of the database schema (the database's underlying structure). `CDynamicAccessor` methods get column information such as column names, count, and data type. You use this column information to create an accessor dynamically at run time. The column information is stored in a buffer that is created and managed by this class. Get data from the buffer using the [GetValue](./cdynamicaccessor-class.md#getvalue) method.
 
-## Example: Dynamic accessors
+## Example: CDynamic accessors
 
 ```cpp
 // Using_Dynamic_Accessors.cpp