Форум программистов, компьютерный форум CyberForum.ru
Наши страницы

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
 
Рейтинг: Рейтинг темы: голосов - 34, средняя оценка - 4.79
Zzzzzz
0 / 0 / 0
Регистрация: 25.04.2011
Сообщений: 14
#1

Класс "комплексное число" - C++

25.04.2011, 22:22. Просмотров 4526. Ответов 22
Метки нет (Все метки)

Здрасти!!!! Я не могу никак написать программу!!!! А завтра уже сдавать!!! Пожалста помогите моя жизнь в ваших руках!!!!!

Задание:
определить класс "комплексное число".Перегрузить операции:>>,<<(вывод в виде "ai+b"),!=,унарный-.

Я начал но не знаю правильно ли:
C++
1
2
3
4
5
6
7
8
9
10
11
#include<iostream>
using namespace std;
class complex
{
    inta,b;
public:
    friend ostream& operator <<(ostream&,complex);
    friend istream& operator >>(istream&,complex&);
    friend complex& operator --(complex&,int);
    friend bool operator !=(complex&,complex&);
};
Подскажите пжалста!!!!
0
Лучшие ответы (1)
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
25.04.2011, 22:22
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Класс "комплексное число" (C++):

Реализовать класс родительский класс "Пара чисел" и класс-наследник "Комплексное число" - C++
Ткма работы создать класс pair (пара чисел); определить метод перемножения полей и операцию сложения пар (a,b)+(c,d) =(a+b,c+d)...

Класс "Комплексное число". Как считать и записать данные в файл? - C++
Надо переделать код программы, чтобы данные шли из входного файла и записывались в выходной Во входном файле 2 комплексных числа a и...

Класс "Комплексное число" - C++
Написать программу с базовым классом для реализации комплексных чисел в алгебраической форме и основных операций с ними : сложения,...

Класс "Комплексное число" - C++
Производный от СТРОКА класс КОМЛЕКСНОЕ_ЧИСЛО. Строки данного класса состоят из двух полей, разделенных символом i. Первое поле задает...

Класс "Комплексное число" - C++
Нужно создать класс Complex и реализовать +-*/ возведение в степень комплексного числа и Получение корня n-й степени +-*/ я...

Класс "Комплексное число" - C++
Сразу скажу, что я умею пользоваться поиском. Однако необходимого решения на форуме я не нашёл. Новую тему я создал по причине того, что...

Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
ForEveR
В астрале
Эксперт С++
7972 / 4734 / 321
Регистрация: 24.06.2010
Сообщений: 10,541
Завершенные тесты: 3
25.04.2011, 23:15 #2
Zzzzzz, Поиск юзайте. Огромное кол-во классов комплексных чисел было на форуме на моей памяти
0
Zzzzzz
0 / 0 / 0
Регистрация: 25.04.2011
Сообщений: 14
25.04.2011, 23:27  [ТС] #3
Я примерно написал скажите правильно ли я сделал??

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
#include<iostream>
#include <math.h>
using namespace std;
class complex
{
    int a,b;
public:
    friend ostream& operator <<(ostream&,complex);
    friend istream& operator >>(istream&,complex&);
    friend complex& operator -(complex&);
    friend bool operator !=(complex&,complex&);
};
ostream& operator <<(ostream&out,complex C)
{
    out<<C.a<<"*i+"<<C.b<<endl;
    return out;
}
istream& operator >>(istream& in ,complex& C)
{
cout<<"Введите а и b"<<endl;
in>>C.a;
 in>>C.b;
 return in;
}
complex& operator -(complex&X)
{
    X.a=-X.a;
    X.b=-X.b;
    return X;
}
bool operator !=(complex&C,complex& C1)
{
    if(sqrt((double)(C.a*C.a+C.b*C.a))==sqrt((double)(C1.a*C1.a+C1.b*C1.a)))
        return true;
    else
        return false;
}
void main()
{
    setlocale(LC_ALL,"rus");
    cout<<"Введите первое комплексное число:"<<endl;
    complex C,C1;
    cin>>C;
    cout<<"Введите второе комплексное число:"<<endl;
    cin>>C1;
    cout<<C<<endl<<C1<<endl;
    -C;
    -C1;
    cout<<C<<endl<<C1<<endl;
    if(C!=C1)
        cout<<"Равны!"<<endl;
    else
        cout<<"Не Равны!"<<endl;
}
 Комментарий модератора 
