Esempio n. 1
0
// Example from C++11 Wiki web page:
// C++ has always had the concept of constant expressions. These are expressions such as 3+4 that will 
// always yield the same results, at compile time and at run time. Constant expressions are optimization 
// opportunities for compilers, and compilers frequently execute them at compile time and hardcode the 
// results in the program. Also, there are a number of places where the C++ specification requires the 
// use of constant expressions. Defining an array requires a constant expression, and enumerator values 
// must be constant expressions.

// However, constant expressions have always ended whenever a function call or object constructor was 
// encountered. So a piece of code as simple as this is illegal:

int get_five() {return 5;}
 
int some_value[get_five() + 7]; // Create an array of 12 integers. Ill-formed C++

// This was not legal in C++03, because get_five() + 7 is not a constant expression. A C++03 compiler 
// has no way of knowing if get_five() actually is constant at runtime. In theory, this function could 
// affect a global variable, call other non-runtime constant functions, etc.

// C++11 introduced the keyword constexpr, which allows the user to guarantee that a function or object 
// constructor is a compile-time constant [8]. The above example can be rewritten as follows:

constexpr int get_five() {return 5;}
 
int some_value[get_five() + 7]; // Create an array of 12 integers. Legal C++11

// This allows the compiler to understand, and verify, that get_five is a compile-time constant.

// The use of constexpr on a function imposes some limitations on what that function can do. First, the 
// function must have a non-void return type. Second, the function body cannot declare variables or define 
// new types. Third, the body may contain only declarations, null statements and a single return statement. 
Esempio n. 2
0
//    Core language runtime performance enhancements
//        Rvalue references and move constructors

class A {
    A& operator=(A&& rhs) {
    }
};

//        Generalized constant expressions 

// GCC 4.6
constexpr int get_five() {return 5;}
int some_value[get_five() + 7];

constexpr double acceleration_due_to_gravity = 9.8;
constexpr double moon_gravity = acceleration_due_to_gravity / 6.0;

//        Modification to the definition of plain old data 


//    Core language build time performance enhancements
//        Extern template 

template<class T> class B {
};
extern template class B<int>;


//    Core language usability enhancements
//        Initializer lists