แอปพลิเคชันของตัวดำเนินการประมวลผล ## preprocessor และ gotchas ที่ต้องพิจารณามีอะไรบ้าง?

ดังที่ได้กล่าวไว้ในคำถามก่อนหน้านี้หลายข้อฉันกำลังทำงานผ่าน K&R และกำลังอยู่ในพรีโปรเซสเซอร์ สิ่งที่น่าสนใจอีกอย่างหนึ่ง - สิ่งที่ฉันไม่เคยรู้มาก่อนจากการพยายามเรียนรู้ C - ก่อนหน้านี้คือ##ตัวดำเนินการก่อนโปรเซสเซอร์ ตาม K&R:

ตัวดำเนินการตัวประมวลผลก่อน## จัดเตรียมวิธีการต่ออาร์กิวเมนต์ที่แท้จริงระหว่างการขยายมาโคร หากพารามิเตอร์ในข้อความแทนที่อยู่ติดกับ a ##พารามิเตอร์จะถูกแทนที่ด้วยอาร์กิวเมนต์จริง ##และช่องว่างรอบ ๆ จะถูกลบออกและผลลัพธ์จะถูกสแกนใหม่ ตัวอย่างเช่นแมโครpaste เชื่อมสองอาร์กิวเมนต์:

#define paste(front, back) front ## back

เพื่อสร้างโทเค็นpaste(name, 1) name1

ทำไมคนถึงใช้สิ่งนี้ในโลกแห่งความเป็นจริง ตัวอย่างการใช้งานจริงมีอะไรบ้างและมีข้อควรพิจารณาหรือไม่?

CrashRpt: การใช้ ## เพื่อแปลงสตริงมาโครหลายไบต์เป็น Unicode

การใช้งานที่น่าสนใจใน CrashRpt (ไลบรารีการรายงานข้อขัดข้อง) มีดังต่อไปนี้:

#define WIDEN2(x) L ## x
#define WIDEN(x) WIDEN2(x)
//Note you need a WIDEN2 so that __DATE__ will evaluate first.

ที่นี่พวกเขาต้องการใช้สตริงสองไบต์แทนสตริงหนึ่งไบต์ต่อถ่าน นี่อาจดูเหมือนว่าไม่มีจุดหมายจริงๆ แต่พวกเขาทำด้วยเหตุผลที่ดี

 std::wstring BuildDate = std::wstring(WIDEN(__DATE__)) + L" " + WIDEN(__TIME__);

ใช้กับมาโครอื่นที่ส่งคืนสตริงพร้อมวันที่และเวลา

การวางไว้Lข้าง a __ DATE __จะทำให้คุณมีข้อผิดพลาดในการคอมไพล์

Windows: การใช้ ## สำหรับสตริง Unicode ทั่วไปหรือหลายไบต์

Windows ใช้สิ่งต่อไปนี้:

#ifdef  _UNICODE
    #define _T(x)      L ## x
#else
    #define _T(x) x
#endif

และ_Tใช้ทุกที่ในรหัส

ไลบรารีต่างๆที่ใช้สำหรับชื่อตัวเข้าถึงและตัวปรับแต่งที่สะอาด:

ฉันเคยเห็นมันใช้ในรหัสเพื่อกำหนดตัวเข้าถึงและตัวปรับแต่ง:

#define MYLIB_ACCESSOR(name) (Get##name)
#define MYLIB_MODIFIER(name) (Set##name)

ในทำนองเดียวกันคุณสามารถใช้วิธีเดียวกันนี้สำหรับการสร้างชื่อที่ชาญฉลาดประเภทอื่น ๆ

ไลบรารีต่างๆโดยใช้เพื่อทำการประกาศตัวแปรหลายตัวพร้อมกัน:

#define CREATE_3_VARS(name) name##1, name##2, name##3
int CREATE_3_VARS(myInts);
myInts1 = 13;
myInts2 = 19;
myInts3 = 77;

สิ่งหนึ่งที่ควรระวังเมื่อคุณใช้ตัวดำเนินการก่อนการประมวลผลtoken-paste (' ##') หรือ stringizing (' #') คือคุณต้องใช้อินดิเรเตอร์ในระดับพิเศษเพื่อให้ทำงานได้อย่างถูกต้องในทุกกรณี

