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

Как вы учили деревья - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Вычислить сумму конечного отрезка ряда http://www.cyberforum.ru/cpp-beginners/thread708077.html
Помогите, плиз, как написать программу с помощью функций??? (в С++) Дано натуральное число N. Вычислить сумму конечного отрезка ряда:
C++ Как очистить массив выделеной памяти #include <iostream> #include <string.h> #include <cstdlib> using namespace std; int main() { int koltest; int kolday; char obmen; http://www.cyberforum.ru/cpp-beginners/thread708075.html
Построение бинарного дерева C++
Написать программу построения бинарного дерева с помощью связных структур и поиска в дереве при симметричном порядке обхода его. Если возможно с комментариями. Буду очень благодарен.
C++ Поиск по случайному деререву
Написать программу поиска по случайному дереву при обратном порядке обхода его. Дерево представлено с помощью массива. Если можно, то с комментариями. Заранее спасибо.
C++ Конечные автоматы с реализацией http://www.cyberforum.ru/cpp-beginners/thread708062.html
Есть такая работа,делал не я. http://f1.s.qip.ru/G1CCNne7.png http://f2.s.qip.ru/G1CCNne8.png вот реализация #include <iostream> using namespace std;
C++ Описать структуру с именем Student Вот задание . Описать структуру с именем Student, содержащую следующие поля: name – имя, group – группа, marks – успеваемость (массив из 4 элементов) 1)Написать программу, выполняющую ввод с клавиатуры данных в массив students, состоящий из 25 структур типа Student. 2)Записи должны быть упорядочены по возрастанию поля group. Вывести на дисплей имена и группы всех студентов, имеющих хотя бы... подробнее

Показать сообщение отдельно
taras atavin
Ушёл с форума.
 Аватар для taras atavin
