PrepBro
← Назад к вопросам

Что такое макросы?

1.6 Junior🔥 231 комментариев
#Сборка и инструменты#Язык C++

Комментарии (1)

🐱
claude-haiku-4.5PrepBro AI30 мар. 2026 г.(ред.)

Ответ сгенерирован нейросетью и может содержать ошибки

Макросы в C/C++: препроцессор и метапрограммирование

Макросы — это инструмент препроцессора C/C++, который выполняет текстовую подстановку кода до компиляции. Препроцессор обрабатывает код на этапе препроцессинга, заменяя макросы на их определения, прежде чем компилятор даже посмотрит на исходный код.

Этапы компиляции C++

Исходный код (.cpp)
    ↓
[ПРЕПРОЦЕССОР] ← Обработка макросов #define, #include
    ↓
Предварительно обработанный код
    ↓
[КОМПИЛЯТОР] ← Семантический анализ, типизация
    ↓
Объектный код (.o)
    ↓
[ЛИНКЕР]
    ↓
Используемый файл (a.out, .exe)

Типы макросов

1. Объектные макросы (Object-like macros)

Просто заменяют имя на значение:

#define PI 3.14159
#define MAX_BUFFER_SIZE 4096
#define DEBUG 1

int main() {
    float area = PI * 5 * 5;        // → 3.14159 * 5 * 5
    char buffer[MAX_BUFFER_SIZE];   // → char buffer[4096];
    return 0;
}

Препроцессор буквально заменяет текст:

// ДО препроцессинга
float area = PI * 5 * 5;

// ПОСЛЕ препроцессинга
float area = 3.14159 * 5 * 5;

2. Функциональные макросы (Function-like macros)

Принимают аргументы и выполняют более сложные подстановки:

#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define SQUARE(x) ((x) * (x))

int main() {
    int a = MAX(10, 20);      // → ((10) > (20) ? (10) : (20))
    int b = SQUARE(5);         // → ((5) * (5))
    return 0;
}

Важно: макросы работают на уровне текста, не на уровне типов!

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

int x = MAX(5, 3);              // OK: 5
double y = MAX(5.5, 3.2);       // OK: 5.5
std::string s = MAX("a", "b");  // Компилируется, но может дать неожиданный результат

3. Вариативные макросы (Variadic macros)

Принимают переменное количество аргументов:

#define PRINT(fmt, ...) printf(fmt, __VA_ARGS__)

PRINT("Hello %s\n", "world");       // → printf("Hello %s\n", "world")
PRINT("%d %d %d\n", 1, 2, 3);       // → printf("%d %d %d\n", 1, 2, 3)

Это очень полезно для логирования:

#define LOG(level, fmt, ...) fprintf(stderr, "[%s] " fmt "\n", level, __VA_ARGS__)

LOG("INFO", "User %s logged in", username);
// → fprintf(stderr, "[INFO] User john logged in\n", username);

Специальные макросы

Препроцессор предоставляет встроенные макросы:

#include <iostream>

int main() {
    std::cout << __FILE__ << "\n";           // "main.cpp"
    std::cout << __LINE__ << "\n";           // 5
    std::cout << __FUNCTION__ << "\n";       // "main"
    std::cout << __PRETTY_FUNCTION__ << "\n"; // "int main()"
    std::cout << __DATE__ << "\n";           // "Mar 29 2026"
    std::cout << __TIME__ << "\n";           // "14:23:45"
    return 0;
}

Это очень полезно для логирования и отладки:

#define LOG(msg) std::cout << "[" << __FILE__ << ":" << __LINE__ << "] " << msg << std::endl

LOG("Something happened");
// → std::cout << "[main.cpp:42] Something happened" << std::endl;

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

Макросы используются для условной компиляции:

#ifdef DEBUG
    #define ASSERT(condition) if (!(condition)) throw std::runtime_error(#condition)
#else
    #define ASSERT(condition)  // В Release это ничего не делает
#endif

int divide(int a, int b) {
    ASSERT(b != 0);
    return a / b;
}

// Для компиляции с DEBUG: g++ -DDEBUG main.cpp

Другие директивы препроцессора:

#if defined(WINDOWS)
    #include <windows.h>
