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

Задача на прямоугольники С++ - C++

Восстановить пароль Регистрация
 
Рейтинг: Рейтинг темы: голосов - 12, средняя оценка - 4.83
stepanov_ivan
0 / 0 / 0
Регистрация: 17.02.2011
Сообщений: 16
14.10.2011, 08:49     Задача на прямоугольники С++ #1
Нужно создать класс Прямоугольник со стороной на оси ОХ.
Нужно перегрузить бинарные операторы: пересечения прямоугольников(*), объединение двух прямоугольников(+), несимметрическая разность двух прямоугольников(-). Следует учесть все специальные случаи
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
#include <cstdlib>
#include <iostream>
 
using namespace std;
class Point{
      int X,Y;
      public:
             Point(int a=0, int b=0):X(a),Y(b){}
             ~Point(){}
             int getX()const{return X;}
             int  getY()const{return Y;}
             void print()const{cout<<"\n<"<<X<<","<<Y<<")";}
             void setx(int a) {X=a;}
             void sety(int a) {Y=a;}
             };
//объявляем класс прямоугольник
class Rect{
      Point  Left,Right;
      public:
             Rect(Point A, Point C):Left(A),Right(C){}
             Rect(int A_x, int A_y, int C_x, int C_y){
                  Left.setx(A_x); Left.sety(A_y);   
                  Right.setx(A_x);Right.sety(A_y);  
                  };
              void setLeft(Point A){Left=A;}
              void setRight(Point C){Right=C;}
      Point getLeft()const{return Left;}     
      Point getRight()const{return Right;}
      void print()const{Left.print();Right.print();}
      };
int main()
{    
system("PAUSE");
    return 0;
}
Класс я описал, а как описать функции не могу понять, подскажите хоть немного
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Overmind024
99 / 99 / 6
Регистрация: 10.09.2010
Сообщений: 267
14.10.2011, 09:52     Задача на прямоугольники С++ #2
Операции объединения и пересечения прямоугольников не замкнуты на множестве прямоугольников. То есть например если два прямоугольника не имеют обшей области то их объединение не есть прямоугольником. То же самое и с остальными операциями.

И для описания такого прямоугольника достаточно трех переметных, а не четырех как у вас.
Nameless One
Эксперт С++
 Аватар для Nameless One
5755 / 3404 / 255
Регистрация: 08.02.2010
Сообщений: 7,393
14.10.2011, 09:58     Задача на прямоугольники С++ #3
Цитата Сообщение от Overmind024 Посмотреть сообщение
Операции объединения и пересечения прямоугольников не замкнуты на множестве прямоугольников
это смотря как задать эти операции
Mr.X
Эксперт С++
 Аватар для Mr.X
2803 / 1579 / 247
Регистрация: 03.05.2010
Сообщений: 3,669
14.10.2011, 14:09     Задача на прямоугольники С++ #4
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
/////////////////////////////////////////////////////////////////////////////////////////
//Нужно создать класс Прямоугольник со стороной на оси ОХ.
//Нужно перегрузить бинарные операторы: пересечения прямоугольников(*), 
//объединение двух прямоугольников(+), несимметрическая разность двух прямоугольников(-). 
//Следует учесть все специальные случаи.
/////////////////////////////////////////////////////////////////////////////////////////
#include <complex>
#include <ctime>
#include <cstdlib>
#include <iostream>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::complex<int>  T_point;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_rect
{
    int  x_;
    int  Ax_;
    int  Ay_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_rect
        (
            int  x,
            int  Ax,
            int  Ay
        )
        :
        x_   (x),
        Ax_  (Ax),
        Ay_  (Ay)
    {}
    //-----------------------------------------------------------------------------------
    bool  empty() const
    {
        return      Ax_ <= 0
                ||  Ay_ <= 0;
    }
    //-----------------------------------------------------------------------------------
    void  print() const
    {
        if( empty() )
        {
            std::cout << "<empty rect>";
        }
        else
        {
            std::cout << "<"
                      << x_
                      << ","
                      << T_point(Ax_, Ay_)
                      << ">";
        }
    }
    //-----------------------------------------------------------------------------------
    T_rect  operator*(const T_rect&  r)
    {
        if( r.empty () )    return  r;
        if( empty   () )    return  *this;
        int  x_left_res   = std::max( x_left (),  r.x_left () );
        int  x_right_res  = std::min( x_right(),  r.x_right() );
        int  Ay_res       = std::min( Ay_      ,  r.Ay_       );
 
        return  T_rect
                    ( 
                        x_left_res,
                        x_right_res - x_left_res,
                        Ay_res
                    );
    }
    //-----------------------------------------------------------------------------------
    T_rect  operator+(const T_rect&  r)
    {
        if( empty   () )    return  r;
        if( r.empty () )    return  *this;        
        int  x_left_res   = std::min( x_left (),  r.x_left () );
        int  x_right_res  = std::max( x_right(),  r.x_right() );
        int  Ay_res       = std::max( Ay_      ,  r.Ay_       );
 
        return  T_rect
                    ( 
                        x_left_res,
                        x_right_res - x_left_res,
                        Ay_res
                    );
    }
    //-----------------------------------------------------------------------------------
    T_rect  operator-(const T_rect&  r)
    {
        if( (*this * r).empty() )
        {
            return  *this;
        }
        
        int     x_left_res    = x_left(); 
        int     x_right_res   = x_right();
        T_rect  intersection  = *this * r;        
 
        if( x_left_res == intersection.x_left() )
        {
            x_left_res = intersection.x_right();
        }
        
        if( x_right_res == intersection.x_right() )
        {
            x_right_res = intersection.x_left();
        }       
 
        return  T_rect
                    ( 
                        x_left_res,
                        x_right_res - x_left_res,
                        Ay_
                    );
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    int  x_left() const
    {
        return  x_;
    }
    //-----------------------------------------------------------------------------------
    int  x_right() const
    {
        return  x_ + Ax_;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int  get_plus_minus_from_1_to(int  a)
{
    return  ( rand() % a + 1 ) * ( rand() % 10 ? 1 : -1 );
}
/////////////////////////////////////////////////////////////////////////////////////////
T_rect  get_rand_rect(int  a)
{
    return  T_rect
                ( 
                    get_plus_minus_from_1_to(a), 
                    get_plus_minus_from_1_to(a), 
                    get_plus_minus_from_1_to(a) 
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    srand(unsigned(time(0)));
    T_rect  A = get_rand_rect(5);
    std::cout << "A: ";
    A.print();
    std::cout << std::endl;
 
    T_rect  B = get_rand_rect(5);
    std::cout << "B: ";
    B.print();
    std::cout << std::endl;
 
    T_rect  C = A * B;
    std::cout << "A * B: ";
    C.print();
    std::cout << std::endl;
 
    T_rect  CC = A + B;
    std::cout << "A + B: ";
    CC.print();
    std::cout << std::endl;
 
    T_rect  CCC = A - B;
    std::cout << "A - B: ";
    CCC.print();
    std::cout << std::endl;
}
stepanov_ivan
0 / 0 / 0
Регистрация: 17.02.2011
Сообщений: 16
18.10.2011, 09:47  [ТС]     Задача на прямоугольники С++ #5
можно написать комментарии к функциям когда мы перегружаем операторы, а то не понятно многое
Yandex
Объявления
18.10.2011, 09:47     Задача на прямоугольники С++
Ответ Создать тему
Опции темы

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