ошибка шаблона конкретизации реф квалифицированных членов

Question

#include <iostream> 
using std::cout; 


template<typename T> 
class A{ 
    public: 
    template<typename U> 
    void f(U const&) & ; 
    template<typename U> 
    void f(U const&) && ; 
}; 


    template<typename T> 
    template<typename U> 
    void A<T>::f(U const& x) & { std::cout << "lvalue object\n" ; } 
    template<typename T> 
    template<typename U> 
    void A<T>::f(U const& x) && { std::cout << "rvalue object\n" ; } 

// template class A<int> ; 
// template void A<int>::f<int>(int const&) & ; 
// template void A<float>::f<int>(int const&) &&; 


int main(){ 

    A<int> a ; 
      a.f<int>(2); // lvalue 
    A<float>().f<int>(1); // rvalue 
} 

код работает, за исключением, если я попытаюсь разбить его на отдельные-компиляции (* .hh, * .cc, * .ie и основной). Заявления (прокомментированные) выдадут компилятор ICE.

Я не вижу ничего плохого в синтаксисе создания экземпляра. Может кто-то помочь мне в этом ...

Answer 1

Код работает, кроме, если я попытаюсь разбить его на отдельные-компиляции (* .hh, * .cc, * .ie и основной).

С помощью шаблонов вы не можете отделить заголовок и реализацию. Это должно быть все в одном месте. Вы должны сделать что-то вроде этого (имейте в виду, я не проверял это):

A.hpp:

#include <iostream> 
using std::cout; 


template<typename T> 
class A{ 
    public: 
    template<typename U> 
    void f(U const&) & ; 
    template<typename U> 
    void f(U const&) && ; 
}; 

    // Consider just throwing this in the class definition itself 
    template<typename T> 
    template<typename U> 
    void A<T>::f(U const& x) & { std::cout << "lvalue object\n" ; } 
    template<typename T> 
    template<typename U> 
    void A<T>::f(U const& x) && { std::cout << "rvalue object\n" ; } 

main.cpp

#include "A.hpp" 

int main(){ 
    A<int> a; 
      a.f<int>(2); // lvalue 
    A<float>().f<int>(1); // rvalue 
} 

Answer 2

// ---------------- *.hh ------------ 

#include <iostream> 
using std::cout; 


#include <iostream> 

template<typename T> 
class A{ 
    public: 
    void f() & ; 
    void f() && ; 
    void g() ; 
    void g(int) ; 
}; 


// ---------- *.cc -- you compile this (no linking) just lib code ------ 
#include "e.hh" 

    template<typename T> 
    void A<T>::f() & { std::cout << "lvalue object\n" ; } 
    template<typename T> 
    void A<T>::f() && { std::cout << "rvalue object\n" ; } 

    template<typename T> 
    void A<T>::g() { std::cout << "lvalue object\n" ; } 
    template<typename T> 
    void A<T>::g(int x) { std::cout << "rvalue object\n" ; } 

extern template class A<int> ; 
//extern template class A<float> ; 
//template void A<int>::f(float const&) & ; 
//template void A<int>::f<int>() && ; 

template void A<int>::f() &; 
//template void A<float>::f() && ; 


template void A<int>::g() ;  // see ! ... these work ! 
template void A<int>::g(int) ; // ... but not the ref-qual ones 

// ---------------------- *.cc (main) -------------- 
// here you compile + link the previous one 
#include <iostream> 
#include "e.hh" 
using std::cout; 


int main(){ 

    A<int> a ; 
      a.f(); // lvalue 
// A<float>().f(); // rvalue 
      a.g(); // lvalue 
      a.g(3); // lvalue 
}