Как ввести одномерный массив c

7

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

В результате на экране мы увидим примерно следующий текст: a[1] = 4 a[2] = 15 a[3] = -2 .

Name already in use

csharp_for_beginners / c7.md

• Go to file T
• Go to line L
• Copy path
• Copy permalink

1 contributor

Users who have contributed to this file

• Open with Desktop
• View raw
• Copy raw contents Copy raw contents

Copy raw contents

Copy raw contents

ГЛАВА 7. Массивы и строки

В этой главе речь вновь пойдет о типах данных в С#. В ней рассматриваются массивы и тип string, а так­ же оператор цикла foreach.

Массив представляет собой совокупность перемен­ ных одного типа с общим для обращения к ним именем. В C# массивы могут быть как одномерными, так и многомер­ ными, хотя чаще всего применяются одномерные массивы. Массивы служат самым разным целям, поскольку они пре­ доставляют удобные средства для объединения связанных вместе переменных. Например, в массиве можно хранить максимальные суточные температуры, зарегистрированные в течение месяца, перечень биржевых курсов или же назва­ ния книг по программированию из домашней библиотеки.

Главное преимущество массива — в организации данных таким образом, чтобы ими было проще манипулировать. Так, если имеется массив, содержащий дивиденды, выпла­ чиваемые по определенной группе акций, то, организовав циклическое обращение к элементам этого массива, можно без особого труда рассчитать средний доход от этих акций. Кроме того, массивы позволяют организовать данные та­ ким образом, чтобы легко отсортировать их.

Массивами в C# можно пользоваться практически так же, как и в других языках программирования. Тем не менее у них имеется одна особенность: они реализованы в виде объектов. Именно поэтому их рассмотрение было отло­ жено до тех пор, пока в этой книге не были представлены объекты. Реализация массивов в виде объектов дает ряд существенных преимуществ, и далеко не самым последним среди них является возможность утилизировать неис­ пользуемые массивы средствам «сборки мусора».

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

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

где тип объявляет конкретный тип элемента массива. Тип элемента определяет тип данных каждого элемента, составляющего массив. Обратите внимание на квадратные скобки, которые сопровождают тип. Они указывают на то, что объявляется одномер­ ный массив. А размер определяет число элементов массива.

ПРИМЕЧАНИЕ Если у вас имеется некоторый опыт программирования на С или C++, обратите особое внимание на то, как объявляются массивы в С#. В частности, квадратные скобки следуют после названия типа, а не имени массива.

Обратимся к конкретному примеру. В приведенной ниже строке кода создается массив типа int, который составляется из десяти элементов и связывается с перемен­ ной ссылки на массив, именуемой sample.

В переменной sample хранится ссылка на область памяти, выделяемой для массива оператором new. Эта область памяти должна быть достаточно большой, чтобы в ней могли храниться десять элементов массива типа int.

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

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

Доступ к отдельному элементу массива осуществляется по индексу: Индекс обозна­ чает положение элемента в массиве. В языке C# индекс первого элемента всех массивов оказывается нулевым. В частности, массив sample состоит из 10 элементов с индекса­ ми от 0 до 9. Для индексирования массива достаточно указать номер требуемого эле­ мента в квадратных скобках. Так, первый элемент массива sample обозначается как sample [0], а последний его элемент — как sample[9]. Ниже приведен пример про­ граммы, в которой заполняются все 10 элементов массива sample.

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

Схематически массив sample можно представить таким образом.

Массивы часто применяются в программировании потому, что они дают возмож­ ность легко обращаться с большим числом взаимосвязанных переменных. Например, в приведенной ниже программе выявляется среднее арифметическое ряда значений, хранящихся в массиве nums, который циклически опрашивается с помощью операто­ ра цикла for.

Результат выполнения этой программы выглядит следующим образом.

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

где val1-valN обозначают первоначальные значения, которые присваиваются по оче­ реди, слева направо и по порядку индексирования. Для хранения инициализаторов массива в C# автоматически распределяется достаточный объем памяти. А необходи­ мость пользоваться оператором new явным образом отпадает сама собой. В качестве примера ниже приведен улучшенный вариант программы, вычисляющей среднее арифметическое.

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

Несмотря на свою избыточность, форма инициализации массива с оператором new оказывается полезной в том случае, если новый массив присваивается уже существую­ щей переменной ссылки на массив. Например:

В данном случае переменная nums объявляется в первом операторе и инициализи­ руется во втором.

