다중 상속을 사용하는 복사 할당 연산자

Question

아래의 복사 생성자가 제대로 작동하지만 복사 할당 연산자가 잘못되었음을 이해하지 못합니다.

#include <iostream> 

template <typename... Ts> class foo; 

template <typename Last> 
class foo<Last> { 
    Last last; 
public: 
    foo (Last r) : last(r) { } 
    foo() = default; 
    foo (const foo& other) : last(other.last) { } 

    foo& operator= (const foo& other) { 
     last = other.last; 
     return *this; 
    } 
}; 

template <typename First, typename... Rest> 
class foo<First, Rest...> : public foo<Rest...> { 
    First first; 
public: 
    foo (First f, Rest... rest) : foo<Rest...>(rest...), first(f) { } 
    foo() = default; 
    foo (const foo& other) : foo<Rest...>(other), first(other.first) { std::cout << "[Copy constructor called]\n"; } 

    foo& operator= (const foo& other) { // Copy assignment operator 
     if (&other == this) 
      return *this; 
     first = other.first; 
     return foo<Rest...>::operator= (other); 
    } 
}; 

int main() { 
    const foo<int, char, bool> a(4, 'c', true); 
    foo<int, char, bool> b = a; // Copy constructor works fine. 
    foo<int, char, bool> c; 
// c = a; // Won't compile. 
} 

오류 메시지 :

error: invalid initialization of reference of type 'foo<int, char, bool>&' from expression of type 'foo<char, bool>' 
     return foo<Rest...>::operator= (other); 
              ^

누군가가 여기에 문제를 지적 할 수 있습니까?

Answer 1

귀하의 return 문

return foo<Rest...>::operator= (other); 

돌려 foo<Rest...> (즉으로 정의 참조 operator=의 유형이다). 그러나 연산자를 사용하면 foo<First, Rest...>&을 돌려 주어야합니다.

기본적으로 Derived& 참조가 예상되는 Base을 반환합니다. 이 참조는 단순히 묶이지 않습니다.

Fortunatly 수정 방법은 간단합니다. foo<Rest...>::operator=의 결과를 반환하지 말고 대신 *this을 반환하십시오.

foo& operator= (const foo& other) { // Copy assignment operator 
    if (&other == this) 
     return *this; 
    first = other.first; 
    foo<Rest...>::operator= (other); 
    return *this; 
} 

Answer 2

는 파생 클래스에서 operator=에서 반환처럼 보이는 것은 올바르지 않습니다 : 그것은 기본 클래스를 반환

return foo<Rest...>::operator= (other); 

, 그것은 *this을해야합니다 동안. 이야기꾼에

this -> foo<Rest...>::operator= (other); 
return *this; 

Answer 3

감사로 변경, 여기에 완전히 컴파일 최적화 된 솔루션입니다 (연산자 = 자기 할당을 확인하지 않는 다른 이름 멤버 이름 copy_data에 위임, 재귀 적 구현) :

#include <iostream> 

template <typename... Ts> class foo; 

template <typename Last> 
class foo<Last> { 
    Last last; 
public: 
    foo (Last r) : last(r) { } 
    foo() = default; 
    foo (const foo& other) : last(other.last) { } 

    foo& operator= (const foo& other) { 
     if (&other == this) 
      return *this; 
     last = other.last; 
     return *this; 
    } 
protected: 
    void copy_data (const foo& other) { 
     last = other.last; 
    } 
}; 

template <typename First, typename... Rest> 
class foo<First, Rest...> : public foo<Rest...> { 
    First first; 
public: 
    foo (First f, Rest... rest) : foo<Rest...>(rest...), first(f) { } 
    foo() = default; 
    foo (const foo& other) : foo<Rest...>(other), first(other.first) { std::cout << "[Copy constructor called]\n"; } 

    foo& operator= (const foo& other) { // Copy assignment operator 
     if (&other == this) 
      return *this; 
     first = other.first; 
//  foo<Rest...>::operator= (other); 
     foo<Rest...>::copy_data(other); 
     std::cout << "[Assignment operator called]\n"; 
     return *this; 
    } 
protected: 
    void copy_data (const foo& other) { 
     first = other.first; 
     foo<Rest...>::copy_data(other); 
    } 
}; 

int main() { 
    const foo<int, char, bool> a(4, 'c', true); 
    foo<int, char, bool> b = a; // Copy constructor works fine. 
    foo<int, char, bool> c; 
    c = b; // Copy assignment operator works fine (and optimized). 
}