Как заменить этот макрос препроцессора на #include?

Это требует шаблона.

class Example<class T>
{
    ...class definition...
};

Прямой ответ на последнюю часть вашего вопроса - «учитывая, что я больше не участвую в макроопределении, как заставить работать операторы вставки и преобразования строк» ​​- это «Вы не можете». Эти операторы работают только в макросах, поэтому вам придется писать вызовы макросов, чтобы заставить их работать.

Добавлен:

@mackenir сказал, что "шаблоны не подходят". Почему шаблоны не подходят? Код имитирует шаблоны старомодным предварительным стандартом, предварительно шаблонным способом, и это вызывает много боли и горя. Использование шаблонов позволит избежать этой боли - хотя потребуется операция преобразования.

@mackenir спросил: "Есть ли способ заставить все работать с макросами?" Да, можно, но вам следует использовать шаблоны - они более надежны и удобны в обслуживании. Чтобы он работал с макросами, вам нужно, чтобы имена функций в коде во включенном заголовке были вызовами макросов. Чтобы это работало правильно, вам нужно пройти определенный уровень косвенного обращения:

#define PASTE_NAME(x, y) PASTE_TOKENS(x, y)
#define PASTE_TOKENS(x, y) x ## y

#define TYPE_NAME Example
int PASTE_NAME(TYPE_NAME, _function_suffix)(void) { ... }

Этот уровень косвенного обращения часто является необходимой идиомой как для токенизирующих, так и для строковых операторов.

Дополнительные комментарии от @mackenir указывают на продолжающиеся проблемы. Давайте конкретизируем.

At the moment I am using a macro to define a bunch of fields and methods on various classes, like this:

class Example
{
    // Use FIELDS_AND_METHODS macro to define some methods and fields
    FIELDS_AND_METHODS(Example)
};

FIELDS_AND_METHODS is a multi-line macro that uses stringizing and token-pasting operators.

I would like to replace this with the following kind of thing

class Example
{
    // Include FieldsNMethods.h, with TYPE_NAME preprocessor symbol
    // defined, to achieve the same result as the macro.
    #define TYPE_NAME Example
    #include "FieldsNMethods.h"
};

В ПОРЯДКЕ. Чтобы сделать это конкретным, нам нужен макрос FIELDS_AND_METHODS(type), который является многострочным и использует вставку токенов (я не собираюсь заниматься структурированием - тем не менее, будут применяться те же базовые механизмы).

#define FIELDS_AND_METHODS(type) \
    type *next; \
    type() : next(0) { } \
    type * type ## _next() { return next; }

Если повезет, он объявляет член типа «указатель на тип аргумента», конструктор для этого типа и метод (в данном случае Example_next), который возвращает этот указатель.

Итак, это может быть макрос - и нам нужно заменить его таким образом, чтобы '#include' выполнял аналогичную работу.

Содержимое fieldsNmethods.h становится следующим:

#ifndef TYPE_NAME
#error TYPE_NAME not defined
#endif
#define FNM_PASTE_NAME(x, y)    FNM_PASTE_TOKENS(x, y)
#define FNM_PASTE_TOKENS(x, y)  x ## y

TYPE_NAME *next;
TYPE_NAME() : next(0) { }
TYPE_NAME * FNM_PASTE_NAME(TYPE_NAME, _next)() { return next; }

#undef FNM_PASTE_NAME
#undef FNM_PASTE_TOKENS

Обратите внимание, что заголовок не будет содержать защиты множественного включения; его смысл в том, чтобы позволить включать его несколько раз. Он также отменяет определение своих вспомогательных макросов, чтобы разрешить множественное включение (ну, поскольку переопределения будут идентичными, они «мягкие» и не вызовут ошибки), и я добавил к ним префикс FNM_ в качестве примитивного элемента управления пространством имен для макросов. Это генерирует код, который я ожидал от препроцессора C. а G ++ не светится, а создает пустой объектный файл (потому что объявленные типы не используются в моем примере кода).

Обратите внимание, что для этого не требуется никаких изменений в вызывающем коде, кроме указанного в вопросе. Я думаю, что вопрос следует улучшить, используя принцип SPOT "Single Point of Truth" (или DRY "Don't Repeat Yourself"):

#define TYPE_NAME Example
class TYPE_NAME
{
    // Include FieldsNMethods.h, with TYPE_NAME preprocessor symbol
    // defined, to achieve the same result as the macro.
    #include "FieldsNMethods.h"
};

Нет, вы не можете определять определения классов или функций на лету. Они должны быть указаны либо путем непосредственного ввода, либо путем определения в препроцессоре.

Как правило, нет необходимости создавать подобные классы, и определения классов создаются перед компиляцией, будь то путем ввода всего текста или с помощью какой-либо генерации кода. Иногда существует отдельный этап генерации кода (например, в текущей Visual Studio вы можете определить этапы предварительной и последующей обработки).

Теперь, если вам нужно создать разные версии некоторых классов для разных типов данных, вы должны использовать шаблоны. Таким образом нельзя создавать штампы классов с разными именами.

Последний вопрос: зачем вы это делаете? Я никогда не был в ситуации, когда что-то подобное выглядело бы полезным в C++, и на языках, где это имеет смысл, есть средства для этого.

Вы должны обернуть строку другим макросом (2 необходимы из-за того, как работает препроцессор)

В FieldsNMethods.h

#define MAKE_STR_X( _v ) # _v
#define MAKE_STR( _v ) MAKE_STR_X( _v )

char *method() { return MAKE_STR( TYPE_NAME ); }

Вам нужно добавить дополнительный слой макросов:

#define STRINGIZE(x) STRINGIZE2(x)
#define STRINGIZE2(x) #x

#define TOKENPASTE(x, y) TOKENPASTE2(x, y)
#define TOKENPASTE2(x, y) x ## y

Причина в том, что когда у вас есть макрос, препроцессор обычно рекурсивно расширяет аргументы перед выполнением подстановки макроса. Однако, если какой-либо аргумент используется с оператором строкового преобразования # или оператором вставки токена ##, он расширяется нет. Следовательно, вам нужен дополнительный уровень макросов, где первый уровень расширяет аргументы, а второй уровень выполняет преобразование в строку или вставку токена.

Если аргументы необходимо расширить несколько раз (например, #define A B, #define B C, #define C D, STRINGIZE(A)), вам необходимо добавить еще столько слоев, прежде чем применять операторы # или ##.