Способы объявления одномерных массивов

Содержание

1. Объявление массива
2. Инициализация массивов
3. Работа с массивами
3.1. Доступ к элементу массива
3.2. Обработка массивов
3.3. Ввод/вывод массивов
3.4. Пример 1. Обработка одномерного массива
3.5. Пример 2. Обработка двумерного массива
Первый способ
Второй способ
3.6. Пример 3. Суммирование элементов матрицы
Одномерные массивы (Руководство по программированию на C#)
Инициализация массива
Массивы типов значений и ссылочных типов
Получение данных из массива
Объявление одномерных массивов

1. Объявление массива

Объявление массива имеет следующий синтаксис:
[ ]; [ ];

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

Объявление массива может иметь одну из двух синтаксических форм, указанных выше. Квадратные скобки, следующие за именем, – признак того, что переменная является массивом. Константное выражение, заключенное в квадратные скобки определяет число элементов в массиве. Индексация элементов массива в языке C++ начинается с нуля. Таким образом, последний элемент массива имеет индекс на единицу меньше, чем число элементов массива.

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

Многомерный массив, или массив массивов, объявляется путем задания последовательности константных выражений в квадратных скобках, следующей за именем:
[ ][ ] . ;

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

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

Примеры объявлений массивов

int x[10];	// Одномерный массив из 10 целых чисел. Индексы меняются от 0 до 9.
double y[2][10];	// Двумерный массив вещественных чисел из 2 строк и 10 столбцов.

2. Инициализация массивов

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

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

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

Примеры инициализации массивов

int a[3] = <0, 1, 2>;	// Число инициализаторов равно числу элементов
double b[5] = <0.1, 0.2, 0.3>;	// Число инициализаторов меньше числа элементов
int c[ ] = <1, 2, 4, 8, 16>;	// Число элементов массива определяется по числу инициализаторов
int d[2][3] = <<0, 1, 2>, <3, 4, 5>>;	// Инициализация двумерного массива. Массив состоит из двух строк, // в каждой из которых по 3 элемента. Элементы первой строки // получают значения 0, 1 и 2, а второй – значения 3, 4 и 5.
int e[3] = <0, 1, 2, 3>;	// Ошибка – число инициализаторов больше числа элементов

Обратите внимание, что не существует присваивания массиву, соответствующего описанному выше способу инициализации.

int a[3] = <0, 1, 2>;	// Объявление и инициализация
a = <0, 1, 2>;	// Ошибка

3. Работа с массивами

3.1. Доступ к элементу массива

Для доступа к конкретному элементу массива используются так называемые индексные выражения:
[ ]

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

Индекс массива может быть не только константой, но и выражением, которое имеет целочисленный тип, например, a [ i + 1] (здесь a должно быть именем ранее объявленного массива, а i – переменной целого типа).

Объявление массива и индексное выражение, используемое для доступа к элементу массива, имеют схожий синтаксис. Различаются они по месту в программе. Это особенно важно, когда мы определяем индекс последнего элемента массива. Как было сказано ранее, индексы элементов массива в языке C начинаются с 0, и номер последнего элемента на 1 меньше количества элементов массива. Поэтому если Вы объявили массив x из 10 элементов, Вы не можете написать индексное выражение x [10], т.к. в этом случае Вы пытаетесь обратиться к элементу с индексом 10, которого нет в Вашем массиве. Компилятор не выдаст сообщения об ошибке, но результаты работы такой программы будут непредсказуемы.

Имя массива является адресом его начала! Оно имеет тип константный указатель на . Конструкция a [ i ] эквивалентна *( a + i ) (см. лекцию 5).

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

3.2. Обработка массивов

Для обработки элементов массива обычно используется оператор пошагового цикла for .

for (i = 0;	// Присваиваем счетчику цикла значение индекса первого элемента
i	// В теле цикла происходит обработка одного элемента массива

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

Массивы не самодостаточны в том смысле, что не гарантируется хранение информации о количестве элементов вместе с самим массивом. В большинстве реализаций С++ отсутствует проверка диапазона индексов для массивов. Таков традиционный низкоуровневый подход к массивам. Более совершенное понятие массива можно реализовать при помощи классов.

В С++ массивы тесно связаны с указателями. Имя массива можно использовать в качестве указателя на его первый элемент. Гарантируется осмысленность значения указателя на элемент, следующий за последним элементом массива. Это важно для многих алгоритмов. Но ввиду того, что такой указатель на самом деле не указывает ни на какой элемент массива, его нельзя использовать ни для чтения, ни для записи. Результат получения адреса элемента массива, предшествующего первому, не определён, и такой операции следует избегать.

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

int f(. int x[], . ) < . >int f(. *int x**, . ) < . >void main() < int a[10]; .	// Можно использовать любой из двух вариантов
f(. a, . ); . >	// Передаём в функцию f указатель на массив a

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

При объявлении многомерного массива как параметра функции можно опустить только первую размерность.

int g(. int x[][10], . )

// Вторая и последующие размерности обязательны

Это ограничение при желании можно обойти. Правда, при этом возникают другие проблемы (см. пример 3 в конце лекции).

3.3. Ввод/вывод массивов

В языке C нет возможности вводить и выводить весь массив одним оператором ввода/вывода. Можно вводить и выводить только один элемент массива. Следовательно, для того чтобы ввести весь массив, надо использовать цикл.

int a[10], n; printf(«Введите количество элементов массива (от 0 до 9): «);

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

scanf(«%d», &n);

// Ввод количества элементов массива

if (n 9)

// Если входные данные неверны, // то печатаем соответствующее сообщение и выходим из программы

for (i = 0; i for (i = 0; i a[1] = 4 a[2] = 15 a[3] = -2 .

3.4. Пример 1. Обработка одномерного массива

Даны три массива разной размерности. Определить в каком массиве больше сумма элементов. #include #include const int nmax = 100; int ArrayInput( int *n, double x[], char *fname); // Функция ввода массива из файла double Sum( double x[], int n); // Функция поиска суммы элементов массива void main( int argc, char *argv[]) < double a[nmax], b[nmax], c[nmax]; double sa, sb, sc, max; int na, nb, nc; setlocale(LC_ALL, "rus"); // Меняем кодировку для консольного приложения if (argc return ; >if (!ArrayInput(&na, a, argv[1])) return ; if (!ArrayInput(&nb, b, argv[2])) return ; if (!ArrayInput(&nc, c, argv[3])) return ; sa = Sum(a, na); sb = Sum(b, nb); sc = Sum(c, nc); max = sa; if (sb > max) max = sb; if (sc > max) max = sc; if (sa == max) printf(«Массив А имеет максимальную сумму элементов: %9.3lf\n», max); if (sb == max) printf(«Массив B имеет максимальную сумму элементов: %9.3lf\n», max); if (sc == max) printf(«Массив C имеет максимальную сумму элементов: %9.3lf\n», max); > double Sum( double x[], int n) < double s = 0; for ( int i = 0; i return s; >int ArrayInput( int *n, double x[], char *fname) < FILE *file; if ((file = fopen(fname, "r")) == NULL) < printf("Невозможно открыть файл '%s'\n", fname); return 0; >if (fscanf(file, «%d», n) return 0; > if (*n nmax) < printf("Кол-во эл-тов массива должно быть от 1 до %d! (файл '%s')\n", nmax, fname); return 0; >for ( int i = 0; i if (fscanf(file, «%lf», &x[i]) return 0; > fclose(file); return 1; >

3.5. Пример 2. Обработка двумерного массива

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

Первый способ

Второй способ

3.6. Пример 3. Суммирование элементов матрицы

Даны две матрицы разного размера. Функция Sum находит сумму элементов матрицы, не зависимо от того, что матрицы имеют разное количество столбцов. Обратите внимание, что функция будет выдавать корректный результат, только если используются все объявленные элементы матриц. #include #include double Sum( double *x, int m, int n); void main( int argc, char *argv[]) < const int na = 4, mb = 3, nb = 5; double a[na][na], b[mb][nb]; double sa, sb; FILE *file; setlocale(LC_ALL, "rus"); if (argc return ; >if ((file = fopen(argv[1], «r»)) == NULL) < printf("Невозможно открыть файл '%s'\n", argv[1]); return ; >for ( int i = 0; i for ( int j = 0; j if (fscanf(file, «%lf», &a[i][j]) return ; > fclose(file); if ((file = fopen(argv[2], «r»)) == NULL) < printf("Невозможно открыть файл '%s'\n", argv[2]); return ; >for ( int i = 0; i for ( int j = 0; j if (fscanf(file, «%lf», &b[i][j]) return ; > fclose(file); sa = Sum(a[0], na, na); // a[0] — указатель на первую строку матрицы // (и, соответственно, на начало всей матрицы). sb = Sum( reinterpret_cast double *>(b), mb, nb); // Преобразование без проверки с помощью reinterpret_cast. // Просто b нельзя написать — это вызовет сообщение // о невозможности преобразовать матрицу в указатель. printf(«SumA = %6.2lf\nSumB = %6.2lf\n», sa, sb); > double Sum( double *x, int m, int n) < double s = 0; for ( int i = 0; i for ( int j = 0; j return s; > Содержание

Источник

Одномерные массивы (Руководство по программированию на C#)

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

Этот массив содержит элементы с array[0] по array[4] . Элементы массива инициализируются до значения по умолчанию для типа элемента. Для целых чисел это 0 .

Массивы могут хранить любой указанный тип элемента. Например, в следующем примере приводится объявление массива строк:

Инициализация массива

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

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

Если массив инициализируется при объявлении, можно не использовать выражение new и тип массива, как показано в следующем коде. Такой массив называется неявно типизированным:

Переменную массива можно объявить без ее создания, но при присвоении нового массива этой переменной необходимо использовать оператор new . Пример:

Массивы типов значений и ссылочных типов

Рассмотрим следующее объявление массива:

Результат этого оператора зависит от того, является ли SomeType типом значения или ссылочным типом. Если это тип значения, оператор создает массив из 10 элементов, каждый из которых имеет тип SomeType . Если SomeType является ссылочным типом, этот оператор создает массив из 10 элементов, каждый из которых инициализируется с использованием ссылки NULL. В обоих случаях элементы инициализируются до значения по умолчанию для типа элемента. См. дополнительные сведения о типах значений и ссылочных типах.

Получение данных из массива

Получить данные из массива можно с помощью индекса. Пример:

Источник

Объявление одномерных массивов

Дата добавления: 2015-08-14 ; просмотров: 4719 ; Нарушение авторских прав

Тема 8. Массивы

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

Каждый элемент массива однозначно определяется именем и индексами. Имя массива (идентификатор) подбирают по тем же правилам, что и для переменных. Индексы определяют местоположение элемента в массиве. Например, элементы вектора имеют один индекс — номер по порядку; элементы матриц и таблиц имеют по два индекса: первый определяет номер строки, второй — номер столбца. Количество индексов определяет размерность массива. Например, векторы в программах — это одномерные массивы, матрицы — двумерные. Пока будут рассматриваться только одномерные массивы.

Объявление одномерных массивов

Одномерный массив объявляется в программе следующим образом:

тип_данных имя_массива [размер_массива];

Имя_массива — это идентификатор массива. Тип_данных задает тип элементов объявляемого массива. Размер_массива в квадратных скобках задает количество элементов массива. В отличие от языка Pascal, в С не проверяется выход за пределы массива, поэтому, чтобы избежать ошибок в программе, нужно следить за размерами описанных массивов.

Используя имя массива и индекс, можно адресоваться к элементам массива:

имя массива [ значение_индекса ]

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

объявляет массив с именем А, содержащий 10 целых чисел. А[0] — значение первого элемента, А[1] — второго, А[9] — последнего.

Типу массива соответствует память, которая требуется для размещения всех его элементов. Элементы массива с первого до последнего запоминаются в последовательных возрастающих адресах памяти. Между элементами массива в памяти разрывы отсутствуют. Элементы массива запоминаются друг за другом поэлементно. Так, под размещение элементов одномерного массива int В[5] выделяется по 4 байта под каждый из 5-ти элементов массива — всего 20 байтов.

Элементы В[0] В[1] В[2] В[3] В[4]

Байты

Таким образом, чтобы получить доступ к i-тому элементу массива В, можно написать В[і]. При этом величина i умножается на размер типа int и представляет собой адрес і-го элемента массива В от его начала, после чего осуществляется выборка элемента массива В по сформированному адресу.

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

Вот несколько примеров описания массивов:

int grades [ 125 ];

double vector[ 1500 ];

Первый из массивов N содержит 20 символов. Обращением к элементам массива может быть N[0], N[1], . N[19].

Второй массив grades содержит 125 целых чисел. Обращением к элементам массива может быть grades [0], grades [1], . grades[124].

Третий массив mass содержит 30 вещественных чисел. Обращением к элементам массива может быть mass[0], mass[1], . mass[1499].

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

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

Примеры задач с использованием массивов

Задача 1. Ввести одномерный массив из 8 вещественных элементов в Мемо и вычислить сумму всех элементов массива.

Пример формы с результатами работы приведен на рисунке 1. На форме расположены компоненты Memo1, Edit1, Label 1, Button1, Button2, Button3. Кнопки «Очистка» и «Выход» не рассматриваем, так как их код уже использовался в предыдущих темах.

Рисунок 1 – Форма программы

void fastcall TForm1::Button1Click(TObject *Sender) // Кнопка «Сумма»

for (int i = 0; i Lines->Strings[i]); // сам процесс считывания значения i-го // элемента массива из i-ой (соответствующей) строки Мемо, т.е. судя по форме, A[0]=1.3, // A[1]=0.137 и т.д.

sum += A[i]; > // добавляем к сумме i-ый элемент массива и завершаем тело цикла

Edit1->Text = FormatFloat(«0.000», sum) ; > // выводим сумму

Задача 2. Создать одномерный массив из 15 элементов по формуле A_i = lg(i) + tg(2 i ) , где і = 1, 2, . 15 и вывести их на форму, а также определить минимальный элемент и его порядковый номер.

Схема алгоритма программы и пример вида формы с результатами работы приведены на рисунках 2, 3 и 4. На форме расположены компоненты Memo1, Edit1, Button1, Button2.

Рисунок 2 – Форма программы

float A[15]; int i; // объявляем массив и индекс его элементов. Объявляется ДОкнопок

void fastcall TForm1::Button1Click (TObject*Sender) // Кнопка «Вычисление вектора»

Clear(); //эта запись очищает поле Мемо перед использованием (необязательно)

for (i = 0; i Lines->Add(FormatFloat(«0.000», A[i]));>//выводим (добавляем) посчитанный i-ый //элемент массива в Мемо

>// конец функции кнопки

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

void fastcall TForm1::Button2Click(TObject *Sender) // Кнопка «Минимальный элемент»

int ind = 0; //объявляем переменную под индекс и присваиваем ей индекс первого элемента

for (i = 1; i A[i]) // условие проверки на минимальность. Если i-ый элемент меньше min, то //логично, что min уже не минимальный, поэтому мы выполняем следующую строку

< min=A[i]; ind=i; >>//присваиваем значение i-го элемента переменной min, т.е. теперь i-ый //элемент будет минимальным, ну и, соответственно, индекс минимального эл. будет i

Edit1->Text = FormatFloat(«0.000″, min) + » индекс — » + IntToStr(ind + 1);> // выводим //минимальный элемент в Эдит вместе с его индексом. Можно также вывести индекс в //отдельный Эдит. Мы выводим не просто ind, а ind+1 потому, что мы найдем индекс мин. элемента, но этот индекс С++овский, а реальный индекс на 1 больше.

Рисунок 3 – Схема для кнопки «Вычисление вектора»

Рисунок 4 – Схема для кнопки «Минимальный элемент»

Задача 3. Ввести массив из N целых элементов в Мемо. Все нечетные элементы (по значению, а не по индексу) заменить единицами, а четные элементы — нулями.

Схема алгоритма программы представлена на рисунке 5.

void fastcall TForm1::Button1Click(TObject *Sender)

int N=StrToInt(Edit1->Text); // задаем размер массива (N Lines->Strings[i]); // процесс считывания

if (V[i] % 2==0) // ставим условие на четность

// если i-ый элемент – четный, то он равняется 0

else // иначе i-ый элемент будет равен 1

Memo2->Lines->Add(IntToStr(V[i]));> // выводим уже замененный элемент в новое Мемо

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

Рисунок 5 – Схема программы

Задача 4. Создать массив из N элементов (до 30) по формуле v_i = 3 cos(4i) + е -2i и вывода их на форму проекта в компонент Memo. Найти:

1) произведение ненулевых элементов вектора;

2) количество отрицательных элементов вектора;

3) поменять местами первый элемент вектора с минимальным

Для решения поставленных задач разработать отдельные кнопки для вычисления определенной задачи. Форма проекта с результатами и схемы алгоритмов для всех кнопок показаны на рисунках 6 – 8.

Рисунок 6 – Форма программы

float v[30]; int i, N; // создаем глобальные переменные (ДОкнопок), чтобы все кнопки //могли пользоваться этими переменными

void fastcall TForm1::Button1Click(TObject *Sender) // Кнопка «Вектор»

N = StrToInt(Edit1->Text); // Ввод количества элементов массива

for(i = 0; i Lines->Add(FormatFloat(«0.000», v[i])); //вывод на форму

void fastcall TForm1::Button2Click(TObject *Sender)// Кнопка ««Произведение ненулевых //элементов»

for(i = 0; i Text = FloatToStr(P); // Вывод результата

void fastcall TForm1::Button3Click(TObject *Sender)//Кнопка «Количество элементов Text=IntToStr(kol); // Вывод результата

void fastcall TForm1::Button4Click(TObject *Sender) // Кнопка «Перестановка»

int ind=0; // И его индекс нулевой

for(i = 1; i Lines->Add(FormatFloat(«0.000», v[i]));> // Вывод массива

Рисунок 7 – Схема для кнопки «Вектор»

Рисунок 8 – Схемы для кнопок: а) «Произведение …», б) «Количество…»,

1. Ввести массив из 11 целых чисел через Мемо. Найти среднее арифметическое всех элементов.

2. Создать массив из 10 элементов по формуле: В_i = . Найти максимальный элемент.

3. Ввести массив из N целых чисел через Мемо. Найти количество элементов, которые больше 3.

4. Ввести массив из R вещественных чисел через Мемо. Если какой-то из элементов массива равен 0 (предполагаем что может быть только один нулевой элемент или вообще ни одного), вывести сообщение: «Элемент с индексом … равен 0». Иначе вывести сообщение: «В массиве нет нулевых элементов!».

5*. Создать массив из 25 элементов по формуле: f_i = . Найти произведение нечетных элементов (по индексам, непо значениям). Заменить максимальный элемент массива на среднее арифметическое всех элементов и вывести полученный массив в другое Мемо.

Примечание. Нечетный элемент – это элемент с математическимииндексами i=1,3,5,7…25.

Источник