Почему компиляторы C и C ++ допускают длину массивов в сигнатурах функций, когда они никогда не применяются?

Вот что я обнаружил в период обучения:

#include<iostream>
using namespace std;
int dis(char a[1])
{
    int length = strlen(a);
    char c = a[2];
    return length;
}
int main()
{
    char b[4] = "abc";
    int c = dis(b);
    cout << c;
    return 0;
}  

Таким образом , в переменной int dis(char a[1]), то , [1]кажется , не делать ничего и не работает на
всех, потому что я могу использовать a[2]. Также как int a[]или char *a. Я знаю, что имя массива - это указатель и как передать массив, поэтому моя загадка не в этой части.

Я хочу знать, почему компиляторы допускают такое поведение ( int a[1]). Или у него есть другие значения, о которых я не знаю?

Это причуда синтаксиса для передачи массивов функциям.

На самом деле невозможно передать массив в C. Если вы напишете синтаксис, который выглядит так, как будто он должен передавать массив, на самом деле вместо него передается указатель на первый элемент массива.

Поскольку указатель не содержит информации о длине, содержимое вашего []в списке формальных параметров функции фактически игнорируется.

Решение разрешить этот синтаксис было принято в 1970-х годах и с тех пор вызвало много путаницы ...

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

#include <stdio.h>

void foo(int args[10][20])
{
    printf("%zd\n", sizeof(args[0]));
}

int main(int argc, char **argv)
{
    int a[2][20];
    foo(a);
    return 0;
}

Размер первого измерения [10]игнорируется; компилятор не помешает вам выполнить индексацию с конца (обратите внимание, что формальный элемент требует 10 элементов, а фактический предоставляет только 2). Однако размер второго измерения [20]используется для определения шага каждого ряда, и здесь формальное значение должно совпадать с фактическим. Опять же, компилятор не помешает вам индексировать конец второго измерения.

Смещение байта от основания массива до элемента args[row][col]определяется:

sizeof(int)*(col + 20*row)

Обратите внимание, что если col >= 20, то вы фактически индексируете следующую строку (или конец всего массива).

sizeof(args[0]), возвращается 80на мою машину где sizeof(int) == 4. Однако, если я попытаюсь принять sizeof(args), я получаю следующее предупреждение компилятора:

foo.c:5:27: warning: sizeof on array function parameter will return size of 'int (*)[20]' instead of 'int [10][20]' [-Wsizeof-array-argument]
    printf("%zd\n", sizeof(args));
                          ^
foo.c:3:14: note: declared here
void foo(int args[10][20])
             ^
1 warning generated.

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

Проблема и как ее решить в C ++

Проблема была объяснена широко по погладить и Мэтта . Компилятор в основном игнорирует первое измерение размера массива, фактически игнорируя размер переданного аргумента.

С другой стороны, в C ++ вы можете легко преодолеть это ограничение двумя способами:

• используя ссылки
• используя std::array(начиная с C ++ 11)

Ссылки

Если ваша функция пытается только прочитать или изменить существующий массив (не копируя его), вы можете легко использовать ссылки.

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

void reset(int (&array)[10]) { ... }

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

Вы также можете использовать шаблоны, чтобы сделать приведенный выше код универсальным :

template<class Type, std::size_t N>
void reset(Type (&array)[N]) { ... }

И наконец, вы можете воспользоваться constправильностью. Рассмотрим функцию, которая печатает массив из 10 элементов:

void show(const int (&array)[10]) { ... }

Применяя constквалификатор, мы предотвращаем возможные модификации .

Стандартный библиотечный класс для массивов

Если вы считаете приведенный выше синтаксис некрасивым и ненужным, как и я, мы можем выбросить его и использовать std::arrayвместо него (начиная с C ++ 11).

Вот код после рефакторинга:

void reset(std::array<int, 10>& array) { ... }
void show(std::array<int, 10> const& array) { ... }

Разве это не прекрасно? Не говоря уже о том, что трюк с общим кодом, который я научил вас ранее, все еще работает:

template<class Type, std::size_t N>
void reset(std::array<Type, N>& array) { ... }

template<class Type, std::size_t N>
void show(const std::array<Type, N>& array) { ... }

Не только это, но вы также получаете копирование и перемещение семантики бесплатно. :)

void copy(std::array<Type, N> array) {
    // a copy of the original passed array 
    // is made and can be dealt with indipendently
    // from the original
}

Чего же ты ждешь? Иди и используй std::array.

Это забавная особенность C, которая позволяет вам эффективно стрелять себе в ногу, если вы так склонны.

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

Кроме того, назначение размера аргументу функции имеет то преимущество, что, когда функция используется другим программистом, есть вероятность, что он заметит ограничение размера. Простое использование указателя не передает эту информацию следующему программисту.

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