Используйте теги форматирования кода.
0
ForEveR
В астрале
Эксперт С++
7972 / 4734 / 321
Регистрация: 24.06.2010
Сообщений: 10,541
Завершенные тесты: 3
25.04.2011, 23:34 #4
Zzzzzz, По сути да. Но если делать нормально - нет.
1
Zzzzzz
0 / 0 / 0
Регистрация: 25.04.2011
Сообщений: 14
25.04.2011, 23:42  [ТС] #5
Можете подсказать ошибку??? Хочу програмировать правильно!!!!!
0
silent_1991
Эксперт С++
4964 / 3040 / 149
Регистрация: 11.11.2009
Сообщений: 7,027
Завершенные тесты: 1
25.04.2011, 23:53 #6
Лучший ответ Сообщение было отмечено автором темы, экспертом или модератором как ответ
Писал тут как-то...

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
#ifndef COMPLEX_H
#define COMPLEX_H
 
#include <iostream>
#include <cmath>
 
//-----------------------------------------------------------------------------
 
template< typename T >
class Complex;
 
//-----------------------------------------------------------------------------
 
template< typename T >
std::ostream &operator<<(std::ostream &, const Complex< T > &);
template< typename T >
std::istream &operator>>(std::istream &, Complex< T > &);
 
//-----------------------------------------------------------------------------
 
template< typename T >
Complex< T > operator-(const Complex< T > &);
 
//-----------------------------------------------------------------------------
 
template< typename T >
Complex< T > operator+(const Complex< T > &, const Complex< T > &);
template< typename T >
Complex< T > operator-(const Complex< T > &, const Complex< T > &);
template< typename T >
Complex< T > operator*(const Complex< T > &, const Complex< T > &);
template< typename T >
Complex< T > operator/(const Complex< T > &, const Complex< T > &);
 
//-----------------------------------------------------------------------------
 
template< typename T >
bool operator==(const Complex< T > &, const Complex< T > &);
template< typename T >
bool operator!=(const Complex< T > &, const Complex< T > &);
template< typename T >
bool operator<(const Complex< T > &, const Complex< T > &);
template< typename T >
bool operator<=(const Complex< T > &, const Complex< T > &);
template< typename T >
bool operator>(const Complex< T > &, const Complex< T > &);
template< typename T >
bool operator>=(const Complex< T > &, const Complex< T > &);
 
//-----------------------------------------------------------------------------
 
template< typename T >
class Complex
{
    static const T zero;
    static const T one;
 
public:
    Complex();
    Complex(const T &);
    Complex(const T &, const T &);
 
    void set_real(const T &);
    T get_real() const;
 
    void set_image(const T &);
    T get_image() const;
 
    double magnitude() const;
    double argument() const;
 
    Complex conjugate() const;
    Complex negate() const;
 
    friend std::ostream &operator<<< >(std::ostream &, const Complex< T > &);
    friend std::istream &operator>>< >(std::istream &, Complex< T > &);
 
    friend Complex< T > operator-< >(const Complex< T > &);
 
    friend Complex< T > operator+< >(const Complex< T > &, const Complex< T > &);
    friend Complex< T > operator-< >(const Complex< T > &, const Complex< T > &);
    friend Complex< T > operator*< >(const Complex< T > &, const Complex< T > &);
    friend Complex< T > operator/< >(const Complex< T > &, const Complex< T > &);
 
    Complex &operator+=(const Complex &);
    Complex &operator-=(const Complex &);
    Complex &operator*=(const Complex &);
    Complex &operator/=(const Complex &);
 
    friend bool operator==< >(const Complex< T > &, const Complex< T > &);
    friend bool operator!=< >(const Complex< T > &, const Complex< T > &);
    friend bool operator< < >(const Complex< T > &, const Complex< T > &);
    friend bool operator<=< >(const Complex< T > &, const Complex< T > &);
    friend bool operator>< >(const Complex< T > &, const Complex< T > &);
    friend bool operator>=< >(const Complex< T > &, const Complex< T > &);
 
private:
    T m_real;
    T m_image;
};
 
template< typename T >
const T Complex< T >::zero(0);
template< typename T >
const T Complex< T >::one(1);
 
//-----------------------------------------------------------------------------
 
template< typename T >
Complex< T >::Complex():
m_real(0),
m_image(0)
{
}
 
template< typename T >
Complex< T >::Complex(const T &real):
m_real(real),
m_image(0)
{
}
 
