Как правильно использовать operator= при наследовании в полиморфных и неполиморфных классах

@4elovek37 · Регистрация: 10.10.2014

Студворк — интернет-сервис помощи студентам

Доброго времени суток! Изучаю книгу С. Прата "Язык программирования C++. Лекции и упражнения." Закончил 13-ю главу, посвященную наследованию и приступил к выполнению упражнений. Проблема возникла на этом упражнении:

Кликните здесь для просмотра всего текста

Союз программистов-меценатов собирает коллекцию бутылочного портвейна.
Для ее описания администратор союза разработал класс Port, Завершив определения методов для класса Port, администратор написал
производный класс Vintage Port, прежде чем был уволен

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class Port//портвейн!
{
private:
    char * brand;
    char style[20];
    int bottles;
public:
    Port(const char * brand = "none", const char * style = "none", 
        int bottles = 0);
    Port(const Port & p);//конструктор копирования
    virtual ~Port() { delete [] brand_; }
    Port & operator=(const Port & p);
    Port & operator+=(int bottles);
    Port & operator-=(int bottles);
    int BottleCount() const { return bottles_; }
    virtual void Show() const;
    friend std::ostream & operator<<(std::ostream & os, const Port & p);
};
 
class VintagePort : public Port
{
private:
    char * nickname;
    int year;
public:
    VintagePort();
    VintagePort(const char *  br, int b, const char * nn, int y);
    VintagePort(const VintagePort & vp);
    ~VintagePort() { delete [] nickname; }
    VintagePort & operator=(const VintagePort & vp);
    void Show() const;
    friend std::ostream & operator<<(std::ostream & os, const VintagePort & p);
};

Вам поручено завершить разработку класса VintagePort.
а. Первое задание — нужно заново создать определения методов Port, т.к.
предыдущий администратор уничтожил свой код.
б. Второе задание — объясните, почему одни методы переопределены, а другие
нет.
в. Третье задание — объясните, почему функции operator= () и operator« ()
не определены как виртуальные.
г. Четвертое задание — обеспечьте определения для методов VintagePort.

В общем и целом все понятно, но увидев пункт "в" я встал в ступор. Функция operator<<() не может быть виртуальной, т.к. она friend. Но почему operator=() не виртуальная? Внимательно проглядел код последних примеров из книги - operator=() не виртуальная, но я почему-то в свое время это забыл и при выполнении упражнений с полиморфным наследованием делал ее виртуальной, и все работало. Покопавшись еще, я совсем запутался, к примеру сделав ф-ю operator= в предыдущем упражнении не виртуальной я получил рабочую программу, хотя вроде и не должно бы:

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/empty.h
#ifndef EMPTY_H_
#define EMPTY_H_
#include <iostream>
#include <string>
//Абстрактный базовый класс
class BaseDMA
{
private:
    char * label_;
    int rating_;
public:
    BaseDMA(const char * label = "null", int rating = 0);
    BaseDMA(const BaseDMA & rs);
    virtual ~BaseDMA();
    BaseDMA & operator=(const BaseDMA & rs);
    virtual void View() const = 0;
    friend std::ostream & operator<<(std::ostream &, const BaseDMA &);
    friend std::ostream & operator<<(std::ostream &, const BaseDMA *);
};
//Класс, просто класс
class DMA :public BaseDMA
{
 
public:
    DMA(const char * label = "null", int rating = 0);
    DMA(const DMA & rs);
    ~DMA() {}
    DMA & operator=(const DMA & rs);
    void View() const;
};
 
//Производный класс без динамического выделения памяти
//Деструктор не нужен
//Используется неявный к-р копирования
//Используется неявная операция присваивания
class LacksDMA :public BaseDMA
{
private:
    enum { COL_LEN_ = 40};
    char color_[COL_LEN_];
public:
    LacksDMA(const char * color = "blank", const char * label = "null",
        int rating = 0);
    LacksDMA(const char * color, const BaseDMA & rs);
    void View() const;
};
 
