Добавление целых чисел в массивы на С++?

как работает «число + 1», учитывая, что числа [] являются массивом int, и вы не должны иметь возможность добавлять целое число к константе int []?

Не существует int[] константы. numbers затухает до указателя, а numbers+1 представляет собой простую арифметику указателя, применяемую к параметру, переданному рекурсивному вызову.

В качестве примечания к ответу @πάντα ῥεῖ приведем несколько пояснений по терминологии:

Ниже приведен еще один способ изобразить нотацию массива:

Фраза numbers[1] также может быть выражена как *(numbers + 1), где говорится, что оператор * разыменовывает адрес указателя numbers + 1. В этом случае разыменование можно рассматривать как чтение значения, на которое указывает.

Итак, код в вашем примере использует арифметика указателей. Фраза numbers + 1 представляет собой нотацию указателя, указывающую на второе место int указателя numbers. size - 1 — это количество байтов от ячейки памяти, начиная с numbers до конца массива.

Что касается значения decayed:
Как правило, в контексте аргументов массива C decay передает идею о том, что аргумент массива испытывает потерю информации о типе и размерности. Говорят, что ваш const int numbers[] (возможно) распадается в int *, поэтому больше не может предоставлять информацию о размере массива. (Например, использование макроса sizeof() обеспечивает не длину массива, а размер указателя.) Это также является причиной предоставления второго аргумента для передачи информации о размере.

Однако в контексте этого вопроса значение распада является академическим, как указал @Ben Voigt: последовательность токенов const int numbers[], когда он появляется в списке формальных параметров, объявляет указатель, а не массив. (Он никогда не распадался на указатель, потому что он был указателем с самого начала.)

Как говорит πάντα ῥεῖ int[] распадается на int*.

Но эта функция sum — решение для бедных, вам следует предпочесть accumulate:

cout << accumulate(numbers, next(numbers, size), decay_t<decltype(numbers[0])>{});

Живой пример

Если у вас C++17 и статически выделенный массив, например int numbers[size], вы можете воспользоваться преимуществами cbegin и cend:

cout << accumulate(cbegin(numbers), cend(numbers), decay_t<decltype(numbers[0])>{});

Я попытался сравнить рекурсивный sum с accumulate, однако sum исчерпал место в стеке, прежде чем я смог достичь размера vector со значимой разницей, что сделало accumulate явным победителем.

Я связываю тип init аргумента accumulate с типом элементов numbers': decay_t<decltype(numbers[0])>{}. Причина этого в том, что если кто-то вернется и изменит тип numbers, а не изменит тип аргумента init accumulate, накопление будет присвоено неправильному типу.

Например, если мы используем линию накопления: cout << accumulate(cbegin(numbers), cend(numbers), 0), это нормально для int numbers[]. Проблема возникла бы, если бы мы переключились на определение: double numbers[] = {1.3, 2.3, 3.3, 4.3};, но не смогли изменить аргумент init, мы бы суммировали doubles в int. В результате получится 10, а не 11,2: http://ideone.com/A12xin.

int sum(int *num,int size)
{
int total=0;
                                   /* function to sum integer array */
if (size <= 0) return(ERROR);
while(size--) total+= *num++;
return total;
}

Он быстрее, компактнее и устойчив к ошибкам.

числа - это указатель; на каждой итерации функция sum() продвигается по массиву (это то, что делает numbers+1), в то же время уменьшая размер на 1 (--size будет работать точно также).

Когда размер достигает 0, это условие выхода, и рекурсия заканчивается.