Как работает макрос на этапе препроцессинга?

Ответ: Макросы - текстовые подстановки на этапе препроцессинга

Макросы обрабатываются препроцессором (до компиляции) и выполняют простую текстовую замену. Это одна из самых мощных и опасных возможностей C++.

Основные типы макросов

1. Простые замены (define без параметров)

#define MAX 100
#define PI 3.14159
#define ASSERT(x) ((void)0)

int main() {
    int arr[MAX];  // Заменяется на: int arr[100];
    double circle_area = PI * r * r;  // Заменяется на: double circle_area = 3.14159 * r * r;
}

Препроцессор видит исходный код и замещает все вхождения MAX на 100.

2. Макросы-функции (Function-like macros)

#define ADD(a, b) ((a) + (b))
#define SQ(x) ((x) * (x))
#define DOUBLE(x) (x) + (x)

int main() {
    int result = ADD(2, 3);  // Заменяется на: int result = ((2) + (3));
    int sq = SQ(5);          // Заменяется на: int sq = ((5) * (5));
    
    // ❌ Опасно!
    int bad = DOUBLE(2 + 3); // Заменяется на: int bad = (2 + 3) + (2 + 3) = 10
                             // А не 2*(2+3) = 10! В этом случае совпало
}

Процесс замены

#define MULTIPLY(a, b) a * b

int result = MULTIPLY(2 + 3, 4 + 5);

// ❌ Что выполнится:
// int result = 2 + 3 * 4 + 5;  // 2 + 12 + 5 = 19
// Порядок операций неправильный!

// ✅ Правильный макрос:
#define MULTIPLY(a, b) ((a) * (b))
int result = MULTIPLY(2 + 3, 4 + 5);
// Заменяется на: int result = ((2 + 3) * (4 + 5)) = 45

Видимость макросов

// file1.cpp
#define VERSION 1

int version = VERSION;  // OK, 1

// file2.cpp
int another_version = VERSION;  // ❌ ERROR: VERSION не определён

// Макросы не имеют области видимости как переменные!
// Нужно переопределять в каждом файле

Условная компиляция

#define DEBUG 1

int main() {
#if DEBUG
    std::cout << "Debug mode" << std::endl;  // Включится
#else
    std::cout << "Release mode" << std::endl;
#endif

#ifdef DEBUG
    // Этот блок скомпилируется
#endif

#ifndef NDEBUG
    assert(condition);  // Debug версия
#endif
}

// При компиляции с -DDEBUG=0 строка Debug mode исчезнет!

Макросы со строками

#define STRINGIFY(x) #x
#define CONCAT(a, b) a ## b

const char* str = STRINGIFY(hello);  // Заменяется на: "hello"
int CONCAT(var, 1) = 10;              // Заменяется на: int var1 = 10;

Опасности макросов

Проблема 1: Отсутствие type safety

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int x = MAX(5, 10);              // OK, 10
double y = MAX(1.5, 2.5);        // OK, 2.5
struct MyStruct s1, s2;
struct MyStruct s = MAX(s1, s2);  // ❌ ERROR на этапе компиляции
                                   // Оператор > не определён для struct

// Лучше: шаблонная функция
template<typename T>
const T& max(const T& a, const T& b) {
    return a > b ? a : b;
}

Проблема 2: Множественное вычисление

#define DOUBLE(x) ((x) + (x))

int i = 0;
int result = DOUBLE(i++);  // i++ вычисляется ДВАЖДЫ!
                           // i становится 2!
                           // result = 0 + 1 = 1

int j = 0;
int result2 = 2 * (j++);   // j++ вычисляется один раз
                           // j становится 1
                           // result2 = 2 * 0 = 0

Проблема 3: Глобальное загрязнение пространства имён

#define COUNT 5

namespace mylib {
    int get_count() { return COUNT; }  // Использует глобальный COUNT
    // Нет COUNT в mylib::COUNT
}

// Где-то в другом файле
#define COUNT 10  // Переопределяем!

mylib::get_count();  // Может вернуть 10 вместо 5!

Примеры из STL

// std::max - это МАКРОС в Windows!
#ifdef _MSC_VER
    #define max(a, b) ((a) > (b) ? (a) : (b))
#endif

// Это ломает std::max!
std::vector<int> v;
auto it = std::max_element(v.begin(), v.end());  // ❌ Конфликт!

// Решение: отключить макрос
#undef max
#undef min

Хорошие практики с макросами

1. Используй ALL_CAPS для макросов

#define MAX_SIZE 100      // ✅ Ясно, что это макрос
#define BUFFER_SIZE 256

int max_size = 100;  // ❌ Путаница с макросом
int MAX_VAR = 50;    // ❌ Выглядит как макрос, но переменная

2. Всегда оборачивай параметры в скобки

#define BAD_ADD(a, b) a + b          // ❌
#define GOOD_ADD(a, b) ((a) + (b))   // ✅

int result = BAD_ADD(2 * 3, 4);      // 2 * 3 + 4 = 10 (неправильно)
int result = GOOD_ADD(2 * 3, 4);     // (2 * 3) + (4) = 10 (правильно)

3. Используй do-while для многострочных макросов

#define LOG(msg) do { \
    std::cout << "[LOG] " << msg << std::endl; \
} while(0)

#define LOG_BAD(msg) { \
    std::cout << "[LOG] " << msg << std::endl; \
}

// Проблема LOG_BAD в if-else
if (condition)
    LOG_BAD("message");  // Точка с запятой после }
else
    LOG("other");        // ❌ Синтаксическая ошибка

// С do-while работает правильно
if (condition)
    LOG("message");
else
    LOG("other");        // ✅ OK

4. Используй constexpr и inline вместо макросов

// ❌ Макрос
#define FACTORIAL(n) (n <= 1 ? 1 : n * FACTORIAL(n - 1))

// ✅ constexpr (C++11)
constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

// Преимущества:
// - Type safe
// - Можно отладить
// - Имеет область видимости
// - Работает на compile-time

Инструменты для debug макросов

# Раскрыть препроцессор
g++ -E program.cpp | less

# Увидеть результат препроцессинга
g++ -E -dM program.cpp  # Все определённые макросы

Современный C++: альтернативы

// Вместо макросов используй:

// 1. constexpr для констант
constexpr int MAX_SIZE = 100;  // Вместо #define MAX_SIZE 100

// 2. Шаблонные функции
template<typename T>
T max(T a, T b) { return a > b ? a : b; }  // Вместо #define MAX

// 3. enum class
enum class Color { RED, GREEN, BLUE };  // Вместо #define RED 0

// 4. static const в классах
class Configuration {
public:
    static constexpr int DEFAULT_SIZE = 100;
};

// 5. constexpr if (C++17)
if constexpr (sizeof(int) == 4) {
    // Вместо #ifdef
}

Итог

✅ Препроцессор работает до компилятора ✅ Текстовая замена - простая, но опасная ✅ Всегда оборачивай параметры в скобки ✅ Используй ALL_CAPS для имён макросов ✅ Избегай макросов где возможно (используй constexpr, шаблоны) ⚠️ Отсутствие type safety - главная проблема ⚠️ Множественное вычисление - побочные эффекты