Trang 1 trên tổng số 2 12 Cuối cùngCuối cùng
Từ 1 tới 10 trên tổng số 17 kết quả

Đề tài: Bài tập lớn...!!!Về vẽ đồ thị

  1. #1
    No Avatar
    garung Khách

    Question Bài tập lớn...!!!Về vẽ đồ thị

    Mình có một bài tập lớn như thế này , mong các bạn nêu ý tưởng, cách làm giúp m với ...Bạn nào có code thì cho mình nhé. Thanks !
    Đề bài : Xây dựng lớp hàm số và một số lớp khác, áp dụng vẽ đồ thị hàm số y=f(x).

  2. #2
    Ngày gia nhập
    09 2007
    Bài viết
    724

    ý tường để vẽ một đồ thị hàm số y=f(x). thì bạn phải biết cái đồ thị đó người dùng yêu cầu vẽ trong khoảng bao nhiêu(miền đối số của đồ thị hàm số tức là [xMin, xMax])
    rồi chia nó ra thành N đoạn thẳng và nối chúng lại với nhau.
    ok đây là code:

    Code:
    void drawCurve2D(CDC *pDC, CCurve *f, int xmin, int xmax, int N)
    {
          float dx, x,y;
          dx = (xmax - xmin)/N * 1.0;
          x = xmin;
          y = f->f(x);
          pDC->MoveTo((int)x, (int)y);
          for(int i = 0; i<N; i++)
          {
               x+= dx;
               y = f->f(x);
               pDC->LineTo((int)x,(int)y);
           }
    }
    còn Class CCurve thì bạn phải thiết kế sao cho phù hợp với từng trường hợp.

    một gợi ý là bạn dùng Đa Xạ trong OOP.

    vì đây là bài tập của bạn nên mình chỉ gợi ý cho bạn sơ sơ vậy thôi.
    Đã được chỉnh sửa lần cuối bởi zkday2686 : 20-11-2007 lúc 11:57 PM.

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

    Nếu được thì zkday2686 có thể giảng sơ cho mình cấu trúc của bài này được không ? Cho mình hỏi luôn : Đa Xạ trong OOP là gì thế nhỉ ? Ý mình không phải là xin code nhưng zkday2686 có thể gợi ý thêm cho mình tạo những lớp nào với những phương thức nào cần để mình có thể hình dung ra cấu trúc nó được không ? Cám ơn trước zkday2686 nhé !

  4. #4
    Ngày gia nhập
    09 2007
    Bài viết
    724

    Trích dẫn Nguyên bản được gửi bởi rox_rook Xem bài viết
    Nếu được thì zkday2686 có thể giảng sơ cho mình cấu trúc của bài này được không ? Cho mình hỏi luôn : Đa Xạ trong OOP là gì thế nhỉ ? Ý mình không phải là xin code nhưng zkday2686 có thể gợi ý thêm cho mình tạo những lớp nào với những phương thức nào cần để mình có thể hình dung ra cấu trúc nó được không ? Cám ơn trước zkday2686 nhé !
    1: trong C++ có một từ khóa là virtual thì đa xạ hiểu nôm na là cách dùng nó trong các lớp có mà lớp này được kế thừa từ lớp khác.
    2: Thực tế vấn đề ở đây không phải là làm sao để vẽ được một đường cong với một hàm số nào đó được cho trước mà làm sao để chương trình biết khi nào cần dùng hàm tính f nào để tính.

    trong đây thì mình viết 3 lớp cho lớp:CCurve, CCurve2, CCurve3;

    để tiện cho việc nói mình xin code luôn trong class<cách này hơi bưởi>
    Code:
    class CCurve{
    public:
         CCurver();
         virtual ~CCurve();
         virtual double f(int x){
            return 0.0;
          }
    }
    
    class CCurve1 : public CCurve { 
    private:
       double a,b;
     public:
        CCurve1();
        CCurve1(double a, double b){
                this->a = a;
                this->b = b;
        }
        virtual ~CCurve1();
        virtual double f(int x)
        {
              // cài đặt tính f đối với hàm số bậc 2;
              double y;
              y = a*x + b;
              return y;
        }
    }
    
    // cài đặt lớp cho hàm số y = a*x2 + b*x + c
    
    class CCurve2 : public CCurve { 
    private:
       double a,b,c;
     public:
        CCurve2();
        CCurve2(double a, double b, double c){
                this->a = a;
                this->b = b;
                this->c = c;
        }
        virtual ~CCurve2();
        virtual double f(int x)
        {
              // cài đặt tính f đối với hàm số bậc 2;
              double y;
              y = x*(a*x + b) + c;
              return y;
        }
    }
    
    // cài đặt cho hàm số y=a*x3 + b*x2 + c*x + d;
    class CCurve3 : public CCurve { 
    private:
       double a,b,c,d;
     public:
        CCurve3();
        CCurve3(double a, double b,double c, double d){
                this->a = a;
                this->b = b;
                this->c = c;
                this->d = d;
        }
        virtual ~CCurve3();
        virtual double f(int x)
        {
              // cài đặt tính f đối với hàm số bậc 2;
              double y;
              y = x*(x*(a*x + b) +c) + d;
              return y;
        }
        void Seta(int a){this->a = a;};
        void Setb(int b){this->b = b;};
    }
    ở đây để tiện mình chọn trong hàm OnPaint()

    Code:
         // giả sử khi cần vẽ hàm bậc 2: y = 2*x2 + 3 thì vẽ như sau
          CCurve *bac2;
          bac2 = new CCurve2(2,0,3);
          drawCurve2D(pDC, bac2, 0, 100, 50);
          // vẽ hàm bậc 1: y = 2*x + 3
          CCurve *bac1;
          bac1 = new CCurve1(2,3);
          drawCurve2D(pDC, bac1, 100, 200, 50);

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

    Ok ! mình đã hiểu sơ sơ vấn đề rồi !
    Bây h để mình nêu sự hình dung sơ khởi của mình xem sao nhé :
    Đầu tiên ta có 1 lớp hàm số. Nhưng mình nghĩ chỉ làm cho hàm bậc 1,2,3, hàm căn bậc 2 trước đã nhé. Còn những hàm như đa thức có tiệm cận thì có lẽ cái đó mình sẽ nâng cấp lên sau.
    PHP Code:
    class Function
    {
           public : 
                    
    int Tính Điểm Uốn();
                    
    int Tính miền xác định();
           private :
                    
    int MaxMin;
                    
    int tọa độ x;
                    
    int tọa độ y;
                    
    int bậc;
                    
    int hằng số a;

    Mình nghĩ lớp này sẽ được lớp vẽ kế thừa.
    Hay là ta có thể viết 2 lớp ( hàm bậc 1->3 và hàm căn bậc 2 ). Sau đó ta sẽ có 1 lớp Function là lớp cha của 2 lớp này lưu trữ tọa độ, min, max và miền xác định cũng được.
    Hic, thôi để mình suy nghĩ thêm coi cần gì đã nhé, vẫn chưa có 1 hình dung rõ ràng và logic gì hết hichic.
    À nhân tiên cho mình hỏi đoạn này tí nhé :
    PHP Code:
    CCurve3(double adouble b,double cdouble d){
                
    this->a;
                
    this->b;
                
    this->c;
                
    this->d
    Mình dùng con trỏ hằng ở đây để trỏ tới tạo để truy xuất đến a và gán nó bằng a là sao nhỉ? Bạn có thể giải thích cho mình chỗ này được không ? Cám ơn zkday2686 nhiều nhé !

  6. #6
    Ngày gia nhập
    09 2007
    Bài viết
    724

    Mặc định Bài tập lớn...!!!Về vẽ đồ thị

    Trích dẫn Nguyên bản được gửi bởi rox_rook Xem bài viết
    À nhân tiên cho mình hỏi đoạn này tí nhé :
    PHP Code:
    CCurve3(double adouble b,double cdouble d){
                
    this->a;
                
    this->b;
                
    this->c;
                
    this->d
    Mình dùng con trỏ hằng ở đây để trỏ tới tạo để truy xuất đến a và gán nó bằng a là sao nhỉ? Bạn có thể giải thích cho mình chỗ này được không ?
    OK. mình có một câu về con trỏ this thế này.


    bên trong thân hàm this là một con trỏ đối tượng. nó giữ địa chỉ của đối tượng mà lớp đó thuộc về.


    EX:
    Code:
          CCurve *bac3;
          bac3 = new CCurve3(2,0,3,5);
          drawCurve2D(pDC, bac2, 0, 100, 50);
    với đoạn code trên thì con trỏ this nó giữ địa chỉ của lớp đối tượng bac3. như vậy this ở đây là bac3.

    và khi vào copy Constructor tương ứng của class CCurver3 thì nó sẽ thực thi những lệnh sau như sau:

    Code:
                bac3->a = a;
                bac3->b = b;
                bac3->c = c;
                bac3->d = d;
    cái này nói thì khó hiểu nhưng mình bạn chỉ cần hiểu cái câu ở trên thì bạn sẽ hiểu.

  7. #7
    No Avatar
    garung Khách

    cám ơn các bạn ...
    nếu dùng con trỏ hàm để xây dựng công thức và vẽ hình thì sao ? xây dựng lớp công thức chung như thế nào để có thể cho bất kì hàm nào cũng vẽ được ....?

  8. #8
    Ngày gia nhập
    09 2007
    Bài viết
    724

    Trích dẫn Nguyên bản được gửi bởi garung Xem bài viết
    cám ơn các bạn ...
    nếu dùng con trỏ hàm để xây dựng công thức và vẽ hình thì sao ? xây dựng lớp công thức chung như thế nào để có thể cho bất kì hàm nào cũng vẽ được ....?
    1. mình đã nói ở trên rồi, bạn coi lại đi nhé.
    2. cái class để các class khác thừa kế lại thì mình đã làm rồi. cái còn lại của bạn là phải viết thật nhiều class để vẽ được nhiều hàm số hơn mà thôi. và phải tính f làm sao cho nhanh nhất.

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

    Mình có đọc lại về con trỏ this, mình có 1 đoạn code sau :
    PHP Code:
    #include <iostream>

    using namespace std;

    class CLASS
    {
      public : 
            CLASS ( 
    int );
            
    void print();
      private :
            
    int x;
    };

    CLASS::CLASS ( 
    int value )
          : 
    x(value)
    {
    }
          
    void CLASS::print() 
    {
          
    cout << "var " << x;
          
    cout << "\n this->var " << this->x;
          
    cout << "\n *this " << *this /*Dòng này lỗi*/
    }
    void main()
    {
          CLASS 
    Object(12);
          
    Object.print();

    Mình thấy mình vẫn chưa hiểu hết con trỏ this 1 cách triệt để, bạn có thể giải thích chỗ này cho mình được không ? Mình muốn cout ra xem *this là cái gì mà nó cũng không cho, hic hic !
    Đây là bug :
    test.cpp:23: no match for `ostream & << CLASS &'
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:77: candidates are: ostream::operator <<(char)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:78: ostream::operator <<(unsigned char)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:79: ostream::operator <<(signed char)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:80: ostream::operator <<(const char *)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:82: ostream::operator <<(const unsigned char *)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:84: ostream::operator <<(const signed char *)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:85: ostream::operator <<(const void *)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:86: ostream::operator <<(int)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:87: ostream::operator <<(unsigned int)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:88: ostream::operator <<(long int)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:89: ostream::operator <<(long unsigned int)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:91: ostream::operator <<(long long int)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:92: ostream::operator <<(long long unsigned int)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:94: ostream::operator <<(short int)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:95: ostream::operator <<(short unsigned int)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:97: ostream::operator <<(bool)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:99: ostream::operator <<(double)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:100: ostream::operator <<(float)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:104: ostream::operator <<(long double)
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:106: ostream::operator <<(ostream & (*)(ostream &))
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:107: ostream::operator <<(ios & (*)(ios &))
    \\cygnus\\cygwin-b20\\H-i586-cygwin32\\lib\\gcc-lib\\i586-cygwin32\\egcs-2.91.57\\..\\..\\..\\..\\..\\include\\g++\\iostrea m.h:108: ostream::operator <<(streambuf *)
    >Exit code: 1
    Mình đọc lại nữa thì thấy nó dùng con trỏ this cho việc "cascading", cái này mình cũng chẳng biết dịch ra tiếng việt sao nữa, nhưng sau đây là đoạn code ví dụ :
    PHP Code:
    #include <iostream>
    using std::cout;
    using std::endl;

    #include <iomanip>
    using std::setw;
    using std::setfill;


    class 
    Time
    {
          public :
                
    Time int 0int 0int );
                
    Time &setTime intintint );
                
    Time &setHour ( int );
                
    Time &setMinute ( int );
                
    Time &setSecond ( int );
          
                
    int getHour() const;
                
    int getMinute() const;
                
    int getSecond() const;
          
                
    void printUniversal() const;
                
    void printStandard() const;
          private :
                
    int hour;
                
    int minute;
                
    int second;
    };

    Time::Time int hint mint s )
    {
          
    setTime hm);
    }

    Time &Time::setTime int hint mint s )
    {
          
    setHour );
          
    setMinute );
          
    setSecond );

          return *
    this/*Enable cascading*/
    }

    Time &Time::setHourint h )
    {
          
    hour = ( >= && 24 ) ? ;
          return *
    this/*Enable cascading*/
    }

    Time &Time::setMinute int m )
    {
          
    minute = ( >= && 60 ) ? 0;
          return *
    this;
    }

    Time &Time::setSecondint s )
    {
          
    second = ( >= && 60 ) ? 0;
          return *
    this/*Enable cascading*/
    }

    int Time::getHour() const
    {
          return 
    hour;
    }

    int Time::getMinute() const
    {
          return 
    minute;
    }

    int Time::getSecond() const
    {
          return 
    second;
    }

    void Time::printUniversal() const
    {
          
    cout << setfill ('0') << setw(2) << hour << ":"
               
    << setw(2) << minute << ":"
               
    << setw(2) << second;
    }

    void Time::printStandard() const
    {
          
    cout << ( ( hour == || hour == 12 ) ? 12 hour 12 )
               << 
    ":" << setfill('0') << setw(2) << minute
               
    << ":" << setw(2) << second
               
    << ( hour 12 "AM" "PM" );
    }

    int main(void)
    {
          
    Time Obj;
          
          
    /*Cascaded function calls*/
          
    Obj.setHour(18).setMinute(30).setSecond(22);

          
    cout << "\nUniversal time :";
          
    Obj.printUniversal();
          
          
    cout << "\nStandard time : ";
          
    Obj.printStandard();

          
    cout << "\n\nNew standard time ";

          
    Obj.setTime 202020 ).printStandard();
          
          
    cout << endl;
         
          
    system("pause");
          return 
    0;

    Mình hiểu cái này là hàm Time &Time sẽ trả về tham chiếu, để thực hiện dòng lệnh này :
    Obj.setHour(18).setMinute(30).setSecond(22);
    Nhưng mình thấy vẫn còn mập mờ lắm, tại sao nó lại phải return *this.
    Thêm nữa thường thì mình thấy 1 hàm có 1 kiểu nhất định như void, int, double...Cái này có phải là hàm kiểu đối tượng ? Tại sao nhất thiết nó phải dùng trả về tham chiếu chỗ này nhỉ? Mà về tham chiếu thì mình hiểu nó là 1 alias tham chiếu đến 1 cái gì đó, vậy nếu trả về tham chiếu thìi nó phải chăng nó trả về địa chỉ của đối tượng đó ? Bạn có thể giải thích mấy cái này cho mình được không ? Cám ơn bạn nhiều lắm ! Thân !

  10. #10
    Ngày gia nhập
    09 2006
    Nơi ở
    /usr/share/.hack@
    Bài viết
    1,433

    Đối tượng kiểu gì thì con trỏ trả về đối tượng kiểu đó
    tưởng tượng thế này :
    Bạn tạo một hàm kiểu int thì kiểu trả về phải là int. OK ? Lúc sử dụng sẽ tham chiếu kiểu int
    Giờ tạo một class RoxR, tạo một hàm kiểu RoxR, thiết lập cho đối tượng cái gì đó; kết thúc thì trả về cái đối tượng xử lý xong.
    'this' là cái đối tượng đang xử lý hiện tại lúc gọi, tham chiếu kiểu RoxR thì phải trả về một đối tượng kiểu RoxR, chính là 'this'
    None!

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

  1. Dạy vẽ móng, vẽ nail chuyên nghiệp
    Gửi bởi marketeronline trong diễn đàn Giới thiệu website, sản phẩm của bạn
    Trả lời: 1
    Bài viết cuối: 14-04-2012, 11:14 AM
  2. Đồ họa trên C++ Hàm vẽ điểm glVertex3f vẽ sai trong openGL?
    Gửi bởi kazat trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 0
    Bài viết cuối: 26-03-2012, 08:21 PM
  3. Trả lời: 2
    Bài viết cuối: 24-05-2011, 12:29 AM
  4. Vẽ một bông hoa bằng cách vẽ các elip nghiêng 1 góc G độ với các màu khác nhau?
    Gửi bởi kimhieuqtvn trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 2
    Bài viết cuối: 09-04-2011, 02:40 PM
  5. Chế độ tô vẽ và vẽ mượt mà (antialiashing) trong lập trình C#
    Gửi bởi neverland87 trong diễn đàn Tutorials và Thủ thuật lập trình C#, ASP.NET
    Trả lời: 0
    Bài viết cuối: 24-06-2007, 01:06 PM

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