หากคุณไม่ทำเช่นนี้และรายการที่ส่งไปยังตัวดำเนินการวางโทเค็นเป็นมาโครเองคุณจะได้ผลลัพธ์ที่อาจไม่ใช่สิ่งที่คุณต้องการ:

#include <stdio.h>

#define STRINGIFY2( x) #x
#define STRINGIFY(x) STRINGIFY2(x)
#define PASTE2( a, b) a##b
#define PASTE( a, b) PASTE2( a, b)

#define BAD_PASTE(x,y) x##y
#define BAD_STRINGIFY(x) #x

#define SOME_MACRO function_name

int main() 
{
    printf( "buggy results:\n");
    printf( "%s\n", STRINGIFY( BAD_PASTE( SOME_MACRO, __LINE__)));
    printf( "%s\n", BAD_STRINGIFY( BAD_PASTE( SOME_MACRO, __LINE__)));
    printf( "%s\n", BAD_STRINGIFY( PASTE( SOME_MACRO, __LINE__)));

    printf( "\n" "desired result:\n");
    printf( "%s\n", STRINGIFY( PASTE( SOME_MACRO, __LINE__)));
}

ผลลัพธ์:

buggy results:
SOME_MACRO__LINE__
BAD_PASTE( SOME_MACRO, __LINE__)
PASTE( SOME_MACRO, __LINE__)

desired result:
function_name21

นี่คือ gotcha ที่ฉันพบเมื่ออัปเกรดเป็นคอมไพเลอร์เวอร์ชันใหม่:

