С Новым годом! Форум программистов, компьютерный форум, киберфорум
С++ для начинающих
Форум программистов и сисадминов Киберфорум > Форум программистов > C/C++ > C++ > С++ для начинающих
Войти
Регистрация
Восстановить пароль
Карта форума Темы раздела Блоги Сообщество Поиск Заказать работу  
 
Рейтинг 4.95/21: Рейтинг темы: голосов - 21, средняя оценка - 4.95
41 / 4 / 0
Регистрация: 24.11.2013
Сообщений: 139
1

Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла)

05.08.2014, 20:21. Показов 3789. Ответов 10
Метки нет (Все метки)
Author24 — интернет-сервис помощи студентам
Задача такова: Только для любителей математики: создайте класс Polar, который предна-
значен для хранения полярных координат (радиуса и угла). Перегрузите
операцию + для выполнения сложения для объектов класса Polar. Сложе-
ние двух объектов выполняется путем сложения координат X объектов,
а затем координат Y. Результат будет координатами новой точки. Таким
образом, вам нужно будет преобразовать полярные координаты к прямо-
угольным, сложить их, а затем обратно преобразовать прямоугольные ко-
ординаты результата к полярным.

кажется я так до конца не поняла как преобразовывать типы данных, уже мозги пухнут %) здесь попытка сделать это через конструкторы. конечно можно все проще сделать, убрать один класс, но мне хочется по красивому, 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
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

#include "stdafx.h"
#include<iostream>
#include <string>
#include <stdlib.h>
#include <iomanip>
#include <cmath>
using namespace std;
class Polar
{
private:
  double corner;
  double radius;
public:
    Polar() : corner(0), radius (0)
    {}
    Polar (double cor, double rad) : corner(cor), radius(rad)
    {}
    Polar (Cartesian cartes)
    {
        double x = cartes.get_X();
        double y = cartes.get_Y();
        corner = tan(y/x);
        radius = sqrt(pow(x, 2) + pow(y, 2));
    }
    void get ()
    {
        cout << "Enter polar coordinate. Enter corner: " << endl;
        cin >> corner;
        if (corner < 0)
            if (corner > 360)
                exit(1);
        cout << "Enter radius: " << endl;
        cin >> radius;
    }
    void display() const
    {
        cout << "The result of adding: " << endl 
            << "corner: " << corner << endl
            << "radius: " << radius << endl;
    }
    double get_corner () const
    {return corner; }
    double get_radius () const
    {return radius; }
};
 
class Cartesian
{
private:
    double X;
    double Y;
public:
    Cartesian() : X(0), Y(0)
    {}
    Cartesian (double x, double y) : X(x), Y(y)
    {}
    Cartesian (Polar pol)
    {
        double cor = pol.get_corner();
        double rad = pol.get_radius();
        double x = rad * cos(cor);
        double y = rad * sin(cor);
    }
    Cartesian operator + (Cartesian coord2)
    {
        double tempY = Y + coord2.Y;
        double tempX = X + coord2.X;
        return Cartesian( tempX, tempY);
    }
    double get_X () const
    { return X;}
    double get_Y () const
    {return Y;}
};
    
int main()
{
    Polar coordinate1, coordinate2, result_coordinate;
    Cartesian coord1, coord2, result_coord;
    coordinate1.get();
    coordinate2.get();
    coord1 = coordinate1;
    coord2 = coordinate2;
    result_coord = coord1 + coord2;
    result_coordinate = result_coord;
    result_coordinate.display();
    system ("pause");
    return 0;
}
0
Лучшие ответы (1)
Сообщение: #6492947
cpp_developer
Эксперт
20123 / 5690 / 1417
Регистрация: 09.04.2010
Сообщений: 22,546
Блог
 05.08.2014, 20:21
Ответы с готовыми решениями:

Создать класс для перевода полярных координат в декартовы
Класс CPtoD для перевода полярных координат в декартовы. Свойства класса: • угол в радианах rad;...

Создайте класс для хранения данных о студенте
1. Создайте класс для хранения данных о студенте: фамилия, специальность, курс, успеваемость...

Создайте класс Stack, реализующий стек для хранения символов
Создайте класс Stack, реализующий стек для хранения символов. Используйте методы push ()...

Реализуйте класс для хранения ФИО и номера телефона человека, класс для хранения даты рождения человека, а также класс для хранения ФИО и почтового ад
Реализуйте класс для хранения ФИО и номера телефона человека, класс для хранения даты рождения...

10
102 / 75 / 17
Регистрация: 23.07.2014
Сообщений: 877
Записей в блоге: 1
05.08.2014, 20:41 2
Лучший ответ Сообщение было отмечено Pari как решение

Решение

Pari, ну с минимальными исправлениями так:
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

#include<iostream>
#include <string>
#include <stdlib.h>
#include <iomanip>
#include <cmath>
using namespace std;
 
class Cartesian;
class Polar;
 
class Polar
{
private:
  double corner;
  double radius;
public:
    Polar() : corner(0), radius (0)
    {}
    Polar (double cor, double rad) : corner(cor), radius(rad)
    {}
    Polar (const Cartesian& cartes);
    void get ()
    {
        cout << "Enter polar coordinate. Enter corner: " << endl;
        cin >> corner;
        if (corner < 0)
            if (corner > 360)
                exit(1);
        cout << "Enter radius: " << endl;
        cin >> radius;
    }
    void display() const
    {
        cout << "The result of adding: " << endl 
            << "corner: " << corner << endl
            << "radius: " << radius << endl;
    }
    double get_corner () const
    {return corner; }
    double get_radius () const
    {return radius; }
};
 
class Cartesian
{
private:
    double X;
    double Y;
public:
    Cartesian() : X(0), Y(0)
    {}
    Cartesian (double x, double y) : X(x), Y(y)
    {}
    Cartesian (const Polar& pol);
    Cartesian operator + (Cartesian coord2)
    {
        double tempY = Y + coord2.Y;
        double tempX = X + coord2.X;
        return Cartesian( tempX, tempY);
    }
    double get_X () const
    { return X;}
    double get_Y () const
    {return Y;}
};
 
Cartesian::Cartesian(const Polar& pol)
{
    double cor = pol.get_corner();
    double rad = pol.get_radius();
    X = rad * cos(cor);
    Y = rad * sin(cor);
}
 
Polar::Polar(const Cartesian& cartes)
{
    double x = cartes.get_X();
    double y = cartes.get_Y();
    corner = tan(y/x);
    radius = hypot(x, y);
}
 
int main()
{
    Polar coordinate1, coordinate2, result_coordinate;
    Cartesian coord1, coord2, result_coord;
    coordinate1.get();
    coordinate2.get();
    coord1 = coordinate1;
    coord2 = coordinate2;
    result_coord = coord1 + coord2;
    result_coordinate = result_coord;
    result_coordinate.display();
    return 0;
}
0
41 / 4 / 0
Регистрация: 24.11.2013
Сообщений: 139
05.08.2014, 20:54  [ТС] 3
CyberSolver, спасибо огромное! а почему с минимальными? все так плохо у у меня?

Добавлено через 3 минуты
и можете пожалуйста объяснить, почему вы добавили в конструкторы const?
0
Эксперт С++
3225 / 1752 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
06.08.2014, 01:39 4
Ну, вы, ребята, даете! Кто ж так
C++
1

corner = tan(y/x);
угол-то вычисляет?

Мой вариант:
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

/////////////////////////////////////////////////////////////////////////////////////////
//Задача такова: Только для любителей математики: создайте класс Polar, который 
//предназначен для хранения полярных координат (радиуса и угла). Перегрузите
//операцию + для выполнения сложения для объектов класса Polar. Сложение двух 
//объектов выполняется путем сложения координат X объектов,
//а затем координат Y. Результат будет координатами новой точки. Таким
//образом, вам нужно будет преобразовать полярные координаты к прямо-
//угольным, сложить их, а затем обратно преобразовать прямоугольные ко-
//ординаты результата к полярным.
/////////////////////////////////////////////////////////////////////////////////////////
#include <cmath>
#include <complex>
#include <iostream>
/////////////////////////////////////////////////////////////////////////////////////////
class   T_cartesian
{
    //-----------------------------------------------------------------------------------
    double  x_;
    double  y_;
    //-----------------------------------------------------------------------------------
    friend  std::ostream& operator<<
        (
            std::ostream            &   os,
            const   T_cartesian     &   c
        )
    {
        os  <<  std::complex<double>
                    (
                        c.x(),
                        c.y()
                    );
 
        return os;
    }
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_cartesian()
        :
        x_  (),
        y_  ()
    {}
    //-----------------------------------------------------------------------------------
    T_cartesian
        (
            double  x,
            double  y
        )
        :
        x_  (x),
        y_  (y)
    {}
    //-----------------------------------------------------------------------------------
    double  &  x()
    {
        return  x_;
    }
    //-----------------------------------------------------------------------------------
    double  x()                                                                     const
    {
        return  x_;
    }
    //-----------------------------------------------------------------------------------
    double  &  y()
    {
        return  y_;
    }
    //-----------------------------------------------------------------------------------
    double  y()                                                                     const
    {
        return  y_;
    }
    //-----------------------------------------------------------------------------------
    T_cartesian     operator+   ( T_cartesian   const   &   c )                     const
    {
        return  T_cartesian
                    (
                        x()     +   c.x(),
                        y()     +   c.y()
                    );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class   T_polar
{
    //-----------------------------------------------------------------------------------
    double  angle_;
    double  radius_;
    //-----------------------------------------------------------------------------------
    friend  std::ostream& operator<<
        (
            std::ostream        &   os,
            const   T_polar     &   p
        )
    {
        os  <<  "< ang = "
            <<  p.angle()
            <<  ", rad = "
            <<  p.radius()
            <<  " >";
 
        return os;
    }
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_polar()
        :
        angle_  (),
        radius_ ()
    {}
    //-----------------------------------------------------------------------------------
    T_polar
        (
            double  angle,
            double  radius
        )
        :
        angle_  ( angle     ),
        radius_ ( radius    )
    {}
    //-----------------------------------------------------------------------------------
    T_polar( T_cartesian    const   &   c )
        :
        radius_
            (
                sqrt
                    (
                            c.x() * c.x()
                        +   c.y() * c.y()
                    )
            )
    {
        if( radius_     ==  0 )
        {
            angle_  =   0;
        }
        else
        {
            double  sin_val     =   c.y() / radius_;
            double  cos_val     =   c.x() / radius_;
 
            if( cos_val     ==  -1 )
            {
                angle_  =   acos( cos_val );
            }
            else
            {
                double  tg_angle_2  =   sin_val / ( 1 + cos_val );
                angle_              =   2 * atan( tg_angle_2 );
            }//else
        }//else
    }
    //-----------------------------------------------------------------------------------
    double  &   angle()
    {
        return  angle_;
    }
    //-----------------------------------------------------------------------------------
    double  angle()                                                                 const
    {
        return  angle_;
    }
    //-----------------------------------------------------------------------------------
    double  &   radius()
    {
        return  radius_;
    }
    //-----------------------------------------------------------------------------------
    double  radius()                                                                const
    {
        return  radius_;
    }
    //-----------------------------------------------------------------------------------
    T_polar     operator+   ( T_polar   const   &   p )                             const
    {
        return  T_polar
                    (
                        T_cartesian( *this )  +   p
                    );
    }
    //-----------------------------------------------------------------------------------
    operator    T_cartesian()                                                       const
    {
        return  T_cartesian
                    (
                        radius()    *   cos( angle() ),
                        radius()    *   sin( angle() )
                    );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    const   double  PI      =   acos( -1.0 );
 
    for( int  grad = -180; grad <= 180; grad += 2 )
    {
        T_polar     p   (
                            grad / 180.0 * PI,
                            1.0
                        );
 
        T_cartesian     c   =   p;
        T_polar         pp  =   c;
 
        std::cout   <<  grad
                    <<  '\t'
                    <<  pp.angle() / PI * 180
                    <<  std::endl;
    }//for
 
    T_polar         p   ( T_cartesian(1, 1) );
    T_polar         pp  ( T_cartesian(2, 2) );
    T_polar         sum_p   =   p + pp;
    T_cartesian     sum_c   =   sum_p;
 
    std::cout   <<  sum_c
                <<  std::endl
                <<  p + sum_c
                <<  std::endl
                <<  sum_c + p
                <<  std::endl;
 
    system("pause");
}
1
102 / 75 / 17
Регистрация: 23.07.2014
Сообщений: 877
Записей в блоге: 1
06.08.2014, 06:40 5
Цитата Сообщение от Pari Посмотреть сообщение
и можете пожалуйста объяснить, почему вы добавили в конструкторы const?
Чтобы не копировать весь объект.
Цитата Сообщение от Mr.X Посмотреть сообщение
Ну, вы, ребята, даете! Кто ж так
C++
1

corner = tan(y/x);
угол-то вычисляет?
Ну по-хорошему нужен atan2, но вопрос топикстартера не про это.
Цитата Сообщение от Mr.X Посмотреть сообщение
radius_
(
sqrt
(
c.x() c.x()
+ c.y() c.y()
)
)
А кто так вычисляет радиус, когда есть hypot?
0
Эксперт С++
3225 / 1752 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
06.08.2014, 07:48 6
Цитата Сообщение от CyberSolver Посмотреть сообщение
не про это
Интересный ответ. Т.е. признавать ошибки мы в принципе не способны?
Цитата Сообщение от CyberSolver Посмотреть сообщение
atan2
Цитата Сообщение от CyberSolver Посмотреть сообщение
hypot
А, да, спасибо, я что-то забыл про них, с ними действительно изящнее:
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

/////////////////////////////////////////////////////////////////////////////////////////
//Задача такова: Только для любителей математики: создайте класс Polar, который 
//предназначен для хранения полярных координат (радиуса и угла). Перегрузите
//операцию + для выполнения сложения для объектов класса Polar. Сложение двух 
//объектов выполняется путем сложения координат X объектов,
//а затем координат Y. Результат будет координатами новой точки. Таким
//образом, вам нужно будет преобразовать полярные координаты к прямо-
//угольным, сложить их, а затем обратно преобразовать прямоугольные ко-
//ординаты результата к полярным.
/////////////////////////////////////////////////////////////////////////////////////////
#include <cmath>
#include <complex>
#include <iostream>
/////////////////////////////////////////////////////////////////////////////////////////
class   T_cartesian
{
    //-----------------------------------------------------------------------------------
    double  x_;
    double  y_;
    //-----------------------------------------------------------------------------------
    friend  std::ostream& operator<<
        (
            std::ostream            &   os,
            const   T_cartesian     &   c
        )
    {
        os  <<  std::complex<double>
                    (
                        c.x(),
                        c.y()
                    );
 
        return os;
    }
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_cartesian()
        :
        x_  (),
        y_  ()
    {}
    //-----------------------------------------------------------------------------------
    T_cartesian
        (
            double  x,
            double  y
        )
        :
        x_  (x),
        y_  (y)
    {}
    //-----------------------------------------------------------------------------------
    double  &  x()
    {
        return  x_;
    }
    //-----------------------------------------------------------------------------------
    double  x()                                                                     const
    {
        return  x_;
    }
    //-----------------------------------------------------------------------------------
    double  &  y()
    {
        return  y_;
    }
    //-----------------------------------------------------------------------------------
    double  y()                                                                     const
    {
        return  y_;
    }
    //-----------------------------------------------------------------------------------
    T_cartesian     operator+   ( T_cartesian   const   &   c )                     const
    {
        return  T_cartesian
                    (
                        x()     +   c.x(),
                        y()     +   c.y()
                    );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class   T_polar
{
    //-----------------------------------------------------------------------------------
    double  angle_;
    double  radius_;
    //-----------------------------------------------------------------------------------
    friend  std::ostream& operator<<
        (
            std::ostream        &   os,
            const   T_polar     &   p
        )
    {
        os  <<  "< ang = "
            <<  p.angle()
            <<  ", rad = "
            <<  p.radius()
            <<  " >";
 
        return os;
    }
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_polar()
        :
        angle_  (),
        radius_ ()
    {}
    //-----------------------------------------------------------------------------------
    T_polar
        (
            double  angle,
            double  radius
        )
        :
        angle_  ( angle     ),
        radius_ ( radius    )
    {}
    //-----------------------------------------------------------------------------------
    T_polar( T_cartesian    const   &   c )
        :
        radius_
            (
                hypot( c.x(), c.y() )
            )
    {
        double  sin_val     =   c.y() / radius_;
        double  cos_val     =   c.x() / radius_;
 
        angle_  =   atan2( sin_val,     cos_val );
    }
    //-----------------------------------------------------------------------------------
    double  &   angle()
    {
        return  angle_;
    }
    //-----------------------------------------------------------------------------------
    double  angle()                                                                 const
    {
        return  angle_;
    }
    //-----------------------------------------------------------------------------------
    double  &   radius()
    {
        return  radius_;
    }
    //-----------------------------------------------------------------------------------
    double  radius()                                                                const
    {
        return  radius_;
    }
    //-----------------------------------------------------------------------------------
    T_polar     operator+   ( T_polar   const   &   p )                             const
    {
        return  T_polar
                    (
                        T_cartesian( *this )  +   p
                    );
    }
    //-----------------------------------------------------------------------------------
    operator    T_cartesian()                                                       const
    {
        return  T_cartesian
                    (
                        radius()    *   cos( angle() ),
                        radius()    *   sin( angle() )
                    );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    const   double  PI      =   acos( -1.0 );
 
    T_polar         p   ( T_cartesian(1, 1) );
    T_polar         pp  ( T_cartesian(2, 2) );
    T_polar         sum_p   =   p + pp;
    T_cartesian     sum_c   =   sum_p;
 
    std::cout   <<  sum_c
                <<  std::endl
                <<  p + sum_c
                <<  std::endl
                <<  sum_c + p
                <<  std::endl;
 
    system("pause");
}
0
102 / 75 / 17
Регистрация: 23.07.2014
Сообщений: 877
Записей в блоге: 1
06.08.2014, 08:02 7
Цитата Сообщение от Mr.X Посмотреть сообщение
Интересный ответ
Какой есть. Вопрос ТС - не за красоту кода.
Цитата Сообщение от Mr.X Посмотреть сообщение
Т.е. признавать ошибки мы в принципе не способны?
У ТС было так - я менять не стал. Какие-то проблемы?
Цитата Сообщение от Mr.X Посмотреть сообщение
А, да, спасибо, я что-то забыл про них, с ними действительно изящнее:
С ними не "изящнее", с ними правильнее. Прежде чем высокомерно поучать других, будьте готовы, что и вас ткнут носом в лужу. Извините за мой французский, не в духе сегодня.
0
Эксперт С++
3225 / 1752 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
06.08.2014, 08:43 8
Цитата Сообщение от CyberSolver Посмотреть сообщение
Вопрос ТС - не за красоту кода.
Цитата Сообщение от CyberSolver Посмотреть сообщение
У ТС было так - я менять не стал. Какие-то проблемы?
При чем тут красота. У вас в программе математическая ошибка, из-за которой она работает неправильно.
Вообще-то на ошибках учимся, и обращение внимания на ошибки друг друга - это, по-моему, среди программистов нормальная практика, а вы это как оскорбление воспринимаете.
Цитата Сообщение от CyberSolver Посмотреть сообщение
С ними не "изящнее", с ними правильнее.
Да нет, моя программа и без них правильно работает.
Цитата Сообщение от CyberSolver Посмотреть сообщение
Прежде чем высокомерно
Т.е. каждый, кто найдет у вас ошибку - проявляет тем самым высокомерие?
Вы что-то совсем в истерику впали, разве можно так неадекватно реагировать на критику.
0
102 / 75 / 17
Регистрация: 23.07.2014
Сообщений: 877
Записей в блоге: 1
06.08.2014, 09:17 9
Цитата Сообщение от Mr.X Посмотреть сообщение
У вас в программе математическая ошибка, из-за которой она работает неправильно.
Да вижу, вижу, но пусть ТС разбирается.
Цитата Сообщение от Mr.X Посмотреть сообщение
Вы что-то совсем в истерику впали, разве можно так неадекватно реагировать на критику.
Где вы истерику увидели? Давайте уже закроем тему, всё все поняли.

Мирись, мирись, и больше не дерись
0
41 / 4 / 0
Регистрация: 24.11.2013
Сообщений: 139
06.08.2014, 13:08  [ТС] 10
Цитата Сообщение от CyberSolver Посмотреть сообщение
А кто так вычисляет радиус, когда есть hypot?
не знала что есть такая функция

Добавлено через 2 минуты
Цитата Сообщение от Mr.X Посмотреть сообщение
угол-то вычисляет?
для меня ваш код не понятен абсолютно, извините, знаний у меня не так много. friend еще не изучила

Добавлено через 2 минуты
скажите, пожалуйста, прямо, где у меня ошибка в алгоритме? а то вы кажется про мой код малехо забыли... CyberSolver, я так и не поняла, значит вы не исправили ошибку в вычислениях?
0
Эксперт С++
3225 / 1752 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
06.08.2014, 13:59 11
Цитата Сообщение от Pari Посмотреть сообщение
скажите, пожалуйста, прямо, где у меня ошибка в алгоритме?
Ну, прямее не бывает, она у вас в строке 22, где вы углу присваиваете тангенс.
А правильное вычисление можете посмотреть в моей программе:
Цитата Сообщение от Mr.X Посмотреть сообщение
C++
1
2
3
4
5
6
7
8
9
10
11
12

    T_polar( T_cartesian    const   &   c )
        :
        radius_
            (
                hypot( c.x(), c.y() )
            )
    {
        double  sin_val     =   c.y() / radius_;
        double  cos_val     =   c.x() / radius_;
 
        angle_  =   atan2( sin_val,     cos_val );
    }
1
06.08.2014, 13:59
raxper
Эксперт
30234 / 6612 / 1498
Регистрация: 28.12.2010
Сообщений: 21,154
Блог
 06.08.2014, 13:59
Помогаю со студенческими работами здесь

Класс для хранения координат прямоугольных «окон» на экране
Класс для хранения координат прямоугольных «окон» на экране (хранить координаты левого верхнего и...

Как создать класс для хранения координат точки на плоскости?
Задание звучит так: &quot;Спроектировать и создать класс с именем «coord», предназначенный для хранения...

Как создать класс в ООП для хранения координат точки на плоскости?
Само задание: &quot;Спроектировать и создать класс с именем «coord», предназначенный для хранения...

Создайте класс time, содержащий три поля, предназначенные для хранения часов, минут и секунд
Создайте класс с именем time, содержащий три поля типа int, предназначенные для хранения часов,...


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

Или воспользуйтесь поиском по форуму:
11
Ответ Создать тему
Новые блоги и статьи
Как написать микросервис на C# с Kafka, MediatR, Redis и GitLab CI/CD
InfoMaster 15.01.2025
В современной разработке программного обеспечения микросервисная архитектура стала стандартом де-факто для создания масштабируемых и гибких приложений. Этот подход позволяет разделить сложную систему. . .
Что такое CQRS и как это реализовать на C# с MediatR
InfoMaster 15.01.2025
Концепция CQRS и её роль в современной разработке В современном мире разработки программного обеспечения архитектурные паттерны играют ключевую роль в создании масштабируемых и поддерживаемых. . .
Как настроить CI/CD с Azure DevOps
InfoMaster 15.01.2025
CI/ CD, или непрерывная интеграция и непрерывное развертывание, представляет собой современный подход к разработке программного обеспечения, который позволяет автоматизировать и оптимизировать процесс. . .
Как настроить CI/CD с помощью Jenkins
InfoMaster 15.01.2025
Введение в CI/ CD и Jenkins В современной разработке программного обеспечения непрерывная интеграция (CI) и непрерывная доставка (CD) стали неотъемлемыми элементами процесса создания качественных. . .
Как написать микросервис на Go/Golang с Kafka, REST и GitHub CI/CD
InfoMaster 14.01.2025
Определение микросервиса, преимущества использования Go/ Golang Микросервис – это архитектурный подход к разработке программного обеспечения, при котором приложение состоит из небольших, независимо. . .
Как написать микросервис с нуля на C# с RabbitMQ, CQRS, Swagger и CI/CD
InfoMaster 14.01.2025
В современном мире разработки программного обеспечения микросервисная архитектура стала стандартом де-факто для создания масштабируемых и гибких приложений. Этот архитектурный подход предполагает. . .
Как создать интернет-магазин на PHP и JavaScript
InfoMaster 14.01.2025
В современном мире электронная коммерция стала неотъемлемой частью бизнеса. Создание собственного интернет-магазина открывает широкие возможности для предпринимателей, позволяя достичь большей. . .
Как написать Тетрис на Ассемблере
InfoMaster 14.01.2025
Тетрис – одна из самых узнаваемых и популярных компьютерных игр, созданная в 1984 году советским программистом Алексеем Пажитновым. За прошедшие десятилетия она завоевала симпатии миллионы людей по. . .
Как создать игру "Танчики" на Unity3d и C#
InfoMaster 14.01.2025
Разработка игр – это увлекательный процесс, сочетающий в себе творчество и технические навыки. В этой статье мы рассмотрим создание классической игры "Танчики" с использованием Unity3D и языка. . .
Организую платный онлайн микро-курс по доработке Android-клиента Telegram
_Ivana 14.01.2025
Официальная версия и распространенные форки не полностью устраивают? Сделай свою кастомную версию клиента! 4 занятия по 2 часа (2 недели пн, ср 19:00-21:00 по Москве). Первое вводное занятие. . .
Как создать приложение для фитнеса для iOS/iPhone на Kotlin
InfoMaster 14.01.2025
Создание собственного фитнес-приложения — это не только захватывающий, но и полезный процесс, ведь оно может стать вашим верным помощником на пути к здоровому и активному образу жизни. В современных. . .
Как создать приложение магазина для iOS/iPhone на Swift
InfoMaster 14.01.2025
Введение в разработку iOS-приложений Разработка приложений для iPhone и других устройств на базе iOS открывает огромные возможности для создания инновационных мобильных решений. В данной статье мы. . .
КиберФорум - форум программистов, компьютерный форум, программирование
Поддержать - Реклама - Условия использования - Обратная связь
Powered by vBulletin
Copyright ©2000 - 2025, CyberForum.ru