Длина массива в аргументе функции

массив распады к указателю при передаче.

раздел 6.4 C FAQ покрывает это очень хорошо и обеспечивает ссылки К&Р ЕТК.

---

это в стороне, представьте, что функция может знать размер памяти, выделенной в указателе. Вы можете вызвать функцию два или более раз, каждый раз с разными входными массивами, которые потенциально имеют разную длину; поэтому длина должна быть передана как секретная скрытая переменная каким-то образом. А затем рассмотрим, если вы передали смещение в другой массив, или массив, выделенный в куче (malloc и все это библиотечные функции-то, на что компилятор ссылается, а не видит и рассуждает о теле).

его становится трудно представить, как это может работать без некоторых закулисных объектов среза и такого права?

---

Symbian действительно был AllocSize() функция, которая возвращает размер выделения с malloc(); это работало только для литерального указателя, возвращенного malloc, и вы получите gobbledygook или сбой, если вы попросите его узнать размер недопустимого указателя или смещение указателя от одного.

вы не хотите верить, что это невозможно, но это действительно не так. единственный способ узнать длину чего-то, переданного в функцию, - это отслеживать длину самостоятельно и передавать ее в себя как отдельный явный параметр.

как указано в @Will, распад происходит во время передачи параметров. Один из способов обойти это-передать количество элементов. Чтобы добавить к этому, вы можете найти _countof() макрос полезный - он делает эквивалент того, что вы сделали;)

во-первых, лучшее использование для вычисления количества элементов, когда фактическое объявление массива находится в области действия:

sizeof array / sizeof array[0]

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

во-вторых, как незначительный момент, обратите внимание, что sizeof не является функцией, поэтому выражение выше не нуждается в скобках вокруг аргумента к sizeof.

в-третьих, C не имеет ссылок, поэтому ваше использование & в декларации не будет работать.

Я согласен, что правильное решение C состоит в том, чтобы передать длину (используя size_t type) в качестве отдельного аргумента, и использовать sizeof в том месте, где выполняется вызов, если аргумент является" реальным " массивом.

обратите внимание, что часто вы работаете с памятью вернулись, например,malloc(), и в этих случаях у вас никогда не будет "истинного" массива для вычисления размер выключен, поэтому проектирование функции для использования количества элементов является более гибким.

относительно int main ():

согласно стандарту, argv указывает на нуль -расторгнут массив (указателей на null-завершенной строки). (5.1.2.2.1:1).

то есть argv = (char **){ argv[0], ..., argv[argc - 1], 0 };.

следовательно, вычисление размера выполняется функцией, которая является тривиальной модификацией strlen().

argc - это только там, чтобы сделать argv расчет длины O (1).

метод count-until-NULL будет не работа для ввода универсального массива. Вам нужно будет вручную указать размер в качестве второго аргумента.

Это старый вопрос, и OP, похоже, смешивает C++ и C в своих намерениях/примерах. В C, когда вы передаете массив функции, он распадается на указатель. Таким образом, нет никакого способа передать размер массива, кроме как с помощью второго аргумента в функции, которая хранит размер массива:

void func(int A[]) 
// should be instead: void func(int * A, const size_t elemCountInA)

Это очень мало случаев, когда вам это не нужно, например, когда вы используете многомерные массивы:

void func(int A[3][whatever here]) // That's almost as if read "int* A[3]"

использование нотации массива в сигнатуре функции по-прежнему полезно, для разработчика, так как это может быть помощь, чтобы сказать, сколько элементов ваши функции ожидает. Например:

void vec_add(float out[3], float in0[3], float in1[3])

легче понять, чем этот (хотя ничто не мешает доступу к 4-му элементу в функции в обеих функциях):

void vec_add(float * out, float * in0, float * in1)

если вы используете C++, то вы можете фактически захватить размер массива и получить то, что вы ожидаете:

template <size_t N>
void vec_add(float (&out)[N], float (&in0)[N], float (&in1)[N])
{
    for (size_t i = 0; i < N; i++) 
        out[i] = in0[i] + in1[i];
}

в этом случае компилятор будет гарантировать, что вы не добавляете 4D вектор с 2D вектор (что невозможно в C без передачи размерности каждого измерения в качестве аргументов функции). Будет столько же экземпляров функции vec_add, сколько и количество измерений, используемых для ваших векторов.

int arsize(int st1[]) {
    int i = 0;
    for (i; !(st1[i] & (1 << 30)); i++);
    return i;
}

это работает для меня :)

лучший пример здесь

спасибо #определить размер 10

void size(int arr[SIZE])
{
    printf("size of array is:%d\n",sizeof(arr));
}

int main()
{
    int arr[SIZE];
    size(arr);
    return 0;
}