И последнее замечание: при инициализации массива его размер можно указывать явным образом, но этот размер должен совпадать с числом инициализаторов. В каче­ стве примера ниже приведен еще один способ инициализации массива nums.

В этом объявлении размер массива nums задается равным 10 явно.

Соблюдение границ массива

Границы массива в C# строго соблюдаются. Если границы массива не достигаются или же превышаются, то возникает ошибка при выполнении. Для того чтобы убедить­ ся в этом, попробуйте выполнить приведенную ниже программу, в которой намерен­ но превышаются границы массива.

Как только значение переменной i достигает 10, возникнет исключительная ситуа­ ция типа IndexOutOfRangeException, связанная с выходом за пределы индексирова­ ния массива, и программа преждевременно завершится. (Подробнее об исключитель­ ных ситуациях и их обработке речь пойдет в главе 13.)

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

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

В следующей строке кода объявляется двумерный массив integer размерами 10×20.

Обратите особое внимание на объявление этого массива. Как видите, оба его разме­ ра разделяются запятой. В первой части этого объявления синтаксическое обозначение

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

В данном объявлении создается массив размерами 10×20, но и в этом случае его раз­ меры разделяются запятой.

Для доступа к элементу двумерного массива следует указать оба индекса, разделив их запятой. Например, в следующей строке кода элементу массива table с координа­ тами местоположения (3,5) присваивается значение 10.

Ниже приведен более наглядный пример в виде небольшой программы, в которой двумерный массив сначала заполняется числами от 1 до 12, а затем выводится его со­ держимое.

В данном примере элемент массива table[0,0] будет иметь значение 1, элемент массива table[0,1] — значение 2, элемент массива table[0,2] — значение 3 и т.д. А значение элемента массива table[2,3] окажется равным 12. На рис. 7.1 показано схематически расположение элементов этого массива и их значений.

Рис. 7.1. Схематическое представление массива table, созданного в программе TwoD

СОВЕТ Если вам приходилось раньше программировать на С, C++ или Java, то будьте особенно внимательны, объявляя или организуя доступ к многомерным массивам в С#. В этих языках программирования размеры массива и индексы указываются в отдельных квадратных скобках, тогда как в C# они разделяются запятой.

Массивы трех и более измерений

В C# допускаются массивы трех и более измерений. Ниже приведена общая форма объявления многомерного массива.

Например, в приведенном ниже объявлении создается трехмерный целочислен­ ный массив размерами 4×10×3.

А в следующем операторе элементу массива multidim с координатами местополо­ жения (2,4,1) присваивается значение 100.

Ниже приведен пример программы, в которой сначала организуется трехмерный массив, содержащий матрицу значений 3×3×3, а затем значения элементов этого мас­ сива суммируются по одной из диагоналей матрицы.

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

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

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

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

В качестве примера ниже приведена программа, в которой двумерный массив sqrs инициализируется числами от 1 до 10 и квадратами этих чисел.

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

В приведенных выше примерах применения двумерного массива, по существу, соз­ давался так называемый прямоугольный массив. Двумерный массив можно представить в виде таблицы, в которой длина каждой строки остается неизменной по всему масси­ ву. Но в C# можно также создавать специальный тип двумерного массива, называемый ступенчатым массивом. Ступенчатый массив представляет собой массив массивов, в ко­ тором длина каждого массива может быть разной. Следовательно, ступенчатый массив может быть использован для составления таблицы из строк разной длины.

Ступенчатые массивы объявляются с помощью ряда квадратных скобок, в которых указывается их размерность. Например, для объявления двумерного ступенчатого мас­ сива служит следующая общая форма:

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

После выполнения этого фрагмента кода массив jagged выглядит так, как показа­ но ниже.

Теперь нетрудно понять, почему такие массивы называются ступенчатыми! После создания ступенчатого массива доступ к его элементам осуществляется по индексу, указываемому в отдельных квадратных скобках. Например, в следующей строке кода элементу массива jagged, находящемуся на позиции с координатами (2,1), присваи­ вается значение 10.

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

В приведенном ниже примере программы демонстрируется создание двумерного ступенчатого массива.

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

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

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

В следующей строке кода элементу массива jagged[0] присваивается ссылка на массив размерами 4×2.

А в приведенной ниже строке кода элементу массива jagged[0][1,0] присваива­ ется значение переменной i.

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

