Скажите, пожалуйста, как исправить оператор?

@CodC · Регистрация: 17.11.2018

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

Скажите пожалуйста, как исправить оператор

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
ostream& operator << (ostream& out, Set& a) // перегрузка вывода на экран
{
    int k = 0, j = 0, i, raz;
    string pom;
    if (a.Size() == 0)
        cout << endl << "Empty" << endl;
    for (i = 0; i < a.Size(); i++)
    {
        pom = a[i] + " "; // "помощь" - хранит данных элемент и пробел
        if (k < 5)
        {
            raz = pom.size(); // кол-во символов в данном элементе
            if (raz < (80 - j))
                cout << pom;
            else
                cout << endl << pom;
            j += raz; // кол-во использованных "мест" в строке (всего 80 "мест")
            k++; // кол-во элементов в одной строке
        }
        else
        {
            k = 0;
            cout << endl;
        }
    }
    cout << endl;
    return out;
}
}

Добавлено через 2 минуты
если нужен полный код

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
#pragma once
#include <string>
 
class Set {
private:
    int length = 0, capacity = 0;
    std::string *items = 0;
 
    void printInternals() const;
 
public:
    Set();
 
    Set(const Set& other);
 
    Set& operator=(Set& other);
 
    Set(Set&& other);
 
    Set& operator=(Set&& other);
         
    ~Set();
 
    bool contain(std::string value) const;
 
    void add(std::string value);
 
    void remove(std::string value);
 
    Set& operator += (const Set& a);
    Set& operator -= (const Set& a);
    Set& operator *= (const Set& a);
    //string operator [] (int n);
 
    
    friend Set operator + (const Set &b, const Set &a);
    friend Set operator - (const Set &b, const Set &a);
    friend Set operator * (const Set &b, const Set &a);
    friend bool operator == (const Set &b, const Set &a);
};
ostream& operator << (ostream& out, Set& a);

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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
#include "Set.h"
 
using namespace std;
 
 
void Set::printInternals() const {
    printf("Set{%p, items:%p, length:%i/%i}\n", this, items, length, capacity);
}
 
Set::Set() {
    printf("the default ctor was called for ");
    printInternals();
}
 
Set::Set(const Set & other) {
    printf("the copy ctor was called for ");
    printInternals();
    printf("\tshould be copied from ");
    other.printInternals();
 
    if (other.length > 0) {
        length = other.length;
        capacity = other.capacity;
        items = new string[capacity];
        printf("allocated %p <==> string[%i]\n", items, capacity);
 
        printf("deep copying items...\n");
        for (int i = 0; i < length; ++i)
            items[i] = other.items[i];
    }
    printf("current object is ");
    printInternals();
}
 
Set& Set::operator=(Set& other) {
    printf("the copy assignment operator was called for ");
    printInternals();
    printf("\tshould be copied from ");
    other.printInternals();
 
    if (this != &other) {
        if (other.length > 0) {
            length = other.length;
            capacity = other.capacity;
            items = new string[capacity];
            printf("allocated %p <==> string[%i]\n", items, capacity);
 
            printf("deep copying items...\n");
            for (int i = 0; i < length; ++i)
                items[i] = other.items[i];
        }
        printf("current object is ");
        printInternals();
    }
    else printf("nothing to do: objects are identical");
    return *this;
}
 
Set::Set(Set && other) {
    printf("the move ctor was called for ");
    printInternals();
    printf("\tsource is ");
    other.printInternals();
 
    swap(items, other.items);
    swap(length, other.length);
    swap(capacity, other.capacity);
 
    printf("current object is ");
    printInternals();   
    printf("\tsource is ");
    other.printInternals();
}
 
Set& Set::operator=(Set&& other) {
    printf("the move assignment operator was called for ");
    printInternals();
    printf("\tsource is ");
    other.printInternals();
 
    swap(items, other.items);
    swap(length, other.length);
    swap(capacity, other.capacity);
 
    printf("current object is ");
    printInternals();
    printf("\tsource is ");
    other.printInternals();
    return *this;
}
 
Set::~Set() {
    printf("destroy ");
    printInternals();
 
    if (items != 0) {
        printf("delete %p <==> string[%i]\n", items, capacity);
        delete[] items;
    }
}
 
bool Set::contain(string value) const {
    for (int i = 0; i < length; ++i) {
        if (items[i] == value)
            return true;
    }
    return false;
}
 
void Set::add(string value) {
    printf("adding new value: %s\n", value.data());
    if (contain(value)) {
        printf("value %s already added\n", value.data());
        return;
    }
    if (length == capacity) {
        printf("there is not enought space, should expend 'items'\n");
        ++capacity;
 
        string *newItems = new string[capacity];
        printf("allocated %p <==> string[%i]\n", newItems, capacity);
 
        printf("deep copying items...\n");
        for (int i = 0; i < length; ++i)
            newItems[i] = items[i];
 
        printf("delete %p <==> string[%i]\n", items, capacity);
        delete[] items;
 
        items = newItems;
    }       
    items[length] = value;
    ++length;
 
    printf("current object is ");
    printInternals();
}
 
void Set::remove(std::string value) {
    printf("removing value: %s\n", value.data());
 
    for (int i = 0; i < length; ++i) {
        if (items[i] == value) {
            swap(items[i], items[--length]);
 
            printf("current object is ");
            printInternals();
            return;
        }
    }
    printf("value %s wasn't found\n", value.data());
    return;
 
 
}
Set& Set::operator += (const Set& a)
{
    for (int i = 0; i < a.length; i++)
        if (contain(a.items[i]) == false)
            add(a.items[i]);
    return (*this);
}
Set& Set::operator -= (const Set& a)
{
    for (int i = 0; i < a.length; i++)
        if (contain(a.items[i]) == true)
        {
            remove(a.items[i]);
            //i--; //Убрал декремент
        }
    return *this;
}
Set& Set::operator *= (const Set& a)
{
    Set tmp;
    for (int i = length; i-->0;)
    {
        if (a.contain(items[i]) == false)
            remove(items[i]);
            //tmp.add(items[i]);
    *this = tmp;
    return *this;
}
//string Set::operator [] (int n)
//{
//  if ((n < 0) || (n >= ))
//      return "";
//  else
//      return el[n];
//}
 
ostream& operator << (ostream& out, Set& a) // перегрузка вывода на экран
{
    int k = 0, j = 0, i, raz;
    string pom;
    if (a.Size() == 0)
        cout << endl << "Empty" << endl;
    for (i = 0; i < a.Size(); i++)
    {
        pom = a[i] + " "; // "помощь" - хранит данных элемент и пробел
        if (k < 5)
        {
            raz = pom.size(); // кол-во символов в данном элементе
            if (raz < (80 - j))
                cout << pom;
            else
                cout << endl << pom;
            j += raz; // кол-во использованных "мест" в строке (всего 80 "мест")
            k++; // кол-во элементов в одной строке
        }
        else
        {
            k = 0;
            cout << endl;
        }
    }
    cout << endl;
    return out;
}
Set operator + (const Set &b, const Set &a)
{
    Set itog;
    itog = b;
    itog += a;
    return itog;
}
Set operator - (const Set &b, const Set &a)
{
    Set itog;
    itog = b;
    itog -= a;
    return itog;
}
Set operator * (const Set &b, const Set &a) {
    Set itog;
    itog = b;
    itog *= a;
    return itog;
}
bool operator == (const Set &b, const Set &a)
{
    Set pom;
        pom = b - a;
    if (pom.length == 0)
        return true;
    else
        return false;
}

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
#include "Set.h"
 
#include <iostream>
#include <string>
 
using namespace std;
 
 
int main() {
    Set a, b = a, c;
    a.add("1");
    a.add("2");
    a.add("3");
    a.remove("1");
    a.remove("2");
    a.remove("3");
    a.remove("4");
    a.add("5");
    a.add("4");
 
    c = move(a);
 
    Set d = move(c);
    return 0;
}

Добавлено через 10 минут
Скажите пожалуйста, как исправить оператор. Извините, я изменил немного

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
ostream& operator << (ostream& out, Set& a) // перегрузка вывода на экран
{
    int k = 0, j = 0, i, raz;
    string pom;
    if (a.Length() == 0)
        cout << endl << "Empty" << endl;
    for (i = 0; i < a.Length(); i++)
    {
        pom = a[i] + " "; // "помощь" - хранит данных элемент и пробел
        if (k < 5)
        {
            raz = pom.Length(); // кол-во символов в данном элементе
            if (raz < (80 - j))
                cout << pom;
            else
                cout << endl << pom;
            j += raz; // кол-во использованных "мест" в строке (всего 80 "мест")
            k++; // кол-во элементов в одной строке
        }
        else
        {
            k = 0;
            cout << endl;
        }
    }
    cout << endl;
    return out;
}

если нужен полный код

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
#pragma once
#include <string>
 
class Set {
private:
    int length = 0, capacity = 0;
    std::string *items = 0;
 
    void printInternals() const;
 
public:
    Set();
 
    Set(const Set& other);
 
    Set& operator=(Set& other);
 
    Set(Set&& other);
 
    Set& operator=(Set&& other);
         
    ~Set();
 
    int Length();
 
    bool contain(std::string value) const;
 
    void add(std::string value);
 
    void remove(std::string value);
 
    Set& operator += (const Set& a);
    Set& operator -= (const Set& a);
    Set& operator *= (const Set& a);
    //string operator [] (int n);
 
    
    friend Set operator + (const Set &b, const Set &a);
    friend Set operator - (const Set &b, const Set &a);
    friend Set operator * (const Set &b, const Set &a);
    friend bool operator == (const Set &b, const Set &a);
};
ostream& operator << (ostream& out, Set& a);

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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
#include "Set.h"
 
using namespace std;
 
 
void Set::printInternals() const {
    printf("Set{%p, items:%p, length:%i/%i}\n", this, items, length, capacity);
}
 
Set::Set() {
    printf("the default ctor was called for ");
    printInternals();
}
 
Set::Set(const Set & other) {
    printf("the copy ctor was called for ");
    printInternals();
    printf("\tshould be copied from ");
    other.printInternals();
 
    if (other.length > 0) {
        length = other.length;
        capacity = other.capacity;
        items = new string[capacity];
        printf("allocated %p <==> string[%i]\n", items, capacity);
 
        printf("deep copying items...\n");
        for (int i = 0; i < length; ++i)
            items[i] = other.items[i];
    }
    printf("current object is ");
    printInternals();
}
 
Set& Set::operator=(Set& other) {
    printf("the copy assignment operator was called for ");
    printInternals();
    printf("\tshould be copied from ");
    other.printInternals();
 
    if (this != &other) {
        if (other.length > 0) {
            length = other.length;
            capacity = other.capacity;
            items = new string[capacity];
            printf("allocated %p <==> string[%i]\n", items, capacity);
 
            printf("deep copying items...\n");
            for (int i = 0; i < length; ++i)
                items[i] = other.items[i];
        }
        printf("current object is ");
        printInternals();
    }
    else printf("nothing to do: objects are identical");
    return *this;
}
 
Set::Set(Set && other) {
    printf("the move ctor was called for ");
    printInternals();
    printf("\tsource is ");
    other.printInternals();
 
    swap(items, other.items);
    swap(length, other.length);
    swap(capacity, other.capacity);
 
    printf("current object is ");
    printInternals();   
    printf("\tsource is ");
    other.printInternals();
}
 
Set& Set::operator=(Set&& other) {
    printf("the move assignment operator was called for ");
    printInternals();
    printf("\tsource is ");
    other.printInternals();
 
    swap(items, other.items);
    swap(length, other.length);
    swap(capacity, other.capacity);
 
    printf("current object is ");
    printInternals();
    printf("\tsource is ");
    other.printInternals();
    return *this;
}
 
Set::~Set() {
    printf("destroy ");
    printInternals();
 
    if (items != 0) {
        printf("delete %p <==> string[%i]\n", items, capacity);
        delete[] items;
    }
}
 
bool Set::contain(string value) const {
    for (int i = 0; i < length; ++i) {
        if (items[i] == value)
            return true;
    }
    return false;
}
 
void Set::add(string value) {
    printf("adding new value: %s\n", value.data());
    if (contain(value)) {
        printf("value %s already added\n", value.data());
        return;
    }
    if (length == capacity) {
        printf("there is not enought space, should expend 'items'\n");
        ++capacity;
 
        string *newItems = new string[capacity];
        printf("allocated %p <==> string[%i]\n", newItems, capacity);
 
        printf("deep copying items...\n");
        for (int i = 0; i < length; ++i)
            newItems[i] = items[i];
 
        printf("delete %p <==> string[%i]\n", items, capacity);
        delete[] items;
 
        items = newItems;
    }       
    items[length] = value;
    ++length;
 
    printf("current object is ");
    printInternals();
}
 
void Set::remove(std::string value) {
    printf("removing value: %s\n", value.data());
 
    for (int i = 0; i < length; ++i) {
        if (items[i] == value) {
            swap(items[i], items[--length]);
 
            printf("current object is ");
            printInternals();
            return;
        }
    }
    printf("value %s wasn't found\n", value.data());
    return;
 
 
}
int Set::Length()
{
    return length;
}
 
Set& Set::operator += (const Set& a)
{
    for (int i = 0; i < a.length; i++)
        if (contain(a.items[i]) == false)
            add(a.items[i]);
    return (*this);
}
Set& Set::operator -= (const Set& a)
{
    for (int i = 0; i < a.length; i++)
        if (contain(a.items[i]) == true)
        {
            remove(a.items[i]);
            //i--; //Убрал декремент
        }
    return *this;
}
Set& Set::operator *= (const Set& a)
{
    Set tmp;
    for (int i = length; i-->0;)
    {
        if (a.contain(items[i]) == false)
            remove(items[i]);
            //tmp.add(items[i]);
    *this = tmp;
    return *this;
}
//string Set::operator [] (int n)
//{
//  if ((n < 0) || (n >= ))
//      return "";
//  else
//      return el[n];
//}
 
ostream& operator << (ostream& out, Set& a) // перегрузка вывода на экран
{
    int k = 0, j = 0, i, raz;
    string pom;
    if (a.Length() == 0)
        cout << endl << "Empty" << endl;
    for (i = 0; i < a.Length(); i++)
    {
        pom = a[i] + " "; // "помощь" - хранит данных элемент и пробел
        if (k < 5)
        {
            raz = pom.Length(); // кол-во символов в данном элементе
            if (raz < (80 - j))
                cout << pom;
            else
                cout << endl << pom;
            j += raz; // кол-во использованных "мест" в строке (всего 80 "мест")
            k++; // кол-во элементов в одной строке
        }
        else
        {
            k = 0;
            cout << endl;
        }
    }
    cout << endl;
    return out;
}
Set operator + (const Set &b, const Set &a)
{
    Set itog;
    itog = b;
    itog += a;
    return itog;
}
Set operator - (const Set &b, const Set &a)
{
    Set itog;
    itog = b;
    itog -= a;
    return itog;
}
Set operator * (const Set &b, const Set &a) {
    Set itog;
    itog = b;
    itog *= a;
    return itog;
}
bool operator == (const Set &b, const Set &a)
{
    Set pom;
        pom = b - a;
    if (pom.length == 0)
        return true;
    else
        return false;
}

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
#include "Set.h"
 
#include <iostream>
#include <string>
 
using namespace std;
 
 
int main() {
    Set a, b = a, c;
    a.add("1");
    a.add("2");
    a.add("3");
    a.remove("1");
    a.remove("2");
    a.remove("3");
    a.remove("4");
    a.add("5");
    a.add("4");
 
    c = move(a);
 
    Set d = move(c);
    return 0;
}

@L0M · 03.05.2019, 03:19

Сообщение от CodC

Скажите пожалуйста, как исправить оператор

Вы очень много букв написали. А если коротко, в чём проблема?

@zayats80888 · 03.05.2019, 08:18

CodC, вам что-то вроде этого нужно?

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
#include <iostream>
#include <string>
#include <vector>
 
std::ostream& operator<<(std::ostream& os, const std::vector<std::string>& v)
{
    std::string line;
    os << std::endl;
    for (size_t i = 0; i < v.size(); ++i)
        if (line.size() + v[i].size() < 81)
            line += v[i] + ' ';
        else
            if (!line.empty())
            {
                os << line;
                if (line.size() < 80) os << std::endl;
                line.resize(0);
                --i;
            }
            else
                os << v[i] << std::endl;
    if (line.size())
        os << line << std::endl;
    return os;
}
int main()
{
    std::vector<std::string> vs
    {
        "aaaaaaaa",
        "bb",
        "ccccccccc",
        "eeeeeeeeeeeeeeeeeeeeee",
        "ffffffffff",
        "ggggggggggggggg",
        "hhhhh",
        "i",
        "jjjjjjjjjjjjjjj",
        "kkkkkkkkkkkkkk",
        "lllllllllllllllllllllllllllllllllllllllllllllllll"
        "lllllllllllllllllllllllllllllllllllllllllllllllll"
        "lllllllllllllllllllllllllllllllllllllllllllllllll"
        "lllllllllllllllllllllllllllllllllllllllllllllllll",
        "mmmmmmmmmmmmmmmm",
        "nnnnnnnnnnnnnnnnnnnnnnnnnn"
    };
 
    std::cout << vs;
}

@CodC · 03.05.2019, 18:31 **[ТС]**

L0M, zayats80888, Проблема с выводом cout, не знаю как его норм сделать

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
std::ostream& operator << (std::ostream& out, const Set& a) // перегрузка вывода на экран
{
    int k = 0, j = 0, i, raz;
    string pom;
    if (a.length == 0)
        out << endl << "Empty" << endl;
    for (i = 0; i < a.length; i++)
    {
        pom = a[i] + " "; // "помощь" - хранит данных элемент и пробел
        if (k < 5)
        {
            raz = pom.size; // кол-во символов в данном элементе
            if (raz < (80 - j))
                out << pom;
            else
                out << endl << pom;
            j += raz; // кол-во использованных "мест" в строке (всего 80 "мест")
            k++; // кол-во элементов в одной строке
        }
        else
        {
            k = 0;
            out << endl;
        }
    }
    out << endl;
    return out;
}

вот полный код

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
#pragma once
#include <string>
#include <iostream>
 
class Set {
private:
    int length = 0, capacity = 0;
    std::string *items = 0;
 
    //void printInternals() const;
 
public:
    Set();
 
    Set(const Set& other);
 
    Set& operator=(const Set& other);
 
    Set(Set&& other);
 
    Set& operator=(Set&& other);
         
    ~Set();
 
    //int Length();
 
    bool contain(std::string value) const;
 
    void add(std::string value);
 
    void remove(std::string value);
 
    Set& operator += (const Set& a);
    Set& operator -= (const Set& a);
    Set& operator *= (const Set& a);
    std::string operator [] (int n);
 
 
    friend Set operator + (const Set &b, const Set &a);
    friend Set operator - (const Set &b, const Set &a);
    friend Set operator * (const Set &b, const Set &a);
    friend bool operator == (const Set &b, const Set &a);
    friend std::ostream& operator << (std::ostream& out, const Set& a);
};

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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
#include "Set.h"
#include <iostream>
#include <vector>
 
using namespace std;
 
 
//void Set::printInternals() const {
//  printf("Set{%p, items:%p, length:%i/%i}\n", this, items, length, capacity);
//}
//
Set::Set() {
    /*printf("the default ctor was called for ");
    printInternals();*/
}
 
Set::Set(const Set & other) {
    /*printf("the copy ctor was called for ");
    printInternals();
    printf("\tshould be copied from ");
    other.printInternals();*/
 
    if (other.length > 0) {
        length = other.length;
        capacity = other.capacity;
        items = new string[capacity];
        /*printf("allocated %p <==> string[%i]\n", items, capacity);
 
        printf("deep copying items...\n");*/
        for (int i = 0; i < length; ++i)
            items[i] = other.items[i];
    }
    /*printf("current object is ");
    printInternals();*/
}
 
Set& Set::operator=(const Set& other) {
    /*printf("the copy assignment operator was called for ");
    printInternals();
    printf("\tshould be copied from ");
    other.printInternals();*/
 
    if (this != &other) {
        if (other.length > 0) {
            length = other.length;
            capacity = other.capacity;
            items = new string[capacity];
            /*printf("allocated %p <==> string[%i]\n", items, capacity);
 
            printf("deep copying items...\n");*/
            for (int i = 0; i < length; ++i)
                items[i] = other.items[i];
        }
        /*printf("current object is ");
        printInternals();*/
    }
    else printf("nothing to do: objects are identical");
    return *this;
}
 
Set::Set(Set && other) {
    /*printf("the move ctor was called for ");
    printInternals();
    printf("\tsource is ");
    other.printInternals();*/
 
    swap(items, other.items);
    swap(length, other.length);
    swap(capacity, other.capacity);
 
    /*printf("current object is ");
    printInternals();   
    printf("\tsource is ");
    other.printInternals();*/
}
 
Set& Set::operator=(Set&& other) {
    /*printf("the move assignment operator was called for ");
    printInternals();
    printf("\tsource is ");
    other.printInternals();*/
 
    swap(items, other.items);
    swap(length, other.length);
    swap(capacity, other.capacity);
 
    /*printf("current object is ");
    printInternals();
    printf("\tsource is ");
    other.printInternals();*/
    return *this;
}
 
Set::~Set() {
    /*printf("destroy ");
    printInternals();*/
 
    if (items != 0) {
        /*printf("delete %p <==> string[%i]\n", items, capacity);*/
        delete[] items;
    }
}
 
bool Set::contain(string value) const {
    for (int i = 0; i < length; ++i) {
        if (items[i] == value)
            return true;
    }
    return false;
}
 
void Set::add(string value) {
    /*printf("adding new value: %s\n", value.data());*/
    if (contain(value)) {
        /*printf("value %s already added\n", value.data());*/
        return;
    }
    if (length == capacity) {
        /*printf("there is not enought space, should expend 'items'\n");*/
        ++capacity;
 
        string *newItems = new string[capacity];
        /*printf("allocated %p <==> string[%i]\n", newItems, capacity);
 
        printf("deep copying items...\n");*/
        for (int i = 0; i < length; ++i)
            newItems[i] = items[i];
 
        /*printf("delete %p <==> string[%i]\n", items, capacity);*/
        delete[] items;
 
        items = newItems;
    }       
    items[length] = value;
    ++length;
 
    /*printf("current object is ");
    printInternals();*/
}
 
void Set::remove(std::string value) {
    /*printf("removing value: %s\n", value.data());*/
 
    for (int i = 0; i < length; ++i) {
        if (items[i] == value) {
            swap(items[i], items[--length]);
 
            /*printf("current object is ");
            printInternals();*/
            return;
        }
    }
    /*printf("value %s wasn't found\n", value.data());*/
    return;
 
 
}
 
Set& Set::operator += (const Set& a)
{
    for (int i = 0; i < a.length; i++)
        if (contain(a.items[i]) == false)
            add(a.items[i]);
    return (*this);
}
Set& Set::operator -= (const Set& a)
{
    for (int i = 0; i < a.length; i++)
        if (contain(a.items[i]) == true)
        {
            remove(a.items[i]);
            //i--; //Убрал декремент
        }
    return *this;
}
Set& Set::operator *= (const Set& a)
{
    Set tmp;
    for (int i = length; i-- > 0;)
    {
        if (a.contain(items[i]) == false)
            remove(items[i]);
        //tmp.add(items[i]); //Разве эта строка не нужна ?
    }
    *this = tmp;
    return *this;
}
std::string Set::operator [](int n)
{
    if ((n < 0) || (n >= length))
        return "";
    else
        return items[n];
}
 
std::ostream& operator << (std::ostream& out, const Set& a) // перегрузка вывода на экран
{
    int k = 0, j = 0, i, raz;
    string pom;
    if (a.length == 0)
        out << endl << "Empty" << endl;
    for (i = 0; i < a.length; i++)
    {
        pom = a[i] + " "; // "помощь" - хранит данных элемент и пробел
        if (k < 5)
        {
            raz = pom.size; // кол-во символов в данном элементе
            if (raz < (80 - j))
                out << pom;
            else
                out << endl << pom;
            j += raz; // кол-во использованных "мест" в строке (всего 80 "мест")
            k++; // кол-во элементов в одной строкеы
        }
        else
        {
            k = 0;
            out << endl;
        }
    }
    out << endl;
    return out << "{....... }";
}
Set operator + (const Set &b, const Set &a)
{
    Set itog;
    itog = b;
    itog += a;
    return itog;
}
Set operator - (const Set &b, const Set &a)
{
    Set itog;
    itog = b;
    itog -= a;
    return itog;
}
Set operator * (const Set &b, const Set &a) {
    Set itog;
    itog = b;
    itog *= a;
    return itog;
}
bool operator == (const Set &b, const Set &a)
{
    Set pom;
        pom = b - a;
        return pom.length == 0;
    /*if (pom.length == 0)
        return true;*/
    /*else
        return false;*/
}

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
#include "Set.h"
 
#include <iostream>
#include <string>
 
using namespace std;
 
 
int main() {
    //Set a, b = a, c;
    Set a, b, c, d, e;
    a.add("1");
    a.add("2");
    a.add("3");
    b.add("2");
    b.add("4");
    d.add("1");
    d.add("2");
    d.add("3");
    cout << a << endl;
    cout << b << endl;
 
    c = a;
    c += b;
    cout << c << endl;
    c = a;
    c -= b;
    cout << c << endl;
    c = a;
    c *= b;
    cout << c << endl;
    c = a;
    cout << c[0] << endl;
    e = d - a;
    cout << e << endl;
 
    /*a.remove("1");
    a.remove("2");
    a.remove("3");
    a.remove("4");
    a.add("5");
    a.add("4");*/
 
    /*c = move(a);
 
    Set d = move(c);*/
    return 0;
}

@L0M · 03.05.2019, 23:18

CodC,

Сообщение от CodC

Проблема с выводом cout, не знаю как его норм сделать

"норм" - штука очень расплывчатая, и каждый понимает это по-своему.

Вы словами можете написать что вам нужно от operator << и чем не устраивает текущая реализация?

@CodC · 03.05.2019, 23:22 **[ТС]**

L0M, она не работает просто. мне нужно чтобы выводил он мне все что находится в main файле, сам код я скинул

@L0M · 04.05.2019, 02:14

Я вам поправил несколько ошибок. Смотрел не очень внимательно, поэтому полное отсутствие ошибок не гарантируется.

По файлам растащите сами. Мне лениво было делать проект с тремя файлами, поэтому свалил всё в кучу.

Так и не могу понять что вы хотите получить от operator <<. Вот такой вывод программы вас чем не устраивает?

Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1 2 3
{....... }
2 4
{....... }
1 2 3 4
{....... }
1 3
{....... }
2
{....... }
1
 
Empty
 
{....... }

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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
#include <iostream>
#include <string>
 
using namespace std;
 
// Set.h
//#pragma once
//#include <string>
//#include <iostream>
 
class Set {
private:
    int length = 0, capacity = 0;
    std::string* items = nullptr;
 
    //void printInternals() const;
 
public:
    Set();
 
    Set(const Set& other);
 
    Set& operator=(const Set& other);
 
    Set(Set&& other) noexcept;
 
    Set& operator=(Set&& other) noexcept;
 
    ~Set();
 
    //int Length();
 
    bool contain(const string& value) const;
 
    void add(const string& value);
 
    void remove(const string& value);
 
    Set& operator += (const Set& a);
    Set& operator -= (const Set& a);
    Set& operator *= (const Set& a);
    std::string operator [] (int n) const;
 
 
    friend Set operator + (const Set& b, const Set& a);
    friend Set operator - (const Set& b, const Set& a);
    friend Set operator * (const Set& b, const Set& a);
    friend bool operator == (const Set& b, const Set& a);
    friend std::ostream& operator << (std::ostream& out, const Set& a);
};
 
// Set.cpp
//#include "Set.h"
//#include <iostream>
 
using namespace std;
 
 
//void Set::printInternals() const {
//  printf("Set{%p, items:%p, length:%i/%i}\n", this, items, length, capacity);
//}
//
Set::Set() {
    /*printf("the default ctor was called for ");
    printInternals();*/
}
 
Set::Set(const Set& other) {
    /*printf("the copy ctor was called for ");
    printInternals();
    printf("\tshould be copied from ");
    other.printInternals();*/
 
    if (other.length > 0) {
        length = other.length;
        capacity = other.capacity;
        items = new string[capacity];
        /*printf("allocated %p <==> string[%i]\n", items, capacity);
 
        printf("deep copying items...\n");*/
        for (int i = 0; i < length; ++i)
            items[i] = other.items[i];
    }
    /*printf("current object is ");
    printInternals();*/
}
 
Set& Set::operator=(const Set & other) {
    /*printf("the copy assignment operator was called for ");
    printInternals();
    printf("\tshould be copied from ");
    other.printInternals();*/
 
    if (this != &other) {
        if (other.length > 0) {
            length = other.length;
            capacity = other.capacity;
            if (items != nullptr)
                delete[] items;
            items = new string[capacity];
            /*printf("allocated %p <==> string[%i]\n", items, capacity);
 
            printf("deep copying items...\n");*/
            for (int i = 0; i < length; ++i)
                items[i] = other.items[i];
        }
        /*printf("current object is ");
        printInternals();*/
    }
    else printf("nothing to do: objects are identical");
    return *this;
}
 
Set::Set(Set && other) noexcept {
    /*printf("the move ctor was called for ");
    printInternals();
    printf("\tsource is ");
    other.printInternals();*/
 
    if (items != nullptr)
        delete[] items;
    items = other.items;
    length = other.length;
    capacity = other.capacity;
 
    other.items = nullptr;
    other.length = other.capacity = 0;
 
    /*printf("current object is ");
    printInternals();
    printf("\tsource is ");
    other.printInternals();*/
}
 
Set& Set::operator=(Set && other) noexcept {
    /*printf("the move assignment operator was called for ");
    printInternals();
    printf("\tsource is ");
    other.printInternals();*/
 
    if (this != &other) {
        if (items != nullptr)
            delete[] items;
        items = other.items;
        length = other.length;
        capacity = other.capacity;
 
        other.items = nullptr;
        other.length = other.capacity = 0;
    }
 
    /*printf("current object is ");
    printInternals();
    printf("\tsource is ");
    other.printInternals();*/
    return *this;
}
 
Set::~Set() {
    /*printf("destroy ");
    printInternals();*/
 
    if (items != nullptr) {
        /*printf("delete %p <==> string[%i]\n", items, capacity);*/
        delete[] items;
    }
}
 
bool Set::contain(const string & value) const {
    for (int i = 0; i < length; ++i) {
        if (items[i] == value)
            return true;
    }
    return false;
}
 
void Set::add(const string & value) {
    /*printf("adding new value: %s\n", value.data());*/
    if (contain(value)) {
        /*printf("value %s already added\n", value.data());*/
        return;
    }
    if (length == capacity) {
        /*printf("there is not enought space, should expend 'items'\n");*/
        capacity += 10;
 
        string* newItems = new string[capacity];
        /*printf("allocated %p <==> string[%i]\n", newItems, capacity);
 
        printf("deep copying items...\n");*/
        for (int i = 0; i < length; ++i)
            newItems[i] = items[i];
 
        /*printf("delete %p <==> string[%i]\n", items, capacity);*/
        delete[] items;
 
        items = newItems;
    }
    items[length] = value;
    ++length;
 
    /*printf("current object is ");
    printInternals();*/
}
 
void Set::remove(const string & value) {
    /*printf("removing value: %s\n", value.data());*/
 
    for (int i = 0; i < length; ++i) {
        if (items[i] == value) {
            swap(items[i], items[--length]);
 
            /*printf("current object is ");
            printInternals();*/
            return;
        }
    }
    /*printf("value %s wasn't found\n", value.data());*/
    return;
 
 
}
 
Set& Set::operator += (const Set & a)
{
    for (int i = 0; i < a.length; i++)
        if (contain(a.items[i]) == false)
            add(a.items[i]);
    return (*this);
}
Set & Set::operator -= (const Set & a)
{
    for (int i = 0; i < a.length; i++)
        if (contain(a.items[i]) == true)
        {
            remove(a.items[i]);
            //i--; //Убрал декремент
        }
    return *this;
}
Set& Set::operator *= (const Set & a)
{
    Set tmp;
    for (int i = length; i-- > 0;)
    {
        if (a.contain(items[i]) == false)
            remove(items[i]);
        //tmp.add(items[i]); //Разве эта строка не нужна ?
    }
    *this = tmp;
    return *this;
}
std::string Set::operator [](int n) const
{
    if ((n < 0) || (n >= length))
        return "";
    else
        return items[n];
}
 
Set operator + (const Set & b, const Set & a)
{
    Set itog;
    itog = b;
    itog += a;
    return itog;
}
Set operator - (const Set & b, const Set & a)
{
    Set itog;
    itog = b;
    itog -= a;
    return itog;
}
Set operator * (const Set & b, const Set & a) {
    Set itog;
    itog = b;
    itog *= a;
    return itog;
}
bool operator == (const Set & b, const Set & a)
{
    Set pom;
    pom = b - a;
    return pom.length == 0;
    /*if (pom.length == 0)
        return true;*/
        /*else
            return false;*/
}
 
std::ostream& operator << (std::ostream & out, const Set & a) // перегрузка вывода на экран
{
    int k = 0, j = 0, i, raz;
    string pom;
    if (a.length == 0)
        out << endl << "Empty" << endl;
    for (i = 0; i < a.length; i++)
    {
        pom = a[i] + " "; // "помощь" - хранит данных элемент и пробел
        if (k < 5)
        {
            raz = pom.size(); // кол-во символов в данном элементе
            if (raz < (80 - j))
                out << pom;
            else
                out << endl << pom;
            j += raz; // кол-во использованных "мест" в строке (всего 80 "мест")
            k++; // кол-во элементов в одной строкеы
        }
        else
        {
            k = 0;
            out << endl;
        }
    }
    out << endl;
    return out << "{....... }";
}
 
 
int main() {
    //Set a, b = a, c;
    Set a, b, c, d, e;
    a.add("1");
    a.add("2");
    a.add("3");
 
    b.add("2");
    b.add("4");
 
    d.add("1");
    d.add("2");
    d.add("3");
 
    cout << a << endl;
    cout << b << endl;
 
    c = a;
    c += b;
    cout << c << endl;
    c = a;
    c -= b;
    cout << c << endl;
    c = a;
    c *= b;
    cout << c << endl;
    c = a;
    cout << c[0] << endl;
    e = d - a;
    cout << e << endl;
 
    /*a.remove("1");
    a.remove("2");
    a.remove("3");
    a.remove("4");
    a.add("5");
    a.add("4");*/
 
    /*c = move(a);
 
    Set d = move(c);*/
    return 0;
}

@CodC · 05.05.2019, 00:34 **[ТС]**

L0M, Меня все устраивает, единственное что не устраивает, так именно вот такая ошибка, сейчас покажу на скрине. Но если открыть код который вы поправили, то все действует, а если быть точнее, не хочу чистый копипаст, укажите пожалуйста на ошибку, и покажите как исправили ее, буду очень благодарен вам.

@nalbe666 · 05.05.2019, 01:35

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
class Cl
{
    std::string str = "0123456";
 
public:
    char& operator[](int n) {
        return str[n];
    }
};
 
std::ostream& operator<<(std::ostream& os, const Cl& cl) {
    return os;
}
 
 
 
int main()
{
    Cl cl;
 
    std::cout << cl[5] << "\n";
 
    system("pause");
    return 0;
}

@L0M · 05.05.2019, 05:10

Сообщение от CodC

а если быть точнее, не хочу чистый копипаст, укажите пожалуйста на ошибку, и покажите как исправили ее, буду очень благодарен вам.

Вот интересный вы человек. Компилятор указывает вам ошибку, в моём варианте её нет. Ошибка связана с operator[]. Ну код-то сравнить можно?

C++
1
    std::string operator [] (int n) const;

В operator<< вы передаёте константную ссылку на Set. Следовательно внутри функции нельзя применять методы, изменяющие состояние объекта. А operator[] у вас был описан неконстантным.

Вообще-то говоря, правильная (традиционная) сигнатура перегрузки этого оператора выглядит как

C++
1
    std::string& operator [] (int n);

для того, что бы можно было с его помощью изменять значение "массива" по указанному индексу. Т.е. использовать в левой части оператора присваивания. Но вам это не нужно. Поэтому решение более простое.

А насчёт "чистой копипасты" - не парьтесь. Это ваш код. Я просто поправил кое-какие ошибки. Если хотите для себя извлечь пользу - проанализируйте изменения.

@CodC · 05.05.2019, 05:56 **[ТС]**

L0M, Спасибо большое вам))) очень благодарен)))

Новые блоги и статьи Все статьи Все блоги /
YAFU@home — распределённые вычисления для математики. На CPU Programma_Boinc 20.01.2026 YAFU@home — распределённые вычисления для математики. На CPU YAFU@home — это BOINC-проект, который занимается факторизацией больших чисел и исследованием aliquot-последовательностей. Звучит. . .	http://iceja.net/ математические сервисы iceja 20.01.2026 Обновила свой сайт http:/ / iceja. net/ , приделала Fast Fourier Transform экстраполяцию сигналов. Однако предсказывает далеко не каждый сигнал (см ограничения http:/ / iceja. net/ fourier/ docs ). Также. . .	http://iceja.net/ сервер решения полиномов iceja 18.01.2026 Выкатила http:/ / iceja. net/ сервер решения полиномов (находит действительные корни полиномов методом Штурма). На сайте документация по API, но скажу прямо VPS слабенький и 200 000 полиномов. . .	Расчёт переходных процессов в цепи постоянного тока igorrr37 16.01.2026 / * Дана цепь постоянного тока с R, L, C, k(ключ), U, E, J. Программа составляет систему уравнений по 1 и 2 законам Кирхгофа, решает её и находит: токи, напряжения и их 1 и 2 производные при t = 0;. . .
Восстановить юзерскрипты Greasemonkey из бэкапа браузера damix 15.01.2026 Если восстановить из бэкапа профиль Firefox после переустановки винды, то список юзерскриптов в Greasemonkey будет пустым. Но восстановить их можно так. Для этого понадобится консольная утилита. . .	Сукцессия микоризы: основная теория в виде двух уравнений. anaschu 11.01.2026 https:/ / rutube. ru/ video/ 7a537f578d808e67a3c6fd818a44a5c4/	WordPad для Windows 11 Jel 10.01.2026 WordPad для Windows 11 — это приложение, которое восстанавливает классический текстовый редактор WordPad в операционной системе Windows 11. После того как Microsoft исключила WordPad из. . .	Classic Notepad for Windows 11 Jel 10.01.2026 Old Classic Notepad for Windows 11 Приложение для Windows 11, позволяющее пользователям вернуть классическую версию текстового редактора «Блокнот» из Windows 10. Программа предоставляет более. . .

Скажите, пожалуйста, как исправить оператор?

Решение

Решение

@CodC 1 / 1 / 0 Регистрация: 17.11.2018 Сообщений: 33
	03.05.2019, 23:22 [ТС]
	L0M, она не работает просто. мне нужно чтобы выводил он мне все что находится в main файле, сам код я скинул 0

@CodC 1 / 1 / 0 Регистрация: 17.11.2018 Сообщений: 33
	05.05.2019, 00:34 [ТС]
	L0M, Меня все устраивает, единственное что не устраивает, так именно вот такая ошибка, сейчас покажу на скрине. Но если открыть код который вы поправили, то все действует, а если быть точнее, не хочу чистый копипаст, укажите пожалуйста на ошибку, и покажите как исправили ее, буду очень благодарен вам. Миниатюры 0

@CodC 1 / 1 / 0 Регистрация: 17.11.2018 Сообщений: 33
	05.05.2019, 05:56 [ТС]
	L0M, Спасибо большое вам))) очень благодарен))) 0