Какие приложения оператора ## препроцессора и ошибки должны быть рассмотрены?

StackOverflow https://stackoverflow.com/questions/216875

Вопрос

Как упоминалось во многих моих предыдущих вопросах, я работаю через K & amp; R и в настоящее время работаю в препроцессоре. Одна из самых интересных вещей & # 8212; что-то, чего я никогда не знал ни по одной из моих предыдущих попыток выучить C & # 8212; является оператором препроцессора ## . По данным K & R:

  

Оператор препроцессора ##   обеспечивает способ объединения фактических   аргументы при расширении макроса. Если   параметр в тексте замены   рядом с ## , параметр   заменен фактическим аргументом,    ## и окружающие пробелы   удаляется, и результат повторно сканируется.   Например, макрос paste   объединяет два аргумента:

     

#dedeine paste (спереди, сзади) спереди ## сзади

     

поэтому 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 рядом с __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 (' ## ') или строковые (' # '), вы должны знать, что вы необходимо использовать дополнительный уровень косвенности для правильной работы во всех случаях.

Если вы этого не сделаете, а элементы, переданные оператору вставки токенов, сами являются макросами, вы получите результаты, которые, вероятно, не соответствуют вашим ожиданиям: 

#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

Вот кое-что, с чем я столкнулся при обновлении до новой версии компилятора:

Ненужное использование оператора вставки токена ( ## ) непереносимо и может генерировать нежелательные пробелы, предупреждения или ошибки.

Если результат операции вставки токена не является допустимым токеном препроцессора, оператор вставки токена не нужен и, возможно, вреден.

Например, можно попытаться построить строковые литералы во время компиляции, используя оператор вставки токена: 

#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 по конкатенации содержит более полезная информация об операторе вставки токена.

Это полезно во всех ситуациях, чтобы не повторяться без необходимости. Ниже приведен пример из исходного кода 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 " (и рискует ошибиться в написании одного из них).

Я использую его в программах на 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

Вы можете использовать вставку токена, когда вам нужно объединить параметры макроса с чем-то еще.

Может использоваться для шаблонов: 

#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;
};

Точно так же вы можете написать шаблон функции для обхода списка.

Я использую его для добавления пользовательских префиксов в переменные, определенные макросами. Так что-то вроде: 

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)

Или, если ваш компилятор не поддерживает function и func : 

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

Вышеуказанные «функции» регистрирует сообщение и показывает, какая именно функция зарегистрировала сообщение.

Мой синтаксис C ++ может быть не совсем правильным.

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top