Присваивание значения одной переменной ссылки на массив другой перемен­ ной, по существу, означает, что обе переменные ссылаются на один и тот же массив, и в этом отношении массивы ничем не отличаются от любых других объектов. Такое присваивание не приводит ни к созданию копии массива, ни к копированию содержи­ мого одного массива в другой. В качестве примера рассмотрим следующую программу.

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

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

Применение свойства Length

Реализация в C# массивов в виде объектов дает целый ряд преимуществ. Одно из них заключается в том, что с каждым массивом связано свойство Length, содержащее число элементов, из которых может состоять массив. Следовательно, у каждого масси­ ва имеется специальное свойство, позволяющее определить его длину. Ниже приведен пример программы, в которой демонстрируется это свойство.

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

Обратите внимание на то, как в классе LengthDemo свойство nums.Length исполь­ зуется в циклах for для управления числом повторяющихся шагов цикла. У каждого массива имеется своя длина, поэтому вместо отслеживания размера массива вручную можно использовать информацию о его длине. Следует, однако, иметь в виду, что зна­ чение свойства Length никак не отражает число элементов, которые в нем использу­ ются на самом деле. Свойство Length содержит лишь число элементов, из которых может состоять массив.

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

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

Как подтверждает приведенный выше результат, свойство Length содержит число элементов, из которых может состоять массив (в данном случае — 300 (10×5×6) эле­ ментов). Тем не менее свойство Length нельзя использовать для определения длины массива в отдельном его измерении.

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

Выполнение этой программы дает следующий результат.

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

Применение свойства Length при обращении со ступенчатыми массивами

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

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

Обратите особое внимание на то, как свойство Length используется в ступенчатом массиве network_nodes. Напомним, что двумерный ступенчатый массив представля­ ет собой массив массивов. Следовательно, когда используется выражение

то в нем определяется число массивов, хранящихся в массиве network_nodes (в дан­ ном случае — четыре массива). А для получения длины любого отдельного массива, составляющего ступенчатый массив, служит следующее выражение.

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

Неявно типизированные массивы

Как пояснялось в главе 3, в версии C# 3.0 появилась возможность объявлять неявно типизированные переменные с помощью ключевого слова var. Это переменные, тип которых определяется компилятором, исходя из типа инициализирующего выраже­ ния. Следовательно, все неявно типизированные переменные должны быть непремен­ но инициализированы. Используя тот же самый механизм, можно создать и неявно типизированный массив. Как правило, неявно типизированные массивы предназна­ чены для применения в определенного рода вызовах, включающих в себя элементы языка LINQ, о котором речь пойдет в главе 19. А в большинстве остальных случаев используется «обычное» объявление массивов. Неявно типизированные массивы рас­ сматриваются здесь лишь ради полноты представления о возможностях языка С#.

Неявно типизированный массив объявляется с помощью ключевого слова var, но без последующих квадратных скобок []. Кроме того, неявно типизированный мас­ сив должен быть непременно инициализирован, поскольку по типу инициализато­ ров определяется тип элементов данного массива. Все инициализаторы должны быть одного и того же согласованного типа. Ниже приведен пример объявления неявно ти­ пизированного массива.

В данном примере создается массив типа int, состоящий из пяти элементов. Ссыл­ ка на этот массив присваивается переменной vals. Следовательно, тип этой перемен­ ной соответствует типу int массива, состоящего из пяти элементов. Обратите внима­ ние на то, что в левой части приведенного выше выражения отсутствуют квадратные скобки []. А в правой части этого выражения, где происходит инициализация масси­ ва, квадратные скобки присутствуют. В данном контексте они обязательны.

Рассмотрим еще один пример, в котором создается двумерный массив типа double.

В данном случае получается массив vals размерами 2×3.

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

Выполнение этой программы дает следующий результат.

Обратите особое внимание на объявление массива jagged.

Как видите, оператор new[] используется в этом объявлении двояким образом. Во-первых, этот оператор создает массив массивов. И во-вторых, он создает каждый массив в отдельности, исходя из количества инициализаторов и их типа. Как и следо­ вало ожидать, все инициализаторы отдельных массивов должны быть одного и того же типа. Таким образом, к объявлению любого неявно типизированного ступенчатого массива применяется тот же самый общий подход, что и к объявлению обычных сту­ пенчатых массивов.

Как упоминалось выше, неявно типизированные массивы чаще всего применяются в LINQ-ориентированных запросах. А в остальных случаях следует использовать явно типизированные массивы.

