private:

int j; // Different access control

};

The last two requirements can perhaps be better illustrated with code. In the next example, even though Base is standard-layout, `Derived` is not standard layout because both it (the most derived class) and `Base` have non-static data members:

return 0;

}

- Arrays of void, scalar types or references

- A class that has a trivial destructor, and one or more constexpr constructors that are not move or copy constructors. Additionally, all its non-static data members and base classes must be literal types and not volatile.

[Basic Concepts](../cpp/basic-concepts-cpp.md)

```

```

```

[Keywords](../cpp/keywords-cpp.md)

**END Microsoft Specific**

**Microsoft Specific**

```cpp

__try {

**__finally** *compound-statement*

For related information and a code sample, see [try-except Statement](../cpp/try-except-statement.md). For more information on structured exception handling in general, see [Structured Exception Handling](../cpp/structured-exception-handling-c-cpp.md). For more information on handling exceptions in managed applications, see [Exception Handling under /clr](../windows/exception-handling-cpp-component-extensions.md).

A **goto** statement can also jump out of the guarded section, but it degrades performance because it invokes stack unwinding. The **__leave** statement is more efficient because it does not cause stack unwinding.

If a **try** block is prematurely terminated for any reason, including a jump out of the block, the system executes the associated **finally** block as a part of the process of unwinding the stack. In such cases, the [AbnormalTermination](http://msdn.microsoft.com/library/windows/desktop/ms679265) function returns **true** if called from within the **finally** block; otherwise, it returns **false**.

**END Microsoft Specific**

[Writing a Termination Handler](../cpp/writing-a-termination-handler.md)

[Structured Exception Handling (C/C++)](../cpp/structured-exception-handling-c-cpp.md)

[Keywords](../cpp/keywords-cpp.md)

```cpp

MyData md;

try {

   // Code that could throw an exception

}

```

[C++ Exception Handling](../cpp/cpp-exception-handling.md)

[Keywords](../cpp/keywords-cpp.md)

[Unhandled C++ Exceptions](../cpp/unhandled-cpp-exceptions.md)

num = num2;

cout << "unsigned val = " << num << " signed val = " << num2 << endl;

```

Notice that values are reinterpreted in both directions. If your program produces odd results in which the sign of the value seems inverted from what you expect, look for implicit conversions between signed and unsigned integral types. In the following example, the result of the expression ( 0 - 1) is implicitly converted from **int** to **unsigned int** when it's stored in `num`. This causes the bit pattern to be reinterpreted.

```cpp

unsigned int u3 = 0 - 1;

cout << u3 << endl; // prints 4294967295

```

The compiler does not warn about implicit conversions between signed and unsigned integral types. Therefore, we recommend that you avoid signed-to-unsigned conversions altogether. If you can't avoid them, then add to your code a runtime check to detect whether the value being converted is greater than or equal to zero and less than or equal to the maximum value of the signed type. Values in this range will transfer from signed to unsigned or from unsigned to signed without being reinterpreted.

```cpp

char* s = "Help" + 3;

```

```cpp

(int) x; // old-style cast, old-style syntax

int(x); // old-style cast, functional syntax

```

The C-style cast operator is identical to the call operator () and is therefore inconspicuous in code and easy to overlook. Both are bad because they're difficult to recognize at a glance or search for, and they're disparate enough to invoke any combination of **static**, **const**, and **reinterpret_cast**. Figuring out what an old-style cast actually does can be difficult and error-prone. For all these reasons, when a cast is required, we recommend that you use one of the following C++ cast operators, which in some cases are significantly more type-safe, and which express much more explicitly the programming intent:

// No error but not necessarily safe.

Base* b = new Base();

Derived* d2 = static_cast<Derived*>(b);

```

For more information, see [static_cast](../cpp/static-cast-operator.md).

}

//Output: d3 is null;

```

For more information, see [dynamic_cast](../cpp/dynamic-cast-operator.md).

const double pi = 3.14;

Func(const_cast<double&>(pi)); //No error.

}

```

For more information, see [const_cast](../cpp/const-cast-operator.md).

// to do this?

int k = reinterpret_cast<int>(str);// Programming intent is clear.

// However, it is not 64-bit safe.

```

For more information, see [reinterpret_cast Operator](../cpp/reinterpret-cast-operator.md).

[C++ Type System](../cpp/cpp-type-system-modern-cpp.md)

[Welcome Back to C++](../cpp/welcome-back-to-cpp-modern-cpp.md)

[C++ Language Reference](../cpp/cpp-language-reference.md)

ms.workload: ["cplusplus"]

class type_info {

};

```

```

```

}

```

```

```

```

[Templates](../cpp/templates-cpp.md)

[Keywords](../cpp/keywords-cpp.md)