3569 / 1752 / 91
Регистрация: 24.11.2009
Сообщений: 27,619
29.11.2012, 09:15     Как вы учили деревья
TArray.hpp:
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
#ifndef TARRAY_HPP_INCLUDED
#define TARRAY_HPP_INCLUDED
//=================================================================================================
template <class TItem> class TArray
{
//-------------------------------------------------------------------------------------------------
 protected:
//-------------------------------------------------------------------------------------------------
  TItem             *Data;
  size_t             Count;
//-------------------------------------------------------------------------------------------------
 public   :
//-------------------------------------------------------------------------------------------------
                     TArray          (                          );
                     TArray          (TArray           &Original);
//-------------------------------------------------------------------------------------------------
                    ~TArray          (                          );
//-------------------------------------------------------------------------------------------------
  TArray             operator =      (TArray           &Original);
//-------------------------------------------------------------------------------------------------
  TItem             &operator []     (size_t            Index   );
//-------------------------------------------------------------------------------------------------
                     operator bool   (                          );
                     operator size_t (                          );
//-------------------------------------------------------------------------------------------------
};
//=================================================================================================
template
<class TItem>
TArray <TItem> ::    TArray          (                          )
{
 Data =NULL;
 Count=0;
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem> ::    TArray          (TArray           &Original)
{
 TItem *Source;
 TItem *Target;
 if (Original.Count>0)
 {
  Data=new TItem [Original.Count];
  if (Data)
  {
   for (Source=Original.Data+Original.Count-1, Target=Data+Original.Count-1; Target>=Data; --Source, --Target)
   {
    *Target=*Source;
   }
   Count=Original.Count;
  }
  else
  {
   Count=0;
  }
 }
 else
 {
  Data =NULL;
  Count=0;
 }
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem> ::   ~TArray          (                          )
{
 if (Data)
 {
  delete [] Data;
 }
 Data =NULL;
 Count=0;
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem>
TArray <TItem> ::    operator =      (TArray           &Original)
{
 TItem *Source;
 TItem *Target;
 if (Original.Count>0)
 {
  Data=new TItem [Original.Count];
  if (Data)
  {
   for (Source=Original.Data+Original.Count-1, Target=Data+Original.Count-1; Target>=Data; --Source, --Target)
   {
    *Target=*Source;
   }
   Count=Original.Count;
  }
  else
  {
   Count=0;
  }
 }
 else
 {
  Data =NULL;
  Count=0;
 }
 return *this;
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TItem               &
TArray <TItem> ::    operator []     (size_t            Index   )
{
 return Data[Index];
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem> ::    operator bool   (                          )
{
 return (Count>0);
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem> ::    operator size_t (                          )
{
 return Count;
}
//=================================================================================================
#endif // TARRAY_HPP_INCLUDED
, TVector.hpp:
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
#ifndef TVECTOR_HPP_INCLUDED
#define TVECTOR_HPP_INCLUDED
//=================================================================================================
#include <math.h>
//=================================================================================================
class TVector
{
//-------------------------------------------------------------------------------------------------
 public   :
//-------------------------------------------------------------------------------------------------
  double             x;
  double             y;
  double             z;
//-------------------------------------------------------------------------------------------------
                     TVector         (                          );
                     TVector         (TVector          &Original);
//-------------------------------------------------------------------------------------------------
                    ~TVector         (                          );
//-------------------------------------------------------------------------------------------------
  TVector            operator =      (TVector          &Original);
//-------------------------------------------------------------------------------------------------
  TVector            operator +      (TVector          &Right   );
  void               operator +=     (TVector          &Right   );
//-------------------------------------------------------------------------------------------------
  TVector            operator -      (TVector          &Right   );
  void               operator -=     (TVector          &Right   );
//-------------------------------------------------------------------------------------------------
  TVector            operator *      (double           &Right   );
  void               operator *=     (double           &Right   );
//-------------------------------------------------------------------------------------------------
  friend
  TVector            operator *      (double           &Left    ,
                                      TVector          &Right   );
//-------------------------------------------------------------------------------------------------
  TVector            operator /      (double           &Right   );
  void               operator /=     (double           &Right   );
//-------------------------------------------------------------------------------------------------
  friend
  TVector            VectorProduct   (TVector          &Left    ,
                                      TVector          &Right   );
//-------------------------------------------------------------------------------------------------
  void               VectorProduct   (TVector          &Right   );
//-------------------------------------------------------------------------------------------------
  friend
  double             ScalarProduct   (TVector          &Left    ,
                                      TVector          &Right   );
//-------------------------------------------------------------------------------------------------
  friend
  double             abs             (TVector          &Vector  );
//-------------------------------------------------------------------------------------------------
};
//=================================================================================================
TVector        ::    TVector         (                          )
{
 x=0.0;
 y=0.0;
 z=0.0;
}
//-------------------------------------------------------------------------------------------------
TVector        ::    TVector         (TVector          &Original)
{
 x=Original.x;
 y=Original.y;
 z=Original.z;
}
//-------------------------------------------------------------------------------------------------
TVector        ::   ~TVector         (                          )
{
}
//-------------------------------------------------------------------------------------------------
TVector
TVector        ::    operator =      (TVector          &Original)
{
 x=Original.x;
 y=Original.y;
 z=Original.z;
 return *this;
}
//-------------------------------------------------------------------------------------------------
TVector
TVector        ::    operator +      (TVector          &Right   )
{
 TVector Result;
 Result.x=x+Right.x;
 Result.y=y+Right.y;
 Result.z=z+Right.z;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TVector        ::    operator +=     (TVector          &Right   )
{
 x+=Right.x;
 y+=Right.y;
 z+=Right.z;
}
//-------------------------------------------------------------------------------------------------
TVector
TVector        ::    operator -      (TVector          &Right   )
{
 TVector Result;
 Result.x=x-Right.x;
 Result.y=y-Right.y;
 Result.z=z-Right.z;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TVector        ::    operator -=     (TVector          &Right   )
{
 x-=Right.x;
 y-=Right.y;
 z-=Right.z;
}
//-------------------------------------------------------------------------------------------------
TVector
TVector        ::    operator *      (double           &Right   )
{
 TVector Result;
 Result.x=x*Right;
 Result.y=y*Right;
 Result.z=z*Right;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TVector        ::    operator *=     (double           &Right   )
{
 x*=Right;
 y*=Right;
 z*=Right;
}
//-------------------------------------------------------------------------------------------------
TVector              operator *      (double           &Left    ,
                                      TVector          &Right   )
{
 TVector Result;
 Result.x=Left*Right.x;
 Result.y=Left*Right.y;
 Result.z=Left*Right.z;
 return Result;
}
//-------------------------------------------------------------------------------------------------
TVector
TVector        ::    operator /      (double           &Right   )
{
 TVector Result;
 Result.x=x/Right;
 Result.y=y/Right;
 Result.z=z/Right;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TVector        ::    operator /=     (double           &Right   )
{
 x/=Right;
 y/=Right;
 z/=Right;
}
//-------------------------------------------------------------------------------------------------
TVector              VectorProduct   (TVector          &Left    ,
                                      TVector          &Right   )
{
 TVector Result;
 Result.x=Left.y*Right.z-Left.z*Right.y;
 Result.y=Left.z*Right.x-Left.x*Right.z;
 Result.z=Left.x*Right.y-Left.y*Right.x;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TVector        ::    VectorProduct   (TVector          &Right   )
{
 TVector Result;
 Result.x=y*Right.z-z*Right.y;
 Result.y=z*Right.x-x*Right.z;
 Result.z=x*Right.y-y*Right.x;
 *this=Result;
}
//-------------------------------------------------------------------------------------------------
double               ScalarProduct   (TVector          &Left    ,
                                      TVector          &Right   )
{
 return (Left.x*Right.x+Left.y*Right.y+Left.z*Right.z);
}
//-------------------------------------------------------------------------------------------------
double               abs             (TVector          &Vector  )
{
 return sqrt(Vector.x*Vector.x+Vector.y*Vector.y+Vector.z*Vector.z);
}
//=================================================================================================
#endif // TVECTOR_HPP_INCLUDED
TMatixRow.hpp:
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
#ifndef TMATIXROW_HPP_INCLUDED
#define TMATIXROW_HPP_INCLUDED
//=================================================================================================
class TMatrixRow
{
//-------------------------------------------------------------------------------------------------
 protected:
//-------------------------------------------------------------------------------------------------
  double             Items[3];
//-------------------------------------------------------------------------------------------------
 public   :
//-------------------------------------------------------------------------------------------------
                     TMatrixRow      (                          );
                     TMatrixRow      (TMatrixRow       &Original);
//-------------------------------------------------------------------------------------------------
                    ~TMatrixRow      (                          );
//-------------------------------------------------------------------------------------------------
  TMatrixRow         operator =      (TMatrixRow       &Original);
//-------------------------------------------------------------------------------------------------
  double            &operator []     (size_t            Index   );
//-------------------------------------------------------------------------------------------------
};
//=================================================================================================
TMatrixRow     ::    TMatrixRow      (                          )
{
 Items[0]=0.0;
 Items[1]=0.0;
 Items[2]=0.0;
}
//-------------------------------------------------------------------------------------------------
TMatrixRow     ::    TMatrixRow      (TMatrixRow       &Original)
{
 Items[0]=Original.Items[0];
 Items[1]=Original.Items[1];
 Items[2]=Original.Items[2];
}
//-------------------------------------------------------------------------------------------------
TMatrixRow     ::   ~TMatrixRow      (                          )
{
}
//-------------------------------------------------------------------------------------------------
TMatrixRow
TMatrixRow     ::    operator =      (TMatrixRow       &Original)
{
 Items[0]=Original.Items[0];
 Items[1]=Original.Items[1];
 Items[2]=Original.Items[2];
 return *this;
}
//-------------------------------------------------------------------------------------------------
double              &
TMatrixRow     ::    operator []     (size_t            Index   )
{
 return Items[Index];
}
//=================================================================================================
#endif // TMATIXROW_HPP_INCLUDED
, TMatrix.hpp:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
#ifndef TMATRIX_HPP_INCLUDED
#define TMATRIX_HPP_INCLUDED
//=================================================================================================
#include "TMatixRow.hpp"
//=================================================================================================
class TMatrix
{
//-------------------------------------------------------------------------------------------------
 protected:
//-------------------------------------------------------------------------------------------------
  TMatrixRow         Rows[3];
//-------------------------------------------------------------------------------------------------
 public   :
//-------------------------------------------------------------------------------------------------
                     TMatrix         (                          );
                     TMatrix         (TMatrix          &Original);
//-------------------------------------------------------------------------------------------------
                    ~TMatrix         (                          );
//-------------------------------------------------------------------------------------------------
  TMatrix            operator =      (TMatrix          &Original);
//-------------------------------------------------------------------------------------------------
  TMatrixRow        &operator []     (size_t            Index   );
//-------------------------------------------------------------------------------------------------
  TMatrix            operator +      (TMatrix          &Right   );
  void               operator +=     (TMatrix          &Right   );
//-------------------------------------------------------------------------------------------------
  TMatrix            operator -      (TMatrix          &Right   );
  void               operator -=     (TMatrix          &Right   );
//-------------------------------------------------------------------------------------------------
  TMatrix            operator *      (TMatrix          &Right   );
  void               operator *=     (TMatrix          &Right   );
//-------------------------------------------------------------------------------------------------
  TMatrix            operator *      (double           &Right   );
  void               operator *=     (double           &Right   );
//-------------------------------------------------------------------------------------------------
  friend
  TMatrix            operator *      (double           &Left    ,
                                      TMatrix          &Right   );
//-------------------------------------------------------------------------------------------------
  TMatrix            operator /      (double           &Right   );
  void               operator /=     (double           &Right   );
//-------------------------------------------------------------------------------------------------
  friend
  double             determinant     (TMatrix          &Matrix);
//-------------------------------------------------------------------------------------------------
  friend
  TMatrix            invert          (TMatrix          &Matrix  );
  void               invert          (                          );
//-------------------------------------------------------------------------------------------------
  friend
  TMatrix            transpose       (TMatrix          &Matrix  );
  void               transpose       (                          );
//-------------------------------------------------------------------------------------------------
  friend
  TVector            operator *      (TVector          &Vector  ,
                                      TMatrix          &Matrix  );
//-------------------------------------------------------------------------------------------------
  friend
  void               operator *=     (TVector          &Vector  ,
                                      TMatrix          &Matrix  );
//-------------------------------------------------------------------------------------------------
};
//=================================================================================================
TMatrix        ::    TMatrix         (                          )
{
 Rows[0][0]=1.0;
 Rows[0][1]=0.0;
 Rows[0][2]=0.0;
 Rows[1][0]=0.0;
 Rows[1][1]=1.0;
 Rows[1][2]=0.0;
 Rows[2][0]=0.0;
 Rows[2][1]=0.0;
 Rows[2][2]=1.0;
}
//-------------------------------------------------------------------------------------------------
TMatrix        ::    TMatrix         (TMatrix          &Original)
{
 Rows[0]=Original.Rows[0];
 Rows[1]=Original.Rows[1];
 Rows[2]=Original.Rows[2];
}
//-------------------------------------------------------------------------------------------------
TMatrix        ::   ~TMatrix         (                          )
{
 
}
//-------------------------------------------------------------------------------------------------
TMatrix
TMatrix        ::    operator =      (TMatrix          &Original)
{
 Rows[0]=Original.Rows[0];
 Rows[1]=Original.Rows[1];
 Rows[2]=Original.Rows[2];
 return *this;
}
//-------------------------------------------------------------------------------------------------
TMatrixRow          &
TMatrix        ::    operator []     (size_t            Index   )
{
 return Rows[Index];
}
//-------------------------------------------------------------------------------------------------
TMatrix
TMatrix        ::    operator +      (TMatrix          &Right   )
{
 TMatrix Result;
 Result[0][0]=(*this)[0][0]+Right[0][0];
 Result[0][1]=(*this)[0][1]+Right[0][1];
 Result[0][2]=(*this)[0][2]+Right[0][2];
 Result[1][0]=(*this)[1][0]+Right[1][0];
 Result[1][1]=(*this)[1][1]+Right[1][1];
 Result[1][2]=(*this)[1][2]+Right[1][2];
 Result[2][0]=(*this)[2][0]+Right[2][0];
 Result[2][1]=(*this)[2][1]+Right[2][1];
 Result[2][2]=(*this)[2][2]+Right[2][2];
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    operator +=     (TMatrix          &Right   )
{
 (*this)[0][0]+=Right[0][0];
 (*this)[0][1]+=Right[0][1];
 (*this)[0][2]+=Right[0][2];
 (*this)[1][0]+=Right[1][0];
 (*this)[1][1]+=Right[1][1];
 (*this)[1][2]+=Right[1][2];
 (*this)[2][0]+=Right[2][0];
 (*this)[2][1]+=Right[2][1];
 (*this)[2][2]+=Right[2][2];
}
//-------------------------------------------------------------------------------------------------
TMatrix
TMatrix        ::    operator -      (TMatrix          &Right   )
{
 TMatrix Result;
 Result[0][0]=(*this)[0][0]-Right[0][0];
 Result[0][1]=(*this)[0][1]-Right[0][1];
 Result[0][2]=(*this)[0][2]-Right[0][2];
 Result[1][0]=(*this)[1][0]-Right[1][0];
 Result[1][1]=(*this)[1][1]-Right[1][1];
 Result[1][2]=(*this)[1][2]-Right[1][2];
 Result[2][0]=(*this)[2][0]-Right[2][0];
 Result[2][1]=(*this)[2][1]-Right[2][1];
 Result[2][2]=(*this)[2][2]-Right[2][2];
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    operator -=     (TMatrix          &Right   )
{
 (*this)[0][0]-=Right[0][0];
 (*this)[0][1]-=Right[0][1];
 (*this)[0][2]-=Right[0][2];
 (*this)[1][0]-=Right[1][0];
 (*this)[1][1]-=Right[1][1];
 (*this)[1][2]-=Right[1][2];
 (*this)[2][0]-=Right[2][0];
 (*this)[2][1]-=Right[2][1];
 (*this)[2][2]-=Right[2][2];
}
//-------------------------------------------------------------------------------------------------
TMatrix
TMatrix        ::    operator *      (TMatrix          &Right   )
{
 TMatrix Result;
 Result[0][0]=(*this)[0][0]*Right[0][0]+(*this)[0][1]*Right[1][0]+(*this)[0][2]*Right[2][0];
 Result[0][1]=(*this)[0][0]*Right[0][1]+(*this)[0][1]*Right[1][1]+(*this)[0][2]*Right[2][1];
 Result[0][2]=(*this)[0][0]*Right[0][2]+(*this)[0][1]*Right[1][2]+(*this)[0][2]*Right[2][2];
 Result[1][0]=(*this)[1][0]*Right[0][0]+(*this)[1][1]*Right[1][0]+(*this)[1][2]*Right[2][0];
 Result[1][1]=(*this)[1][0]*Right[0][1]+(*this)[1][1]*Right[1][1]+(*this)[1][2]*Right[2][1];
 Result[1][2]=(*this)[1][0]*Right[0][2]+(*this)[1][1]*Right[1][2]+(*this)[1][2]*Right[2][2];
 Result[2][0]=(*this)[2][0]*Right[0][0]+(*this)[2][1]*Right[1][0]+(*this)[2][2]*Right[2][0];
 Result[2][1]=(*this)[2][0]*Right[0][1]+(*this)[2][1]*Right[1][1]+(*this)[2][2]*Right[2][1];
 Result[2][2]=(*this)[2][0]*Right[0][2]+(*this)[2][1]*Right[1][2]+(*this)[2][2]*Right[2][2];
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    operator *=     (TMatrix          &Right   )
{
 TMatrix Result;
 Result[0][0]=(*this)[0][0]*Right[0][0]+(*this)[0][1]*Right[1][0]+(*this)[0][2]*Right[2][0];
 Result[0][1]=(*this)[0][0]*Right[0][1]+(*this)[0][1]*Right[1][1]+(*this)[0][2]*Right[2][1];
 Result[0][2]=(*this)[0][0]*Right[0][2]+(*this)[0][1]*Right[1][2]+(*this)[0][2]*Right[2][2];
 Result[1][0]=(*this)[1][0]*Right[0][0]+(*this)[1][1]*Right[1][0]+(*this)[1][2]*Right[2][0];
 Result[1][1]=(*this)[1][0]*Right[0][1]+(*this)[1][1]*Right[1][1]+(*this)[1][2]*Right[2][1];
 Result[1][2]=(*this)[1][0]*Right[0][2]+(*this)[1][1]*Right[1][2]+(*this)[1][2]*Right[2][2];
 Result[2][0]=(*this)[2][0]*Right[0][0]+(*this)[2][1]*Right[1][0]+(*this)[2][2]*Right[2][0];
 Result[2][1]=(*this)[2][0]*Right[0][1]+(*this)[2][1]*Right[1][1]+(*this)[2][2]*Right[2][1];
 Result[2][2]=(*this)[2][0]*Right[0][2]+(*this)[2][1]*Right[1][2]+(*this)[2][2]*Right[2][2];
 *this=Result;
}
//-------------------------------------------------------------------------------------------------
TMatrix
TMatrix        ::    operator *      (double           &Right   )
{
 TMatrix Result;
 Result[0][0]=(*this)[0][0]*Right;
 Result[0][1]=(*this)[0][2]*Right;
 Result[0][2]=(*this)[0][1]*Right;
 Result[1][0]=(*this)[1][0]*Right;
 Result[1][1]=(*this)[1][2]*Right;
 Result[1][2]=(*this)[1][1]*Right;
 Result[2][0]=(*this)[2][0]*Right;
 Result[2][1]=(*this)[2][2]*Right;
 Result[2][2]=(*this)[2][1]*Right;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    operator *=     (double           &Right   )
{
 (*this)[0][0]*=Right;
 (*this)[0][1]*=Right;
 (*this)[0][2]*=Right;
 (*this)[1][0]*=Right;
 (*this)[1][1]*=Right;
 (*this)[1][2]*=Right;
 (*this)[2][0]*=Right;
 (*this)[2][1]*=Right;
 (*this)[2][2]*=Right;
}
//-------------------------------------------------------------------------------------------------
TMatrix              operator *      (double           &Left    ,
                                      TMatrix          &Right   )
{
 TMatrix Result;
 Result[0][0]=Left*Right[0][0];
 Result[0][1]=Left*Right[0][1];
 Result[0][2]=Left*Right[0][2];
 Result[1][0]=Left*Right[1][0];
 Result[1][1]=Left*Right[1][1];
 Result[1][2]=Left*Right[1][2];
 Result[2][0]=Left*Right[2][0];
 Result[2][1]=Left*Right[2][1];
 Result[2][2]=Left*Right[2][2];
 return Result;
}
//-------------------------------------------------------------------------------------------------
TMatrix
TMatrix        ::    operator /      (double           &Right   )
{
 TMatrix Result;
 Result[0][0]=(*this)[0][0]/Right;
 Result[0][1]=(*this)[0][2]/Right;
 Result[0][2]=(*this)[0][1]/Right;
 Result[1][0]=(*this)[1][0]/Right;
 Result[1][1]=(*this)[1][2]/Right;
 Result[1][2]=(*this)[1][1]/Right;
 Result[2][0]=(*this)[2][0]/Right;
 Result[2][1]=(*this)[2][2]/Right;
 Result[2][2]=(*this)[2][1]/Right;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    operator /=     (double           &Right   )
{
 (*this)[0][0]/=Right;
 (*this)[0][1]/=Right;
 (*this)[0][2]/=Right;
 (*this)[1][0]/=Right;
 (*this)[1][1]/=Right;
 (*this)[1][2]/=Right;
 (*this)[2][0]/=Right;
 (*this)[2][1]/=Right;
 (*this)[2][2]/=Right;
}
//-------------------------------------------------------------------------------------------------
double               determinant     (TMatrix          &Matrix)
{
 return Matrix[0][0]*(Matrix[1][1]*Matrix[2][2]-Matrix[1][2]*Matrix[2][1])-Matrix[0][1]*(Matrix[1][0]*Matrix[2][2]-Matrix[1][2]*Matrix[2][0])+Matrix[2][1]*(Matrix[1][0]*Matrix[2][1]-Matrix[1][1]*Matrix[2][0]);
}
//-------------------------------------------------------------------------------------------------
TMatrix              invert          (TMatrix          &Matrix  )
{
 TMatrix Result;
 double det;
 det=determinant(Matrix);
 Result[0][0]=(Matrix[1][1]*Matrix[2][2]-Matrix[1][2]*Matrix[2][1])/det;
 Result[0][1]=(Matrix[1][2]*Matrix[2][0]-Matrix[1][0]*Matrix[2][2])/det;
 Result[0][2]=(Matrix[1][0]*Matrix[2][1]-Matrix[1][1]*Matrix[2][0])/det;
 Result[1][0]=(Matrix[0][2]*Matrix[2][1]-Matrix[0][1]*Matrix[2][2])/det;
 Result[1][1]=(Matrix[0][0]*Matrix[2][2]-Matrix[0][2]*Matrix[2][0])/det;
 Result[1][2]=(Matrix[0][1]*Matrix[2][0]-Matrix[0][0]*Matrix[2][1])/det;
 Result[2][0]=(Matrix[0][1]*Matrix[1][2]-Matrix[0][2]*Matrix[1][1])/det;
 Result[2][1]=(Matrix[0][2]*Matrix[1][0]-Matrix[0][0]*Matrix[1][2])/det;
 Result[2][2]=(Matrix[0][0]*Matrix[1][1]-Matrix[0][1]*Matrix[1][0])/det;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    invert          (                          )
{
 TMatrix Result;
 double det;
 det=determinant(*this);
 Result[0][0]=((*this)[1][1]*(*this)[2][2]-(*this)[1][2]*(*this)[2][1])/det;
 Result[0][1]=((*this)[1][2]*(*this)[2][0]-(*this)[1][0]*(*this)[2][2])/det;
 Result[0][2]=((*this)[1][0]*(*this)[2][1]-(*this)[1][1]*(*this)[2][0])/det;
 Result[1][0]=((*this)[0][2]*(*this)[2][1]-(*this)[0][1]*(*this)[2][2])/det;
 Result[1][1]=((*this)[0][0]*(*this)[2][2]-(*this)[0][2]*(*this)[2][0])/det;
 Result[1][2]=((*this)[0][1]*(*this)[2][0]-(*this)[0][0]*(*this)[2][1])/det;
 Result[2][0]=((*this)[0][1]*(*this)[1][2]-(*this)[0][2]*(*this)[1][1])/det;
 Result[2][1]=((*this)[0][2]*(*this)[1][0]-(*this)[0][0]*(*this)[1][2])/det;
 Result[2][2]=((*this)[0][0]*(*this)[1][1]-(*this)[0][1]*(*this)[1][0])/det;
 *this=Result;
}
//-------------------------------------------------------------------------------------------------
TMatrix              transpose       (TMatrix          &Matrix  )
{
 TMatrix Result;
 Result[0][0]=Matrix[0][0];
 Result[0][1]=Matrix[1][0];
 Result[0][2]=Matrix[2][0];
 Result[1][0]=Matrix[0][1];
 Result[1][1]=Matrix[1][1];
 Result[1][2]=Matrix[2][1];
 Result[2][0]=Matrix[0][2];
 Result[2][1]=Matrix[1][2];
 Result[2][2]=Matrix[2][2];
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    transpose       (                          )
{
TMatrix Result;
 Result[0][0]=(*this)[0][0];
 Result[0][1]=(*this)[1][0];
 Result[0][2]=(*this)[2][0];
 Result[1][0]=(*this)[0][1];
 Result[1][1]=(*this)[1][1];
 Result[1][2]=(*this)[2][1];
 Result[2][0]=(*this)[0][2];
 Result[2][1]=(*this)[1][2];
 Result[2][2]=(*this)[2][2];
 *this=Result;
}
//-------------------------------------------------------------------------------------------------
TVector              operator *      (TVector          &Vector  ,
                                      TMatrix          &Matrix  )
{
 TVector Result;
 Result.x=Vector.x*Matrix[0][0]+Vector.y*Matrix[1][0]+Vector.z*Matrix[2][0];
 Result.y=Vector.x*Matrix[0][1]+Vector.y*Matrix[1][1]+Vector.z*Matrix[2][1];
 Result.z=Vector.x*Matrix[0][2]+Vector.y*Matrix[1][2]+Vector.z*Matrix[2][2];
 return Result;
}
//-------------------------------------------------------------------------------------------------
void                 operator *=     (TVector          &Vector  ,
                                      TMatrix          &Matrix  )
{
 TVector Result;
 Result.x=Vector.x*Matrix[0][0]+Vector.y*Matrix[1][0]+Vector.z*Matrix[2][0];
 Result.y=Vector.x*Matrix[0][1]+Vector.y*Matrix[1][1]+Vector.z*Matrix[2][1];
 Result.z=Vector.x*Matrix[0][2]+Vector.y*Matrix[1][2]+Vector.z*Matrix[2][2];
 Vector=Result;
}
//=================================================================================================
#endif // TMATRIX_HPP_INCLUDED
, TOrientation:
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
#ifndef TORIENTATION_HPP_INCLUDED
#define TORIENTATION_HPP_INCLUDED
//=================================================================================================
#include "TMatrix.hpp"
//=================================================================================================
class TOrientation
{
//-------------------------------------------------------------------------------------------------
 public   :
//-------------------------------------------------------------------------------------------------
  TMatrix            TurnMatrix;
//-------------------------------------------------------------------------------------------------
                     TOrientation    (                          );
                     TOrientation    (TOrientation     &Original);
//-------------------------------------------------------------------------------------------------
                    ~TOrientation    (                          );
//-------------------------------------------------------------------------------------------------
  TOrientation       operator =      (TOrientation     &Original);
//-------------------------------------------------------------------------------------------------
};
//=================================================================================================
TOrientation   ::    TOrientation    (                          )
{
 
}
//-------------------------------------------------------------------------------------------------
TOrientation   ::    TOrientation    (TOrientation     &Original)
{
 TurnMatrix=Original.TurnMatrix;
}
//-------------------------------------------------------------------------------------------------
TOrientation   ::   ~TOrientation    (                          )
{
 
}
//-------------------------------------------------------------------------------------------------
TOrientation
TOrientation   ::    operator =      (TOrientation     &Original)
{
 TurnMatrix=Original.TurnMatrix;
 return *this;
}
//=================================================================================================
#endif // TORIENTATION_HPP_INCLUDED
TBone.hpp:
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
#ifndef TBONE_HPP_INCLUDED
#define TBONE_HPP_INCLUDED
//=================================================================================================
#include <string>
//=================================================================================================
#include "TVector.hpp"
#include "TOrientation.hpp"
#include "TArray.hpp"
//=================================================================================================
class TBone
{
//-------------------------------------------------------------------------------------------------
 public   :
//-------------------------------------------------------------------------------------------------
  TBone             *Parent;
  TOrientation       Orientation;
  TVector            Position;
  std::string        Name;
//-------------------------------------------------------------------------------------------------
  TArray <TBone>     Childs;
//-------------------------------------------------------------------------------------------------
                     TBone           (                          );
                     TBone           (TBone            &Original);
//-------------------------------------------------------------------------------------------------
                    ~TBone           (                          );
//-------------------------------------------------------------------------------------------------
  TBone              operator =      (TBone            &Original);
//-------------------------------------------------------------------------------------------------
};
//=================================================================================================
TBone          ::    TBone           (                          )
{
 Parent=NULL;
 Name  ="";
}
//-------------------------------------------------------------------------------------------------
TBone          ::    TBone           (TBone            &Original)
{
 Parent     =Original.Parent;
 Orientation=Original.Orientation;
 Position   =Original.Position;
 Name       =Original.Name;
 Childs     =Original.Childs;
}
//-------------------------------------------------------------------------------------------------
TBone          ::   ~TBone           (                          )
{
}
//-------------------------------------------------------------------------------------------------
TBone
TBone          ::    operator =      (TBone            &Original)
{
 Parent     =Original.Parent;
 Orientation=Original.Orientation;
 Position   =Original.Position;
 Name       =Original.Name;
 Childs     =Original.Childs;
 return *this;
}
//=================================================================================================
#endif // TBONE_HPP_INCLUDED
.Вот такая вот коряга дерево моей мечты.
 
Текущее время: 18:31. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru