Khi nào các macro C ++ có lợi? [đóng cửa]

Bộ tiền xử lý C được cộng đồng C ++ sợ hãi và xa lánh. Các hàm, các hằng và mẫu trong hàng thường là sự thay thế an toàn và vượt trội hơn so với a #define.

Macro sau:

#define SUCCEEDED(hr) ((HRESULT)(hr) >= 0)  

không có cách nào vượt trội so với loại an toàn:

inline bool succeeded(int hr) { return hr >= 0; }

Nhưng các macro có vị trí của chúng, vui lòng liệt kê các công dụng bạn tìm thấy cho các macro mà bạn không thể thực hiện nếu không có bộ xử lý trước.

Vui lòng đặt từng trường hợp sử dụng vào một câu trả lời riêng biệt để có thể bỏ phiếu và nếu bạn biết cách đạt được một trong những câu trả lời mà không cần người chuẩn bị chỉ ra cách nhận xét của câu trả lời đó.

Như wrappers cho các chức năng debug, để tự động chuyển những thứ như __FILE__, __LINE__, vv:

#ifdef ( DEBUG )
#define M_DebugLog( msg )  std::cout << __FILE__ << ":" << __LINE__ << ": " << msg
#else
#define M_DebugLog( msg )
#endif

Các phương thức phải luôn luôn đầy đủ, có thể biên dịch mã; macro có thể là các đoạn mã. Do đó, bạn có thể định nghĩa một macro foreach:

#define foreach(list, index) for(index = 0; index < list.size(); index++)

Và sử dụng nó như vậy:

foreach(cookies, i)
    printf("Cookie: %s", cookies[i]);

Kể từ C ++ 11, điều này được thay thế bởi vòng lặp dựa trên phạm vi .

Tiêu đề bảo vệ tập tin bắt buộc macro.

Có khu vực nào khác cần macro không? Không nhiều (nếu có).

Có bất kỳ tình huống nào khác được hưởng lợi từ macro? ĐÚNG!!!

Một nơi tôi sử dụng macro là với mã rất lặp đi lặp lại. Ví dụ, khi gói mã C ++ được sử dụng với các giao diện khác (.NET, COM, Python, v.v ...), tôi cần phải bắt các loại ngoại lệ khác nhau. Đây là cách tôi làm điều đó:

#define HANDLE_EXCEPTIONS \
catch (::mylib::exception& e) { \
    throw gcnew MyDotNetLib::Exception(e); \
} \
catch (::std::exception& e) { \
    throw gcnew MyDotNetLib::Exception(e, __LINE__, __FILE__); \
} \
catch (...) { \
    throw gcnew MyDotNetLib::UnknownException(__LINE__, __FILE__); \
}

Tôi phải đặt các sản phẩm khai thác này trong mọi chức năng bao bọc. Thay vì gõ các khối bắt đầy đủ mỗi lần, tôi chỉ gõ:

void Foo()
{
    try {
        ::mylib::Foo()
    }
    HANDLE_EXCEPTIONS
}

Điều này cũng làm cho bảo trì dễ dàng hơn. Nếu tôi phải thêm một loại ngoại lệ mới, chỉ có một nơi tôi cần thêm nó.

Cũng có những ví dụ hữu ích khác: nhiều trong số đó bao gồm các macro __FILE__và __LINE__tiền xử lý.

Dù sao, macro rất hữu ích khi được sử dụng một cách chính xác. Macro không phải là xấu xa - lạm dụng của họ là xấu xa.

Hầu hết:

1. Bao gồm bảo vệ
2. Biên soạn có điều kiện
3. Báo cáo (các macro được xác định trước như __LINE__và __FILE__)
4. (hiếm khi) Sao chép các mẫu mã lặp đi lặp lại.
5. Trong mã của đối thủ cạnh tranh của bạn.

Bên trong trình biên dịch có điều kiện, để khắc phục các vấn đề về sự khác biệt giữa các trình biên dịch:

#ifdef ARE_WE_ON_WIN32
#define close(parm1)            _close (parm1)
#define rmdir(parm1)            _rmdir (parm1)
#define mkdir(parm1, parm2)     _mkdir (parm1)
#define access(parm1, parm2)    _access(parm1, parm2)
#define create(parm1, parm2)    _creat (parm1, parm2)
#define unlink(parm1)           _unlink(parm1)
#endif

