gcc can compile a variadic template while clang cannot

by

Clang’s behavior is correct. This is a GCC bug (and the claim in the presentation is also incorrect). §3.3.2 [basic.scope.pdecl]/p1,6:

1 The point of declaration for a name is immediately after its
complete declarator (Clause 8) and before its initializer (if any),
except as noted below.

6 After the point of declaration of a class member, the member name can
be looked up in the scope of its class.

And §3.3.7 [basic.scope.class]/p1 says

The following rules describe the scope of names declared in classes.

1) The potential scope of a name declared in a class consists not only
of the declarative region following the name’s point of declaration,
but also of all function bodies, default arguments,
exception-specifications, and brace-or-equal-initializers of
non-static data members in that class (including such things in nested
classes).

trailing-return-types are not in that list.

The trailing return type is part of the declarator (§8 [dcl.decl]/p4):

declarator:
    ptr-declarator
    noptr-declarator parameters-and-qualifiers trailing-return-type

and so the variadic version of sum isn’t in scope within its own trailing-return-type and cannot be found by name lookup.

In C++14, simply use actual return type deduction (and omit the trailing return type). In C++11, you may use a class template instead and a function template that simply forwards:

template<class T, class... Args>
struct Sum {
    static auto sum(T n, Args... rest) -> decltype(n + Sum<Args...>::sum(rest...)) {
        return n + Sum<Args...>::sum(rest...);
    }
};

template<class T>
struct Sum<T>{
    static T sum(T n) { return n; }
};

template<class T, class... Args>
auto sum(T n, Args... rest) -> decltype(Sum<T, Args...>::sum(n, rest...)){
    return Sum<T, Args...>::sum(n, rest...);
}

More Related Contents:

  1. Is there a compiler bug exposed by my implementation of an is_complete type trait?
  2. constexpr and initialization of a static const void pointer with reinterpret cast, which compiler is right?
  3. Can I use C++11 with Xcode?
  4. What are the differences between -std=c++11 and -std=gnu++11?
  5. Overloaded lambdas in C++ and differences between clang and gcc
  6. Why can’t I move std::ofstream?
  7. const auto std::initializer_list difference between Clang and GCC
  8. Optimization code for a debug function (c++11 with templates) [closed]
  9. Is cout synchronized/thread-safe?
  10. C++11 does not deduce type when std::function or lambda functions are involved
  11. Explicit specialization in non-namespace scope [duplicate]
  12. How to convert a lambda to an std::function using templates
  13. C++11 aggregate initialization for classes with non-static member initializers
  14. When to use std::forward to forward arguments?
  15. 😃 (and other Unicode characters) in identifiers not allowed by g++
  16. Preventing compiler optimizations while benchmarking
  17. What does this variadic template code do?
  18. SFINAE works differently in cases of type and non-type template parameters
  19. Can the point-of-instantiation be delayed until the end of the translation unit?
  20. Default template argument when using std::enable_if as templ. param.: why OK with two template functions that differ only in the enable_if parameter?
  21. How to pass a template function in a template argument list
  22. How can I use C++ 11 features in Clang?
  23. Why can I call a non-constexpr function inside a constexpr function?
  24. Interfacing C++11 array with Cython
  25. templated typedef?
  26. std::enable_if : parameter vs template parameter
  27. GCC std::thread not found in namespace std
  28. Is there a way to write make_unique() in VS2012?
  29. Concatenate compile-time strings in a template at compile time?
  30. using extern template (C++11) to avoid instantiation

Leave a Comment