//Производный класс с динамическим выделением памяти
class HasDMA :public BaseDMA
{
private:
    char * style_;
public :
    HasDMA(const char * style = "none", const char * label = "null",
        int rating = 0);
    HasDMA(const char * style, const BaseDMA & rs);
    HasDMA(const HasDMA & hs);
    ~HasDMA();
    HasDMA & operator=(const HasDMA & rs);
    void View() const;
};
 
#endif

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include <iostream>
#include <cstring>
#include "empty.h"
//Методы BaseDMA
BaseDMA::BaseDMA(const char * label, int rating)
{
    label_ = new char[std::strlen(label) + 1];
    std::strcpy(label_, label);
    rating_ = rating;
}
BaseDMA::BaseDMA(const BaseDMA & rs)
{
    label_ = new char[std::strlen(rs.label_) + 1];
    std::strcpy(label_, rs.label_);
    rating_ = rs.rating_;
}
BaseDMA::~BaseDMA()
{
    delete [] label_;
}
BaseDMA & BaseDMA::operator=(const BaseDMA & rs)
{
    if(this == &rs)
        return *this;
    delete [] label_;
    label_ = new char[std::strlen(rs.label_) + 1];
    std::strcpy(label_, rs.label_);
    rating_ = rs.rating_ + 300;
    return *this;
}
void BaseDMA::View() const
{
    std::cout << "Label: " << label_ << ", Rating: " << rating_ << std::endl;
}
//Методы DMA
DMA::DMA(const char * label, int rating) :BaseDMA(label, rating)
{
    
}
DMA::DMA(const DMA & rs) :BaseDMA(rs)
{
    
}
DMA & DMA::operator=(const DMA & rs) 
{
    if (this == &rs)
        return *this;
    BaseDMA::operator=(rs);
    return *this;
}
void DMA::View() const
{
    BaseDMA::View();
}
 
//Методы LacksDMA
LacksDMA::LacksDMA(const char * color, const char * label, int rating)
    :BaseDMA(label, rating)
{
    std::strncpy(color_, color, 39);
    color_[39] = '\0';//IMHO, TAK SEBE RESHENIE
}
LacksDMA::LacksDMA(const char * color, const BaseDMA & rs)
    
{
    std::strncpy(color_, color, COL_LEN_ - 1);
    color_[COL_LEN_ - 1] = '\0';//IMHO, TAK SEBE RESHENIE
}
void LacksDMA::View() const
{
    BaseDMA::View();
    std::cout << "Color: " << color_ << std::endl;
}
 
//Методы HasDMA
HasDMA::HasDMA(const char * style, const char * label, int rating)
    :BaseDMA(label, rating)
    
{
    style_ = new char [std::strlen(style) + 1];
    std::strcpy(style_, style);
}
HasDMA::HasDMA(const char * style, const BaseDMA & rs)
    :BaseDMA(rs)
 
{
    style_ = new char[std::strlen(style) + 1];
    std::strcpy(style_, style);
}
HasDMA::HasDMA(const HasDMA & hs)
    :BaseDMA(hs)//: BaseDMA(hs)//Вызывает к-р копирования базового класса
{
    style_ = new char[std::strlen(hs.style_) + 1];
    std::strcpy(style_, hs.style_);
}
HasDMA::~HasDMA()
{
    delete [] style_;
}
HasDMA & HasDMA::operator=(const HasDMA & hs)
{
    if(this == &  hs)
        return *this;
    BaseDMA::operator=(hs);//BaseDMA::operator=(hs);//копирование базовой части
    delete [] style_;//Подготовка к операци new для style_
    style_ = new char[std::strlen(hs.style_) + 1];
    std::strcpy(style_, hs.style_);
    return *this;
}
void HasDMA::View() const
{
    BaseDMA::View();
    std::cout << "Style: " << style_ << std::endl;
}
 
//Перегрузка операции << для вызова нужного virtual метода View
std::ostream & operator<<(std::ostream & os, const BaseDMA * hs)
{
    hs->View();
    return os;
}
std::ostream & operator<<(std::ostream & os, const BaseDMA & hs)
{
    hs.View();
    return os;
}

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include "empty.h"
 
int main()
{
    setlocale(0,"Rus");
    using std::cin;
    using std::cout;
    using std::endl;
    BaseDMA * pdma = new DMA("DMA", 0);
    BaseDMA * phas = new HasDMA("STYLE", "HAS", 0);
    BaseDMA * placks = new LacksDMA("COLOR", "LACKS", 0);
 
    pdma->View();
    placks->View();
    phas->View();
    cout << "PDMA = PLACKS:\n";
    pdma = placks;
    pdma->View();
    placks->View();
    cout << "PLACKS = PHAS:\n";
    cout << (void *)placks << "|||||" << (void *)phas << endl;
    placks = phas;
    cout << (void *)placks << "|||||" << (void *)phas << endl;
    placks->View();
    phas->View();
    system ("pause");
    return 0;
}

Как это работает? Если мы оперируем ссылками на базовый класс, а operator=() не виртуальная (т.е. не используем таблицу виртуальных методов, и компилятор смотрит на тип указателя), то при использовании операции присваивания должна использоваться БАЗОВЫЙ_КЛАСС::operator=(), и соответственно, копироваться только базовая часть! Но в моем коде все прекрасно копируется, кроме того, получается присвоить объекту одного производного класса объект другого производного класса!
У меня ощущение, что я блуждаю в 3-х соснах. Объясните, пожалуйста, как это работает, и как правильно использовать operator=() при полиморфном наследовании и без него. Заранее благодарю.

@zss · 31.08.2016, 21:15

Сообщение от 4elovek37

pdma = placks;

Это не вызов operator=, а просто присваивание указателю другого адреса.

@4elovek37 · 31.08.2016, 21:45 **[ТС]**

zss, пардон, под вечер совсем окосел. Самое обидное, что ведь даже добавил выведение адресов, а все равно проглядел!

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
pdma->View();
    placks->View();
    phas->View();
    cout << "\nPDMA = PLACKS:\n";
    *pdma = *placks;
    pdma->View();
    placks->View();
    cout << "\nPLACKS = PHAS:\n";
    cout << (void *)placks << "|||||" << (void *)phas << endl;
    *placks = *phas;
    cout << (void *)placks << "|||||" << (void *)phas << endl;
    placks->View();
    phas->View();
    cout << "\nPLACKS = PDMA:\n";
    delete pdma;
    pdma = new DMA("DMA", 0);
    *placks = *pdma;
    placks->View();
    pdma->View();

Вот так стало работать "как надо" (точнее, как "не надо"). И еще раз - я правильно понял, что operator= должен быть строго виртуальным, если мы собираемся работать с полиморфным на следованием? Тогда как правильно ответить на вопрос из задачи С. Прата?

@Usagi · 02.09.2016, 11:24

Операции присваивания не наследуются (стр 716 "Соображения по поводу операции присваивания"). operator<< в данном примере дружественная функция, она не может быть виртуальной - не член класса (там же 719 Прата).

Тоже думал об этом, додумался до написанного мной выше. И тоже читаю этот же учебник -

@4elovek37 · 02.09.2016, 13:31 **[ТС]**

Usagi,

operator<< в данном примере дружественная функция

Да, с этим все просто.
По поводу operator=() по ходу решения задачи с портвейном(доставляют в этом учебнике подобные задачи) пришло соображение, почему так делают: Оперируя массивом указателей на базовый класс, мы не можем заранее знать на объект какого класса (базового, или одного из производных) указывает указатель. Теоретически пользователь может попытаться:
1)Присвоить объект производного класса базовому - тут все более менее нормально и при virtual op=() и при non-virtual вызовется оператор присваивания базового класса и мы заберем однозначно существующие данные-члены от объекта произв. класса;
2)Присвоить объект базового класса производному - а вот тут могут возникнуть проблемы: если у нас virtual op=(), то вызовется оператор присваивания производного класса, который, скопировав базовую часть, попытается обратится к данным-членам, которых у присваиваемого объекта базового класса попросту нет. Результат не определен. Если же у нас non-virtual op=(), то мы скопируем только базовую часть, не пытаясь обратиться к несуществующим данным. Смысла в подобных действиях мало (получится смешанный набор данных), но зато ошибок точно не будет.
3)Присвоить объект одного произв. класса объекту другого произв. класса. Тут можно см. п.2, с небольшими отличиями.
Короче говоря, non-virtual op=() гарантирует что при использовании этой операции мы гарантированно скопируем только однозначно существующие данные, принадлежащие базовому классу. За всем остальным к ручному приведению типов, тогда уже пользователь берет ответственность целиком и полностью на себя.
Как то так. Может, я опять что-то напутал, у меня в последнее время такое ощущение все чаще

И тоже читаю этот же учебник

И как Вам? Есть прогресс?

@Usagi · 02.09.2016, 15:03

2)Присвоить объект базового класса производному

Объект базового класса просто вызовет свой operator=(), скопирует базовую часть и на этом успокоится. Члены произвольного класса использоваться не будут. Присваивается же объекту базового класса, поэтому это будет транслировано в базовый_класс.operator=(производный_клас с).

3)Присвоить объект одного произв. класса объекту другого произв. класса. Тут можно см. п.2, с небольшими отличиями.

Если все эти оба объекта имеют одного общего предка, то проблем тоже возникнуть не должно. Скопируется общая часть классов - базовая, так как сначала будет вызвана операция присваивания базового класса.

Если operator=() объявлен как виртуальный, всё равно будет вызвана операция базового класса, а потом производного. Модель открытого наследования, отношение "является". Единственное, что мне не понятно, почему его можно объявить виртуальным.

А по учебнику - очень хорошая вещь. Даже купил, хотя и читаю в электроном виде. Прогресс? Конечно. Большая разница между "до" и "после".

Добавлено через 11 минут

Единственное, что мне не понятно, почему его можно объявить виртуальным.

Не так: "Зачем его объявлять виртуальным?".

Добавлено через 13 минут

2)Присвоить объект базового класса производному

Объект базового класса просто вызовет свой operator=(), скопирует базовую часть и на этом успокоится. Члены произвольного класса использоваться не будут. Присваивается же объекту базового класса, поэтому это будет транслировано в базовый_класс.operator=(производный_клас с).

Ошибка, утверждение верно для присваивания объекта производного класса объекту базового.
Если присваивать объект базового класса производному, то без явно определённого operator=() для присваивания базового класса производному или конструктора преобразования не сработает.

@4elovek37 · 02.09.2016, 15:16 **[ТС]**

Если присваивать объект базового класса производному, то без явно определённого operator=() для присваивания базового класса производному или конструктора преобразования не сработает.

Сработает, если имеем дело с указателями. Все приведенные мной примеры, естественно, при условии использовании указателей на базовый класс (к примеру массив указателей на базовый класс, фактически содержащий смешанный контингент из объектов базового класса и производных). Именно тут и появляются "скользкие моменты", расписанные мной ранее.

Не так: "Зачем его объявлять виртуальным?".

Если используем динамические выделение памяти, и при присваивании нужно выполнять "глубокое копирование".

@Usagi · 02.09.2016, 16:40

Да, через ссылки или указатели такое присваивание будет работать, но только для базовой (общей) части. Неявное восходящие преобразование же?

Я понял, что Вы имеете ввиду: что если работать через ссылки (указатели) и определён виртуальный оператор присваивания, то согласно таблице виртуальных функций при присваивании объекту производного класса объекта базового класса должен быть вызван оператор присваивания производного класса. В этом случае будет вызван только оператор присваивания базового класса. Даже где-то у Праты написано, что операция присваивания относится к специальным членам класса.

У каждого класса свой оператор присваивания. Его нет нужды объявлять виртуальным. Я это имел ввиду.
Для "глубокого копирования" просто берётся и явно определяется оператор присваивания в нужном классе. Это 703 страница Праты. Случай с динамическим выделением памяти (под "глубокое копирование") и без него.

Новые блоги и статьи Все статьи Все блоги /
SDL3 для Web (WebAssembly): Реализация движения на Box2D v3 - трение и коллизии с повёрнутыми стенами 8Observer8 20.02.2026 Содержание блога Box2D позволяет легко создать главного героя, который не проходит сквозь стены и перемещается с заданным трением о препятствия, которые можно располагать под углом, как верхнее. . .	Конвертировать закладки radiotray-ng в m3u-плейлист damix 19.02.2026 Это можно сделать скриптом для PowerShell. Использование . \СonvertRadiotrayToM3U. ps1 <path_to_bookmarks. json> Рядом с файлом bookmarks. json появится файл bookmarks. m3u с результатом. # Check if. . .	Семь CDC на одном интерфейсе: 5 U[S]ARTов, 1 CAN и 1 SSI Eddy_Em 18.02.2026 Постепенно допиливаю свою "многоинтерфейсную плату". Выглядит вот так: https:/ / www. cyberforum. ru/ blog_attachment. php?attachmentid=11617&stc=1&d=1771445347 Основана на STM32F303RBT6. На борту пять. . .	Камера Toupcam IUA500KMA Eddy_Em 12.02.2026 Т. к. у всяких "хикроботов" слишком уж мелкий пиксель, для подсмотра в ESPriF они вообще плохо годятся: уже 14 величину можно рассмотреть еле-еле лишь на экспозициях под 3 секунды (а то и больше),. . .
И ясному Солнцу zbw 12.02.2026 И ясному Солнцу, и светлой Луне. В мире покоя нет и люди не могут жить в тишине. А жить им немного лет.	«Знание-Сила» zbw 12.02.2026 «Знание-Сила» «Время-Деньги» «Деньги -Пуля»	SDL3 для Web (WebAssembly): Подключение Box2D v3, физика и отрисовка коллайдеров 8Observer8 12.02.2026 Содержание блога Box2D - это библиотека для 2D физики для анимаций и игр. С её помощью можно определять были ли коллизии между конкретными объектами и вызывать обработчики событий столкновения. . . .	SDL3 для Web (WebAssembly): Загрузка PNG с прозрачным фоном с помощью SDL_LoadPNG (без SDL3_image) 8Observer8 11.02.2026 Содержание блога Библиотека SDL3 содержит встроенные инструменты для базовой работы с изображениями - без использования библиотеки SDL3_image. Пошагово создадим проект для загрузки изображения. . .

@Usagi 0 / 0 / 3 Регистрация: 03.07.2016 Сообщений: 22
	02.09.2016, 11:24
	Операции присваивания не наследуются (стр 716 "Соображения по поводу операции присваивания"). operator<< в данном примере дружественная функция, она не может быть виртуальной - не член класса (там же 719 Прата). Тоже думал об этом, додумался до написанного мной выше. И тоже читаю этот же учебник - 0

@Usagi 0 / 0 / 3 Регистрация: 03.07.2016 Сообщений: 22
	02.09.2016, 16:40
	Да, через ссылки или указатели такое присваивание будет работать, но только для базовой (общей) части. Неявное восходящие преобразование же? Я понял, что Вы имеете ввиду: что если работать через ссылки (указатели) и определён виртуальный оператор присваивания, то согласно таблице виртуальных функций при присваивании объекту производного класса объекта базового класса должен быть вызван оператор присваивания производного класса. В этом случае будет вызван только оператор присваивания базового класса. Даже где-то у Праты написано, что операция присваивания относится к специальным членам класса. У каждого класса свой оператор присваивания. Его нет нужды объявлять виртуальным. Я это имел ввиду. Для "глубокого копирования" просто берётся и явно определяется оператор присваивания в нужном классе. Это 703 страница Праты. Случай с динамическим выделением памяти (под "глубокое копирование") и без него. 0