П усть нам необходимо работать с большим количеством однотипных данных. Например, у нас есть тысяча измерений координаты маятника с каким-то шагом по времени. Создавать 1000 переменных для хранения всех значений очень... обременительно. Вместо этого множество однотипных данных можно объединить под одним именем и обращаться к каждому конкретному элементу по его порядковому номеру.
Массив в си определяется следующим образом
<тип> <имя массива>[<размер>];
Например,
int a;
Мы получим массив с именем a , который содержит сто элементов типа int . Как и в случае с переменными, массив содержит мусор.
Для получения доступа до первого элемента, в квадратных скобках пишем его номер (индекс). Например

#include #include void main() { int a; a = 10; a = 333; a = 234; printf("%d %d %d", a, a, a); getch(); }

Первый элемент имеет порядковый номер 0. Важно понимать, почему. В дальнейшем будем представлять память компьютера в виде ленты. Имя массива - это указатель на адрес памяти, где располагаются элементы массива.

Рис. 1 Массив хранит адрес первого элемента. Индекс i элемента - это сдвиг на i*sizeof(тип) байт от начала

Индекс массива указывает, на сколько байт необходимо сместиться относительно начала массива, чтобы получить доступ до нужно элемента. Например, если массив A имеет тип int , то A означает, что мы сместились на 10*sizeof(int) байт относительно начала. Первый элемент находится в самом начале и у него смещение 0*sizeof(int) .
В си массив не хранит своего размера и не проверяет индекс массива на корректность. Это значит, что можно выйти за пределы массива и обратиться к памяти, находящейся дальше последнего элемента массива (или ближе).

Начальная инициализация массива.

Н апишем простую программу. Создадим массив, после чего найдём его максимальный элемент.

#include #include void main() { int a = {1, 2, 5, 3, 9, 6, 7, 7, 2, 4}; unsigned i; int max; max = a; for (i = 1; i<10; i++) { if (a[i] >

Разберём пример. Сначала мы создаём массив и инициализируем его при создании. После этого присваиваем максимальному найденному элементу значение первого элемента массива.

Max = a;

После чего проходим по массиву. Так как мы уже просмотрели первый элемент (у него индекс 1), то нет смысла снова его просматривать.
Тот же пример, только теперь пользователь вводит значения

#include #include void main() { int a; unsigned i; int max; printf("Enter 10 numbers\n"); for (i = 0; i<10; i++) { printf("%d. ", i); scanf("%d", &a[i]); } max = a; for (i = 1; i<10; i++) { if (a[i] > max) { max = a[i]; } } printf("max element is %d", max); getch(); }

В том случае, если при инициализации указано меньше значений, чем размер массива, остальные элементы заполняются нулями.

#include #include void main() { int a = {1,2,3}; unsigned i; for (i = 0; i<10; i++) { printf("%d ", a[i]); } getch(); }

Если необходимо заполнить весь массив нулями, тогда пишем

Int a = {0};

Можно не задавать размер массива явно, например

Int a = {1, 2, 3};

массив будет иметь размер 3

Размер массива

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

Printf("Enter length of array "); scanf("%d", &length); { float x; }

Создание динамических массивов будет рассмотрено дальше, при работе с указателями и памятью
В некоторых случаях можно узнать размер массива с помощью функции sizeof.

#include #include void main() { int A; //sizeof возвращает размер всего массива в байтах //Для определения количества элементов необходимо //разделить размер массива на размер его элемента int size = sizeof(A) / sizeof(int); printf("Size of array equals to %d", size); getch(); }

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

Переполнение массива

П ускай у вас есть такой код

Int A; int i; for (i=0; i<=10; i++) { A[i] = 1; }

Здесь цикл for задан с ошибкой. В некоторых старых версиях компиляторов этот код зацикливался. Дело в том, что переменная i располагалась при компиляции сразу за массивом A . При выходе за границы массива счётчик переводился в 1.
Массивы небезопасны, так как неправильная работа с индексом может приводить к доступу к произвольному участку памяти (Теоретически. Современные компиляторы сами заботятся о том, чтобы вы не копались в чужой памяти).
Если вы работаете с массивами, то необходимо следить за тем, чтобы счётчик не превышал размер массива и не был отрицательным. Для этого, как минимум,

• 1. Используйте тип size_t для индексирования. Он обезопасит вас от отрицательных значений и его всегда хватит для массива любого размера.
• 2. Помните, что массив начинается с нуля.
• 3. Последний элемент массива имеет индекс (размер массива - 1)

Никаких полноценных способов проверки, вышли мы за пределы массива или нет, не существует. Поэтому либо мы точно знаем его размер, либо храним в переменной и считываем при надобности.

Примеры

Т еперь несколько типичных примеров работы с массивами
1. Переворачиваем массив.

#include #include //Это макрос. SIZE в коде будет заменено на 10u #define SIZE 10u void main() { int A = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; unsigned i, j; //счётчики unsigned half; //середина массива unsigned tmp; //временная переменная для обмена значениями half = SIZE / 2; //Один счётчик идёт слева напрво, другой справа налево for (i = 0, j = SIZE - 1; i < half; i++, j--) { tmp = A[i]; A[i] = A[j]; A[j] = tmp; } for (i = 0; i < SIZE; i++) { printf("%d ", A[i]); } getch(); }

Здесь незнакомая для вас конструкция

#define SIZE 10u