Оператор цикла foreach

Как упоминалось в главе 5, в языке C# определен оператор цикла foreach, но его рас­ смотрение было отложено до более подходящего момента. Теперь этот момент настал.

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

Здесь тип имя_переменной_цикла обозначает тип и имя переменной управле­ ния циклом, которая получает значение следующего элемента коллекции на каждом шаге выполнения цикла foreach. А коллекция обозначает циклически опрашивае­ мую коллекцию, которая здесь и далее представляет собой массив. Следовательно, тип переменной цикла должен соответствовать типу элемента массива. Кроме того, тип может обозначаться ключевым словом var. В этом случае компилятор определяет тип переменной цикла, исходя из типа элемента массива. Это может оказаться полезным для работы с определенного рода запросами, как будет показано далее в данной книге. Но, как правило, тип указывается явным образом.

Оператор цикла foreach действует следующим образом. Когда цикл начинается, первый элемент массива выбирается и присваивается переменной цикла. На каждом последующем шаге итерации выбирается следующий элемент массива, который со­ храняется в переменной цикла. Цикл завершается, когда все элементы массива окажут­ ся выбранными. Следовательно, оператор foreach циклически опрашивает массив по отдельным его элементам от начала и до конца.

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

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

Выполнение приведенного выше кода дает следующий результат.

Как видите, оператор foreach циклически опрашивает массив по порядку индек­ сир ования от самого первого до самого последнего его элемента. Несмотря на то что цикл foreach повторяется до тех пор, пока не будут опрошены все элементы массива, его можно завершить преждевременно, воспользовавшись опе­ ратором break. Ниже приведен пример программы, в которой суммируются только пять первых элементов массива nums.

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

Совершенно очевидно, что цикл foreach завершается после выбора и вывода зна­ чения пятого элемента массива.

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

Выполнение этой программы дает следующий результат.

Оператор foreach допускает циклическое обращение к массиву только в опреде­ ленном порядке: от начала и до конца массива, поэтому его применение кажется, на первый взгляд, ограниченным. Но на самом деле это не так. В большом числе алго­ ритмов, самым распространенным из которых является алгоритм поиска, требуется именно такой механизм. В качестве примера ниже приведена программа, в которой цикл foreach используется для поиска в массиве определенного значения. Как только это значение будет найдено, цикл прервется.

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

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

С точки зрения регулярного программирования строковый тип данных string от­ носится к числу самых важных в С#. Этот тип определяет и поддерживает символьные строки. В целом ряде других языков программирования строка представляет собой массив символов. А в C# строки являются объектами. Следовательно, тип string от­ носится к числу ссылочных. И хотя string является встроенным в C# типом данных, его рассмотрение пришлось отложить до тех пор, пока не были представлены классы и объекты.

На самом деле класс типа string уже не раз применялся в примерах программ, начиная с главы 2, но это обстоятельство выясняется только теперь, когда очередь до­ шла до строк. При создании строкового литерала в действительности формируется строковый объект. Например, в следующей строке кода:

текстовая строка «В C# строки являются объектами.» автоматически преобра­ зуется в строковый объект средствами С#. Следовательно, применение класса типа string происходило в предыдущих примерах программ неявным образом. А в этом разделе будет показано, как обращаться со строками явным образом.

Самый простой способ построить символьную строку — воспользоваться строко­ вым литералом. Например, в следующей строке кода переменной ссылки на строку str присваивается ссылка на строковый литерал.

В данном случае переменная str инициализируется последовательностью симво­ лов «Строки в C# весьма эффективны.».

Объект типа string можно также создать из массива типа char. Например:

Как только объект типа string будет создан, его можно использовать везде, где только требуется строка текста, заключенного в кавычки. Как показано в приведенном ниже примере программы, объект типа string может служить в качестве аргумента при вызове метода WriteLine().

Результат выполнения этой программы приведен ниже.

Обращение со строками

