Từ 1 tới 6 trên tổng số 6 kết quả

Đề tài: [Thiết kế OOP] (1)

  1. #1
    Ngày gia nhập
    11 2008
    Bài viết
    186

    Red face [Thiết kế OOP] (1)

    Bài tập thiết kế class đầu tay của Kim.
    Thiết kế một lớp tọa độ điểm Point

    Và đây là những gì Kim thiết kế, bạn nào check thấy lỗi thì cho Kim biết nha

    Gồm 2 file:

    1. game_point.h
    C++ Code:
    1. /////////////////////////////////////////////////////
    2. // @author: bvKim
    3. // @file: game_point.h
    4. // @date: 16-Nov-2008
    5. // @purpose: class Point determine co-ordinate
    6. // @note: declaration of class 'Point'
    7. /////////////////////////////////////////////////////
    8.  
    9. /****************/
    10. /* Preprocessor */
    11. /****************/
    12. #ifndef __GAME_POINT_H__
    13. #define __GAME_POINT_H__
    14.  
    15. #include <iostream>
    16.  
    17. /***************
    18.  * @class Point
    19.  ***************/
    20.  
    21. class Point {
    22.     private:
    23.         int _x;
    24.         int _y;
    25.  
    26.     public:
    27.         /* constructor & destructor */
    28.         Point(); // equavilent : Point() : _x(0), _y(0) { };
    29.         Point(const int, const int);
    30.         Point(const Point&);
    31.         ~Point();
    32.  
    33.         /* operators */
    34.             // binary
    35.         Point  operator+  (const Point&) const;
    36.         Point  operator-  (const Point&) const;
    37.         Point  operator*  (const Point&) const;
    38.             // binary assignment
    39.         Point& operator+= (const Point&);
    40.         Point& operator-= (const Point&);
    41.         Point& operator*= (const Point&);
    42.             // unary
    43.         Point& operator++ ();                   // prefix
    44.         Point  operator++ (int);                // postfix
    45.         Point& operator-- ();                   // prefix
    46.         Point  operator-- (int);                // postfix
    47.             // logical
    48.         bool   operator== (const Point&) const;
    49.         bool   operator!= (const Point&) const;
    50.  
    51.         /* properties */
    52.         void     set_x      (int const&)      ;
    53.         void     set_y      (int const&)      ;
    54.         int      get_x      ()           const;
    55.         int      get_y      ()           const;
    56.  
    57.         /* methods */
    58.         Point    clone      ()           const;
    59.         Point*   clone_ptr  ()           const;
    60. };
    61.  
    62. #endif // __GAME_POINT_H__

    2. game_point.cpp

    C++ Code:
    1. /////////////////////////////////////////////////////
    2. // @author: bvKim
    3. // @file: game_point.cpp
    4. // @date: 16-Nov-2008
    5. // @purpose: class Point determine co-ordinate
    6. // @note: definition of class 'Point'
    7. /////////////////////////////////////////////////////
    8.  
    9. /****************/
    10. /* Preprocessor */
    11. /****************/
    12. #include "game_point.h"
    13.  
    14. /****************************/
    15. /* constructor & destructor */
    16. /****************************/
    17. Point::Point()
    18. {
    19.     this->_x = this->_y = 0;
    20. }
    21.  
    22. Point::Point(int const __x, int const __y)
    23. {
    24.     this->_x = __x;
    25.     this->_y = __y;
    26. }
    27.  
    28. Point::Point(const Point& __p)
    29. {
    30.     this->_x = __p.get_x();
    31.     this->_y = __p.get_y();
    32. }
    33.  
    34. Point::~Point()
    35. {
    36.  
    37. }
    38.  
    39. /************/
    40. /* operator */
    41. /************/
    42.  
    43. /*
    44.  * @operator +
    45.  * @assoc right-to-left
    46.  * @purpose
    47.  */
    48. Point Point::operator+ (const Point& __p) const
    49. {
    50.     return Point(this->_x + __p.get_x(), this->_y + __p.get_y());
    51. }
    52.  
    53. /*
    54.  * @operator -
    55.  * @assoc right-to-left
    56.  * @purpose
    57.  */
    58. Point Point::operator- (const Point& __p) const
    59. {
    60.     return Point(this->_x - __p.get_x(), this->_y - __p.get_y());
    61. }
    62.  
    63. /*
    64.  * @operator *
    65.  * @assoc right-to-left
    66.  * @purpose
    67.  */
    68. Point Point::operator* (const Point& __p) const
    69. {
    70.     return Point(this->_x * __p.get_x(), this->_y * __p.get_y());
    71. }
    72.  
    73. /*
    74.  * @operator +=
    75.  * @assoc right-to-left
    76.  * @purpose
    77.  */
    78. Point& Point::operator+= (const Point& __p)
    79. {
    80.     this->_x += __p.get_x();
    81.     this->_y += __p.get_y();
    82.  
    83.     return *this;
    84. }
    85.  
    86. /*
    87.  * @operator -=
    88.  * @assoc right-to-left
    89.  * @purpose
    90.  */
    91. Point& Point::operator-= (const Point& __p)
    92. {
    93.     this->_x -= __p.get_x();
    94.     this->_y -= __p.get_y();
    95.  
    96.     return *this;
    97. }
    98.  
    99. /*
    100.  * @operator *=
    101.  * @assoc right-to-left
    102.  * @purpose
    103.  */
    104. Point& Point::operator*= (const Point& __p)
    105. {
    106.     this->_x *= __p.get_x();
    107.     this->_y *= __p.get_y();
    108.  
    109.     return *this;
    110. }
    111.  
    112. /*
    113.  * @operator ++
    114.  * @precedence prefix
    115.  * @purpose
    116.  */
    117. Point& Point::operator++ ()
    118. {
    119.     this->_x++;
    120.     this->_y++;
    121.  
    122.     return *this;
    123. }
    124.  
    125. /*
    126.  * @operator ++
    127.  * @precedence postfix
    128.  * @purpose
    129.  */
    130. Point Point::operator++ (int)
    131. {
    132.     Point __t(*this);
    133.     ++(*this);
    134.     return __t;
    135. }
    136.  
    137. /*
    138.  * @operator --
    139.  * @precedence prefix
    140.  * @purpose
    141.  */
    142. Point& Point::operator-- ()
    143. {
    144.     this->_x--;
    145.     this->_y--;
    146.  
    147.     return *this;
    148. }
    149.  
    150. /*
    151.  * @operator --
    152.  * @precedence postfix
    153.  * @purpose
    154.  */
    155. Point Point::operator-- (int)
    156. {
    157.     Point __t(*this);
    158.     --(*this);
    159.     return __t;
    160. }
    161.  
    162. /*
    163.  * @operator ==
    164.  * @assoc right-to-left
    165.  * @purpose
    166.  */
    167. bool Point::operator== (const Point& __p) const
    168. {
    169.     return ( (this->_x == __p.get_x())
    170.         &&   (this->_y == __p.get_y())
    171.            );
    172. }
    173.  
    174. /*
    175.  * @operator !=
    176.  * @assoc right-to-left
    177.  * @purpose
    178.  */
    179. bool Point::operator!= (const Point& __p) const
    180. {
    181.     return !( (this->_x == __p.get_x())
    182.         &&    (this->_y == __p.get_y())
    183.            );
    184. }
    185.  
    186. /**************/
    187. /* properties */
    188. /**************/
    189. void Point::set_x (int const& __x)
    190. {
    191.     this->_x = __x;
    192. }
    193. void Point::set_y (int const& __y)
    194. {
    195.     this->_y = __y;
    196. }
    197.  
    198. int Point::get_x () const
    199. {
    200.     return this->_x;
    201. }
    202. int Point::get_y () const
    203. {
    204.     return this->_y;
    205. }
    206.  
    207. /***********/
    208. /* methods */
    209. /***********/
    210. /*
    211.  * @method clone()
    212.  * @type Point
    213.  * @param -none
    214.  * @purpose create a copy instance of this instanct
    215.  */
    216. Point Point::clone () const
    217. {
    218.     return Point(this->_x, this->_y);
    219. }
    220.  
    221. /*
    222.  * @method clone_ptr()
    223.  * @type Point
    224.  * @param -none
    225.  * @purpose create pointer to an copy of this instance
    226.  */
    227. Point* Point::clone_ptr() const
    228. {
    229.     return new Point(this->_x, this->_y);
    230. }
    Đã được chỉnh sửa lần cuối bởi bvKim : 16-11-2008 lúc 09:55 PM.

  2. #2
    Ngày gia nhập
    11 2008
    Bài viết
    186

    Kim đã update lại thêm đúng như NamVD nói!

  3. #3
    Ngày gia nhập
    07 2008
    Nơi ở
    /media/Anime
    Bài viết
    2,288

    Mới học OOP mà thiết kế vậy là hay lắm rồi đó.
    Càng yêu mèo thì mèo càng mập. Mèo càng mập ta lại càng yêu.

  4. #4
    Ngày gia nhập
    03 2008
    Nơi ở
    Đà Nẵng city
    Bài viết
    40

    KIM viết = VC++ huh? Hay IDE nào khác ?

  5. #5
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    bvKim viết là standard C++, cái nào run cũng được hết !

  6. #6
    Ngày gia nhập
    03 2008
    Nơi ở
    Đà Nẵng city
    Bài viết
    40

    Mặc định [Thiết kế OOP] (1)

    Òy, KIM đang học ở đâu đó, mới học mà viết tốt vậy.
    Àh sao trong phần operator sao ko làm thêm toán tử gán ?

Các đề tài tương tự

  1. Vinacolors.com - Thiết kế kiến trúc, thiết kế nội thất chuyên nghiệp
    Gửi bởi vinacolors trong diễn đàn Giới thiệu website, sản phẩm của bạn
    Trả lời: 0
    Bài viết cuối: 29-09-2013, 11:33 AM
  2. Thiết kế kiến trúc, thiết kế biệt thự, thiết kế nhà dân, thiết kế nội thất, showroom, triển lãm
    Gửi bởi hoangthanh1981hn trong diễn đàn Giới thiệu website, sản phẩm của bạn
    Trả lời: 7
    Bài viết cuối: 16-04-2013, 10:29 AM
  3. www.elegantvn.com - thiết kế website, thiết kế tờ rơi, thiết kế brochure v..v.
    Gửi bởi elegantvn trong diễn đàn Giới thiệu website, sản phẩm của bạn
    Trả lời: 0
    Bài viết cuối: 09-07-2012, 11:32 PM
  4. Thiết kế website , seo top, thiết kế web giá rẻ , thiết kế web đẹp !
    Gửi bởi depzai trong diễn đàn Giới thiệu website, sản phẩm của bạn
    Trả lời: 0
    Bài viết cuối: 19-10-2011, 08:34 AM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn