为什么我不能在派生类运算符>>中调用基类运算符>>？

Question

假设我们有 2 个类：

class base{

protected:
    char first_name;
public: 
    /// constructors , destructor, operator= overloading ...
    
    friend istream& operator >> (istream& in, base &client1) 
    {
        char f_name[1001];
        cout << "First Name: ";
        in >> f_name;
        client1=base(f_name); /// class parameterised constructor;
         
        return in;
    }
};

class derived: public base{

protected:
    char last_name[1001];
public: 
    /// constructors , destructor, operator= overloading ...
    
    friend istream& operator >> (istream& in, derived &client2) 
    {
        char l_name[1001], f_name[1001];
       
        in >> (base) client2; /// it's not working like it dose in operator<<..
        cout << "Last Name: ";
        is >> l_name;
        client2=derived(f_name, l_name); /// class parameterized constructor, 2 parameters because it use base constructor as well;
         
        return in;
    }
};

我重载了一些输出运算符（中调用运算符我不知道这对于操作员>中调用基类运算符>>时，它给了我错误：

" 没有匹配函数调用 'operator>>(std::istream&, abonament)'| "

同样，如果我在 operator

friend ostream& operator << (ostream& out, derived &client) 
    {
       
        out << (base) client; /// it's working;
       
        out << client.last_name;
         
        return in;
    }

是否可以在派生类运算符中调用基类运算符>>> 为什么会发生这种情况以及如何解决？ （我希望我不必在派生类运算符>>中再次重写基类运算符>>中的相同行）

Answer 1

您已成为object slicing 的牺牲品。您可以通过转换为参考来解决眼前的问题。

在

in >> (base) client2;

真正发生的是一个新的临时Base 由client2 组成，丢弃了derived 添加的所有成员。这是合法的。编译器会感到不安，因为临时的Base 不能用作base &client1 参数的参数。临时变量就像听起来一样。它们的时间不长，所以引用一个是编译器阻止你犯的错误。如果它是合法的，临时变量将被Base 的>> 操作符修改，然后立即超出范围，然后才能使用读入的内容。

in >> (base&) client2;

不切片也不做临时变量。 client2 已成功更新。不幸的是，当

client2=derived(f_name, l_name);

用未初始化的变量l_name覆盖它。

因此需要进行更多更改。

不要使用构造函数来完全重新创建和重新分配您正在读取的对象。而是直接读入对象的成员变量。

例子：

class base{

protected:
    char first_name[1001]; // need more than one character
public: 
    /// constructors , destructor, operator= overloading ...
    
    friend istream& operator >> (istream& in, base &client1) 
    {
        // char f_name[1001]; don't need. Read into member
        cout << "First Name: ";
        in >> client1.first_name; // read directly into member
        // client1=base(f_name); don't need. Work done above
         
        return in;
    }
};

class derived: public base{

protected:
    char last_name[1001];
public: 
    /// constructors , destructor, operator= overloading ...
    
    friend istream& operator >> (istream& in, derived &client2) 
    {
        //char l_name[1001], f_name[1001]; don't need. Use member variables
       
        in >> (base&) client2; // client was being sliced. explanatory link above
        //         ^ fixed with reference to allow polymorphism                             
        cout << "Last Name: ";
        in >> client2.last_name; // fixed typo. reading directly into member
        // client2=derived(f_name, l_name); don't need. Work done above
         
        return in;
    }
};

旁注：这是对继承的滥用。这实际上是说姓氏is-a 名字。它不是。阅读 Liskov Substitution 原则以获得一个好的规则，以帮助确定何时继承是有意义的。这是一些入门读物：What is an example of the Liskov Substitution Principle?

旁注：>> 将一个以空格分隔的标记（一个单词）读入给定的char 数组。这里有两个问题。最重要的是它不知道什么时候停止。 1001 字符数组只能部分缓解这种情况。用户需要长时间打字才能溢出缓冲区，但不要怀疑人们这样做是为了好玩或盈利。改用std::string，这个问题就消失了。第二个问题是整个一个词的事情。这个解析器无法处理像“Billy Bob”或“von Doom”这样的名字，幸运的是这个姓氏的所有者是虚构的，因为众所周知他是无情的。