Класс типа string содержит ряд методов для обращения со строками. Некото­ рые из этих методов перечислены в табл. 7.1. Обратите внимание на то, что некото­ рые методы принимают параметр типа StringComparison. Это перечислимый тип, определяющий различные значения, которые определяют порядок сравнения символьных строк. (О перечислениях речь пойдет в главе 12, но для применения типа StringComparison к символьным строкам знать о перечислениях необязательно.) Нетрудно догадаться, что символьные строки можно сравнивать разными способа­ ми. Например, их можно сравнивать на основании двоичных значений символов, из которых они состоят. Такое сравнение называется порядковым. Строки можно также сравнивать с учетом различных особенностей культурной среды, например, в лекси­ кографическом порядке. Это так называемое сравнение с учетом культурной среды. (Учитывать культурную среду особенно важно в локализуемых приложениях.) Кроме того, строки можно сравнивать с учетом или без учета регистра. Несмотря на то что существуют перегружаемые варианты методов Compare(), Equals(), IndexOf() и LastIndexOf(), обеспечивающие используемый по умолчанию подход к сравне­ нию символьных строк, в настоящее время считается более приемлемым явно указы­ вать способ требуемого сравнения, чтобы избежать неоднозначности, а также упро­ стить локализацию приложений. Именно поэтому здесь рассматривают разные спо­ собы сравнения символьных строк.

Как правило и за рядом исключений, для сравнения символьных строк с уче­ том культурной среды (т.е. языковых и региональных стандартов) применяется способ StringComparison.CurrentCulture. Если же требуется сравнить стро­ ки только на основании значений их символов, то лучше воспользоваться спосо­ бом StringComparison.Ordinal, а для сравнения строк без учета регистра — од­ ним из двух способов: StringComparison.CurrentCultureIgnoreCase или StringComparison.OrdinalIgnoreCase. Кроме того, можно указать сравнение строк без учета культурной среды (подробнее об этом — в главе 22).

Обратите внимание на то, что метод Compare() объявляется в табл. 7.1 как static. Подробнее о модификаторе static речь пойдет в главе 8, а до тех пор вкратце по­ ясним, что он обозначает следующее: метод Compare() вызывается по имени своего класса, а не по его экземпляру. Следовательно, для вызова метода Compare() служит следующая общая форма:

где способ обозначает конкретный подход к сравнению символьных строк.

ПРИМЕЧАНИЕ Дополнительные сведения о способах сравнения и поиска символьных строк, включая и особое значение выбора подходящего способа, приведены в главе 22, где подробно рассматривается обработка строк.

Обратите также внимание на методы ToUpper() и ToLower(), преобразующие со­ держимое строки в символы верхнего и нижнего регистра соответственно. Их формы, представленные в табл. 7.1, содержат параметр CultureInfо, относящийся к классу, в котором описываются атрибуты культурной среды, применяемые для сравнения. В примерах, приведенных в этой книге, используются текущие настройки культурной среды (т.е. текущие языковые и региональные стандарты). Эти настройки указываются при передаче методу аргумента CultureInfo.CurrentCulture. Класс CultureInfo относится к пространству имен System.Globalization. Любопытно, имеются вари­ анты рассматриваемых здесь методов, в которых текущая культурная среда исполь­ зуется по умолчанию, но во избежание неоднозначности в примерах из этой книги аргумент CultureInfo.CurrentCulture указывается явно.

Объекты типа string содержат также свойство Length, где хранится длина строки.

Таблица 7.1. Некоторые общеупотребительные методы обращения со строками

Отдельный символ выбирается из строки с помощью индекса, как в приведенном ниже фрагменте кода.

В этом фрагменте кода выводится символ «т», который является первым в строке «тест». Как и в массивах, индексирование строк начинается с нуля. Следует, однако, иметь в виду, что с помощью индекса нельзя присвоить новое значение символу в стро­ ке. Индекс может служить только для выборки символа из строки.

Для проверки двух строк на равенство служит оператор ==. Как правило, если опе­ ратор == применяется к ссылкам на объект, то он определяет, являются ли они ссыл­ ками на один и тот же объект. Совсем иначе обстоит дело с объектами типа string. Когда оператор == применяется к ссылкам на две строки, он сравнивает содержимое этих строк. Это же относится и к оператору !=. В обоих случаях выполняется поряд­ ковое сравнение. Для проверки двух строк на равенство с учетом культурной среды служит метод Equals(), где непременно нужно указать способ сравнения в виде ар­ гумента StringComparison.CurrentCulture. Следует также иметь в виду, что ме­ тод Compare() служит для сравнения строк с целью определить отношение порядка, например для сортировки. Если же требуется проверить символьные строки на ра­ венство, то для этой цели лучше воспользоваться методом Equals() или строковыми операторами.

В приведенном ниже примере программы демонстрируется несколько операций со строками.

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

Прежде чем читать дальше, обратите внимание на то, что метод Compare() вызы­ вается следующим образом.