макрос. Во всём коде препроцессор автоматически заменит все вхождения SIZE на 10u.
2. Удаление элемента, выбранного пользователем.

#include #include #define SIZE 10u void main() { int A = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; unsigned i; //счётчик int index; //индекс, введённый пользователем //Выводим массив for (i = 0; i < SIZE; i++) { printf("(%d)=%d ", i, A[i]); } //Просим пользователя ввести валидный индекс while (1) { printf("\nEnter index of element to delete "); scanf("%d", &index); if (index > 0 && index < SIZE) { break; } } //Копируем следующий элемент массива на место удаляемого //и так до конца for (i = index; i < SIZE-1; i++) { A[i] = A; } //Выводим результат for (i = 0; i < SIZE-1; i++) { printf("(%d)=%d ", i, A[i]); } getch(); }

Удаление элемента в данном случае, конечно, не происходит. Массив остаётся того же размера, что и раньше. Мы просто затираем удаляемый элемент следующим за ним и выводим SIZE-1 элементов.
3. Пользователь вводит значения в массив. После этого вывести все разные значения, которые он ввёл.
Пусть пользователь вводит конечное число элементов, допустим 10. Тогда заранее известно, что всего различных значений будет не более 10. Каждый раз, когда пользователь вводит число будем проходить по массиву и проверять, было ли такое число введено.

#include #include #define SIZE 10u void main() { int A = {0}; unsigned i, j; int counter = 1; //сколько разных чисел введено. Как минимум одно. int input; int wasntFound; //флаг, что введённое число не было найдено //Вводим первое число. Оно ещё не встречалось. printf("0. "); scanf("%d", &A); for (i = 1; i < SIZE; i++) { printf("%d. ", i); scanf("%d", &input); wasntFound = 1; //Проверяем, встречалось ли такое число. Если да, //то выставляем флаг и выходим из цикла for (j = 0; j <= counter; j++) { if (input == A[j]) { wasntFound = 0; break; } } //Если флаг был поднят, то заносим число в массив if (wasntFound) { A = input; counter++; } } for (i = 0; i < counter; i++) { printf("%d ", A[i]); } getch(); }

4. Пользователь вводит число - количество измерений (от 2 до 10). После этого вводит все измерения. Программа выдаёт среднее значение, дисперсию, погрешность.

#include #include #include #define SIZE 20u void main() { //Коэффициенты Стьюдента идут, начиная с двух измерений const float student = {12.7, 4.3, 3.2, 2.8, 2.6, 2.4, 2.4, 2.3, 2.3}; float A; unsigned i; unsigned limit; float tmp; float sum = .0f; float mean; float disp; float absError; float relError; do { printf("Enter number of measurements "); scanf("%u", &limit); if (limit > 1 && limit < 11) { break; } } while(1); for (i = 0; i < limit; i++) { printf("#%d: ", i); scanf("%f", &A[i]); sum += A[i]; } mean = sum / (float)limit; sum = .0f; for (i = 0; i < limit; i++) { tmp = A[i] - mean; sum += tmp * tmp; } disp = sum / (float)limit; absError = student * sqrt(sum / (float)(limit - 1)); relError = absError / mean * 100; printf("Mean = %.6f\n", mean); printf("Dispertion = %.6f\n", disp); printf("Abs. Error = %.6f\n", absError); printf("Rel. Error = %.4f%", relError); getch(); }

5. Сортировка массива пузырьком

#include #include #define SIZE 10 #define false 0 #define true !false void main() { float a = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 0.0f}; float tmp; unsigned i, j; char flag; //Выводи массив for (i = 0; i < SIZE; i++) { printf("%.3f ", a[i]); } printf("\n"); //Пока массив не отсортирован do { flag = false; //Проходим по массиву. Если следующий элемент больше предыдущего, то //меняем их местами и по новой проверяем массив for (i = 1; i < SIZE; i++) { if (a[i] > a) { tmp = a[i]; a[i] = a; a = tmp; flag = true; } } } while(flag == true); //Выводим отсортированный массив for (i = 0; i < SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

6. Перемешаем массив. Воспользуемся для этого алгоритмом

Массивы предназначены для хранения множества значений одного типа. Например, в программе Fahrenheit to Celsius, мы высчитывали среднее значение температуры из трёх. Если значений не три, а намного больше, то тут как раз и нужно использовать массивы.

Прежде чем использовать массив, его нужно определить. Определение массива включает в себя: тип данных хранящихся в массиве, имя массива и в квадратных скобках указывается количество элементов массива:

int array;

В этом коде мы определили массив с идентификатором (именем) array (массив) из десяти элементов типа int.
В таком виде, все элементы массива ещё неинициализированы. Чтобы инициализировать их при обьявлении, нужно использовать следующий синтаксис:

int array = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

При этом, первому элементу массива присваивается значение 0, а последнему - значение 9.
Чтобы присвоить элементам массива значение, можно воспользоваться циклами. Самым подходящим для этого будет цикл for.

код на языке c++ int array; //определение массива for (int i = 0; i < 10; i++) { array[i] = i; }

Здесь мы обращаемся к каждому элементу массива через индекс - число стоящее в квадратных скобках. При каждой итерации цикла оно принимает значения от нуля до 9.

Заметьте, что нумерация индексов начинается с нуля. Поэтому число индексов всегда на единицу меньше числа элементов массива.

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

Строки

До сих пор мы могли хранить строки только в константах: "Пример константной строки". В переменных мы могли хранить только один символ - в типе char. В C++ используется два типа строк: массив элементов типа char и тип str. Сейчас мы сосредоточимся на первом варианте.

Для хранения строки нам нужен массив. Выглядит это примерно так:

char string = {"с","т","р","о"."к","а"};

К счастью есть более простой способ:)

char string = "строка";

В данном случае автоматически создастся массив из семи элементов. Почему из семи? Дело в том что каждая строка должна заканчиваться символьной константой "\0", которая представляет пустой байт.

В предыдущих примерах, если мы попытаемся ввести в массив string строку большую чем шесть символов, то произойдёт переполнение массива т.к. нельзя изменять размер массива во время выполнения программы (хотя, не всегда):

char string; // string может хранить шесть символов и "\0"

string = "строка!"; // в строке содержится семь символов
Так делать не рекомендуется:)

Ещё один момент на который я хочу обратить ваше внимание. В случае, когда пользователь вводит строку, пробелы считаются за "\0". Мы пока не будем вводить строки в наших программах, поэтому я не буду подробно объяснять данный случай.

Массивы массивов (двумерные массивы)

Ну и наконец-то мы подошли к самому важному в этом выпуске.

Карта в стратегических (и не только) играх (RTS) делится на клетки (в английском - tile, плитка). Эти клетки удобно представлять с помощью двумерного массива.

В данном примере мы продолжим работать с программой pseudo_game и с помощью двумерного массива смоделируем карту по которой может перемещаться игрок. До сих пор "перемещиение" представлялось с помощью координат x, y.

Клетки мы будем представлять символами. Размер "карты" - 15x20. Пятнадцать в высоту, двадцвать в ширину. Игрока мы будем представлять символом Т.

Сначала добавьте заголовочный файл stdlib.h.

Усовершенствованная pseudo_game

Я приведу только куски кода. Желательно чтобы у вас перед глазами была полная программа. Найти её Вы можете в разделе "листинги программ" - pseudo_game_0_2. Она компилируется и запускается. Просто скопируйте её в редактор вашей IDE и следите за текстом.

Инициализация данных:

код на языке c++ char act; // переменная для считывания ввода пользователя int ch; // переменная для хранения приведённого значения переменной act int x = 0; // две переменные для хранения координат игрока int y = 0; char map; // массив для хранения игровой карты // инициализация массива for (int i = 0; i < 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

Здесь новым оператором для нас является определение двумерного массива. Но оно почти ничем не отличается от одномерного, просто добавляется ещё одна пара квадратных скобок. В первых скобках мы указали количество строк, во второй - количество столбцов.

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

Приведу подробный пример: после нескольких итераций внешнего цикла, счётчик i становится равным 9. Начинает выполняться тело внешнего цикла: переменная j (счётчик внутреннего цикла) инициализируется нулём, проверяется условие и выполняется тело внутреннего цикла: map = " ";, То есть первому символу (индекс ноль) десятой строки (не забывайте что отсчёт ведётся с нуля) присваивается пробел. Затем, счётчику j присваивается 1, выполняется тело цикла... и так до тех пор пока счётчик j не станет равным 20 - условие не выполняется и происходит выход из внутреннего цикла. Затем инкрементируется внешний счётчик. Теперь он равен 10 и снова выполняется тело внешнего цикла...

После инициализации пробелами мы в первый столбец первой строки помещаем персонажа нашей игры.

В начале основного цикла мы вызываем функцию system() для очистки экрана от прошлого вывода.

Затем идут два цикла похожие на циклы инициализации. Они используются для вывода элементов массива на экран. Единственным существенным отличием является вывод символа новой строки в конце тела первого цикла.

Ну а дальше идёт ветвление в котором определяется какая клавиша нажата. Само ветвление мало изменилось с прошлого раза, а вот в содержимом блоков есть отличия: во-первых мы присваиваем координатам на которых стоит объект пробел. То есть мы очищаем предыдущее место. Затем мы изменяем одну из координат. И затем, элементу массива с новыми индексами, мы присваиваем символ "T".

Пример для кода "75" - движение влево:

код на языке c++ if else (ch == 75) { map[x][y] = " "; y--; map[x][y] = "T"; }

Ну, вот в общем и всё. На данный момент у нас есть карта 15х20 по которой с помощью стрелочек можно перемещать персонаж - букву "T". Для шестого урока неплохо! Данное приложение станет основой для всех наших консольных программ. Никаких графических улучшений не будет. Большего из досовской консоли просто не выжать, а консоль windows мы рассматривать не будем. Это существенно сэкономит время и силы.

Я подробно закомментировал программу pseudo_game и Вы скорее всего без труда в ней разберётесь. Если нет, то перечитывайте листинг программы и этот выпуск пока не разберётесь:). Закрепить материал вам помогут упражнения. Выполнение упражнений обязательно. Если что непонятно, пишите на мой e-mail - постараюсь помочь.

Упражнения:

1. В полном листинге программы я использовал ветвление switch. Здесь же показан код одного блока ветвления if. Допишите остальные блоки if.

2. Сейчас в программе возможна запись в несуществующие элементы массива. Сделайте проверку на выход за пределы карты.

3. Для практики создайте программу рисующую на экране два поля для морского боя. Первое - игрока, второе - противника. Второе поле должно располагаться справа от первого.
Внутренние клетки заполняйте пробелом. Для рисования границы используйте минус и прямую разделительную черту: -, |, а для углов - решётку #. Слева от каждого поля - стобик цифр; сверху - буквы.
Для инициализации всего поля вам может понадобиться несколько циклов. Вот как может выглядеть код для заполнения столбика цифр второго поля:

код на языке c++ int string; // переменная представляющая строки int column; // переменная представляющая столбцы char map; column = 15; for (string = 2; string < 12; string++) { map = string - 1; }

Что такое массивы в си?

Как объявлять массивы в си?

Как инициализировать массивы в си?

Массивы в Си для чайников.

Массивы в C

Массив в Си - это набор элементов одного типа, обратиться к которым можно по индексу. Элементы массивов в C расположены друг за другом в памяти компьютера.

Простой пример создания и заполнения массива в C:

// @author Subbotin B.P..h> void main(void) { int nArr; nArr = 1; nArr = 2; nArr = 3; printf("\n\tArray\n\n"); printf("nArr\t=\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); return 0; }

Получаем:

В примере объявляем массив, содержащий элементы типа int:

здесь имя массива nArr, количество элементов массива равно трём, тип элементов массива int.

Массив - это набор элементов. К каждому элементу массива можно обратиться по его номеру. Номер принято называть индексом. Нумерация элементов массива идёт с нуля. Присвоим значение первому элементу массива, а первый элемент имеет индекс ноль:

Присвоим значение второму элементу массива, а второй элемент имеет индекс один:

Присвоим значение третьему элементу массива, а третий элемент имеет индекс два:

При выводе на экран элементов массива мы получаем их значения. Вот так:

printf("nArr\t=\t%d\n", nArr);

Чтоб получить элемент массива, надо указать имя массива и индекс элемента:

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

Присвоим значение третьего элемента массива переменной int a:

индекс третьего элемента массива равен двум, так как отсчёт индексов ведут с нуля.

Теперь общее правило объявления массивов в Си: при объявлении массива нужно указать его имя, тип элементов, количество элементов. Количество элементов есть натуральное число, т.е. целое положительное. Ноль не может быть количеством элементов. Нельзя задавать переменное количество элементов массива. Вот примеры объявлений массивов в C:

int nArr; // Объявлен массив, предназначенный для хранения ста целых чисел;
float fArr; // Объявлен массив, предназначенный для хранения 5-ти чисел типа float;
char cArr; // Объявлен массив, предназначенный для хранения двух символов;

Ошибкой будет объявить массив с переменным количеством элементов:

Int varElem;
int nArr; // Ошибка! Количество элементов нельзя задавать переменной;

Но можно задавать количество элементов постоянной величиной: или непосредственным целым положительным числом 1, 2, 3... или константой:

Const int arrayLength = 3;
int nArr;

При объявлении массива в Си его сразу можно инициализировать:

int nMassiv = {1, 2, 3};

Можно не указывать количество элементов массива в квадратных скобках, если инициализируются все элементы массива:

int nMassiv = {1, 2, 3};

количество элементов будет в этом случае определено автоматически.

Можно определить лишь часть элементов массива при его объявлении:

int nMassiv = {1, 2};

в этом примере первые два элемента массива инициализированы, а третий не определен.

Пример массива символов:

char cArr = {"S", "B", "P"};

При объявлении массива нельзя указывать количество элементов переменной. Но можно использовать переменные при обращении к элементам массивов:

Int ind = 0;
char cr = cArr;

Это используется при работе с циклами. Пример:

// @author Subbotin B.P..h> void main(void) { const int arrayLength = 3; int nArr; for(int inn = 0; inn < 3; inn++) { nArr = inn + 1; } printf("\n\tArray\n\n"); for(int inn = 0; inn < 3; inn++) { printf("nArr[%d]\t=\t%d\n", inn, nArr); } return 0; }

В примере в первом цикле заполняем массив элементами типа int, а во втором цикле выводим эти элементы на экран.

• Tutorial

В этом посте я постараюсь окончательно разобрать такие тонкие понятия в C и C++, как указатели, ссылки и массивы. В частности, я отвечу на вопрос, так являются массивы C указателями или нет.

Обозначения и предположения

• Я буду предполагать, что читатель понимает, что, например, в C++ есть ссылки, а в C - нет, поэтому я не буду постоянно напоминать, о каком именно языке (C/C++ или именно C++) я сейчас говорю, читатель поймёт это из контекста;
• Также, я предполагаю, что читатель уже знает C и C++ на базовом уровне и знает, к примеру, синтаксис объявления ссылки. В этом посте я буду заниматься именно дотошным разбором мелочей;
• Буду обозначать типы так, как выглядело бы объявление переменной TYPE соответствующего типа. Например, тип «массив длины 2 int"ов» я буду обозначать как int TYPE ;
• Я буду предполагать, что мы в основном имеем дело с обычными типами данных, такими как int TYPE , int *TYPE и т. д., для которых операции =, &, * и другие не переопределены и обозначают обычные вещи;
• «Объект» всегда будет означать «всё, что не ссылка», а не «экземпляр класса»;
• Везде, за исключением специально оговоренных случаев, подразумеваются C89 и C++98.

Указатели и ссылки

Указатели . Что такое указатели, я рассказывать не буду. :) Будем считать, что вы это знаете. Напомню лишь следующие вещи (все примеры кода предполагаются находящимися внутри какой-нибудь функции, например, main):

Int x; int *y = &x; // От любой переменной можно взять адрес при помощи операции взятия адреса "&". Эта операция возвращает указатель int z = *y; // Указатель можно разыменовать при помощи операции разыменовывания "*". Это операция возвращает тот объект, на который указывает указатель

Также напомню следующее: char - это всегда ровно один байт и во всех стандартах C и C++ sizeof (char) == 1 (но при этом стандарты не гарантируют, что в байте содержится именно 8 бит:)). Далее, если прибавить к указателю на какой-нибудь тип T число, то реальное численное значение этого указателя увеличится на это число, умноженное на sizeof (T) . Т. е. если p имеет тип T *TYPE , то p + 3 эквивалентно (T *)((char *)p + 3 * sizeof (T)) . Аналогичные соображения относятся и к вычитанию.

Ссылки . Теперь по поводу ссылок. Ссылки - это то же самое, что и указатели, но с другим синтаксисом и некоторыми другими важными отличиями, о которых речь пойдёт дальше. Следующий код ничем не отличается от предыдущего, за исключением того, что в нём фигурируют ссылки вместо указателей:
int x; int &y = x; int z = y;

Если слева от знака присваивания стоит ссылка, то нет никакого способа понять, хотим мы присвоить самой ссылке или объекту, на который она ссылается. Поэтому такое присваивание всегда присваивает объекту, а не ссылке. Но это не относится к инициализации ссылки: инициализируется, разумеется, сама ссылка. Поэтому после инициализации ссылки нет никакого способа изменить её саму, т. е. ссылка всегда постоянна (но не её объект).

Lvalue . Те выражения, которым можно присваивать, называются lvalue в C, C++ и многих других языках (это сокращение от «left value», т. е. слева от знака равенства). Остальные выражения называются rvalue. Имена переменных очевидным образом являются lvalue, но не только они. Выражения a , some_struct.some_field , *ptr , *(ptr + 3) - тоже lvalue.

Удивительный факт состоит в том, что ссылки и lvalue - это в каком-то смысле одно и то же. Давайте порассуждаем. Что такое lvalue? Это нечто, чему можно присвоить. Т. е. это некое фиксированное место в памяти, куда можно что-то положить. Т. е. адрес. Т. е. указатель или ссылка (как мы уже знаем, указатели и ссылки - это два синтаксически разных способа в C++ выразить понятие адреса). Причём скорее ссылка, чем указатель, т. к. ссылку можно поместить слева от знака равенства и это будет означать присваивание объекту, на который указывает ссылка. Значит, lvalue - это ссылка.

Окей, но ведь (почти любая) переменная тоже может быть слева от знака равенства. Значит, (такая) переменная - ссылка? Почти. Выражение, представляющее собой переменную - ссылка.

Иными словами, допустим, мы объявили int x . Теперь x - это переменная типа int TYPE и никакого другого. Это int и всё тут. Но если я теперь пишу x + 2 или x = 3 , то в этих выражениях подвыражение x имеет тип int &TYPE . Потому что иначе этот x ничем не отличался бы от, скажем, 10, и ему (как и десятке) нельзя было бы ничего присвоить.

Этот принцип («выражение, являющееся переменной - ссылка») - моя выдумка. Т. е. ни в каком учебнике, стандарте и т. д. я этот принцип не видел. Тем не менее, он многое упрощает и его удобно считать верным. Если бы я реализовывал компилятор, я бы просто считал там переменные в выражениях ссылками, и, вполне возможно, именно так и предполагается в реальных компиляторах.

Принцип «любое lvalue - ссылка» - тоже моя выдумка. А вот принцип «любая ссылка - lvalue» - вполне законный, общепризнанный принцип (разумеется, ссылка должна быть ссылкой на изменяемый объект, и этот объект должен допускать присваивание).

Теперь, с учётом наших соглашений, сформулируем строго правила работы со ссылками: если объявлено, скажем, int x , то теперь выражение x имеет тип int &TYPE . Если теперь это выражение (или любое другое выражение типа ссылка) стоит слева от знака равенства, то оно используется именно как ссылка, практически во всех остальных случаях (например, в ситуации x + 2) x автоматически конвертируется в тип int TYPE (ещё одной операцией, рядом с которой ссылка не конвертируется в свой объект, является &, как мы увидим далее). Слева от знака равенства может стоять только ссылка. Инициализировать (неконстантную) ссылку может только ссылка.

Операции * и & . Наши соглашения позволяют по-новому взглянуть на операции * и &. Теперь становится понятно следующее: операция * может применяться только к указателю (конкретно это было всегда известно) и она возвращает ссылку на тот же тип. & применяется всегда к ссылке и возвращает указатель того же типа. Таким образом, * и & превращают указатели и ссылки друг в друга. Т. е. по сути они вообще ничего не делают и лишь заменяют сущности одного синтаксиса на сущности другого! Таким образом, & вообще-то не совсем правильно называть операцией взятия адреса: она может быть применена лишь к уже существующему адресу, просто она меняет синтаксическое воплощение этого адреса.

Замечу, что указатели и ссылки объявляются как int *x и int &x . Таким образом, принцип «объявление подсказывает использование» лишний раз подтверждается: объявление указателя напоминает, как превратить его в ссылку, а объявление ссылки - наоборот.

Также замечу, что &*EXPR (здесь EXPR - это произвольное выражение, не обязательно один идентификатор) эквивалентно EXPR всегда, когда имеет смысл (т. е. всегда, когда EXPR - указатель), а *&EXPR тоже эквивалентно EXPR всегда, когда имеет смысл (т. е. когда EXPR - ссылка).

Массивы

Итак, есть такой тип данных - массив. Определяются массивы, например, так:
int x;
Выражение в квадратных скобках должно быть непременно константой времени компиляции в C89 и C++98. При этом в квадратных скобках должно стоять число, пустые квадратные скобки не допускаются.

Подобно тому, как все локальные переменные (напомню, мы предполагаем, что все примеры кода находятся внутри функций) находятся на стеке, массивы тоже находятся на стеке. Т. е. приведённый код привёл к выделению прямо на стеке огромного блока памяти размером 5 * sizeof (int) , в котором целиком размещается наш массив. Не нужно думать, что этот код объявил некий указатель, который указывает на память, размещённую где-то там далеко, в куче. Нет, мы объявили массив, самый настоящий. Здесь, на стеке.

Чему будет равно sizeof (x) ? Разумеется, оно будет равно размеру нашего массива, т. е. 5 * sizeof (int) . Если мы пишем
struct foo { int a; int b; };
то, опять-таки, место для массива будет целиком выделяться прямо внутри структуры, и sizeof от этой структуры будет это подтверждать.

От массива можно взять адрес (&x), и это будет самый настоящий указатель на то место, где этот массив расположен. Тип у выражения &x , как легко понять, будет int (*TYPE) . В начале массива размещён его нулевой элемент, поэтому адрес самого массива и адрес его нулевого элемента численно совпадают. Т. е. &x и &(x) численно равны (тут я лихо написал выражение &(x) , на самом деле в нём не всё так просто, к этому мы ещё вернёмся). Но эти выражения имеют разный тип - int (*TYPE) и int *TYPE , поэтому сравнить их при помощи == не получится. Но можно применить трюк с void * : следующее выражение будет истинным: (void *)&x == (void *)&(x) .

Хорошо, будем считать, я вас убедил, что массив - это именно массив, а не что-нибудь ещё. Откуда тогда берётся вся эта путаница между указателями и массивами? Дело в том, что имя массива почти при любых операциях преобразуется в указатель на его нулевой элемент.

Итак, мы объявили int x . Если мы теперь пишем x + 0 , то это преобразует наш x (который имел тип int TYPE , или, более точно, int (&TYPE)) в &(x) , т. е. в указатель на нулевой элемент массива x. Теперь наш x имеет тип int *TYPE .

Конвертирование имени массива в void * или применение к нему == тоже приводит к предварительному преобразованию этого имени в указатель на первый элемент, поэтому:
&x == x // ошибка компиляции, разные типы: int (*TYPE) и int *TYPE (void *)&x == (void *)x // истина x == x + 0 // истина x == &(x) // истина

Операция . Запись a[b] всегда эквивалентна *(a + b) (напомню, что мы не рассматриваем переопределения operator и других операций). Таким образом, запись x означает следующее:

• x эквивалентно *(x + 2)
• x + 2 относится к тем операциям, при которых имя массива преобразуется в указатель на его первый элемент, поэтому это происходит
• Далее, в соответствии с моими объяснениями выше, x + 2 эквивалентно (int *)((char *)x + 2 * sizeof (int)) , т. е. x + 2 означает «сдвинуть указатель x на два int"а»
• Наконец, от результата берётся операция разыменования и мы извлекаем тот объект, который размещён по этому сдвинутому указателю

Типы у участвовавших выражений следующие:
x // int (&TYPE), после преобразования типа: int *TYPE x + 2 // int *TYPE *(x + 2) // int &TYPE x // int &TYPE

Также замечу, что слева от квадратных скобок необязательно должен стоять именно массив, там может быть любой указатель. Например, можно написать (x + 2) , и это будет эквивалентно x . Ещё замечу, что *a и a всегда эквивалентны, как в случае, когда a - массив, так и когда a - указатель.

Теперь, как я и обещал, я возвращаюсь к &(x) . Теперь ясно, что в этом выражении сперва x преобразуется в указатель, затем к этому указателю в соответствии с вышеприведённым алгоритмом применяется и в результате получается значение типа int &TYPE , и наконец, при помощи & оно преобразуется к типу int *TYPE . Поэтому, объяснять при помощи этого сложного выражения (внутри которого уже выполняется преобразование массива к указателю) немного более простое понятие преобразования массива к указателю - это был немного мухлёж.

А теперь вопрос на засыпку : что такое &x + 1 ? Что ж, &x - это указатель на весь массив целиком, + 1 приводит к шагу на весь этот массив. Т. е. &x + 1 - это (int (*))((char *)&x + sizeof (int )) , т. е. (int (*))((char *)&x + 5 * sizeof (int)) (здесь int (*) - это int (*TYPE)). Итак, &x + 1 численно равно x + 5 , а не x + 1 , как можно было бы подумать. Да, в результате мы указываем на память, которая находится за пределами массива (сразу после последнего элемента), но кого это волнует? Ведь в C всё равно не проверяется выход за границы массива. Также, заметим, что выражение *(&x + 1) == x + 5 истинно. Ещё его можно записать вот так: (&x) == x + 5 . Также будет истинным *((&x)) == x , или, что тоже самое, (&x) == x (если мы, конечно, не схватим segmentation fault за попытку обращения за пределы нашей памяти:)).

Массив нельзя передать как аргумент в функцию . Если вы напишите int x или int x в заголовке функции, то это будет эквивалентно int *x и в функцию всегда будет передаваться указатель (sizeof от переданной переменной будет таким, как у указателя). При этом размер массива, указанный в заголовке будет игнорироваться. Вы запросто можете указать в заголовке int x и передать туда массив длины 3.

Однако, в C++ существует способ передать в функцию ссылку на массив:
void f (int (&x)) { // sizeof (x) здесь равен 5 * sizeof (int) } int main (void) { int x; f (x); // OK f (x + 0); // Нельзя int y; f (y); // Нельзя, не тот размер }
При такой передаче вы всё равно передаёте лишь ссылку, а не массив, т. е. массив не копируется. Но всё же вы получаете несколько отличий по сравнению с обычной передачей указателя. Передаётся ссылка на массив. Вместо неё нельзя передать указатель. Нужно передать именно массив указанного размера. Внутри функции ссылка на массив будет вести себя именно как ссылка на массив, например, у неё будет sizeof как у массива.

И что самое интересное, эту передачу можно использовать так:
// Вычисляет длину массива template size_t len (t (&a)[n]) { return n; }
Похожим образом реализована функция std::end в C++11 для массивов.

«Указатель на массив» . Строго говоря, «указатель на массив» - это именно указатель на массив и ничто другое. Иными словами:
int (*a); // Это указатель на массив. Самый настоящий. Он имеет тип int (*TYPE) int b; int *c = b; // Это не указатель на массив. Это просто указатель. Указатель на первый элемент некоего массива int *d = new int; // И это не указатель на массив. Это указатель
Однако, иногда под фразой «указатель на массив» неформально понимают указатель на область памяти, в которой размещён массив, даже если тип у этого указателя неподходящий. В соответствии с таким неформальным пониманием c и d (и b + 0) - это указатели на массивы.

Многомерные массивы . Если объявлено int x , то x - это не массив длины 5 неких указателей, указывающих куда-то далеко. Нет, x теперь - это единый монолитный блок размером 5 x 7, размещённый на стеке. sizeof (x) равен 5 * 7 * sizeof (int) . Элементы располагаются в памяти так: x , x , x , x , x , x , x , x и так далее. Когда мы пишем x , события развиваются так:
x // int (&TYPE), после преобразования: int (*TYPE) x // int (&TYPE), после преобразования: int *TYPE x // int &TYPE
То же самое относится к **x . Замечу, что в выражениях, скажем, x + 3 и **x + 3 в реальности извлечение из памяти происходит только один раз (несмотря на наличие двух звёздочек), в момент преобразования окончательной ссылки типа int &TYPE просто в int TYPE . Т. е. если бы мы взглянули на ассемблерный код, который генерируется из выражения **x + 3 , мы бы в нём увидели, что операция извлечения данных из памяти выполняется там только один раз. **x + 3 можно ещё по-другому записать как *(int *)x + 3 .

А теперь посмотрим на такую ситуацию:
int **y = new int *; for (int i = 0; i != 5; ++i) { y[i] = new int; }

Что теперь есть y? y - это указатель на массив (в неформальном смысле!) указателей на массивы (опять-таки, в неформальном смысле). Нигде здесь не появляется единый блок размера 5 x 7, есть 5 блоков размера 7 * sizeof (int) , которые могут находиться далеко друг от друга. Что есть y ?
y // int **&TYPE y // int *&TYPE y // int &TYPE
Теперь, когда мы пишем y + 3 , извлечение из памяти происходит два раза: извлечение из массива y и последующее извлечение из массива y , который может находиться далеко от массива y. Причина этого в том, что здесь не происходит преобразования имени массива в указатель на его первый элемент, в отличие от примера с многомерным массивом x. Поэтому **y + 3 здесь не эквивалентен *(int *)y + 3 .

Объясню ещё разок. x эквивалентно *(*(x + 2) + 3) . И y эквивалентно *(*(y + 2) + 3) . Но в первом случае наша задача найти «третий элемент во втором ряду» в едином блоке размера 5 x 7 (разумеется, элементы нумеруются с нуля, поэтому этот третий элемент будет в некотором смысле четвёртым:)). Компилятор вычисляет, что на самом деле нужный элемент находится на 2 * 7 + 3 -м месте в этом блоке и извлекает его. Т. е. x здесь эквивалентно ((int *)x) , или, что то же самое, *((int *)x + 2 * 7 + 3) . Во втором случае сперва извлекает 2-й элемент в массиве y, а затем 3-й элемент в полученном массиве.

В первом случае, когда мы делаем x + 2 , мы сдвигаемся сразу на 2 * sizeof (int ) , т. е. на 2 * 7 * sizeof (int) . Во втором случае, y + 2 - это сдвиг на 2 * sizeof (int *) .

В первом случае (void *)x и (void *)*x (и (void *)&x !) - это один и тот же указатель, во втором - это не так.

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

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

Массив характеризуется следующими основными понятиями:

Элемент массива (значение элемента массива) – значение, хранящееся в определенной ячейке памяти, расположенной в пределах массива, а также адрес этой ячейки памяти.
Каждый элемент массива характеризуется тремя величинами:

• адресом элемента — адресом начальной ячейки памяти, в которой расположен этот элемент;
• индексом элемента (порядковым номером элемента в массиве);
• значением элемента.

Адрес массива – адрес начального элемента массива.

Имя массива – идентификатор, используемый для обращения к элементам массива.

Размер массива – количество элементов массива

Размер элемента – количество байт, занимаемых одним элементом массива.

Графически расположение массива в памяти компьютера можно представить в виде непрерывной ленты адресов.

