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

Đề tài: Comparing different coding approaches (Dịch)

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

    Talking Comparing different coding approaches (Dịch)

    http://www.codeproject.com/KB/archit...ling_eg_1.aspx

    Hehe, nói là dịch cho oai thôi chứ thực ra bài này chỉ là nêu lên một cách tóm tắt cái bài dài loằng ngoằng bằng tiếng anh ở trên thui...

    A. Inline coding:
    Ex:
    C++ Code:
    1. #ifndef _H_EX
    2. #define _H_EX
    3.  
    4. #include <iostream>
    5.  
    6. using namespace std;
    7.  
    8. class Ex
    9. {
    10. public:
    11.     Ex()
    12.     {
    13.         i = 0;
    14.         iCount++;
    15.     }
    16.  
    17.     void print()
    18.         {
    19.             cout<<"Count: "<<iCount<<" ... i: "<<i<<endl;
    20.         }
    21.  
    22.     void pCount();
    23.  
    24. public:
    25.     int i;
    26.     static int iCount;
    27. };
    28.  
    29. _declspec(selectany) int Ex::iCount = 0;
    30.  
    31. inline void Ex::pCount()
    32. {
    33.     cout<<"pCount: "<<iCount<<endl;
    34. }
    35.  
    36. static int g_Int = 5;
    37.  
    38. static void ePrint()
    39. {
    40.     cout<<Ex::iCount<<endl;
    41. }
    42.  
    43. #endif //_H_EX

    Đây là cách code class,biến toàn bộ (global variable), hàm toàn cục (global function), ... chỉ trong một header file (*.h). Cách code này được khá nhiều người sử dụng (có tui, và cả C# nữa )

    Lưu ý:
    + Tất cả các global function đều phải inline (static cũng được)
    + Tất cả các global variable đều phải _declspec(selectany) (static cũng được)
    + Nếu class có sử dụng biến static thì phải add thêm _declspec(selectany) trước (kô biết cái này chỉ có MSVC hỗ trợ hay tất cả các compiler đều hỗ trợ) vì nếu không khi nhiều file *.cpp cùng include file header này thì sẽ gặp một link error giống như : "Object already defined or declared" (đối tượng đã được khai báo hoặc có body rùi ) ...
    + Nếu class đã khai báo prototype của một function trong class thì nếu muốn khai báo hàm đó ở ngoài mà không bị lỗi "Object already defined or declared" thì phải xài inline (kô xài static được đâu)
    + Definition of global functions require the inline declaration. If the function is recursive (or is part of a recursion mechanism) or has too long a body, the compiler will not expand the body in the expression you call it, but in any case will place an ordinary function call. In any case, the "inline" here, plays the same role of the selectany played above. In fact, also member functions are inline, but for members defined in that way, the inline is implicit. (khúc này hiểu nhưng kô biết giải thích làm sao )

    Bất lợi:

    + Việc đọc code dạng này sẽ khá bất lợi, đặc biệt khi code quá dài hoặc rắc rối (giống như class này sử dụng class kia A USE B AND B USE A) [seo mình kô thấy vậy ta ]
    + Việc sử dụng code cũng sẽ gặp rắc rối trong trường hợp A USE B AND B USE A

    Vậy thì hãy tiến tới cách code thứ hai...

    B. Near Line Coding

    Chôm ví dụ của nó
    C++ Code:
    1. //**********************
    2.  
    3. // file "myclass.h"
    4.  
    5.  
    6. // include used types declarations
    7.  
    8. #include "MyBase.h"
    9.  
    10. #include "MyInterface.h"
    11.  
    12.  
    13. //declare CMyClass
    14.  
    15. class CMyClass:
    16.     public CMyBase,
    17.     public IMyInterface //if any
    18.  
    19. {
    20.     //data members
    21.  
    22.     CSometypeA _memberVariable;
    23.    
    24.     //static member
    25.  
    26.     CSometypeB s_staticMember;
    27.    
    28.     //MyClass functions
    29.  
    30.     inline returntype DoSomething( parameters );
    31.  
    32.     //CMyBase overrides
    33.  
    34.     inline virtual returntype DoOverride ( parameters );
    35.    
    36.     //IMyInterface implementation
    37.  
    38.     inline virtual returntype DoImplement( parameters)
    39. };
    40.  
    41. //reference static members (if externally needed)
    42.  
    43. extern CSometypeB CMyClass::s_staticMember;
    44.  
    45. //instantiate global objects
    46.  
    47. extern CSometypeC g_glbalObject;
    48.  
    49. //declare some global function
    50.  
    51. inline returntype GlobalFunction (parameters);
    52.  
    53. //now include the definitions
    54.  
    55. #include "myclass.hpp"

    C++ Code:
    1. //**************************
    2.  
    3. // file "myclass.hpp"
    4.  
    5. #pragma once
    6.  
    7. // include used types declarations not already in Myclass.h
    8.  
    9.  
    10. // define CMyClass
    11.  
    12.    
    13. //MyClass functions
    14.  
    15. imline returntype CMyClass::DoSomething( parameters )
    16. {
    17.     //function body goes here
    18.  
    19. }
    20.    
    21. //CMyBase overrides
    22.  
    23. inline returntype CMyClass::DoOverride ( parameters )
    24. {
    25.     //function body goes here
    26.  
    27. }
    28.    
    29. //IMyInterface implementation
    30.  
    31. inline returntype CMyClass::DoImplement( parameters)
    32. {
    33.     function body goes here
    34. }
    35.  
    36. //instantiate static members
    37.  
    38. _declspec(selectany) CSometypeB CMyClass::s_staticMember;
    39.  
    40. //instantiate global objects
    41.  
    42. _declspec(selectany) CSometypeC g_glbalObject;
    43.  
    44. //declare some global function
    45.  
    46. inline returntype GlobalFunction (parameters)
    47. {
    48.     //function body
    49.  
    50. }

    Thoạt nhìn cách code này giống như cách code nhiều LTV khác thường làm (viết signature ở header file rồi viết body ở cpp file) nhưng thực ra không phải vậy. Việc include file hpp ở cuối file h sẽ làm cho việc add file h sẽ kèm theo luôn file hpp, và điều này tạo nên sự thuân tiện trong một số trường hợp.

    Lưu ý:
    + Bởi vì chúng ta vẫn chưa add cpp file nên vẫn cần static , inline và _declspec(selectany)
    + Trong file h, khi khai báo biến static của class hay biến toàn cục chưa dùng static và _declspec(selectany) vội mà phải dùng extern rồi mới dùng static và _declspec(selectany) ở file hpp sau
    + Còn lại giông với A. Inline Coding

    Vậy điều gì thực sự khác biệt ở B. Near Line Coding. Có lẽ là việc dễ dàng cho việc đọc code, thuận tiện trong trường hợp A USE B AND B USE A và dễ dàng trong việc tái sử dụng (chỉ cần add file h là sẽ tự động add luôn file hpp)

    C. Ofline Coding
    Đây có lẽ là cách code hay sử dụng nhất của LTV, nên chắc khá quen rồi vậy mình sẽ không trình bày ở đây có gì xem thêm ở cái bài tiếng anh trên

    ... Thấy cái này hay và có lẽ khá hữu dụng trong một số trường hợp nên post lên đây. Mấy hôm trước đang gặp rắc rối trong môt project khá lớn, vớ được cái này mừng hết xiết. Hy vọng sẽ giúp ích cho các bạn


    -----
    I'm not a beginer... just a collector and a manager...
    Đã được chỉnh sửa lần cuối bởi vpdp_pc : 11-04-2008 lúc 08:07 PM.

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

  1. Giải thuật Cách duyệt cây tạo bảng mã bit của huffman coding
    Gửi bởi benokuros trong diễn đàn Thắc mắc CTDL & Giải thuật
    Trả lời: 0
    Bài viết cuối: 01-11-2013, 03:40 AM
  2. Thuật toán C++ Đưa Cây Huffman Coding Sau Khi Duyệt Và Xử Lý Ra Màn Hình
    Gửi bởi vandergun trong diễn đàn Thắc mắc CTDL & Giải thuật
    Trả lời: 0
    Bài viết cuối: 29-11-2012, 04:21 PM
  3. coding standard ?
    Gửi bởi nh0cbilly trong diễn đàn Kinh nghiệm CNTT
    Trả lời: 3
    Bài viết cuối: 24-07-2010, 09:17 PM
  4. Coding convention
    Gửi bởi haian trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 6
    Bài viết cuối: 10-04-2010, 10:00 PM
  5. Tư duy và rèn luyện coding
    Gửi bởi Xcross87 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-11-2007, 04:39 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