Как пояснялось ранее, метод Compare() объявляется как static, и поэтому он вы­ зывается по имени, а не по экземпляру своего класса.

С помощью оператора + можно сцепить (т.е. объединить вместе) две строки. Например, в следующем фрагменте кода:

переменная str4 инициализируется строкой «ОдинДваТри».

И еще одно замечание: ключевое слово string является псевдонимом класса System.String, определенного в библиотеке классов для среды .NET Framework, т.е. оно устанавливает прямое соответствие с этим классом. Следовательно, поля и методы, определяемые типом string, относятся непосредственно к классу System.String, в который входят и многие другие компоненты. Подробнее о классе System.String речь пойдет в части II этой книги.

Аналогично данным любого другого типа, строки могут быть организованы в мас­ сивы. Ниже приведен соответствующий пример.

Вот какой результат дает выполнение приведенного выше кода.

Рассмотрим более интересный пример. В приведенной ниже программе целое чис­ ло выводится словами. Например, число 19 выводится словами «один девять».

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

В данной программе использован массив строк digits для хранения словесных обозначений цифр от 0 до 9. По ходу выполнения программы целое число преобразу­ ется в слова. Для этого сначала получаются отдельные цифры числа, а затем они сохра­ няются в обратном порядке следования в массиве n типа int. После этого выполняется циклический опрос массива n в обратном порядке. При этом каждое целое значение из массива п служит в качестве индекса, указывающего на слова, соответствующие по­ лученным цифрам числа и выводимые как строки.

Как ни странно, содержимое объекта типа string не подлежит изменению. Это означает, что однажды созданную последовательность символов изменить нельзя. Но данное ограничение способствует более эффективной реализации символьных строк. Поэтому этот, на первый взгляд, очевидный недостаток на самом деле превращается в преимущество. Так, если требуется строка в качестве разновидности уже имеющейся строки, то для этой цели следует создать новую строку, содержащую все необходимые изменения. А поскольку неиспользуемые строковые объекты автоматически собирают­ ся в «мусор», то о дальнейшей судьбе ненужных строк можно даже не беспокоиться.

Следует, однако, подчеркнуть, что переменные ссылки на строки (т.е. объекты типа string) подлежат изменению, а следовательно, они могут ссылаться на другой объект. Но содержимое самого объекта типа string не меняется после его создания.

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

где индекс_начала обозначает начальный индекс исходной строки, а длина — длину выбираемой подстроки.

Ниже приведена программа, в которой принцип постоянства строк демонстри­ руется на примере использования метода Substring().

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

Как видите, исходная строка из переменной orgstr не меняется, а выбранная из нее подстрока содержится в переменной substr.

И последнее замечание: несмотря на то, что постоянство строк обычно не являет­ ся ни ограничением, ни помехой для программирования на С#, иногда оказывается полезно иметь возможность видоизменять строки. Для этой цели в C# имеется класс StringBuilder, который определен в пространстве имен System.Text. Этот класс позволяет создавать строковые объекты, которые можно изменять. Но, как правило, в программировании на C# используется тип string, а не класс StringBuilder.

Применение строк в операторах switch

Объекты типа string могут использоваться для управления оператором switch. Это единственный нецелочисленный тип данных, который допускается применять в операторе switch. Благодаря такому применению строк в некоторых сложных си­ туациях удается найти более простой выход из положения, чем может показаться на первый взгляд. Например, в приведенной ниже программе выводятся отдельные циф­ ры, соответствующие словам «один», «два» и «три».

Ввод и вывод массива

Ввод и вывод массива, то есть заполнение массива пользователем программы и выдачу содержимого массива пользователю, можно делать по-разному. Рассмотрим далее два варианта ввода/вывода массива в консольном приложении — scanf/printf и cin/cout.

Ввод/вывод массива с помощью функций scanf и prntif

Функция scanf предназначается для ввода данных с клавиатуры.

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

C Language
Массивы

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

C поддерживает динамически распределенные массивы, размер которых определяется во время выполнения. C99 и более поздние версии поддерживают массивы переменной длины или VLA.

Синтаксис

• имя типа [длина]; / * Определить массив «type» с именем «name» и длиной «length». * /
• int arr [10] = <0>; / * Определить массив и инициализировать ВСЕ элементы в 0. * /
• int arr [10] = <42>; / * Определить массив и инициализировать 1-й элемент до 42, а остаток — 0. * /
• int arr [] = <4, 2, 3, 1>; / * Определить и инициализировать массив длиной 4. * /
• arr [n] = значение; / * Установленное значение при индексе n. * /
• значение = arr [n]; / * Получить значение по индексу n. * /

