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

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

Восстановить пароль Регистрация
 
Pari
40 / 3 / 0
Регистрация: 24.11.2013
Сообщений: 139
05.08.2014, 20:21     Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла) #1
Задача такова: Только для любителей математики: создайте класс 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;
}
Лучшие ответы (1)
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
05.08.2014, 20:21     Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла)
Посмотрите здесь:

Функция для определения полярных координат точки по ее прямоугольным декартовым координатам C++
Создать класс который может быть использован для хранения информации и студентах C++
Реализуйте класс для хранения ФИО и номера телефона человека, класс для хранения даты рождения человека, а также класс для хранения ФИО и почтового ад C++
Создайте класс для хранения данных о студенте C++
C++ Создайте класс, который содержит информацию об имени и адресе
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
CyberSolver
 Аватар для CyberSolver
101 / 74 / 17
Регистрация: 23.07.2014
Сообщений: 686
Записей в блоге: 1
05.08.2014, 20:41     Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла) #2
Сообщение было отмечено автором темы, экспертом или модератором как ответ
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;
}
Pari
40 / 3 / 0
Регистрация: 24.11.2013
Сообщений: 139
05.08.2014, 20:54  [ТС]     Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла) #3
CyberSolver, спасибо огромное! а почему с минимальными? все так плохо у у меня?

Добавлено через 3 минуты
и можете пожалуйста объяснить, почему вы добавили в конструкторы const?
Mr.X
Эксперт С++
 Аватар для Mr.X
2801 / 1577 / 247
Регистрация: 03.05.2010
Сообщений: 3,662
06.08.2014, 01:39     Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла) #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");
}
CyberSolver
 Аватар для CyberSolver
101 / 74 / 17
Регистрация: 23.07.2014
Сообщений: 686
Записей в блоге: 1
06.08.2014, 06:40     Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла) #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?
Mr.X
Эксперт С++
 Аватар для Mr.X
2801 / 1577 / 247
Регистрация: 03.05.2010
Сообщений: 3,662
06.08.2014, 07:48     Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла) #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");
}
CyberSolver
 Аватар для CyberSolver
101 / 74 / 17
Регистрация: 23.07.2014
Сообщений: 686
Записей в блоге: 1
06.08.2014, 08:02     Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла) #7
Цитата Сообщение от Mr.X Посмотреть сообщение
Интересный ответ
Какой есть. Вопрос ТС - не за красоту кода.
Цитата Сообщение от Mr.X Посмотреть сообщение
Т.е. признавать ошибки мы в принципе не способны?
У ТС было так - я менять не стал. Какие-то проблемы?
Цитата Сообщение от Mr.X Посмотреть сообщение
А, да, спасибо, я что-то забыл про них, с ними действительно изящнее:
С ними не "изящнее", с ними правильнее. Прежде чем высокомерно поучать других, будьте готовы, что и вас ткнут носом в лужу. Извините за мой французский, не в духе сегодня.
Mr.X
Эксперт С++
 Аватар для Mr.X
2801 / 1577 / 247
Регистрация: 03.05.2010
Сообщений: 3,662
06.08.2014, 08:43     Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла) #8
Цитата Сообщение от CyberSolver Посмотреть сообщение
Вопрос ТС - не за красоту кода.
Цитата Сообщение от CyberSolver Посмотреть сообщение
У ТС было так - я менять не стал. Какие-то проблемы?
При чем тут красота. У вас в программе математическая ошибка, из-за которой она работает неправильно.
Вообще-то на ошибках учимся, и обращение внимания на ошибки друг друга - это, по-моему, среди программистов нормальная практика, а вы это как оскорбление воспринимаете.
Цитата Сообщение от CyberSolver Посмотреть сообщение
С ними не "изящнее", с ними правильнее.
Да нет, моя программа и без них правильно работает.
Цитата Сообщение от CyberSolver Посмотреть сообщение
Прежде чем высокомерно
Т.е. каждый, кто найдет у вас ошибку - проявляет тем самым высокомерие?
Вы что-то совсем в истерику впали, разве можно так неадекватно реагировать на критику.
CyberSolver
 Аватар для CyberSolver
101 / 74 / 17
Регистрация: 23.07.2014
Сообщений: 686
Записей в блоге: 1
06.08.2014, 09:17     Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла) #9
Цитата Сообщение от Mr.X Посмотреть сообщение
У вас в программе математическая ошибка, из-за которой она работает неправильно.
Да вижу, вижу, но пусть ТС разбирается.
Цитата Сообщение от Mr.X Посмотреть сообщение
Вы что-то совсем в истерику впали, разве можно так неадекватно реагировать на критику.
Где вы истерику увидели? Давайте уже закроем тему, всё все поняли.

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

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

Добавлено через 2 минуты
скажите, пожалуйста, прямо, где у меня ошибка в алгоритме? а то вы кажется про мой код малехо забыли... CyberSolver, я так и не поняла, значит вы не исправили ошибку в вычислениях?
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
06.08.2014, 13:59     Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла)
Еще ссылки по теме:

C++ Наследование. Создайте класс Passport (паспорт), который будет содержать паспортную информацию о гражданине Украниы
C++ 8. Описать структуры для декартовых (x, y) и полярных (r, pi) координат
C++ Создайте класс time, содержащий три поля, предназначенные для хранения часов, минут и секунд

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

Или воспользуйтесь поиском по форуму:
Mr.X
Эксперт С++
 Аватар для Mr.X
2801 / 1577 / 247
Регистрация: 03.05.2010
Сообщений: 3,662
06.08.2014, 13:59     Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла) #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 );
    }
Yandex
Объявления
06.08.2014, 13:59     Создайте класс Polar, который предназначен для хранения полярных координат (радиуса и угла)
Ответ Создать тему
Опции темы

Текущее время: 06:49. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru