dynamic_cast<std::integer>(C)++

March 29, 2010

The C++ Standard Committee has been hard at work defining the next version of the language. Here’s a provisional list of changes to be included:

For consistency with strings, integers have been split into built-in constants of type int (3, 100, 0xFF, etc.) and the std::integer class. The class has operator overloading to make math easy. The built-in int type no longer has these operators. Constants must be cast to the class for the operators to work:
```
Before:  5 + 6
After:   std::integer(5) + 6
```
Note that the 6 does not have to be cast because the + operator is overloaded to take integer constants, conveniently casting them for you. This new consistency between integers (and floats, doubles, char, bool, etc.) and strings will reduce confusion.
Functions often want to return pointers to local variables, or pass pointers to local variables to other functions. This isn’t safe because when the stack is unwound, those pointers are no longer valid. This has been fixed in the new standard by extending the lifetime of local variables indefinitely. The programmer is responsible for releasing the memory explicitly. For example:
```
int add(int a, int b)
{
    std::integer sum = std::integer(a) + b;

    delete &a;
    delete &b;

    int sum_value = sum.c_int();

    delete &sum;

    return sum_value;
}
```
The local variable sum was explicitly freed. Note that the parameters also had to be freed. Did you spot the bug? The local variable sum_value was returned (by value), but its address was never freed, resulting in a memory leak. APIs will have to be carefully documented to specify whose responsibility it is (caller or callee) to free both passed-in parameters and returned values. Addresses can be returned by reference parameters to pointers to variables, but remember to free those pointers too.
Current C++ compilers must maintain complicated data structures of the functions that are declared or used in each source file, in order to generate the appropriate binary object files. In order to reduce this burden on the compiler, footer files have been introduced. These are files that are included at the bottom of a .cpp file, which summarize all functions that are defined or used by that file. The format is somewhat different than a traditional .hpp file (because the needs of the compiler are different there). The standard recommends the extension .fpp for declaring these methods and their signatures.
To remove the confusion over the distinction between the NULL constant, the 0 constant (for pointers), and C++0x’s nullptr constant, and to increase type safety, the null constant is now a template:
```
MyClass *ptr = std::pointer_constants<MyClass *>::null();
```
Implementing the Singleton Pattern (Gamma et al) requires writing the boilerplate method to create a single instance. To facilitate this common pattern, the language introduces the keyword old. The program should create one instance of the object at start-up:
```
MyClass *ptr = new MyClass;
```
and other methods can get a reference to that instance using the following construct:
```
MyClass *ptr = old MyClass;
```
If there are several instances of MyClass in the heap, it is undefined which one is chosen. If there are no instances, a null reference is returned (see previous item). Be careful to not accidentally get a reference to an object on the stack.
To reflect the enhancements to the language since 1983, the name of the language has been changed to: dynamic_cast<std::integer>(C)++.

(With Drew Olbrich)