замечания

Зачем нам нужны массивы?

Массивы обеспечивают способ организации объектов в совокупность с его собственным значением. Например, строки C представляют собой массивы символов ( char s) и строку, такую ​​как «Hello, World!». имеет значение как совокупность, которая не присуща персонажам индивидуально. Аналогично, массивы обычно используются для представления математических векторов и матриц, а также списков многих видов. Более того, без какого-либо элемента для группировки элементов нужно будет решать каждый отдельно, например, через отдельные переменные. Мало того, что это громоздко, он не легко вмещает коллекции разной длины.

Массивы неявно преобразуются в указатели в большинстве контекстов .

За исключением случаев, когда он является операндом оператора sizeof оператором _Alignof (C2011) или оператором unary & (address-of) или как строковый литерал, используемый для инициализации (другого) массива, массив неявно преобразуется в ( «decays to») указатель на свой первый элемент. Это неявное преобразование тесно связано с определением оператора субтипирования массива ( [] ): выражение arr[idx] определяется как эквивалентное *(arr + idx) . Кроме того, поскольку арифметика указателя коммутативна, *(arr + idx) также эквивалентна *(idx + arr) , что, в свою очередь, эквивалентно idx[arr] . Все эти выражения действительны и оцениваются с одинаковым значением при условии, что либо idx либо arr является указателем (или массивом, который распадается на указатель), а другой является целым числом, а целое число является допустимым индексом в массив на который указывает указатель.

В качестве частного случая заметим, что &(arr[0]) эквивалентно &*(arr + 0) , что упрощается до arr . Все эти выражения взаимозаменяемы везде, где последний разпад указателя. Это просто снова выражает, что массив распадается на указатель на его первый элемент.

Напротив, если адрес-оператор применяется к массиву типа T[N] ( т.е. &arr ), тогда результат имеет тип T (*)[N] и указывает на весь массив. Это отличается от указателя на первый элемент массива, по крайней мере, относительно арифметики указателя, которая определяется в терминах размера заостренного типа.

Функциональные параметры не являются массивами .

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

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

Общий синтаксис объявления одномерного массива

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

Объявление массива (массив из 10 переменных int в этом случае) выполняется следующим образом:

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

В массивах также могут быть инициализаторы, в этом примере объявляется массив из 10 int , где первые 3 int будут содержать значения 1 , 2 , 3 , все остальные значения будут равны нулю:

В приведенном выше методе инициализации первое значение в списке будет присвоено первому члену массива, второе значение будет присвоено второму элементу массива и так далее. Если размер списка меньше размера массива, то, как и в предыдущем примере, остальные члены массива будут инициализированы нулями. С назначенной инициализацией списка (ISO C99) возможна явная инициализация элементов массива. Например,

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

Объявление массива нулевой длины недопустимо.

В C99 были добавлены массивы переменной длины (VLA для краткости) и были добавлены в C11. Они равны нормальным массивам, с одной, важной, разницей: длина не обязательно должна быть известна во время компиляции. У VLA есть время автоматического хранения. Только указатели на VLA могут иметь статическую продолжительность хранения.

Важный:

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

Очистка содержимого массива (обнуление)

Иногда необходимо установить массив в ноль после завершения инициализации.

Общим сокращением к вышеуказанному циклу является использование memset() из <string.h> . Проходящий array как показано ниже, заставляет его распадаться на указатель на его 1-й элемент.

Как и в этом примере, array представляет собой массив, а не только указатель на 1-й элемент массива (см. Длину массива на том, почему это важно), возможно третий вариант для вывода из массива:

Длина массива

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

Однако в большинстве контекстов, где массив появляется в выражении, он автоматически преобразуется в указатель («decays to») на свой первый элемент. Случай, когда массив является операндом оператора sizeof является одним из небольшого числа исключений. Результирующий указатель сам по себе не является массивом, и он не несет никакой информации о длине массива, из которого он был получен. Поэтому, если эта длина необходима в сочетании с указателем, например, когда указатель передается функции, он должен передаваться отдельно.

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

Функция может быть реализована следующим образом:

Обратите внимание, в частности, что хотя объявление input параметра похоже на объявление массива, оно фактически объявляет input как указатель (для int ). Это точно эквивалентно объявлению input как int *input . То же самое было бы верно, даже если бы было дано измерение. Это возможно, потому что массивы никогда не могут быть фактическими аргументами для функций (они распадаются на указатели, когда они появляются в выражениях вызова функций), и их можно рассматривать как мнемонические.

Это очень распространенная ошибка, чтобы попытаться определить размер массива из указателя, который не может работать. НЕ ДЕЛАЙТЕ ЭТОГО:

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

Установка значений в массивах

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

В качестве побочного эффекта операндов к оператору + заменить (-> коммутативный закон) следующее эквивалентно:

так что следующие утверждения эквивалентны:

C не выполняет никаких пограничных проверок, доступ к содержимому вне объявленного массива не определен (доступ к памяти за пределами выделенного фрагмента ):

Определить массив и элемент массива доступа

Выделить и нуль инициализировать массив с заданным пользователем размером

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

В случае успеха память освобождается вызовом free() .

Итерация через массив эффективно и порядок строк

Массивы в C можно рассматривать как непрерывный кусок памяти. Точнее, последнее измерение массива — это смежная часть. Мы называем это строковым порядком . Понимая это и тот факт, что ошибка кэша загружает полную кеш-строку в кеш при доступе к нераскрытым данным, чтобы предотвратить последующие ошибки кэша, мы видим, почему доступ к массиву размера 10000×10000 с array[0][0] потенциально может быть загружен в array[0][1] в кеше, но доступ к array[1][0] сразу же сгенерировал бы вторую ошибку кэша, так как это sizeof(type)*10000 bytes from array[0][0] , и, следовательно, в той же строке кэша. Вот почему итерация таким образом неэффективна:

Итерация таким образом более эффективна:

В том же духе, поэтому при работе с массивом с одним измерением и несколькими индексами (скажем, 2 измерения здесь для простоты с индексами i и j) важно выполнить итерацию по массиву следующим образом:

Или с 3 измерениями и индексами i, j и k:

Или более общим образом, когда у нас есть массив с элементами N1 x N2 x . x Nd , d измерениями и индексами, отмеченными как n1, n2, . nd, смещение рассчитывается так

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

Язык программирования C позволяет использовать многомерные массивы . Вот общая форма объявления многомерного массива —

Например, следующее объявление создает трехмерный (5 x 10 x 4) целочисленный массив:

Двумерные массивы

Простейшей формой многомерного массива является двумерный массив. Двумерный массив представляет собой, по существу, список одномерных массивов. Чтобы объявить двумерный целочисленный массив размеров mxn, мы можем написать следующее:

Где type может быть любым допустимым типом данных C ( int , float и т. Д.), А arrayName может быть любым допустимым идентификатором C. Двумерный массив можно визуализировать как таблицу с m строками и n столбцами. Примечание : порядок имеет значение в C. Массив int a[4][3] не совпадает с массивом int a[3][4] . Количество строк приходит сначала в качестве С является строка -Майора языка.

Двумерный массив a , содержащий три строки и четыре столбца, можно показать следующим образом:

Таким образом, каждый элемент в массиве a идентифицируется именем элемента формы a[i][j] , где a — это имя массива, i представляет, какую строку и j представляет собой какой столбец. Напомним, что строки и столбцы нулевые индексируются. Это очень похоже на математическое обозначение для подписи двухмерных матриц.

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

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

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

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

Доступ к двумерным элементам массива

Доступ к элементу в двумерном массиве осуществляется с помощью индексов, то есть индекса строки и индекса столбца массива. Например,

Вышеприведенный оператор берет 4-й элемент из 3-й строки массива. Давайте проверим следующую программу, в которой мы использовали вложенный цикл для обработки двумерного массива:

Когда приведенный выше код компилируется и выполняется, он производит следующий результат:

Трехмерный массив:

3D-массив по существу представляет собой массив массивов массивов: это массив или набор 2D-массивов, а 2D-массив — массив из 1-го массива.

Карта памяти 3D-массива:

Инициализация 3D-массива:

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

Итерация через массив с помощью указателей

Здесь, при инициализации p в первом for цикла условиях, массив a распадается на указатель на его первый элемент, как и во всех местах, где используется такая переменная массива.

Затем ++p выполняет арифметику указателя на указателе p и идет один за другим через элементы массива и ссылается на них путем разыменования их с помощью *p .

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

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