#elif defined(LINUX)
    #include <unistd.h>
#else
    #error "Unsupported platform"
#endif

Практические примеры из production кода

1. Защита от дублирования включений

// vector.h
#ifndef VECTOR_H
#define VECTOR_H

template<typename T>
class Vector { /* ... */ };

#endif

// Или современный способ:
#pragma once

2. Логирование

#define LOG_ERROR(fmt, ...) \
    fprintf(stderr, "[ERROR %s:%d] " fmt "\n", __FILE__, __LINE__, __VA_ARGS__)

#define LOG_INFO(fmt, ...) \
    fprintf(stderr, "[INFO %s:%d] " fmt "\n", __FILE__, __LINE__, __VA_ARGS__)

LOG_ERROR("Failed to open file: %s", filename);  // Указывает точное место ошибки

3. Проверки и ассерты

#define LIKELY(x) __builtin_expect((x), 1)      // Подсказка оптимизатору
#define UNLIKELY(x) __builtin_expect((x), 0)

if (LIKELY(result == 0)) {          // Обычный случай
    return success;
} else if (UNLIKELY(result < 0)) {  // Редкий случай
    handle_error();
}

4. Версионирование

#define VERSION_MAJOR 2
#define VERSION_MINOR 1
#define VERSION_PATCH 5

#if VERSION_MAJOR < 2
    #error "This code requires version 2.0 or higher"
#endif

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

1. Проблемы с оборачиванием в скобки

#define SQUARE(x) x * x  // ❌ Плохо!

int a = SQUARE(2 + 3);      // → 2 + 3 * 2 + 3 = 11 (не 25!)
int b = 100 / SQUARE(2);    // → 100 / 2 * 2 = 100 (не 25!)

#define SQUARE(x) ((x) * (x))  // ✅ Правильно
int c = SQUARE(2 + 3);      // → ((2 + 3) * (2 + 3)) = 25

2. Множественное вычисление аргументов

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

int x = 10;
int result = MAX(x++, 20);    // → ((x++) > (20) ? (x++) : (20))
// x может увеличиться 0, 1 или 2 раза! (неопределённое поведение)

// Правильный способ — использовать inline функции:
inline int max(int a, int b) {
    return a > b ? a : b;
}

3. Конфликты имён

#define LENGTH 256

class MyClass {
public:
    int getLength() { return 100; }  // ❌ Конфликт! LENGTH заменит getLength
};

// Решение: используй namespace
#define MY_PREFIX_LENGTH 256

4. Отладка

Макросы усложняют отладку:

#define ADD(a, b) ((a) + (b))

int x = ADD(5, 10);  // Отладчик не покажет, что это результат макроса

Современные альтернативы макросам

Вместо объектных макросов — используй const переменные

// ❌ Старый способ
#define PI 3.14159

// ✅ Современный способ
constexpr double PI = 3.14159;

Вместо функциональных макросов — используй inline функции

// ❌ Старый способ
#define MAX(a, b) ((a) > (b) ? (a) : (b))

// ✅ Современный способ (C++17)
template<typename T>
constexpr T max(T a, T b) {
    return a > b ? a : b;
}

Для метапрограммирования — используй templates

// ❌ Макросы
#define FOR_EACH(container, item) for (auto& item : container)

// ✅ Современный подход
template<typename Container, typename Func>
void for_each(Container& c, Func f) {
    for (auto& item : c) f(item);
}

Когда всё ещё нужны макросы?

  1. Защита от дублирования — #ifndef HEADER_H
  2. Условная компиляция — #ifdef DEBUG, #ifdef WINDOWS
  3. Логирование с информацией о месте — __FILE__, __LINE__
  4. Высокопроизводительный код — когда нужна compile-time оптимизация
  5. Старый код — когда нельзя менять API

Итог

Макросы — это мощный, но опасный инструмент. Современный C++ старается минимизировать их использование в пользу:

  • constexpr для вычислений
  • inline функции для оптимизации
  • templates для метапрограммирования
  • enum class для констант

Для backend разработчика важно понимать, как работают макросы и их опасности, но избегать их использования в новом коде, предпочитая современные альтернативы.

Что такое макросы? | PrepBro