Some of the important changs in Visual Studio 2010 in regard to VC++ are represented by the support in the C++ compiler of some of the features already approved for the new C++ standard, so far called C++0x. In this post I will give a short overview on then.
static_assert
I already wrote a post about this feature. At that time I considered it rather a niche feature. However, this looks much powerful in conjunction with the type traits classes from TR1.
static_assert checks if an expression is true at compile time. If the expression if false a custom error message is displayed and the compilation fails. If the expression is true the declaration has no effect.
In the following example I create a comparison template function, that is used later to compare values.
template < typename T >
bool CompareNumbers(T v1, T v2)
{
return v1 > v2;
}
int main()
{
bool ret1 = CompareNumbers(1, 20);
bool ret2 = CompareNumbers("b", "a");
return 0;
}
I want this function to be used only for integral types (the reason doesn’t matter) and I’d like the compiler to issue an error when used with any other type. Adding a static_assert check will generate a compilation error for the second call to the function, when passing strings.
#include < type_traits >
template < typename T >
bool CompareNumbers(T v1, T v2)
{
static_assert(std::tr1::is_integral< T >::value, "Type is not numeric");
return v1 > v2;
}
1>d:\marius\vc++\cpp0x\cpp0x.cpp(62): error C2338: Type is not numeric 1> d:\marius\vc++\trainnings\cpp0x\cpp0x.cpp(75) : see reference to function template instantiation 'bool CompareNumbers(T,T)' being compiled 1> with 1> [ 1> T=const char * 1> ]
auto
If you are familiar with C#, this is the C++ equivalent of var. The keyword is used to deduce the type of a declared variable from its initialization expression. The initialization expression can be an assignment, direct initialization or operator new expression. It must be noted that the auto keyword is just a placeholder, not a type, and cannot be used with sizeof or typeid.
auto i = 13; // i is int
auto s = "marius"; // s is std::string
auto p = new foo(); // p is foo*
vector< int > numbers;
generate_n(back_inserter(numbers), 10, rand);
for(auto it = numbers.begin(); it != numbers.end(); ++it)
{
cout << *it << endl;
}
lambda expressions
I already wrote about lambdas, but I will give a short overview again. Again, if you are familiar with C# and .NET, this is the same concept as in .NET.
A lambda functions is a function object whose type is implementation dependent; its type name is only available to the compiler. The lambda expression is composed of several parts:
- lambda_introducer: this is the part that tells the compiler a lambda function is following. Inside the angled brackets a capture-list can be provided; this is used for capturing variables from the scope in which the lambda is created.
- lambda-parameter-declaration: used for specifying the parameters of the lambda function.
- lambda-return-type-clause: used for indicating the type returned by the lambda function. This is optional, because most of the time the compiler can infer the type. There are cases when this is not possible and then the type must be specified. For the example above, the return type (-> bool) is not necessary.
- compound-statement: this is the body of the lambda.
vector<int> numbers;
generate_n(back_inserter(numbers), 10, rand);
for_each(numbers.begin(), numbers.end(), [](int n) {cout << n << endl;});
Here [] is the lambda introducer, (int n) is the lambda parameter declaration, and {cout << n << endl;} is the lambda compound statement. There is no return type clause, because that is auto inferred by the compiler. There are cases when the compiler cannot deduce the return value and then it must be specified explicitly. A lambda expression is a syntactic shortcut for a functor. The code above is equivalent to:
class functor_lambda
{
public:
void operator()(int n) const
{
cout << n << endl;
}
};
vector<int> numbers;
generate_n(back_inserter(numbers), 10, rand);
for_each(numbers.begin(), numbers.end(), functor_lambda());
Lambdas can capture variables from their scope by value, reference or both in any combination. In the example above, there was no value captured. This is a stateless lambda. On the other hand, a lambda that captures variables is said to have a state.
rvalue references
Stephan T. Lavavej wrote the ultimate guide to rvalue references. There is nothing more that can be said that is not already there. I strongly suggest you read his article to familiarize with this concept.
rvalue references are used to hold a reference to a rvalue or lvalue expression, and are introduced with &&. They enable the implementation of move semantics and perfect forwarding.
Move semantics enable transferring resources from one temporary object to another. This is possible because temporary objects (i.e. rvalues) are not referred anywhere else outside the expression in which they live. To implement move semantics you have to provide a move constructor and optionally a move assignment operator. The Standard Template Library was changed to take advantage of this feature. A classic example for the move semantics is represented by operation with sequences like vector or list. A vector allocates memory for a given number of objects. You can add elements to it and no re-allocation is done until the full capacity is reached. But when that happens, the vector has to reallocate memory. In this case it allocates a new larger chunk, copies all the existing content, and then releases the pervious memory. When an insertion operation needs to copy one element several things happen: a new element is created, its copy constructor is called, and then the old element is destroyed. With moves semantics, the allocation of a new element and its copy is no longer necessary, the existing element can be directly moved.
A second scenario where rvalue references are helpful is the perfect forwarding. The forwarding problem occurs when a generic function takes references as parameters and then needs to forward these parameters to another function. If a generic function takes a parameter of type const T& and needs to call a function that takes T&, it can’t do that. So you need an overloaded generic function. What rvalue references enable is having one single generic function that takes arbitrary arguments and then forwards them to another function.
decltype operator
This is used to yield the type of an expression. Its primary purpose is for generic programming, in conjunction with auto, for return types of generic functions where the type depends on the arguments of the function. Here are several examples:
double d = 42.0; // decltype(i) yields double
const int&& f(); // decltype(f()) yields const int&&
struct foo {int i;}; // decltype(f.i) yields int (f being an object of type foo)
It can be used together with auto to declare late specified return type, with the alternative function declaration syntax, which is (terms in squared brackets indicate optional parts)
auto function_name([parameters]) [const] [volatile] -> decltype(expression) [throw] {function_body};
In general, the expression use with decltype here should match the expression used in the return statement.
struct Liters
{
double value;
explicit Liters(double val):value(val){}
};
struct Gallons
{
double value;
explicit Gallons(double val):value(val){}
};
ostream& operator<<(ostream& os, const Liters& l)
{
os << l.value << "l";
return os;
}
ostream& operator<<(ostream& os, const Gallons& g)
{
os << g.value << "gal";
return os;
}
Liters operator+(const Liters& l1, const Liters& l2)
{
return Liters(l1.value + l2.value);
}
Gallons operator+(const Gallons& g1, const Gallons& g2)
{
return Gallons(g1.value + g2.value);
}
Liters operator+(const Liters& l, const Gallons& g)
{
return Liters(l.value + g.value*3.785);
}
Gallons operator+(const Gallons& g, const Liters& l)
{
return Gallons(g.value + l.value*0.264);
}
template <typename T1, typename T2>
auto Plus(T1&& v1, T2&& v2) -> decltype(forward< T1 >(v1) + forward< T2 >(v2))
{
return forward< T1 >(v1) + forward< T2 >(v2);
}
int main()
{
cout << Plus(l1, l2) << endl;
cout << Plus(g1, g2) << endl;
cout << Plus(l1, g1) << endl;
cout << Plus(g2, l2) << endl;
return 0;
}
The result of the execution is:
15l
30gal
42.85l
22.64gal
When function Plus is called with arguments of the same type, the result is that type. But when the arguments differ, the resulting type is also different. In this example, when the first argument is Liters and second is Gallons, the result type must be Liters and the opposite. It is possible to do this without decltype, but the solution requires explicit specification of the resulting type.
template <typename T, typename T1, typename T2>
T Plus(T1&& v1, T2&& v2)
{
return forward< T1 >(v1) + forward< T2 >(v2);
}
int main()
{
cout << Plus<Liters>(l1, l2) << endl;
cout << Plus<Gallons>(g1, g2) << endl;
cout << Plus<Liters>(l1, g1) << endl;
cout << Plus<Gallons>(g2, l2) << endl;
return 0;
}
