Что такое распад массива в указатель (array-to-pointer decay) в C++?

Что такое распад массива в указатель (array decay) в C++?

Вы столкнулись с одним из фундаментальных механизмов C/C++ — неявным преобразованием массива в указатель на его первый элемент. Это и называется "распадом" (decay) или "затуханием" массива. Когда вы используете имя массива в большинстве контекстов (кроме операторов sizeof, & и инициализации ссылок на массив), оно автоматически преобразуется в указатель на первый элемент.

Почему это происходит?

Исторически C (и C++ в наследство) был разработан для эффективной работы с памятью. Массив — это просто последовательность элементов в памяти. Когда вы передаете массив в функцию, копировать весь массив было бы дорого и неэффективно. Вместо этого передается только адрес первого элемента — указатель. Это экономит время и память, но приводит к потере информации о размере.

Разбор вашего примера

int numbers[5] = {1, 2, 3, 4, 5};

• numbers — это массив из 5 целых чисел. sizeof(numbers) возвращает 5 * sizeof(int) = 5 * 4 = 20 байт.
• Когда вы пишете printSize(numbers), массив numbers распадается в указатель на int (int*).
• В объявлении функции void printSize(int arr[]) параметр arr на самом деле является указателем. Синтаксис int arr[] — это просто синтаксический сахар, компилятор видит int* arr.
• sizeof(arr) внутри функции возвращает размер указателя: 8 байт на 64-битной системе, 4 байта на 32-битной.

Другие случаи распада

Распад происходит не только при передаче в функцию. Вот несколько примеров:

int arr[3] = {10, 20, 30};
int* ptr = arr;  // arr распадается в указатель, ptr указывает на arr[0]

// Арифметика указателей:
arr[1] == *(arr + 1); // arr распадается, затем сдвигается

// Присваивание указателю:
int* p = arr; // распад

// Исключение — оператор &:
int (*arr_ptr)[3] = &arr; // &arr НЕ вызывает распад, это указатель на весь массив

Как правильно передавать массивы, сохраняя размер?

Есть несколько способов:

1. Передавать размер отдельным параметром — классический C-стиль:

void printArray(int* arr, int size) {
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
}

int main() {
    int numbers[5] = {1, 2, 3, 4, 5};
    printArray(numbers, 5); // numbers распадается, но размер передаем явно
    return 0;
}

2. Использовать ссылку на массив — распад не происходит:

void printArray(int (&arr)[5]) { // ссылка на массив из 5 элементов
    std::cout << "Размер: " << sizeof(arr) << " байт" << std::endl; // 20
    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " ";
    }
}

int main() {
    int numbers[5] = {1, 2, 3, 4, 5};
    printArray(numbers); // нет распада, numbers передается по ссылке
    return 0;
}

Недостаток: размер фиксирован в сигнатуре функции. Для разных размеров нужен шаблон:

template<size_t N>
void printArray(int (&arr)[N]) {
    std::cout << "Размер: " << N << std::endl;
    for (size_t i = 0; i < N; ++i) {
        std::cout << arr[i] << " ";
    }
}

3. Использовать std::array или std::vector — современный C++:

#include <array>
#include <vector>

void printArray(const std::array<int, 5>& arr) {
    std::cout << "Размер: " << arr.size() << std::endl;
}

void printVector(const std::vector<int>& vec) {
    std::cout << "Размер: " << vec.size() << std::endl;
}

int main() {
    std::array<int, 5> arr = {1, 2, 3, 4, 5};
    std::vector<int> vec = {1, 2, 3, 4, 5};
    printArray(arr);
    printVector(vec);
    return 0;
}

Итог

Распад массива в указатель — это особенность языка, которая повышает производительность, но требует от программиста внимательности. Запомните три вещи:

• Имя массива — это не указатель, но оно превращается в указатель в большинстве контекстов.
• sizeof на массиве работает только в той области видимости, где массив определен.
• Для безопасной работы используйте std::array, std::vector или передавайте размер отдельно.

int arr[5];
int* p1 = arr;      // OK, arr -> int*
int (*p2)[5] = &arr; // OK, &arr -> указатель на массив из 5 int
// int* p3 = &arr;   // Ошибка компиляции! Несоответствие типов

const char* str = "Hello"; // "Hello" распадается в указатель на 'H'
// sizeof("Hello") == 6 (включая нуль-терминатор)