Khi bạn muốn tạo một chuỗi từ một biểu thức, ví dụ tốt nhất cho điều này là assert( #xbiến giá trị của xchuỗi thành một chuỗi).

#define ASSERT_THROW(condition) \
if (!(condition)) \
     throw std::exception(#condition " is false");

Các hằng chuỗi đôi khi được định nghĩa tốt hơn là các macro vì bạn có thể làm nhiều hơn với chuỗi ký tự chuỗi hơn là với a const char *.

ví dụ: chuỗi ký tự có thể dễ dàng nối .

#define BASE_HKEY "Software\\Microsoft\\Internet Explorer\\"
// Now we can concat with other literals
RegOpenKey(HKEY_CURRENT_USER, BASE_HKEY "Settings", &settings);
RegOpenKey(HKEY_CURRENT_USER, BASE_HKEY "TypedURLs", &URLs);

Nếu một const char *đã được sử dụng thì một số loại chuỗi chuỗi sẽ phải được sử dụng để thực hiện nối chuỗi khi chạy:

const char* BaseHkey = "Software\\Microsoft\\Internet Explorer\\";
RegOpenKey(HKEY_CURRENT_USER, (string(BaseHkey) + "Settings").c_str(), &settings);
RegOpenKey(HKEY_CURRENT_USER, (string(BaseHkey) + "TypedURLs").c_str(), &URLs);

Khi bạn muốn thay đổi các chương trình dòng chảy ( return, breakvà continuecode) trong một chức năng cư xử khác với mã số đó là thực sự inlined trong hàm.

#define ASSERT_RETURN(condition, ret_val) \
if (!(condition)) { \
    assert(false && #condition); \
    return ret_val; }

// should really be in a do { } while(false) but that's another discussion.

Rõ ràng bao gồm bảo vệ

#ifndef MYHEADER_H
#define MYHEADER_H

...

#endif

Bạn không thể thực hiện đoản mạch các đối số gọi hàm bằng cách gọi hàm thông thường. Ví dụ:

#define andm(a, b) (a) && (b)

bool andf(bool a, bool b) { return a && b; }

andm(x, y) // short circuits the operator so if x is false, y would not be evaluated
andf(x, y) // y will always be evaluated

Hãy nói rằng chúng ta sẽ bỏ qua những điều rõ ràng như bảo vệ tiêu đề.

Đôi khi, bạn muốn tạo mã cần được sao chép / dán bởi trình biên dịch trước:

#define RAISE_ERROR_STL(p_strMessage)                                          \
do                                                                             \
{                                                                              \
   try                                                                         \
   {                                                                           \
      std::tstringstream strBuffer ;                                           \
      strBuffer << p_strMessage ;                                              \
      strMessage = strBuffer.str() ;                                           \
      raiseSomeAlert(__FILE__, __FUNCSIG__, __LINE__, strBuffer.str().c_str()) \
   }                                                                           \
   catch(...){}                                                                \
   {                                                                           \
   }                                                                           \
}                                                                              \
while(false)

cho phép bạn viết mã này:

RAISE_ERROR_STL("Hello... The following values " << i << " and " << j << " are wrong") ;

Và có thể tạo tin nhắn như:

Error Raised:
====================================
File : MyFile.cpp, line 225
Function : MyFunction(int, double)
Message : "Hello... The following values 23 and 12 are wrong"

Lưu ý rằng việc trộn các mẫu với macro có thể dẫn đến kết quả thậm chí tốt hơn (nghĩa là tự động tạo các giá trị song song với tên biến của chúng)

Những lần khác, bạn cần __FILE__ và / hoặc __LINE__ của một số mã, để tạo thông tin gỡ lỗi, ví dụ. Sau đây là một tác phẩm kinh điển cho Visual C ++:

#define WRNG_PRIVATE_STR2(z) #z
#define WRNG_PRIVATE_STR1(x) WRNG_PRIVATE_STR2(x)
#define WRNG __FILE__ "("WRNG_PRIVATE_STR1(__LINE__)") : ------------ : "

Như với đoạn mã sau:

#pragma message(WRNG "Hello World")

nó tạo ra các thông điệp như:

C:\my_project\my_cpp_file.cpp (225) : ------------ Hello World

Những lần khác, bạn cần tạo mã bằng cách sử dụng các toán tử ghép nối # và ##, như tạo getters và setters cho một thuộc tính (điều này dành cho các trường hợp khá hạn chế, thông qua).

Những lần khác, bạn sẽ tạo mã hơn là không biên dịch nếu được sử dụng thông qua một hàm, như:

#define MY_TRY      try{
#define MY_CATCH    } catch(...) {
#define MY_END_TRY  }

Mà có thể được sử dụng như

MY_TRY
   doSomethingDangerous() ;
MY_CATCH
   tryToRecoverEvenWithoutMeaningfullInfo() ;
   damnThoseMacros() ;
MY_END_TRY

(tuy nhiên, tôi chỉ thấy loại mã này được sử dụng đúng một lần )

Cuối cùng, nhưng không kém phần quan trọng, nổi tiếng boost::foreach!!!

#include <string>
#include <iostream>
#include <boost/foreach.hpp>

int main()
{
    std::string hello( "Hello, world!" );

    BOOST_FOREACH( char ch, hello )
    {
        std::cout << ch;
    }

    return 0;
}

(Lưu ý: sao chép mã / dán từ trang chủ boost)

Đó là cách (IMHO) tốt hơn std::for_each.

Vì vậy, macro luôn hữu ích vì chúng nằm ngoài các quy tắc biên dịch thông thường. Nhưng tôi thấy rằng hầu hết thời gian tôi nhìn thấy một, chúng vẫn là mã C không bao giờ được dịch thành C ++ thích hợp.

Các khung kiểm tra đơn vị cho C ++ như UnitTest ++ xoay quanh các macro tiền xử lý. Một vài dòng mã kiểm tra đơn vị mở rộng thành một hệ thống phân cấp các lớp hoàn toàn không thú vị để nhập thủ công. Không có thứ gì đó như UnitTest ++ và đó là phép thuật tiền xử lý, tôi không biết bạn sẽ viết các bài kiểm tra đơn vị cho C ++ một cách hiệu quả như thế nào.

Sợ tiền xử lý C cũng giống như sợ bóng đèn sợi đốt chỉ vì chúng ta có bóng đèn huỳnh quang. Có, trước đây có thể là {điện | thời gian lập trình} không hiệu quả. Vâng, bạn có thể bị đốt cháy (theo nghĩa đen) bởi họ. Nhưng họ có thể hoàn thành công việc nếu bạn xử lý đúng cách.

Khi bạn lập trình các hệ thống nhúng, C sử dụng làm trình biên dịch biểu mẫu ngoài tùy chọn duy nhất. Sau khi lập trình trên máy tính để bàn với C ++ và sau đó chuyển sang các mục tiêu được nhúng, nhỏ hơn, bạn học cách ngừng lo lắng về việc Inelegancies. Có rất nhiều tính năng C trần (bao gồm các macro) và chỉ cố gắng tìm ra cách sử dụng tốt nhất và an toàn mà bạn có thể nhận được từ những mục tiêu đó đặc trưng.

Alexander Stepanov nói :

Khi chúng ta lập trình trong C ++, chúng ta không nên xấu hổ về di sản C của nó, nhưng hãy tận dụng nó. Các vấn đề duy nhất với C ++ và thậm chí là các vấn đề duy nhất với C, phát sinh khi bản thân chúng không phù hợp với logic riêng của chúng.

Chúng tôi sử dụng __FILE__và __LINE__macro cho mục đích chẩn đoán trong ném, bắt và ghi nhật ký ngoại lệ giàu thông tin, cùng với máy quét tệp nhật ký tự động trong cơ sở hạ tầng QA của chúng tôi.

Ví dụ, macro ném OUR_OWN_THROWcó thể được sử dụng với các tham số loại và hàm tạo ngoại lệ cho ngoại lệ đó, bao gồm mô tả văn bản. Như thế này:

OUR_OWN_THROW(InvalidOperationException, (L"Uninitialized foo!"));

Macro này tất nhiên sẽ ném InvalidOperationExceptionngoại lệ với mô tả là tham số của hàm tạo, nhưng nó cũng sẽ viết một thông điệp tới tệp nhật ký bao gồm tên tệp và số dòng nơi ném xảy ra và mô tả văn bản của nó. Ngoại lệ ném sẽ nhận được một id, cũng được ghi lại. Nếu ngoại lệ được bắt gặp ở một nơi khác trong mã, nó sẽ được đánh dấu như vậy và tệp nhật ký sẽ chỉ ra rằng ngoại lệ cụ thể đó đã được xử lý và do đó không có khả năng là nguyên nhân của bất kỳ sự cố nào có thể được ghi lại sau này. Các ngoại lệ chưa được xử lý có thể dễ dàng được chọn bởi cơ sở hạ tầng QA tự động của chúng tôi.

Mã lặp lại.

Có một cái nhìn để tăng cường thư viện tiền xử lý , đó là một loại lập trình meta-meta. Trong chủ đề-> động lực bạn có thể tìm thấy một ví dụ tốt.

Một số công cụ rất tiên tiến và hữu ích vẫn có thể được xây dựng bằng cách sử dụng bộ tiền xử lý (macro), mà bạn sẽ không bao giờ có thể thực hiện được bằng cách sử dụng "cấu trúc ngôn ngữ" c ++ bao gồm các mẫu.

Ví dụ:

Tạo một cái gì đó cả định danh C và chuỗi

Cách dễ dàng để sử dụng các biến của loại enum như chuỗi trong C

Tăng cường siêu lập trình tiền xử lý

Thỉnh thoảng tôi sử dụng macro để tôi có thể xác định thông tin ở một nơi, nhưng sử dụng nó theo nhiều cách khác nhau trong các phần khác nhau của mã. Nó chỉ hơi ác :)

Ví dụ: trong "field_list.h":

/*
 * List of fields, names and values.
 */
FIELD(EXAMPLE1, "first example", 10)
FIELD(EXAMPLE2, "second example", 96)
FIELD(ANOTHER, "more stuff", 32)
...
#undef FIELD

Sau đó, đối với một enum công khai, nó có thể được định nghĩa chỉ sử dụng tên:

#define FIELD(name, desc, value) FIELD_ ## name,

typedef field_ {

#include "field_list.h"

    FIELD_MAX

} field_en;

Và trong một hàm init riêng, tất cả các trường có thể được sử dụng để điền vào bảng với dữ liệu:

#define FIELD(name, desc, value) \
    table[FIELD_ ## name].desc = desc; \
    table[FIELD_ ## name].value = value;

#include "field_list.h"

Một cách sử dụng phổ biến là phát hiện môi trường biên dịch, để phát triển đa nền tảng, bạn có thể viết một bộ mã cho linux, giả sử và một bộ khác cho các cửa sổ khi không có thư viện đa nền tảng cho mục đích của bạn.

Vì vậy, trong một ví dụ sơ bộ, một mutex đa nền tảng có thể có

void lock()
{
    #ifdef WIN32
    EnterCriticalSection(...)
    #endif
    #ifdef POSIX
    pthread_mutex_lock(...)
    #endif
}

Đối với các chức năng, chúng rất hữu ích khi bạn muốn bỏ qua loại an toàn. Chẳng hạn như nhiều ví dụ trên và dưới đây để làm ASSERT. Tất nhiên, giống như nhiều tính năng C / C ++ bạn có thể tự bắn vào chân mình, nhưng ngôn ngữ cung cấp cho bạn các công cụ và cho phép bạn quyết định phải làm gì.

Cái gì đó như

void debugAssert(bool val, const char* file, int lineNumber);
#define assert(x) debugAssert(x,__FILE__,__LINE__);

Vì vậy, ví dụ bạn có thể có

assert(n == true);

và lấy tên tệp nguồn và số dòng của vấn đề được in ra nhật ký của bạn nếu n sai.

Nếu bạn sử dụng một cuộc gọi chức năng bình thường như

void assert(bool val);

thay vì macro, tất cả những gì bạn có thể nhận được là số dòng của hàm khẳng định của bạn được in vào nhật ký, sẽ ít hữu ích hơn.

#define ARRAY_SIZE(arr) (sizeof arr / sizeof arr[0])

Không giống như giải pháp mẫu 'ưa thích' được thảo luận trong một luồng hiện tại, bạn có thể sử dụng nó như một biểu thức không đổi:

char src[23];
int dest[ARRAY_SIZE(src)];

Bạn có thể sử dụng #defines để giúp gỡ lỗi và kiểm tra kịch bản đơn vị. Ví dụ: tạo các biến thể ghi nhật ký đặc biệt của các hàm bộ nhớ và tạo một memlog_preinclude.h đặc biệt:

#define malloc memlog_malloc
#define calloc memlog calloc
#define free memlog_free

Biên dịch mã của bạn bằng cách sử dụng:

gcc -Imemlog_preinclude.h ...

Một liên kết trong memlog.o của bạn đến hình ảnh cuối cùng. Bây giờ bạn kiểm soát malloc, v.v., có lẽ cho mục đích ghi nhật ký hoặc để mô phỏng các lỗi phân bổ cho các bài kiểm tra đơn vị.

Khi bạn đưa ra quyết định tại thời điểm biên dịch đối với hành vi cụ thể của Trình biên dịch / HĐH / Phần cứng.

Nó cho phép bạn tạo giao diện của mình thành các tính năng cụ thể của Comppiler / OS / Phần cứng.

#if defined(MY_OS1) && defined(MY_HARDWARE1)
#define   MY_ACTION(a,b,c)      doSothing_OS1HW1(a,b,c);}
#elif define(MY_OS1) && defined(MY_HARDWARE2)
#define   MY_ACTION(a,b,c)      doSomthing_OS1HW2(a,b,c);}
#elif define(MY_SUPER_OS)
          /* On this hardware it is a null operation */
#define   MY_ACTION(a,b,c)
#else
#error  "PLEASE DEFINE MY_ACTION() for this Compiler/OS/HArdware configuration"
#endif

Tôi sử dụng macro để dễ dàng xác định Ngoại lệ:

DEF_EXCEPTION(RessourceNotFound, "Ressource not found")

trong đó DEF_EXCEPTION là

#define DEF_EXCEPTION(A, B) class A : public exception\
  {\
  public:\
    virtual const char* what() const throw()\
    {\
      return B;\
    };\
  }\

Trình biên dịch có thể từ chối yêu cầu của bạn để nội tuyến.

Macro sẽ luôn có vị trí của chúng.

Một cái gì đó tôi thấy hữu ích là #define DEBUG để theo dõi gỡ lỗi - bạn có thể để nó 1 trong khi gỡ lỗi một vấn đề (hoặc thậm chí để lại nó trong toàn bộ chu kỳ phát triển) sau đó tắt nó khi đến lúc xuất xưởng.

Trong công việc cuối cùng của tôi, tôi đã làm việc trên một máy quét virus. Để giúp tôi dễ dàng gỡ lỗi hơn, tôi đã đăng nhập rất nhiều ở mọi nơi, nhưng trong một ứng dụng có nhu cầu cao như vậy, chi phí cho một cuộc gọi chức năng là quá đắt. Vì vậy, tôi đã đưa ra Macro nhỏ này, nó vẫn cho phép tôi kích hoạt tính năng ghi nhật ký gỡ lỗi trên phiên bản phát hành tại trang web của khách hàng, mà không phải trả phí cho chức năng gọi sẽ kiểm tra cờ gỡ lỗi và chỉ quay lại mà không đăng nhập bất cứ thứ gì, hoặc nếu được bật , sẽ thực hiện ghi nhật ký ... Macro được xác định như sau:

#define dbgmsg(_FORMAT, ...)  if((debugmsg_flag  & 0x00000001) || (debugmsg_flag & 0x80000000))     { log_dbgmsg(_FORMAT, __VA_ARGS__);  }

Do VA_ARGS trong các hàm nhật ký, đây là trường hợp tốt cho một macro như thế này.

Trước đó, tôi đã sử dụng macro trong một ứng dụng bảo mật cao cần nói với người dùng rằng họ không có quyền truy cập chính xác và nó sẽ cho họ biết họ cần cờ nào.

(Các) Macro được định nghĩa là:

#define SECURITY_CHECK(lRequiredSecRoles) if(!DoSecurityCheck(lRequiredSecRoles, #lRequiredSecRoles, true)) return
#define SECURITY_CHECK_QUIET(lRequiredSecRoles) (DoSecurityCheck(lRequiredSecRoles, #lRequiredSecRoles, false))

Sau đó, chúng tôi chỉ có thể rắc các kiểm tra lên khắp UI và nó sẽ cho bạn biết vai trò nào được phép thực hiện hành động mà bạn đã cố gắng thực hiện, nếu bạn chưa có vai trò đó. Lý do cho hai trong số họ là trả về một giá trị ở một số nơi và trả về từ một hàm void ở những nơi khác ...

SECURITY_CHECK(ROLE_BUSINESS_INFORMATION_STEWARD | ROLE_WORKER_ADMINISTRATOR);

LRESULT CAddPerson1::OnWizardNext() 
{
   if(m_Role.GetItemData(m_Role.GetCurSel()) == parent->ROLE_EMPLOYEE) {
      SECURITY_CHECK(ROLE_WORKER_ADMINISTRATOR | ROLE_BUSINESS_INFORMATION_STEWARD ) -1;
   } else if(m_Role.GetItemData(m_Role.GetCurSel()) == parent->ROLE_CONTINGENT) {
      SECURITY_CHECK(ROLE_CONTINGENT_WORKER_ADMINISTRATOR | ROLE_BUSINESS_INFORMATION_STEWARD | ROLE_WORKER_ADMINISTRATOR) -1;
   }
...

Dù sao, đó là cách tôi đã sử dụng chúng, và tôi không chắc làm thế nào điều này có thể được trợ giúp với các mẫu ... Ngoài ra, tôi cố gắng tránh chúng, trừ khi THỰC SỰ cần thiết.

Một macro foreach khác. T: loại, c: container, i: lặp

#define foreach(T, c, i) for(T::iterator i=(c).begin(); i!=(c).end(); ++i)
#define foreach_const(T, c, i) for(T::const_iterator i=(c).begin(); i!=(c).end(); ++i)

Cách sử dụng (khái niệm hiển thị, không có thực):

void MultiplyEveryElementInList(std::list<int>& ints, int mul)
{
    foreach(std::list<int>, ints, i)
        (*i) *= mul;
}

int GetSumOfList(const std::list<int>& ints)
{
    int ret = 0;
    foreach_const(std::list<int>, ints, i)
        ret += *i;
    return ret;
}

Triển khai tốt hơn có sẵn: Google "BOOST_FOREACH"

Bài viết hay có sẵn: Tình yêu có điều kiện: FOREACH Redux (Eric Niebler) http://www.artima.com/cppsource/foreach.html

Có thể việc sử dụng macro tuyệt vời là trong sự phát triển độc lập với nền tảng. Hãy suy nghĩ về các trường hợp không nhất quán về loại - với macro, bạn chỉ cần sử dụng các tệp tiêu đề khác nhau - như: --WIN_TYPES.H

typedef ...some struct

--POSIX_TYPES.h

typedef ...some another struct

- chương trình.h

#ifdef WIN32
#define TYPES_H "WINTYPES.H"
#else 
#define TYPES_H "POSIX_TYPES.H"
#endif

#include TYPES_H

Theo tôi, nhiều điều dễ đọc hơn là thực hiện nó theo những cách khác.

Có vẻ VA_ARGS chỉ được đề cập gián tiếp cho đến nay:

Khi viết mã C ++ 03 chung và bạn cần số lượng tham số (chung) thay đổi, bạn có thể sử dụng macro thay vì mẫu.

#define CALL_RETURN_WRAPPER(FnType, FName, ...)          \
  if( FnType theFunction = get_op_from_name(FName) ) {   \
    return theFunction(__VA_ARGS__);                     \
  } else {                                               \
    throw invalid_function_name(FName);                  \
  }                                                      \
/**/

_{Lưu ý: Nói chung, kiểm tra / ném tên cũng có thể được tích hợp vào get_op_from_namechức năng giả thuyết . Đây chỉ là một ví dụ. Có thể có mã chung khác xung quanh lệnh gọi VA_ARGS.}

Khi chúng tôi nhận được các mẫu matrixdic với C ++ 11, chúng tôi có thể giải quyết "đúng" này bằng một mẫu.

Tôi nghĩ thủ thuật này là một cách sử dụng thông minh của bộ tiền xử lý không thể được mô phỏng bằng một hàm:

#define COMMENT COMMENT_SLASH(/)
#define COMMENT_SLASH(s) /##s

#if defined _DEBUG
#define DEBUG_ONLY
#else
#define DEBUG_ONLY COMMENT
#endif

Sau đó, bạn có thể sử dụng nó như thế này:

cout <<"Hello, World!" <<endl;
DEBUG_ONLY cout <<"This is outputed only in debug mode" <<endl;

Bạn cũng có thể xác định một macro RELEASE_ONLY.

Bạn có thể #definehằng số trên dòng lệnh trình biên dịch bằng cách sử dụng -Dhoặc /Dtùy chọn. Điều này thường hữu ích khi biên dịch chéo cùng một phần mềm cho nhiều nền tảng vì bạn có thể kiểm soát tệp tạo tệp của mình những hằng số được xác định cho mỗi nền tảng.