các toán tử gán nhiệm vụ quá tải khi lớp là con

Question

Làm cách nào để bạn thiết lập các thành viên lớp cơ sở bằng cách sử dụng thực thi toán tử gán? Nếu ví dụ một người nào đó định nghĩa toán tử gán trong một lớp học có nguồn gốc như thế này:

(nơi cả hai colour và Colour() là thành viên của lớp cơ sở - có nghĩa là các đường chỉ ra dưới đây là bất hợp pháp)

Derived& Derived::operator=(const Derived& rhs) 
{ 
if (&rhs != this) 
{ 

    Colour(rhs.colour); // not allowed 
     Colour(rhs.Colour()); // not allowed 
} 
return *this; 
} 

là những gì dung dịch? Có cách nào liên kết quá tải của nhà điều hành trong cơ sở không? Tôi phải làm một cái gì đó giống như ...

Derived& Derived::operator=(const Derived& rhs) : Base::operator=(rhs) 
...? 

Answer 1

Bạn đang gần, chỉ cần đặt rằng cuộc gọi trong cơ thể phương pháp.

if (&rhs != this) 
{ 
    Base::operator=(rhs); 
    // ... 

Answer 2

Bạn sẽ có thể sử dụng accessors công cộng và mutators:

Derived& Derived::operator=(const Derived& rhs) 
{ 
    if (&rhs != this) 
     SetColour(rhs.GetColour()); 
    return *this; 
} 

Nếu không làm cho các thành viên protected trong lớp cơ sở để các lớp thừa kế có quyền truy cập:

Derived& Derived::operator=(const Derived& rhs) 
{ 
    if (&rhs != this) 
     colour = rhs.colour; 
    return *this; 
} 

Tùy chọn thứ ba có thể là xác định toán tử gán công khai trong lớp cơ sở và yêu cầu lớp dẫn xuất của bạn gọi toán tử cơ sở:

Derived& Derived::operator=(const Derived& rhs) 
{ 
    if (&rhs != this) 
     Base::operator=(rhs); 
    return *this; 
} 

Dưới đây là một trường hợp thử nghiệm hoàn chỉnh:

#define TEST 2 
class Base 
{ 
public: 
    Base() : m_protected(0), m_private(0) {} 
    Base(int pro, int pri) : m_protected(pro), m_private(pri) {} 
    ~Base() {} 

#if TEST == 1 
    Base& operator=(const Base& rhs) 
    { 
     if (this != &rhs) 
     { 
      m_protected = rhs.m_protected; 
      m_private = rhs.m_private; 
     } 

     return *this; 
    } 
#elif TEST == 2 
    void SetPrivate(int i) { m_private = i; } 
    int GetPrivate() const { return m_private; } 
#endif 

protected: 
    int m_protected; 
private: 
    int m_private; 
}; 

class Derived : public Base 
{ 
public: 
    Derived() : Base() {} 
    Derived(int pro, int pri) : Base(pro, pri) {} 
#if TEST == 1 
    Derived& operator=(const Derived& rhs) 
    { 
     Base::operator=(rhs); 
     return *this; 
    } 
#elif TEST == 2 
    Derived& operator=(const Derived& rhs) 
    { 
     if (this != &rhs) 
     { 
      SetPrivate(rhs.GetPrivate()); 
      m_protected = rhs.m_protected; 
     } 
     return *this; 
    } 
#endif 
}; 

int main() 
{ 
    Derived a; 
    Derived b(10, 5); 

    a = b; 
     return 0; 
} 

Answer 3

tôi thực hiện các nhà điều hành = chức năng ấn định/xây dựng màu sắc trong điều hành lớp cơ sở nếu bạn muốn gọi các nhà điều hành cơ sở = từ việc sử dụng lớp Derived:

Base::operator=(rhs) 

trong điều hành lớp Derived =() thực hiện. Chữ ký bạn đã đề xuất cho toán tử Derived = không phải là hợp lệ C++ theo như tôi biết.

Answer 4

Nó được thực hiện như thế này:

class B 
{ 
public: 
    B& operator=(const B & other) 
    { 
    v = other.v; 
    return *this; 
    } 
    int v; 
}; 

class D : public B 
{ 
public: 
    D& operator=(const D & other) 
    { 
    B::operator=(other); 
    return *this; 
    } 
};