Во-вторых, есть уловка, которая позволяет передавать массив по значению функции. Также возможно возвращать массив по значению из функции. Вам просто нужно создать новый тип данных с помощью struct. Например:

typedef struct {
  int a[10];
} myarray_t;

myarray_t my_function(myarray_t foo) {

  myarray_t bar;

  ...

  return bar;

}

Вы должны получить доступ к таким элементам: foo.a [1]. Дополнительный ".a" может выглядеть странно, но этот трюк добавляет отличную функциональность языку C.

Чтобы сообщить компилятору, что myArray указывает на массив не менее 10 целых чисел:

void bar(int myArray[static 10])

Хороший компилятор должен предупреждать вас, если вы обращаетесь к myArray [10]. Без ключевого слова static число 10 вообще ничего не значило бы.

Это хорошо известная «особенность» C, переданная в C ++, потому что C ++ должен правильно компилировать код C.

Проблема возникает по нескольким причинам:

1. Предполагается, что имя массива полностью эквивалентно указателю.
2. C должен быть быстрым, изначально разрабатывался как своего рода «ассемблер высокого уровня» (специально разработанный для написания первой «переносимой операционной системы»: Unix), поэтому он не должен вставлять «скрытый» код; Таким образом, проверка диапазона во время выполнения «запрещена».
3. Машинный код, созданный для доступа к статическому или динамическому массиву (в стеке или выделенному), на самом деле отличается.
4. Поскольку вызываемая функция не может знать «тип» массива, переданного в качестве аргумента, все должно быть указателем и обрабатываться как таковое.

Вы могли бы сказать, что массивы на самом деле не поддерживаются в C (это не совсем так, как я говорил ранее, но это хорошее приближение); массив действительно рассматривается как указатель на блок данных и доступен с использованием арифметики указателей. Поскольку C НЕ имеет какой-либо формы RTTI, вы должны объявить размер элемента массива в прототипе функции (для поддержки арифметики указателей). Это даже «вернее» для многомерных массивов.

В любом случае все вышесказанное больше не соответствует действительности: p

Большинство компиляторов современного C / C ++ сделать поддержку проверки границ, но стандарты требуют, чтобы быть отключена по умолчанию (для обратной совместимости). Например, достаточно свежие версии gcc выполняют проверку диапазона времени компиляции с помощью «-O3 -Wall -Wextra» и полную проверку границ времени выполнения с помощью «-fbounds-check».

C не только преобразует параметр типа int[5]в *int; учитывая объявление typedef int intArray5[5];, он также преобразует параметр типа intArray5в *int. В некоторых ситуациях такое поведение, хотя и нечетное, полезно (особенно с такими вещами, как va_listопределенное в stdargs.h, которое некоторые реализации определяют как массив). Было бы нелогично разрешать в качестве параметра тип, определенный как int[5](игнорируя размер), но не позволяющий int[5]указывать напрямую.

Я считаю, что C обработка параметров типа массива абсурдна, но это следствие усилий взять специальный язык, большие части которого не были особенно четко определены или продуманы, и попытаться придумать поведенческие спецификации, которые согласуются с тем, что существующие реализации сделали для существующих программ. Многие из причуд C имеют смысл, если рассматривать их в этом свете, особенно если учесть, что, когда многие из них были изобретены, большая часть языка, который мы знаем сегодня, еще не существовала. Насколько я понимаю, в предшественнике C, называемом BCPL, компиляторы не очень хорошо отслеживали типы переменных. Объявление int arr[5];было эквивалентно int anonymousAllocation[5],*arr = anonymousAllocation;; после того, как распределение было отложено. компилятор не знал и не заботился о том,arrбыл указателем или массивом. При обращении к нему как arr[x]или к *arrнему он будет рассматриваться как указатель независимо от того, как он был объявлен.

Единственный вопрос, на который еще нет ответа, - это актуальный вопрос.

В уже приведенных ответах объясняется, что массивы не могут быть переданы по значению функции ни в C, ни в C ++. Они также объясняют, что параметр, объявленный как int[], рассматривается как имеющий тип int *, и что такой функции int[]можно передать переменную типа .

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

void f(int *); // makes perfect sense
void f(int []); // sort of makes sense
void f(int [10]); // makes no sense

Почему последнее из них не является ошибкой?

Причина в том, что это вызывает проблемы с определениями типов.

typedef int myarray[10];
void f(myarray array);

Если бы было ошибкой указать длину массива в параметрах функции, вы не смогли бы использовать это myarrayимя в параметре функции. И поскольку некоторые реализации используют типы массивов для стандартных типов библиотек, таких как va_list, и все реализации требуются для создания jmp_bufтипа массива, было бы очень проблематично, если бы не было стандартного способа объявления параметров функции с использованием этих имен: без этой возможности не было бы не быть переносимой реализацией таких функций, как vprintf.

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