การใช้ตัวดำเนินการวางโทเค็นโดยไม่จำเป็น ( ##) ไม่สามารถพกพาได้และอาจทำให้เกิดช่องว่างคำเตือนหรือข้อผิดพลาดที่ไม่ต้องการ

เมื่อผลลัพธ์ของตัวดำเนินการวางโทเค็นไม่ใช่โทเค็นตัวประมวลผลล่วงหน้าที่ถูกต้องตัวดำเนินการวางโทเค็นก็ไม่จำเป็นและอาจเป็นอันตรายได้

ตัวอย่างเช่นอาจพยายามสร้างตัวอักษรสตริงในเวลาคอมไพล์โดยใช้ตัวดำเนินการวางโทเค็น:

#define STRINGIFY(x) #x
#define PLUS(a, b) STRINGIFY(a##+##b)
#define NS(a, b) STRINGIFY(a##::##b)
printf("%s %s\n", PLUS(1,2), NS(std,vector));

ในคอมไพเลอร์บางตัวสิ่งนี้จะให้ผลลัพธ์ที่คาดหวัง:

1+2 std::vector

ในคอมไพเลอร์อื่น ๆ จะรวมถึงช่องว่างที่ไม่ต้องการ:

1 + 2 std :: vector

GCC เวอร์ชันที่ทันสมัยพอสมควร (> = 3.3 หรือมากกว่านั้น) จะไม่สามารถรวบรวมรหัสนี้ได้:

foo.cpp:16:1: pasting "1" and "+" does not give a valid preprocessing token
foo.cpp:16:1: pasting "+" and "2" does not give a valid preprocessing token
foo.cpp:16:1: pasting "std" and "::" does not give a valid preprocessing token
foo.cpp:16:1: pasting "::" and "vector" does not give a valid preprocessing token

วิธีแก้ปัญหาคือการละเว้นตัวดำเนินการวางโทเค็นเมื่อเชื่อมต่อโทเค็นตัวประมวลผลล่วงหน้ากับตัวดำเนินการ C / C ++

#define STRINGIFY(x) #x
#define PLUS(a, b) STRINGIFY(a+b)
#define NS(a, b) STRINGIFY(a::b)
printf("%s %s\n", PLUS(1,2), NS(std,vector));

เอกสารบท GCC CPP ในการเรียงต่อกันมีข้อมูลที่เป็นประโยชน์เพิ่มเติมเกี่ยวกับผู้ประกอบการ token-วาง

สิ่งนี้มีประโยชน์ในทุกสถานการณ์เพื่อไม่ให้ตัวเองทำซ้ำโดยไม่จำเป็น ต่อไปนี้เป็นตัวอย่างจากซอร์สโค้ด Emacs เราต้องการโหลดฟังก์ชันจำนวนหนึ่งจากไลบรารี ควรกำหนดฟังก์ชัน "foo" ให้fn_fooและอื่น ๆ เรากำหนดมาโครต่อไปนี้:

#define LOAD_IMGLIB_FN(lib,func) {                                      \
    fn_##func = (void *) GetProcAddress (lib, #func);                   \
    if (!fn_##func) return 0;                                           \
  }

จากนั้นเราสามารถใช้:

LOAD_IMGLIB_FN (library, XpmFreeAttributes);
LOAD_IMGLIB_FN (library, XpmCreateImageFromBuffer);
LOAD_IMGLIB_FN (library, XpmReadFileToImage);
LOAD_IMGLIB_FN (library, XImageFree);

ข้อดีคือไม่ต้องเขียนทั้งสองอย่างfn_XpmFreeAttributesและ"XpmFreeAttributes"(และเสี่ยงต่อการสะกดผิดอย่างใดอย่างหนึ่ง)

คำถามก่อนหน้านี้ใน Stack Overflow ถามถึงวิธีการที่ราบรื่นในการสร้างการแทนค่าสตริงสำหรับค่าคงที่การนับโดยไม่ต้องพิมพ์ซ้ำบ่อยมาก

ลิงค์

คำตอบของฉันสำหรับคำถามนั้นแสดงให้เห็นว่าการใช้เวทมนตร์ก่อนตัวประมวลผลเล็กน้อยช่วยให้คุณสามารถกำหนดการแจงนับของคุณเช่นนี้ได้อย่างไร (ตัวอย่าง) ... ;

ENUM_BEGIN( Color )
  ENUM(RED),
  ENUM(GREEN),
  ENUM(BLUE)
ENUM_END( Color )

... ด้วยประโยชน์ที่การขยายมาโครไม่เพียง แต่กำหนดการแจงนับ (ในไฟล์. h) เท่านั้น แต่ยังกำหนดอาร์เรย์ของสตริงที่ตรงกัน (ในไฟล์. c)

const char *ColorStringTable[] =
{
  "RED",
  "GREEN",
  "BLUE"
};

ชื่อของตารางสตริงมาจากการวางพารามิเตอร์มาโคร (เช่นสี) ไปยัง StringTable โดยใช้ตัวดำเนินการ ## แอปพลิเคชั่น (เทคนิค?) เช่นนี้คือสิ่งที่ตัวดำเนินการ # และ ## เป็นสิ่งล้ำค่า

คุณสามารถใช้การวางโทเค็นเมื่อคุณต้องการเชื่อมต่อพารามิเตอร์มาโครกับอย่างอื่น

สามารถใช้สำหรับเทมเพลต:

#define LINKED_LIST(A) struct list##_##A {\
A value; \
struct list##_##A *next; \
};

ในกรณีนี้ LINKED_LIST (int) จะให้คุณ

struct list_int {
int value;
struct list_int *next;
};

ในทำนองเดียวกันคุณสามารถเขียนเทมเพลตฟังก์ชันสำหรับการส่งผ่านรายการได้

ฉันใช้มันในโปรแกรม C เพื่อช่วยบังคับใช้ต้นแบบอย่างถูกต้องสำหรับชุดวิธีการที่ต้องเป็นไปตามแบบแผนการเรียกบางประเภท ในทางหนึ่งสิ่งนี้สามารถใช้สำหรับการวางแนววัตถุของคนยากจนในแนวตรง C:

SCREEN_HANDLER( activeCall )

ขยายเป็นดังนี้:

STATUS activeCall_constructor( HANDLE *pInst )
STATUS activeCall_eventHandler( HANDLE *pInst, TOKEN *pEvent );
STATUS activeCall_destructor( HANDLE *pInst );

