될에게 그것의 또 다른 전문에서 순환 종속성을 상속 템플릿 수하거나

Question

아래 코드를 생각 해보자 그 소리의 버그 :

#include <iostream> 
#include <utility> 
#include <tuple> 

template <class TargetIndices, class SourceIndices> 
struct assign; 

template <size_t... TargetIs, size_t... SourceIs> 
struct assign<std::index_sequence<TargetIs...>, std::index_sequence<SourceIs...>>: assign<std::index_sequence<TargetIs>, std::index_sequence<SourceIs>>... { 
    template <class TargetTuple, class SourceTuple> 
    assign(TargetTuple &target, const SourceTuple &source): assign<std::index_sequence<TargetIs>, std::index_sequence<SourceIs>>(target, source)... { } 
}; 

template <size_t FirstTI, size_t FirstSI> 
struct assign<std::index_sequence<FirstTI>, std::index_sequence<FirstSI>> { 
    template <class TargetTuple, class SourceTuple> 
    assign(TargetTuple &target, const SourceTuple &source) { 
     std::get<FirstTI>(target) = std::get<FirstSI>(source); 
    } 
}; 


int main() { 
    std::tuple<int, int, int> t1 = std::make_tuple(0,0,0), t2 = std::make_tuple(1,2,3); 
    assign<std::index_sequence<0,2>, std::index_sequence<2,0>>(t1, t2); 
    std::cout << std::get<0>(t1) << " " << std::get<1>(t1) << " " << std::get<2>(t1) << std::endl; 
} 

연타 ++ 상속에서 순환 종속성이 있음을 주장한다. g ++는 문제없이 컴파일합니다. 어느 컴파일러가 옳은가?

Answer 1

마치 깡패처럼 보입니다.

최소한의 재생은 다음과 같습니다

template <int...> struct q {}; 

template <int... Is> using w = q<Is...>; 

template <class T> 
struct a; 

template <int F> 
struct a<w<F>> {}; 

template <int... T> 
struct a<w<T...>>: a<w<T>>... {}; // g++ OK, clang++ breaks 

템플릿 별칭이 여기에 필수적이다. 원래 템플릿이 템플릿 별칭 대신 마지막 줄에 사용되면 컴파일됩니다.

struct a<q<T...>>: a<q<T>>... {}; // g++, clang++ OK