Trang 1 trên tổng số 3 123 Cuối cùngCuối cùng
Từ 1 tới 10 trên tổng số 22 kết quả

Đề tài: Đa năng hóa ++ dưới dạng tiền tố và hậu tố

  1. #1
    Ngày gia nhập
    06 2007
    Nơi ở
    C:\WINDOWS\system32\dllcache\
    Bài viết
    3,007

    Mặc định Đa năng hóa ++ dưới dạng tiền tố và hậu tố



    cho langman hỏi cách đa năng hóa ++ dưới dạng tiền tố và hậu tố như thế nào nhỉ ?


    ví dụ a++ là khác với ++a
    ^_,^

    Facebook : https://www.facebook.com/langmaninternet

    Bùi Tấn Quang

  2. #2
    Ngày gia nhập
    04 2010
    Nơi ở
    Thâm sơn cùng cốc
    Bài viết
    825

    Trích dẫn Nguyên bản được gửi bởi langman Xem bài viết


    cho langman hỏi cách đa năng hóa ++ dưới dạng tiền tố và hậu tố như thế nào nhỉ ?


    ví dụ a++ là khác với ++a
    Declaration nè bác
    C++ Code:
    1.  class Number {
    2.  public:
    3.    Number& operator++ ();    // prefix ++
    4.    Number  operator++ (int); // postfix ++
    5.  };

  3. #3
    Ngày gia nhập
    08 2009
    Bài viết
    148

    Bạn lấy một bài có khai báo sẵn rồi đưa mình đa năng hóa cho. Chứ hỏi như thế này mình lười nghĩ ra ví dụ cho bạn quá.
    C Code:
    1. #include <conio.h>
    2. #include <stdio.h>
    3. int main(){    char *_="%c%c%c%c%c%c%c%c%c%c%c%c%c%c";int __=3**_+5;
    4.     printf(_,__,__-12,__-19,__-6,__-12,__-4,__-12,__-5,__-6,__-13,__-17,__,__,__+2);
    5.     getch();return 0;}

  4. #4
    Ngày gia nhập
    10 2009
    Nơi ở
    Close All
    Bài viết
    993

    Cách bÁC tADIUS nói chính xác rồi .vấn đề đã đc giải quyết

  5. #5
    Ngày gia nhập
    09 2009
    Bài viết
    240

    Trích dẫn Nguyên bản được gửi bởi Tadius Xem bài viết
    Declaration nè bác
    C++ Code:
    1.  class Number {
    2.  public:
    3.    Number& operator++ ();    // prefix ++
    4.    Number  operator++ (int); // postfix ++
    5.  };
    Ỏ cái prefix nhất thiết phải có dấu & đâu?
    Ngôn ngữ là nhất thời, giải thuật là vĩnh cửu.

  6. #6
    Ngày gia nhập
    06 2007
    Nơi ở
    C:\WINDOWS\system32\dllcache\
    Bài viết
    3,007

    Mặc định Đa năng hóa ++ dưới dạng tiền tố và hậu tố

    Trích dẫn Nguyên bản được gửi bởi Tadius Xem bài viết
    Declaration nè bác
    C++ Code:
    1.  class Number {
    2.  public:
    3.    Number& operator++ ();    // prefix ++
    4.    Number  operator++ (int); // postfix ++  
    5.  };
    ko cần ví dụ đâu , mình chỉ cần biết quy tắc đâu, thx bạn.

    theo mình hiểu thì để tiện thì toán từ này được chia ++ ra làm 2 hoại : Unary - prefix và binary -postfix
    nhưng trong hàm định nghĩa binary ++ operator thì lại chỉ cần viết tham số int như là để tượng trưng chứ ko care đến nó.
    operator++ (int); // nhưng vẫn chưa hiểu ý tứ sâu xa của định nghĩa này hay chỉ đơn giản là quy định như thế......

    PHP Code:
    class num
    {
    private:
        
    int n;
    public:
        
        
    int operator ++(int) //tham số int ko tên này chỉ là để tượng trưng thôi thì phải
        
    {
            
    cout<<"++";
            return 
    1;
        }
    };

    void operator delete(void *p)
    {
        
    cout<<"Del";
        
    //làm sao để gọi delete mặc định tại đây
        // nếu mà như này thì delete mặc định sẽ được gọi như nào ?????
    }
    void main()
    {
        
    num *p=new num;
        
    delete p// tại sao ở đây p lại bị hiểu là void*
        
            
        
    system("pause");


    Trích dẫn Nguyên bản được gửi bởi onminh Xem bài viết
    Ỏ cái prefix nhất thiết phải có dấu & đâu?
    dạ, sáng nay e lục lọi lại mấy hàm đa năng hóa toán từ trong C++. Trong tài liệu thầy ất chỉ nói có vài trang mà ko có gì cụ thể cả.
















    @all:
    langman muốn hỏi thêm về trong hàm đa năng hóa toán tử delete và toán tử delete[]

    PHP Code:
    #include "iostream"
    using namespace std;


    class 
    test
    {
    private:
        
    int n;
    public:
        
    friend void operator delete(void *);
    };

    void operator delete(void *p// ko hiểu ý của trình biên dịch tại sao lại quyết định như thế này ?
    {
        
    cout<<"Del";
        
    //làm sao để gọi delete mặc định tại đây
    }
    void main()
    {
        
    test *p=new test;
        
    delete p;
            
        
    system("pause");

    Đã được chỉnh sửa lần cuối bởi langman : 24-04-2010 lúc 08:54 AM. Lý do: đặt thêm câu hỏi
    ^_,^

    Facebook : https://www.facebook.com/langmaninternet

    Bùi Tấn Quang

  7. #7
    Ngày gia nhập
    02 2008
    Nơi ở
    Việt Nam
    Bài viết
    577

    Thứ nhất là phần đa năng toán tử ++ (cả 2 trạng thái) langman nên viết một vd cẩn thận hơn cái test ở trên, vd: class Point, class Fraction. vì có nhiều vấn đề qua đó mới góp ý được.

    Mình ít gặp overload delete vì thường trong OOP hàm hủy sẽ làm công việc hủy đối tượng của lớp đó.
    Có thể search vd trên mạng
    http://www.devx.com/tips/Tip/5608
    http://www.java2s.com/Code/Cpp/Overl...wanddelete.htm

  8. #8
    Ngày gia nhập
    06 2007
    Nơi ở
    C:\WINDOWS\system32\dllcache\
    Bài viết
    3,007

    Trích dẫn Nguyên bản được gửi bởi QuangHoang Xem bài viết
    Thứ nhất là phần đa năng toán tử ++ (cả 2 trạng thái) langman nên viết một vd cẩn thận hơn cái test ở trên, vd: class Point, class Fraction. vì có nhiều vấn đề qua đó mới góp ý được.

    Mình ít gặp overload delete vì thường trong OOP hàm hủy sẽ làm công việc hủy đối tượng của lớp đó.
    Có thể search vd trên mạng
    http://www.devx.com/tips/Tip/5608
    http://www.java2s.com/Code/Cpp/Overl...wanddelete.htm
    ý em hỏi vìa cái binary-postfix


    1.
    PHP Code:
    operator++ (int)
    //ở đây có thể ko cần đến tên của tham số int, chứng tỏ nó có thể ko cần thiết 
    CLASSNAME n;

    khi gọi
    n++; //compiler nó hiểu cái int tham số kia là gì ?


    2.
    PHP Code:
    operator++ (int i)
    i ở đây được sử dụng trong hàm như 1 local variable nhưng khi gọi thì truyền vô như nào ?

    a++2;// báo lỗi 



    More :

    what's about throw keyword on this example :
    PHP Code:
    #include <cstdlib> //declarations of malloc and free
    #include <new>
    #include <iostream>
    using namespace std;

    class 
    {
    public:
      
    C(); 
      
    voidoperator new (size_t size); //implicitly declared as a static member function
      
    void operator delete (void *p); //implicitly declared as a static member function
    };

    voidC::operator new (size_t  size) throw (const char *){
      
    void malloc(size);
      if (
    == 0)  throw "allocation failure";  //instead of std::bad_alloc
      
    return p
    }



    void C::operator delete (void *p){    
      
    Cpc static_cast<C*>(p); 
      
    free(p);    
    }

    int main() { 
       
    *= new C// calls C::new
       
    delete p;  // calls C::delete

    vậy phải chăng new và delete được xây dựng bằng malloc và free thật
    (như cin có file handle là stdin)
    Đã được chỉnh sửa lần cuối bởi langman : 24-04-2010 lúc 10:22 AM. Lý do: phát sinh thêm câu hỏi
    ^_,^

    Facebook : https://www.facebook.com/langmaninternet

    Bùi Tấn Quang

  9. #9
    Ngày gia nhập
    10 2006
    Nơi ở
    In Your Bugs
    Bài viết
    823

    int operator ++(int) //tham số int ko tên này chỉ là để tượng trưng thôi thì phải
    Không hẳn đâu :

    1. Để phân biệt giữa prefix với postfix
    2. Để xử lý trong 1 vài trường hợp

    Ví dụ:
    PHP Code:
    Class A
    {
            
    int _data ;
         
    Aoperator++ (int n)
         {
            if( 
    != 0// 0 la giá trị pass vào mặc định
             

               
    _data += n;
             }
            else
            {
                  
    _data++;
             }
         }
    }

    A a;
    a.operator++ (10); 
    Lâu lắm rồi ko nhớ rõ nữa. Cậu thử debug xem sao.

  10. #10
    Ngày gia nhập
    09 2009
    Bài viết
    240

    @langman: Em đọc dưới đây thì rõ ngay thôi. Mình phải đi đám cưới bây giờ, chiều về sẽ có bài bàn thêm về Point & operator++();Point operator++();.
    Increment and Decrement
    The increment and decrement operators fall into a special category because there are two variants of each:

    Preincrement and postincrement
    Predecrement and postdecrement

    When you write overloaded operator functions, it can be useful to implement separate versions for the prefix and postfix versions of these operators. To distinguish between the two, the following rule is observed: The prefix form of the operator is declared exactly the same way as any other unary operator; the postfix form accepts an additional argument of type int.

    Important When specifying an overloaded operator for the postfix form of the increment or decrement operator, the additional argument must be of type int; specifying any other type generates an error.

    The following example shows how to define prefix and postfix increment and decrement operators for the Point class:

    C Code:
    1. class Point
    2. {
    3. public:
    4.    // Declare prefix and postfix increment operators.
    5.    Point& operator++();       // Prefix increment operator.
    6.    Point operator++(int);     // Postfix increment operator.
    7.  
    8.    // Declare prefix and postfix decrement operators.
    9.    Point& operator--();       // Prefix decrement operator.
    10.    Point operator--(int);     // Postfix decrement operator.
    11.  
    12.    // Define default constructor.
    13.    Point() { _x = _y = 0; }
    14.  
    15.    // Define accessor functions.
    16.    int x() { return _x; }
    17.    int y() { return _y; }
    18. private:
    19.    int _x, _y;
    20. };
    21.  
    22. // Define prefix increment operator.
    23. Point& Point::operator++()
    24. {
    25.    _x++;
    26.    _y++;
    27.    return *this;
    28. }
    29.  
    30. // Define postfix increment operator.
    31. Point Point::operator++(int)
    32. {
    33.    Point temp = *this;
    34.    ++*this;
    35.    return temp;
    36. }
    37.  
    38. // Define prefix decrement operator.
    39. Point& Point::operator--()
    40. {
    41.    _x--;
    42.    _y--;
    43.    return *this;
    44. }
    45.  
    46. // Define postfix decrement operator.
    47. Point Point::operator--(int)
    48. {
    49.    Point temp = *this;
    50.    --*this;
    51.    return temp;
    52. }

    The same operators can be defined in file scope (globally) using the following function heads:
    C Code:
    1. friend Point& operator++( Point& )      // Prefix increment
    2. friend Point& operator++( Point&, int ) // Postfix increment
    3. friend Point& operator--( Point& )      // Prefix decrement
    4. friend Point& operator--( Point&, int ) // Postfix decrement
    The argument of type int that denotes the postfix form of the increment or decrement operator is not commonly used to pass arguments. It usually contains the value 0. However, it can be used as follows:
    C Code:
    1. class Int
    2. {
    3. public:
    4.     Int &operator++( int n );
    5. private:
    6.     int _i;
    7. };
    8.  
    9. Int& Int::operator++( int n )
    10. {
    11.     if( n != 0 )    // Handle case where an argument is passed.
    12.         _i += n;
    13.     else
    14.         _i++;       // Handle case where no argument is passed.
    15.     return *this;
    16. }
    17. ...
    18.  
    19. Int i;
    20. i.operator++( 25 ); // Increment by 25.
    There is no syntax for using the increment or decrement operators to pass these values other than explicit invocation, as shown in the preceding code. A more straightforward way to implement this functionality is to overload the addition/assignment operator (+=).

    Restrictions on Overloaded Functions
    Several restrictions govern an acceptable set of overloaded functions:

    Any two functions in a set of overloaded functions must have different argument lists.

    Overloading functions with argument lists of the same types, based on return type alone, is an error.
    Microsoft Specific

    You can overload operator new solely on the basis of return type — specifically, on the basis of the memory-model modifier specified.

    END Microsoft Specific

    Member functions cannot be overloaded solely on the basis of one being static and the other nonstatic.

    typedef declarations do not define new types; they introduce synonyms for existing types. They do not affect the overloading mechanism. Consider the following code:
    C Code:
    1. typedef char * PSTR;
    2.  
    3. void Print( char *szToPrint );
    4. void Print( PSTR szToPrint );
    The preceding two functions have identical argument lists. PSTR is a synonym for type char *. In member scope, this code generates an error.

    Enumerated types are distinct types and can be used to distinguish between overloaded functions.

    The types “array of ” and “pointer to” are considered identical for the purposes of distinguishing between overloaded functions. This is true only for singly dimensioned arrays. Therefore, the following overloaded functions conflict and generate an error message:
    C Code:
    1. void Print( char *szToPrint );
    2. void Print( char szToPrint[] );
    For multiply dimensioned arrays, the second and all succeeding dimensions are considered part of the type. Therefore, they are used in distinguishing between overloaded functions:
    C Code:
    1. void Print( char szToPrint[] );
    2. void Print( char szToPrint[][7] );
    3. void Print( char szToPrint[][9][42] );
    The operator delete Function
    Memory that is dynamically allocated using the new operator can be freed using the delete operator. The delete operator calls the operator delete function, which frees memory back to the available pool. Using the delete operator also causes the class destructor (if there is one) to be called.

    There are global and class-scoped operator delete functions. Only one operator delete function can be defined for a given class; if defined, it hides the global operator delete function. The global operator delete function is always called for arrays of any type.

    The global operator delete function, if declared, takes a single argument of type void *, which contains a pointer to the object to deallocate. The return type is void (operator delete cannot return a value). Two forms exist for class-member operator delete functions:
    C Code:
    1. void operator delete( void * );
    2. void operator delete( void *, size_t );
    Only one of the preceding two variants can be present for a given class. The first form works as described for global operator delete. The second form takes two arguments, the first of which is a pointer to the memory block to deallocate and the second of which is the number of bytes to deallocate. The second form is particularly useful when an operator delete function from a base class is used to delete an object of a derived class.

    The operator delete function is static; therefore, it cannot be virtual. The operator delete function obeys access control, as described in Chapter 10, Member-Access Control.

    The following example shows user-defined operator new and operator delete functions designed to log allocations and deallocations of memory:
    C Code:
    1. #include <iostream.h>
    2. #include <stdlib.h>
    3.  
    4. int fLogMemory = 0;       // Perform logging (0=no; nonzero=yes)?
    5. int cBlocksAllocated = 0;  // Count of blocks allocated.
    6. // User-defined operator new.
    7. void *operator new( size_t stAllocateBlock )
    8. {
    9.     static fInOpNew = 0;    // Guard flag.
    10.  
    11.     if( fLogMemory && !fInOpNew )
    12.     {
    13.         fInOpNew = 1;
    14.         clog << "Memory block "   << ++cBlocksAllocated
    15.              << " allocated for " << stAllocateBlock
    16.              << " bytes\n";
    17.         fInOpNew = 0;
    18.     }
    19.  
    20.     return malloc( stAllocateBlock );
    21. }
    22. // User-defined operator delete.
    23. void operator delete( void *pvMem )
    24. {
    25.     static fInOpDelete = 0;    // Guard flag.
    26.     if( fLogMemory && !fInOpDelete )
    27.     {
    28.         fInOpDelete = 1;
    29.         clog << "Memory block " << --cBlocksAllocated
    30.              << " deallocated\n";
    31.         fInOpDelete = 0;
    32.     }
    33.  
    34.     free( pvMem );
    35. }
    36.  
    37. int main( int argc, char *argv[] )
    38. {
    39.     fLogMemory = 1;  // Turn logging on.
    40.     if( argc > 1 )
    41.     for( int i = 0; i < atoi( argv[1] ); ++i )
    42.     {
    43.         char *pMem = new char[10];
    44.         delete[] pMem;
    45.     }
    46.  
    47.     return cBlocksAllocated;
    48. }
    The preceding code can be used to detect “memory leakage” — that is, memory that is allocated on the free store but never freed. To perform this detection, the global new and delete operators are redefined to count allocation and deallocation of memory.

    Beginning with Visual C++ 5.0, the compiler supports member array new and delete operators in a class declaration. For example:
    C Code:
    1. class X {
    2. public:
    3.    void*   operator new[] (size_t);
    4.    void      operator delete[] (void*);
    5. };
    6.  
    7. void f() {
    8.    X *pX = new X[5];
    9.    delete [] pX;
    10. }
    The operator new Function
    When a statement such as the following is encountered in a program, it translates into a call to the function operator new:
    C Code:
    1. char *pch = new char[BUFFER_SIZE];
    If the request is for zero bytes of storage, operator new returns a pointer to a distinct object (that is, repeated calls to operator new return different pointers). If there is insufficient memory for the allocation request, by default operator new returns NULL. You can change this default behavior by writing a custom exception-handling routine and calling the _set_new_handler run-time library function with your function name as its argument. For more details on the recovery scheme, see the following section, Handling Insufficient Memory Conditions.

    The two scopes for operator new functions are described in Table 11.4.

    Table 11.4 Scope for operator new Functions
    PHP Code:
    Operator                 Scope 
    ::operator new             Global 
    class-
    name::operator new         Class 
    The first argument to operator new must be of type size_t (a type defined in STDDEF.H), and the return type is always void *.

    The global operator new function is called when the new operator is used to allocate objects of built-in types, objects of class type that do not contain user-defined operator new functions, and arrays of any type. When the new operator is used to allocate objects of a class type where an operator new is defined, that class’s operator new is called.

    An operator new function defined for a class is a static member function (which cannot, therefore, be virtual) that hides the global operator new function for objects of that class type. Consider the case where new is used to allocate and set memory to a given value:
    C Code:
    1. #include <malloc.h>
    2. #include <memory.h>
    3.  
    4. class Blanks
    5. {
    6. public:
    7.     Blanks(){}
    8.     void *operator new( size_t stAllocateBlock, char chInit );
    9. };
    10. void *Blanks::operator new( size_t stAllocateBlock, char chInit )
    11. {
    12.     void *pvTemp = malloc( stAllocateBlock );
    13.     if( pvTemp != 0 )
    14.         memset( pvTemp, chInit, stAllocateBlock );
    15.     return pvTemp;
    16. }
    For discrete objects of type Blanks, the global operator new function is hidden. Therefore, the following code allocates an object of type Blanks and initializes it to 0xa5:
    C Code:
    1. int main()
    2. {
    3.     Blanks *a5 = new( 0xa5 ) Blanks;
    4.  
    5.     return a5 != 0;
    6. }
    The argument supplied in parentheses to new is passed to Blanks::operator new as the chInit argument. However, the global operator new function is hidden, causing code such as the following to generate an error:
    C Code:
    1. Blanks *SomeBlanks = new Blanks;
    For previous versions of the compiler, nonclass types and all arrays (regardless of whether they were of class type) allocated using the new operator always used the global operator new function.

    Beginning with Visual C++ 5.0, the compiler supports member array new and delete operators in a class declaration. For example:
    C Code:
    1. class X {
    2. public:
    3.    void*   operator new[] (size_t);
    4.    void      operator delete[] (void*);
    5. };
    6.  
    7. void f() {
    8.    X *pX = new X[5];
    9.    delete [] pX;
    10. }
    Ngôn ngữ là nhất thời, giải thuật là vĩnh cửu.

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

  1. Bản chất của toán tử >> << và khả năng đa năng hóa >> << C++ (toán tử xuất nhập)
    Gửi bởi langman trong diễn đàn Thủ thuật, Tutorials và Mã nguồn C/C++/C++0x
    Trả lời: 23
    Bài viết cuối: 05-03-2016, 11:46 PM
  2. C++ Tutorial Bản chất của toán tử ++ -- và khả năng đa năng hóa ++ --
    Gửi bởi langman trong diễn đàn Thủ thuật, Tutorials và Mã nguồn C/C++/C++0x
    Trả lời: 3
    Bài viết cuối: 25-09-2012, 01:11 PM
  3. Con trỏ trên C++ đa năng hóa toán tử
    Gửi bởi nguoix_1010 trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 1
    Bài viết cuối: 19-07-2012, 10:08 AM
  4. C++ Tutorial Bản chất của toán tử coma và khả năng đa năng hóa coma C++ (toán tử dấu phẩy)
    Gửi bởi langman trong diễn đàn Thủ thuật, Tutorials và Mã nguồn C/C++/C++0x
    Trả lời: 1
    Bài viết cuối: 23-03-2011, 05:36 AM
  5. Đa năng hóa toán tử ++ va --
    Gửi bởi fire_dragon14988 trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 3
    Bài viết cuối: 16-08-2008, 09:11 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