template< typename T >
Complex< T >::Complex(const T &real, const T &image):
m_real(real),
m_image(image)
{
}
 
//-----------------------------------------------------------------------------
 
template< typename T >
void Complex< T >::set_real(const T &real)
{
    m_real = real;
}
 
template< typename T >
T Complex< T >::get_real() const
{
    return m_real;
}
 
//-----------------------------------------------------------------------------
 
template< typename T >
void Complex< T >::set_image(const T &image)
{
    m_image = image;
}
 
template< typename T >
T Complex< T >::get_image() const
{
    return m_image;
}
 
//-----------------------------------------------------------------------------
 
template< typename T >
double Complex< T >::magnitude() const
{
    return sqrt(static_cast< double >(m_real * m_real + m_image * m_image));
}
 
template< typename T >
double Complex< T >::argument() const
{
    return atan2(static_cast< double >(m_image), static_cast< double >(m_real));
}
 
//-----------------------------------------------------------------------------
 
template< typename T >
Complex< T > Complex< T >::conjugate() const
{
    return Complex< T > (m_real, -m_image);
}
 
template< typename T >
Complex< T > Complex< T >::negate() const
{
    return Complex< T > (-m_real, m_image);
}
 
//-----------------------------------------------------------------------------
 
template< typename T >
std::ostream &operator<<(std::ostream &output, const Complex< T > &complex)
{
    return output << "(" << complex.m_real << "," << complex.m_image << ")";
}
 
template< typename T >
std::istream &operator>>(std::istream &input, Complex< T > &complex)
{
    Complex< T > result;
 
    input >> std::ws;
    
    char c = input.peek();
 
    if (c == '(')
    {
        input.get();
 
        input >> std::ws >> result.m_real >> std::ws;
 
        c = input.peek();
 
        if (c == ',')
        {
            input.get();
 
            input >> std::ws >> result.m_image >> std::ws;
 
            c = input.peek();
        }
 
        if (c != ')')
            input.clear(input.rdstate() | std::ios::badbit);
    }
    else
    {
        input >> result.m_real;
    }
 
    complex = result;
 
    return input;
}
 
//-----------------------------------------------------------------------------
 
template< typename T >
Complex< T > operator-(const Complex< T > &complex)
{
    return Complex< T > (-complex.m_real, -complex.m_image);
}
 
//-----------------------------------------------------------------------------
 
template< typename T >
Complex< T > operator+(const Complex< T > &left, const Complex< T > &right)
{
    return Complex< T > (left.m_real + right.m_real, left.m_image + right.m_image);
}
 
template< typename T >
Complex< T > operator-(const Complex< T > &left, const Complex< T > &right)
{
    return Complex< T > (left.m_real - right.m_real, left.m_image - right.m_image);
}
 
template< typename T >
Complex< T > operator*(const Complex< T > &left, const Complex< T > &right)
{
    return Complex< T > (left.m_real * right.m_real - left.m_image * right.m_image, left.m_real * right.m_image + left.m_image * right.m_real);
}
 
template< typename T >
Complex< T > operator/(const Complex< T > &left, const Complex< T > &right)
{
    T denominator = right.m_real * right.m_real + right.m_image * right.m_image;
 
    return Complex< T > ((left.m_image * right.m_image + left.m_real * right.m_real) / denominator, (left.m_image * right.m_real - left.m_real * right.m_image) / denominator);
}
 
//-----------------------------------------------------------------------------
 
template< typename T >
Complex< T > &Complex< T >::operator+=(const Complex< T > &right)
{
    return *this = *this + right;
}
 
template< typename T >
Complex< T > &Complex< T >::operator-=(const Complex< T > &right)
{
    return *this = *this - right;
}
 
template< typename T >
Complex< T > &Complex< T >::operator*=(const Complex< T > &right)
{
    return *this = *this * right;
}
 
template< typename T >
Complex< T > &Complex< T >::operator/=(const Complex< T > &right)
{
    return *this = *this / right;
}
 
//-----------------------------------------------------------------------------
 
template< typename T >
bool operator==(const Complex< T > &left, const Complex< T > &right)
{
    return left.m_real == right.m_real && left.m_image == right.m_image;
}
 
template< typename T >
bool operator!=(const Complex< T > &left, const Complex< T > &right)
{
    return !(left == right);
}
 
template< typename T >
bool operator<(const Complex< T > &left, const Complex< T > &right)
{
    return left.m_real * left.m_real + left.m_image * left.m_image < right.m_real * right.m_real + right.m_image * right.m_image;
}
 
template< typename T >
bool operator<=(const Complex< T > &left, const Complex< T > &right)
{
    return left < right || left == right;
}
 
template< typename T >
bool operator>(const Complex< T > &left, const Complex< T > &right)
{
    return right < left;
}
 
template< typename T >
bool operator>=(const Complex< T > &left, const Complex< T > &right)
{
    return right <= left;
}
 
//-----------------------------------------------------------------------------
 
#endif
3
ForEveR
В астрале
Эксперт С++
7972 / 4734 / 321
Регистрация: 24.06.2010
Сообщений: 10,541
Завершенные тесты: 3
25.04.2011, 23:55 #7
Как-нибудь так. Еще бы я явное std:: Использовал... Но это как хотите

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
#include<iostream>
#include <math.h>
using namespace std;
class complex
{
public:
   complex(int a_=1, int b_=1):a(a_), b(b_)
   {
   }
   complex& operator -()
   {
       a = -a;
       b = -b;
       return *this;
   }
   int getA() const {return a;}
   int getB() const {return b;}
   void setA(int a_) {a = a_;}
   void setB(int b_) {b = b_;}
   void setCompl(int a_, int b_)
   {
       a = a_;
       b = b_;
   }
private:
   int a, b;
};
ostream& operator <<(ostream& out, const complex& C)
{
out<<C.getA()<<"*i+"<<C.getB()<<endl;
return out;
}
istream& operator >>(istream& in ,complex& C)
{
cout<<"Введите а и b"<<endl;
int a=0, b=0;
in>>a>>b;
C.setCompl(a, b);
return in;
}
bool operator !=(const complex& C, const complex& C1)
{
return sqrt(static_cast<double>(C.getA() * C.getA() + C.getB() * C.getB())) !=
     sqrt(static_cast<double>(C1.getA() * C1.getA() + C1.getB() * C1.getB()));
}
int main()
{
setlocale(LC_ALL,"rus");
cout<<"Введите первое комплексное число:"<<endl;
complex C,C1;
cin>>C;
cout<<"Введите второе комплексное число:"<<endl;
cin>>C1;
cout<<C<<endl<<C1<<endl;
C = -C;
C1 = -C1;
cout<<C<<endl<<C1<<endl;
if(C != C1)
cout<<"Не равны!"<<endl;
else
cout<<"Равны!"<<endl;
}
1
Zzzzzz
0 / 0 / 0
Регистрация: 25.04.2011
Сообщений: 14
26.04.2011, 01:11  [ТС] #8
Спасибо большое!!!!
0
volovzi
267 / 169 / 8
Регистрация: 14.03.2010
Сообщений: 501
27.04.2011, 04:03 #9
Пример тремя постами выше некорректен и непоследователен.
Некорректен он сравнениями, причём всеми. При использовании в качестве параметра шаблона числа с плавающей точкой равенство-неравенство будет использовать нельзя. А сравнения на больше-меньше для комплексных чисел вообще не определены.
А непоследовательность заключается в том, что арифметические операции определены вне класса, но при этом они являются друзьями этого класса, несмотря на то, что в классе есть функции для доступа к его закрытым переменным. Нелогично.
1
taras atavin
Ушёл с форума.
3569 / 1753 / 91
Регистрация: 24.11.2009
Сообщений: 27,619
27.04.2011, 05:29 #10
Цитата Сообщение от silent_1991 Посмотреть сообщение
std::ws;
Что это такое?
Цитата Сообщение от silent_1991 Посмотреть сообщение
input >> std::ws >> result.m_real >> std::ws;
Это ввод из input в result.m_real ? А почему это именно так выглядит? И зачем
Цитата Сообщение от silent_1991 Посмотреть сообщение
input >> std::ws;
?
1
silent_1991
Эксперт С++
4964 / 3040 / 149
Регистрация: 11.11.2009
Сообщений: 7,027
Завершенные тесты: 1
27.04.2011, 08:22 #11
volovzi, на счёт сравнений согласен, класс написал, но отлаживать не стал (просто не подумал сразу про дабл, не было необходимости). На счёт больше-меньше - не помню, нужно мне было для чего-то сравнение по модулю. Тут логичнее было бы сделать отдельной функцией (все-таки это не совсем сравнение).
На счёт непоследовательности - сначала не предполагалось писать сеттеры-геттеры, они дописывались потом. Обычно делается наоборот, но в этот раз вышло так.
А вообще мне привычнее делать бинарные операции глобальными. Во-первых, с приведениями типов легче (можно выполнять операции над операндами разных типов, главное, чтобы преобразование соответствующее было определено), а во-вторых, удобнее работать с двумя операндами, когда они называются left и right, а не *this и right. Ну, для меня, по крайней мере, это актуально.

taras atavin, это всё, чтобы пробелы игнорить.
1
taras atavin
Ушёл с форума.
3569 / 1753 / 91
Регистрация: 24.11.2009
Сообщений: 27,619
27.04.2011, 09:09 #12
Эйси. А как расшифровать каждую закорючку? И как сделать, если их не надо игнорить? Например, число начинается с действительной части с фиксированной или плавающей запятой, причём, если действительная часть положительна, то она не имеет знака числа, но в плавающей запятой знак порядка обязателен, после действительной части без пробелов следует строго знаковая (то есть и положительные значения начинаются не с цифры, а с символа "+") запись мнимой части с фиксированной или плавающей запятой, в плавающей запятой знак порядка обязателен, потом ставится ровно один пробел и символ "i", если число число мнимое, то запись начинается сразу с мнимой части с фиксированной или плавающей запятой, но положительная минимая часть не имеет знака числа, а в плавающей запятой знак порядка обязателен, потом также ставится ровно один пробел и символ "i", если число действительное, то его запись целиком состоит из записи действительнйо части с фиксированной или плавающей запятой, но положительные значения знака числа не имеют, а в плавающей запятой знак порядка обязателен, если нулю роавны обе части числа (и мнимая, и действительная), то запись числа состоит из одного символа "0", а между мантиссой и знаком порядка ставится символ "e" или "E". Как поддерживать такой формат?
0
silent_1991
Эксперт С++
4964 / 3040 / 149
Регистрация: 11.11.2009
Сообщений: 7,027
Завершенные тесты: 1
27.04.2011, 09:17 #13
Ввод даблов в таком формате поддерживается изначально. Попробуйте запустить такой код:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
#include "Complex.h"
 
#include <iostream>
 
int main()
{
    Complex< double > cnum;
 
    std::cin >> cnum;
    std::cout << cnum << std::endl;
 
    return 0;
}
и ввести (2.71828e-2, 3.14159E3). Результат будет (0.0271828,3141.59) (т.е. всё парсится по дефолту).
Если же надо вводить число в формате im + i*real, то надо дополнительно парсить строку - смотреть, есть ли действительная часть, есть ли мнимая (по-отдельности или вместе), смотреть, какой знак между действительной и мнимой частью и т.д.
0
taras atavin
Ушёл с форума.
3569 / 1753 / 91
Регистрация: 24.11.2009
Сообщений: 27,619
27.04.2011, 09:24 #14
А я хочу
2.34+3.67e+118 i
ровно с одним пробелом, обязательным знаком порядка, символом "i" при наличии мнимой части и без скобок. А иначе чтоб вылезала гога. И лишний плюс тоже чтоб давал гогу.
0
silent_1991
Эксперт С++
4964 / 3040 / 149
Регистрация: 11.11.2009
Сообщений: 7,027
Завершенные тесты: 1
27.04.2011, 09:26 #15
taras atavin, ну напишите соответствующий парсер. В чём проблема, вы программист или где?
0
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
27.04.2011, 09:26
Привет! Вот еще темы с ответами:

Класс "Комплексное число" - C++
Уважаемые программеры, я еще не совсем силен в C++, так что подскажите: нужно вносить какие-то изменения в код? Заранее благодарю. ...

Определить перегруженный бинарный и унарный оператор* для класса "Комплексное число" - C++
Как можно реализовать перегруженный бинарный и унарный оператор* для класса &quot;Комплексное число&quot;?

Структура "Комплексное число", проблемы с выводом - C++
Задание - массив структур типа &quot;Комплексное число&quot;. Неправильно работает, точнее, неправильный вывод. Будто проверяет только первое условие...

Определение класса, описывающего комплексное число. Перегрузка для него бинарного оператора "*" - C++
1. Определить класс, описывающий комплексное число. Для класса перегрузить бинарный оператор *. Написать программу, в которой используется...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
Yandex
Объявления
27.04.2011, 09:26
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru