template-aliases

The port of some C++11 code from Clang to g++ template<class T> using value_t = typename T::value_type; template<class> struct S { using value_type = int; static value_type const C = 0; }; template<class T> value_t<S<T>> // gcc error, typename S<T>::value_type does work const S<T>::C; int main() { static_assert(S<int>::C == 0, ""); } gives different behavior for Clang (versions 3.1 through SVN trunk) versus for any g++ version. For the latter I get errors like this prog.cc:13:13: error: conflicting declaration 'value_t<S<T> > S< <template-parameter-1-1> >::C' const S<T>::C; ^ prog.cc:8:29:

Consider the following code: template<typename F> struct S; template<typename Ret, typename... Args> struct S<Ret(Args...)> { }; template<typename... Args> using Alias = S<void(Args...)>; int main() { S<void(int)> s; Alias<int> alias; } It works fine, as expected and both the line involving S and the one involving Alias define under the hood the same type S<void(int)> . Now, consider the following changes: int main() { S<void(void)> s; // this line compiles Alias<void> alias; // this line does not } I expected it to compile, for reasons that are similar to the ones above mentioned. It goes

We have observed a strange behaviour in the compilation of the follwing source code: template<template<class> class TT> struct X { }; template<class> struct Y { }; template<class T> using Z = Y<T>; int main() { X<Y> y; X<Z> z; z = y; // it fails here } This is a slightly modified example taken from the c++11 standard proposal for template aliases: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf (See page 4) Also note that the proposal "declares y and z to be of the same type." In our interpretation it should therefore be possible to assign (or copy construct) z from y.

In C++03, template parameter deduction does not occur in some contexts. For example: template <typename T> struct B {}; template <typename T> struct A { typedef B<T> type; }; template <typename T> void f(typename A<T>::type); int main() { B<int> b; f(b); // ERROR: no match } Here, int is not deduced for T , because a nested type such as A<T>::type is a non-deduced context. Had I written the function like this: template <typename T> struct B {}; template <typename T> void f(B<T>); int main() { B<int> b; f(b); } everything is fine because B<T> is a deduced context. In C++11, however, template

Here's a simple example: class bar {}; template <typename> class foo {}; template <> using foo<int> = bar; Is this allowed? $ clang++ -std=c++0x test.cpp test.cpp:6:1: error: explicit specialization of alias templates is not permitted template <> ^~~~~~~~~~~ 1 error generated. Reference: 14.1 [temp.decls]/p3: 3 Because an alias-declaration cannot declare a template-id, it is not possible to partially or explicitly specialize an alias template. Aotium Although direct specialization of the alias is impossible, here is a workaround. (I know this is an old post but it's a useful one.) You can

I hope the title makes sense. I probably miss vocabulary to express it correctly. Well, an exemple will probably be more clear. Problem for me is: dynamic downcasting returns 0 at run time in some of the following cases (written in comments). I'd like to know if it's a correct behaviour (using C++11), also why, and what can I do to make it work. Apparently, Templated and A::A_templated are treated as different classes, despite being defined as identical by using alias "using". Problem doesn't appear for simple typedef alias. template <class T> class Templated {}; class A { public : typedef int