Представленный на рисунке массив содержит q элементов с индексами от 0 до q-1 . Каждый элемент занимает в памяти компьютера k байт, причем расположение элементов в памяти последовательное.

Адреса i -го элемента массива имеет значение

Адрес массива представляет собой адрес начального (нулевого) элемента массива. Для обращения к элементам массива используется порядковый номер (индекс) элемента, начальное значение которого равно 0 . Так, если массив содержит q элементов, то индексы элементов массива меняются в пределах от 0 до q-1 .

Длина массива – количество байт, отводимое в памяти для хранения всех элементов массива.

ДлинаМассива = РазмерЭлемента * КоличествоЭлементов

Для определения размера элемента массива может использоваться функция

int sizeof (тип);

Например,

sizeof (char ) = 1;
sizeof (int ) = 4;
sizeof (float ) = 4;
sizeof (double ) = 8;

Объявление и инициализация массивов

Для объявления массива в языке Си используется следующий синтаксис:

тип имя[размерность]={инициализация};

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

int a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // массив a из 10 целых чисел

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

int b = {0}; // массив b из 10 элементов, инициализированных 0

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

int a = {1, 2, 3, 4, 5, 6, 7, 8, 9};

При обращении к элементам массива индекс требуемого элемента указывается в квадратных скобках .

Пример на Си

1
2
3
4
5
6
7
8

#include
int main()
{
int a = { 5, 4, 3, 2, 1 }; // массив a содержит 5 элементов
printf("%d %d %d %d %d\n" , a, a, a, a, a);
getchar();
return 0;
}

Результат выполнения программы:

Однако часто требуется задавать значения элементов массива в процессе выполнения программы. При этом используется объявление массива без инициализации. В таком случае указание количества элементов в квадратных скобках обязательно.

int a;

Для задания начальных значений элементов массива очень часто используется параметрический цикл:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include
int main()
{
int a;
int i;
// Ввод элементов массива
for (i = 0; i<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
// Вывод элементов массива
for (i = 0; i<5; i++)
printf("%d " , a[i]); // пробел в формате печати обязателен
getchar(); getchar();
return 0;
}

Результат выполнения программы

Многомерные массивы

В языке Си могут быть также объявлены многомерные массивы. Отличие многомерного массива от одномерного состоит в том, что в одномерном массиве положение элемента определяется одним индексом, а в многомерном - несколькими. Примером многомерного массива является матрица.

Общая форма объявления многомерного массива

тип имя[размерность1][размерность2]...[размерностьm];

Элементы многомерного массива располагаются в последовательных ячейках оперативной памяти по возрастанию адресов. В памяти компьютера элементы многомерного массива располагаются подряд, например массив, имеющий 2 строки и 3 столбца,

int a;

будет расположен в памяти следующим образом

Общее количество элементов в приведенном двумерном массиве определится как

КоличествоСтрок * КоличествоСтолбцов = 2 * 3 = 6.

Количество байт памяти, требуемых для размещения массива, определится как

КоличествоЭлементов * РазмерЭлемента = 6 * 4 = 24 байта.

Инициализация многомерных массивов

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

Пример на Си

1
2
3
4
5
6
7
8
9

#include
int main()
{
int a = { 1, 2, 3, 4, 5, 6 };
printf("%d %d %d\n" , a, a, a);
getchar();
return 0;
}

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

Пример на Си

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#define _CRT_SECURE_NO_WARNINGS
#include
int main()
{
int a; // массив из 2 строк и 3 столбцов
int i, j;
// Ввод элементов массива
for (i = 0; i<2; i++) // цикл по строкам
{
for (j = 0; j<3; j++) // цикл по столбцам
{
printf("a[%d][%d] = " , i, j);
scanf("%d" , &a[i][j]);
}
}
// Вывод элементов массива
for (i = 0; i<2; i++) // цикл по строкам
{
for (j = 0; j<3; j++) // цикл по столбцам
{
printf("%d " , a[i][j]);
}
printf("\n" ); // перевод на новую строку
}
getchar(); getchar();
return 0;
}

Передача массива в функцию

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

• адрес массива,
• размер массива.

Исключение составляют функции обработки строк, в которые достаточно передать только адрес.

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

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

Пример на Си Дан массив из 10 элементов. Поменять местами наибольший и начальный элементы массива. Для операций поиска максимального элемента и обмена использовать функцию.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#define _CRT_SECURE_NO_WARNINGS
#include
// Функция обмена
void change(int *x, int n)
{
// x - указатель на массив (адрес массива)
// n - размер массива
int i;
int max, index;
max = x;
index = 0;
// Поиск максимального элемента
for (i = 1; i {
if (x[i]>max)
{
max = x[i];
index = i;
}
}
// Обмен
x = x;
x = max;
}
// Главная функция
int main()
{
int a;
int i;
for (i = 0; i<10; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
change(a, 10); // вызов функции обмена
// Вывод элементов массива
for (i = 0; i<10; i++)
printf("%d " , a[i]);
getchar();
getchar();
return
p = p * x[i];
}
return p;
}
// Главная функция
int main()
{
int a; // объявлен массив a из 5 элементов
int i;
int pr;
// Ввод элементов массива
for (i = 0; i<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]); // &a[i] - адрес i-го элемента массива
}
pr = func(a, 5); // вычисление произведения
printf("\n pr = %d" , pr); // вывод произведения четных элементов
getchar(); getchar();
return 0;
}