สิ่งนี้บังคับใช้การกำหนดพารามิเตอร์ที่ถูกต้องสำหรับอ็อบเจ็กต์ "ที่ได้รับ" ทั้งหมดเมื่อคุณทำ:

SCREEN_HANDLER( activeCall )
SCREEN_HANDLER( ringingCall )
SCREEN_HANDLER( heldCall )

ข้างต้นในไฟล์ส่วนหัวของคุณ ฯลฯ นอกจากนี้ยังมีประโยชน์สำหรับการบำรุงรักษาหากคุณต้องการเปลี่ยนคำจำกัดความและ / หรือเพิ่มวิธีการให้กับ "วัตถุ"

SGlibใช้ ## เพื่อฟัดจ์เทมเพลตใน C. เนื่องจากไม่มีฟังก์ชันโอเวอร์โหลด ## จึงใช้เพื่อติดชื่อประเภทลงในชื่อของฟังก์ชันที่สร้างขึ้น ถ้าฉันมีประเภทรายการที่เรียกว่า list_t ฉันจะได้รับฟังก์ชั่นที่มีชื่อว่า sglib_list_t_concat และอื่น ๆ

ฉันใช้มันสำหรับการยืนยันที่บ้านในคอมไพเลอร์ C ที่ไม่ได้มาตรฐานสำหรับฝังตัว:

#define ASSERT(exp) if(!(exp)){ \
                      print_to_rs232("Assert failed: " ## #exp );\
                      while(1){} //Let the watchdog kill us 

ฉันใช้เพื่อเพิ่มคำนำหน้าแบบกำหนดเองให้กับตัวแปรที่กำหนดโดยมาโคร สิ่งที่ชอบ:

UNITTEST(test_name)

ขยายเป็น:

void __testframework_test_name ()

การใช้งานหลักคือเมื่อคุณมีหลักการตั้งชื่อและคุณต้องการให้มาโครของคุณใช้ประโยชน์จากหลักการตั้งชื่อนั้น บางทีคุณอาจมีวิธีการหลายตระกูล: image_create (), image_activate () และ image_release () รวมถึง file_create (), file_activate (), file_release () และ mobile_create (), mobile_activate () และ mobile_release ()

คุณสามารถเขียนมาโครสำหรับจัดการวงจรชีวิตของวัตถุ:

#define LIFECYCLE(name, func) (struct name x = name##_create(); name##_activate(x); func(x); name##_release())

แน่นอนว่า "รุ่นที่น้อยที่สุดของออบเจ็กต์" ไม่ใช่รูปแบบเดียวของการตั้งชื่อที่ใช้กับหลักการตั้งชื่อส่วนใหญ่เกือบทั้งหมดใช้สตริงย่อยทั่วไปเพื่อสร้างชื่อ ชื่อฟังก์ชัน (ตามด้านบน) หรือชื่อฟิลด์ชื่อตัวแปรหรือสิ่งอื่น ๆ ส่วนใหญ่ให้ฉันได้

การใช้งานที่สำคัญอย่างหนึ่งใน WinCE:

#define BITFMASK(bit_position) (((1U << (bit_position ## _WIDTH)) - 1) << (bit_position ## _LEFTSHIFT))

ในขณะที่กำหนดคำอธิบายบิตรีจิสเตอร์เราทำดังต่อไปนี้:

#define ADDR_LEFTSHIFT                          0

#define ADDR_WIDTH                              7

และในขณะที่ใช้ BITFMASK เพียงใช้:

BITFMASK(ADDR)

มีประโยชน์มากสำหรับการตัดไม้ คุณทำได้:

#define LOG(msg) log_msg(__function__, ## msg)

หรือถ้าคอมไพเลอร์ของคุณไม่รองรับฟังก์ชันและfunc :

#define LOG(msg) log_msg(__file__, __line__, ## msg)

ข้อความ "ฟังก์ชัน" ข้างต้นจะบันทึกข้อความและแสดงว่าฟังก์ชันใดบันทึกข้อความ

ไวยากรณ์ C ++ ของฉันอาจไม่ถูกต้องนัก