Объявление массива строк c: C#. Массивы строк типа string[]. Примеры решения задач

Содержание

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

  • Чтение занимает 2 мин

В этой статье

Для создания одномерного массива используется оператор new и указывается тип элементов массива и число элементов.You create a single-dimensional array using the new operator specifying the array element type and the number of elements. В следующем примере показано объявление массива, содержащего пять целых чисел:The following example declares an array of five integers:

int[] array = new int[5];

Этот массив содержит элементы с array[0] по array[4].This array contains the elements from array[0] to array[4]. Элементы массива элементы инициализируются до значения по умолчанию для типа элемента. Для целых чисел это 0.The elements of the array are initialized to the default value of the element type,

0 for integers.

Массивы могут хранить любой указанный тип элемента. Например, в следующем примере приводится объявление массива строк:Arrays can store any element type you specify, such as the following example that declares an array of strings:

string[] stringArray = new string[6];

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

Элементы массива можно инициализировать при объявлении.You can initialize the elements of an array when you declare the array. В этом случае не требуется спецификатор длины, поскольку он уже задан по числу элементов в списке инициализации.The length specifier isn’t needed because it’s inferred by the number of elements in the initialization list. Пример:For example:

int[] array1 = new int[] { 1, 3, 5, 7, 9 };

Ниже приведено объявление массива строк, где каждый элемент массива инициализируется с использованием названия дня:The following code shows a declaration of a string array where each array element is initialized by a name of a day:

string[] weekDays = new string[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };

Если массив инициализируется при объявлении, можно не использовать выражение new и тип массива, как показано в следующем коде.You can avoid the new expression and the array type when you initialize an array upon declaration, as shown in the following code. Такой массив называется неявно типизированным:This is called an implicitly typed array:

int[] array2 = { 1, 3, 5, 7, 9 };
string[] weekDays2 = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };

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

new.You can declare an array variable without creating it, but you must use the new operator when you assign a new array to this variable. Пример:For example:

int[] array3;
array3 = new int[] { 1, 3, 5, 7, 9 };   // OK
//array3 = {1, 3, 5, 7, 9};   // Error

Массивы типов значений и ссылочных типовValue Type and Reference Type Arrays

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

SomeType[] array4 = new SomeType[10];

Результат этого оператора зависит от того, является ли SomeType типом значения или ссылочным типом.The result of this statement depends on whether SomeType is a value type or a reference type. Если это тип значения, оператор создает массив из 10 элементов, каждый из которых имеет тип

SomeType.If it’s a value type, the statement creates an array of 10 elements, each of which has the type SomeType. Если SomeType является ссылочным типом, этот оператор создает массив из 10 элементов, каждый из которых инициализируется с использованием ссылки NULL.If SomeType is a reference type, the statement creates an array of 10 elements, each of which is initialized to a null reference. В обоих случаях элементы инициализируются до значения по умолчанию для типа элемента.In both instances, the elements are initialized to the default value for the element type. См. дополнительные сведения о типах значений и ссылочных типах.For more information about value types and reference types, see Value types and Reference types.

См. такжеSee also

Массивы в C++ — урок 5

Сегодня мы с поговорим о массивах. Вы уже знаете, что переменная — это ячейка в памяти компьютера, где может храниться одно единственное значение.

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

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

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

string students[10] = {
    "Иванов", "Петров", "Сидоров",
    "Ахмедов", "Ерошкин", "Выхин",
    "Андеев", "Вин Дизель", "Картошкин", "Чубайс"
};

Описание синтаксиса

Массив создается почти так же, как и обычная переменная. Для хранения десяти фамилий нам нужен массив, состоящий из 10 элементов. Количество элементов массива задается при его объявлении и заключается в квадратные скобки.

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

Попробуем вывести наш массив на экран с помощью оператора cout.

#include <iostream>
#include <string>

int main()    
{
    std::string students[10] = {
        "Иванов", "Петров", "Сидоров",
        "Ахмедов", "Ерошкин", "Выхин",
        "Андеев", "Вин Дизель", "Картошкин", "Чубайс"
    };
    std::cout << students << std::endl; // Пытаемся вывести весь массив непосредственно
    return 0;
}

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

  • Первый вывод: 0x7ffff8b85820
  • Второй вывод: 0x7fff7a335f90
  • Третий вывод: 0x7ffff847eb40

Мы видим, что выводится адрес этого массива в оперативной памяти, а никакие не «Иванов» и «Петров».

Дело в том, что при создании переменной, ей выделяется определенное место в памяти. Если мы объявляем переменную типа int, то на машинном уровне она описывается двумя параметрами — ее адресом и размером хранимых данных.

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

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

Попробуем вывести первый элемент массива — фамилию студента Иванова.

#include <iostream>
#include <string>

int main()
{    
    std::string students[10] = {
        "Иванов", "Петров", "Сидоров",
        "Ахмедов", "Ерошкин", "Выхин",
        "Андеев", "Вин Дизель", "Картошкин", "Чубайс"
    };
    std::cout << students[0] <<  std::endl;
    return 0;
}

Смотрим, компилируем, запускаем. Убедились, что вывелся именно «Иванов». Заметьте, что нумерация элементов массива в C++ начинается с нуля. Следовательно, фамилия первого студента находится в students[0], а фамилия последнего — в students[9].

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

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

cout?

Конечно же нет! Мы возьмем на вооружение циклы, о которых был написан предыдущий урок.

Вывод элементов массива через цикл

#include <iostream>
#include <string>

int main()
{
    std::string students[10] = {
        "Иванов", "Петров", "Сидоров",
        "Ахмедов", "Ерошкин", "Выхин",
        "Андеев", "Вин Дизель", "Картошкин", "Чубайс"
    };  
    for (int i = 0; i < 10; i++) {
        std::cout << students[i] << std::endl;
    }

    return 0;
}

Если бы нам пришлось выводить массив из нескольких тысяч фамилий, то мы бы просто увеличили конечное значение счетчика цикла — строку

for (...; i < 10; ...) заменили на for (...; i < 10000; ...).

Заметьте что счетчик нашего цикла начинается с нуля, а заканчивается девяткой. Если вместо оператора строгого неравенства — i < 10 использовать оператор «меньше, либо равно» — i <= 10, то на последней итерации программа обратится к несуществующему элементу массива — students[10]. Это может привести к ошибкам сегментации и аварийному завершению программы. Будьте внимательны — подобные ошибки бывает сложно отловить.

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

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

string students[10];
// или
string teachers[5];

Элементы такого массива обычно содержат в себе «мусор» из выделенной, но еще не инициализированной, памяти. Некоторые компиляторы, такие как GCC, заполняют все элементы массива нулями при его создании.

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

int n;
cin >> n;
string students[n]; /* Неверно */

Выделение памяти в процессе выполнения возможно при работе с динамическими массивами. Но о них немного позже.

Заполним с клавиатуры пустой массив из 10 элементов.

Заполнение массива с клавиатуры

#include <iostream>
#include <string>

using std::cout;
using std::cin;
using std::endl;

int main()
{    
        int arr[10];

        // Заполняем массив с клавиатуры
        for (int i = 0; i < 10; i++) {
            cout << "[" << i + 1 << "]" << ": ";
            cin >> arr[i];
        }

        // И выводим заполненный массив.
        cout << "\nВаш массив: ";

        for (int i = 0; i < 10; ++i) {
            cout << arr[i] << " ";
        }

        cout << endl;

        return 0;
}

Скомпилируем эту программу и проверим ее работу.

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

Массивы — очень важная вещь в программировании. Автор советует вам хорошо попрактиковаться в работе с ними.

Следующий урок: Функции в C++ →.

Массивы в C++ | Уроки С++

  Обновл. 15 Сен 2020  | 

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

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

К счастью, структуры не являются единственным агрегированным типом данных в языке C++. Есть еще массив — совокупный тип данных, который позволяет получить доступ ко всем переменным одного и того же типа данных через использование одного идентификатора.

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

// Выделяем 30 целочисленных переменных (каждая с разным именем) int testResultStudent1; int testResultStudent2; int testResultStudent3; // … int testResultStudent30;

// Выделяем 30 целочисленных переменных (каждая с разным именем)

int testResultStudent1;

int testResultStudent2;

int testResultStudent3;

// …

int testResultStudent30;

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

int testResult[30]; // выделяем 30 целочисленных переменных, используя фиксированный массив

int testResult[30]; // выделяем 30 целочисленных переменных, используя фиксированный массив

В объявлении переменной массива мы используем квадратные скобки [], чтобы сообщить компилятору, что это переменная массива (а не обычная переменная), а в скобках — количество выделяемых элементов (это называется длиной или размером массива).

В примере, приведенном выше, мы объявили фиксированный массив с именем testResult и длиной 30. Фиксированный массив (или «массив фиксированной длины») представляет собой массив, размер которого известен во время компиляции. При создании testResult, компилятор выделит 30 целочисленных переменных.

Элементы массива

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

В вышеприведенном примере первым элементом в нашем массиве является testResult[0], второй — testResult[1], десятый — testResult[9], последний — testResult[29]. Хорошо, что уже не нужно отслеживать и помнить кучу разных (хоть и похожих) имен переменных — для доступа к разным элементам нужно изменять только индекс.

Важно: В отличие от повседневной жизни, отсчет в программировании и в языке С++ всегда начинается с 0, а не с 1!

В массиве длиной N элементы массива будут пронумерованы от 0 до N-1! Это называется диапазоном массива.

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

Здесь мы можем наблюдать как определение, так и индексирование массива:

#include <iostream> int main() { int array[5]; // массив из пяти чисел array[0] = 3; // индекс первого элемента — 0 (нулевой элемент) array[1] = 2; array[2] = 4; array[3] = 8; array[4] = 12; // индекс последнего элемента — 4 std::cout << «The array element with the smallest index has the value » << array[0] << «\n»; std::cout << «The sum of the first 5 numbers is » << array[0] + array[1] + array[2] + array[3] + array[4] << «\n»; return 0; }

#include <iostream>

int main()

{

    int array[5]; // массив из пяти чисел

    array[0] = 3; // индекс первого элемента — 0 (нулевой элемент)

    array[1] = 2;

    array[2] = 4;

    array[3] = 8;

    array[4] = 12; // индекс последнего элемента — 4

    std::cout << «The array element with the smallest index has the value » << array[0] << «\n»;

    std::cout << «The sum of the first 5 numbers is » << array[0] + array[1] + array[2] + array[3] + array[4] << «\n»;

    return 0;

}

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

The array element with the smallest index has the value 3
The sum of the first 5 numbers is 29

Типы данных и массивы

Массив может быть любого типа данных. Например, объявляем массив типа double:

#include <iostream> int main() { double array[3]; // выделяем 3 переменные типа double array[0] = 3.5; array[1] = 2.4; array[2] = 3.4; std::cout << «The average is » << (array[0] + array[1] + array[2]) / 3 << «\n»; return 0; }

#include <iostream>

int main()

{

    double array[3]; // выделяем 3 переменные типа double

    array[0] = 3.5;

    array[1] = 2.4;

    array[2] = 3.4;

    std::cout << «The average is » << (array[0] + array[1] + array[2]) / 3 << «\n»;

    return 0;

}

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

The average is 3.1

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

struct Rectangle { int length; int width; }; Rectangle rects[4]; // объявляем массив с 4-мя прямоугольниками

struct Rectangle

{

    int length;

    int width;

};

Rectangle rects[4]; // объявляем массив с 4-мя прямоугольниками

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

Индексы массивов

В языке C++ индексы массивов всегда должны быть интегрального типа данных (т.е. типа char, short, int, long, long long, bool и т.д.). Эти индексы могут быть либо константными значениями, либо неконстантными значениями. Например:

int array[4]; // объявляем массив длиной 4 // Используем литерал (константу) в качестве индекса array[2] = 8; // хорошо // Используем перечисление (константу) в качестве индекса enum Animals { ANIMAL_CAT = 3 }; array[ANIMAL_CAT] = 5; // хорошо // Используем переменную (не константу) в качестве индекса short index = 4; array[index] = 8; // хорошо

int array[4]; // объявляем массив длиной 4

// Используем литерал (константу) в качестве индекса

array[2] = 8; // хорошо

// Используем перечисление (константу) в качестве индекса

enum Animals

{

    ANIMAL_CAT = 3

};

array[ANIMAL_CAT] = 5; // хорошо

// Используем переменную (не константу) в качестве индекса

short index = 4;

array[index] = 8; // хорошо

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

При объявлении массива фиксированного размера, его длина (между квадратными скобками) должна быть константой типа compile-time (которая определяется во время компиляции). Вот несколько разных способов объявления массивов с фиксированным размером:

// Используем литерал int array[7]; // хорошо // Используем макрос-объект с текст_замена в качестве символьной константы #define ARRAY_WIDTH 4 int array[ARRAY_WIDTH]; // синтаксически хорошо, но не делайте этого // Используем символьную константу const int arrayWidth = 7; int array[arrayWidth]; // хорошо // Используем перечислитель enum ArrayElements { MIN_ARRAY_WIDTH = 3 }; int array[MIN_ARRAY_WIDTH]; // хорошо // Используем неконстантную переменную int width; std::cin >> width; int array[width]; // плохо: width должна быть константой типа compile-time! // Используем константную переменную типа runtime int temp = 8; const int width = temp; int array[width]; // плохо: здесь width является константой типа runtime, но должна быть константой типа compile-time!

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

// Используем литерал

int array[7]; // хорошо

// Используем макрос-объект с текст_замена в качестве символьной константы

#define ARRAY_WIDTH 4

int array[ARRAY_WIDTH]; // синтаксически хорошо, но не делайте этого

// Используем символьную константу

const int arrayWidth = 7;

int array[arrayWidth]; // хорошо

// Используем перечислитель

enum ArrayElements

{

    MIN_ARRAY_WIDTH = 3

};

int array[MIN_ARRAY_WIDTH]; // хорошо

// Используем неконстантную переменную

int width;

std::cin >> width;

int array[width]; // плохо: width должна быть константой типа compile-time!

// Используем константную переменную типа runtime

int temp = 8;

const int width = temp;

int array[width]; // плохо: здесь width является константой типа runtime, но должна быть константой типа compile-time!

Обратите внимание, в двух последних случаях мы должны получить ошибку, так как длина массива не является константой типа compile-time. Некоторые компиляторы могут разрешить использование таких массивов, но они являются некорректными в соответствии со стандартами языка C++ и не должны использоваться в программах, написанных на C++.

Чуть-чуть о динамических массивах

Поскольку массивам фиксированного размера память выделяется во время компиляции, то здесь мы имеем два ограничения:

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

   Фиксированные массивы имеют фиксированную длину, которую нельзя изменить.

Во многих случаях эти ограничения являются проблематичными. К счастью, C++ поддерживает еще один тип массивов, известный как динамический массив. Размер такого массива может быть установлен ​​во время выполнения программы и его можно изменить. Однако создание динамических массивов несколько сложнее фиксированных, поэтому мы поговорим об этом несколько позже.

Заключение

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

На следующем уроке мы рассмотрим больше тем, связанных с фиксированными массивами.

Оценить статью:

Загрузка…

Поделиться в социальных сетях:

Руководство по программированию на C#. Массивы

  • Чтение занимает 2 мин

В этой статье

В структуре данных массива можно хранить несколько переменных одного типа.You can store multiple variables of the same type in an array data structure. Чтобы объявить массив, следует указать тип его элементов.You declare an array by specifying the type of its elements. Если требуется, чтобы массив мог хранить элементы любого типа, можно указать object в качестве его типа.If you want the array to store elements of any type, you can specify object as its type. В унифицированной системе типов C# все типы, стандартные и определяемые пользователем, ссылочные типы и типы значений напрямую или косвенно наследуются из Object.In the unified type system of C#, all types, predefined and user-defined, reference types and value types, inherit directly or indirectly from Object.

type[] arrayName;

ПримерExample

В следующих примерах создаются одномерные массивы, многомерные массивы и массивы массивов:The following example creates single-dimensional, multidimensional, and jagged arrays:

class TestArraysClass
{
    static void Main()
    {
        // Declare a single-dimensional array of 5 integers.
        int[] array1 = new int[5];

        // Declare and set array element values.
        int[] array2 = new int[] { 1, 3, 5, 7, 9 };

        // Alternative syntax.
        int[] array3 = { 1, 2, 3, 4, 5, 6 };

        // Declare a two dimensional array.
        int[,] multiDimensionalArray1 = new int[2, 3];

        // Declare and set array element values.
        int[,] multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } };

        // Declare a jagged array.
        int[][] jaggedArray = new int[6][];

        // Set the values of the first array in the jagged array structure.
        jaggedArray[0] = new int[4] { 1, 2, 3, 4 };
    }
}

Общие сведения о массивахArray overview

Массив имеет следующие свойства:An array has the following properties:

  • Массив может быть одномерным, многомерным или массивом массивов.An array can be Single-Dimensional, Multidimensional or Jagged.
  • Количество измерений и длина каждого из измерений задаются, когда создается экземпляр массива.The number of dimensions and the length of each dimension are established when the array instance is created. Эти значения нельзя изменить во время существования экземпляра.These values can’t be changed during the lifetime of the instance.
  • Используемые по умолчанию значения числовых элементов массива равны нулю, и элементам ссылки присвоено значение NULL.The default values of numeric array elements are set to zero, and reference elements are set to null.
  • В массиве массивов элементы являются ссылочными типами и инициализируются значением null.A jagged array is an array of arrays, and therefore its elements are reference types and are initialized to null.
  • Массивы индексируются от нуля: массив с n элементами индексируется от 0 до n-1.Arrays are zero indexed: an array with n elements is indexed from 0 to n-1.
  • Элементы массива могут иметь любой тип, в том числе тип массива.Array elements can be of any type, including an array type.
  • Типы массивов — это ссылочные типы, производные от абстрактного базового типа Array.Array types are reference types derived from the abstract base type Array. Поскольку этот тип реализует IEnumerable и IEnumerable<T>, вы можете просматривать в цикле foreach любые массивы C#.Since this type implements IEnumerable and IEnumerable<T>, you can use foreach iteration on all arrays in C#.

Спецификация языка C#C# language specification

Дополнительные сведения см. в спецификации языка C#.For more information, see the C# Language Specification. Спецификация языка является предписывающим источником информации о синтаксисе и использовании языка C#.The language specification is the definitive source for C# syntax and usage.

См. такжеSee also

Одномерные массивы

— Руководство по программированию на C #

  • 2 минуты на чтение

В этой статье

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

  int [] массив = новый int [5];
  

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

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

  строка [] stringArray = новая строка [6];
  

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

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

  int [] array1 = new int [] {1, 3, 5, 7, 9};
  

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

  строка [] weekDays = новая строка [] {«Вс», «Пн», «Вт», «Ср», «Чт», «Пт», «Сб»};
  

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

  int [] array2 = {1, 3, 5, 7, 9};
string [] weekDays2 = {«Вс», «Пн», «Вт», «Ср», «Чт», «Пт», «Сб»};
  

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

  int [] array3;
array3 = новый int [] {1, 3, 5, 7, 9}; // В ПОРЯДКЕ
// array3 = {1, 3, 5, 7, 9}; // Ошибка
  

Тип значения и массив ссылочного типа

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

  SomeType [] array4 = новый SomeType [10];
  

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

См. Также

.Массивы

— Руководство по программированию на C #

  • 2 минуты на чтение

В этой статье

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

  тип [] имя_массива;
  

Пример

В следующем примере создаются одномерные, многомерные и зубчатые массивы:

  класс TestArraysClass
{
    статическая пустота Main ()
    {
        // Объявить одномерный массив из 5 целых чисел.
        int [] array1 = новый int [5];

        // Объявление и установка значений элементов массива.int [] array2 = новый int [] {1, 3, 5, 7, 9};

        // Альтернативный синтаксис.
        int [] array3 = {1, 2, 3, 4, 5, 6};

        // Объявить двумерный массив.
        int [,] multiDimensionalArray1 = новый int [2, 3];

        // Объявление и установка значений элементов массива.
        int [,] multiDimensionalArray2 = {{1, 2, 3}, {4, 5, 6}};

        // Объявляем массив с зубчатыми краями.
        int [] [] jaggedArray = новый int [6] [];

        // Устанавливаем значения первого массива в структуре зубчатого массива.jaggedArray [0] = новый интервал [4] {1, 2, 3, 4};
    }
}
  

Обзор массива

Массив имеет следующие свойства:

  • Массив может быть одномерным, многомерным или зубчатым.
  • Количество измерений и длина каждого измерения устанавливаются при создании экземпляра массива. Эти значения нельзя изменить в течение времени существования экземпляра.
  • Значения по умолчанию для элементов числового массива равны нулю, а ссылочные элементы равны нулю.
  • Неровный массив — это массив массивов, поэтому его элементы являются ссылочными типами и инициализируются значением null .
  • Массивы имеют нулевой индекс: массив из n элементов индексируется от 0 до n-1 .
  • Элементы массива могут быть любого типа, включая тип массива.
  • Типы массивов — это ссылочные типы, производные от абстрактного базового типа Array. Поскольку этот тип реализует IEnumerable и IEnumerable , вы можете использовать итерацию foreach для всех массивов в C #.

Спецификация языка C #

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

См. Также

.

массивов C ++ (с примерами)

В C ++ массив — это переменная, которая может хранить несколько значений одного типа. Например,

Предположим, в классе 27 учеников, и нам нужно сохранить оценки всех из них. Вместо того, чтобы создавать 27 отдельных переменных, мы можем просто создать массив:

  двойной сорт [27];  

Здесь grade — это массив, который может содержать максимум 27 элементов типа double .

В C ++ размер и тип массивов не могут быть изменены после его объявления.


Объявление массива C ++

  dataType имя_массива [размер_массива];  

Например,

  int x [6];  

Здесь,

  • int — тип сохраняемого элемента
  • x — имя массива
  • 6 — размер массива

Элементы доступа в массиве C ++

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

  // синтаксис для доступа к элементам массива
массив [индекс];  

Рассмотрим массив x , который мы видели выше.

Элементы массива в C ++

Несколько вещей, которые следует помнить:


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

В C ++ можно инициализировать массив во время объявления. Например,

  // объявляем и инициализируем и массив
int x [6] = {19, 10, 8, 17, 9, 15};  
C ++ Элементы массива и их данные

Другой метод инициализации массива во время объявления:

  // объявляем и инициализируем массив
int x [] = {19, 10, 8, 17, 9, 15};  

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


Массив C ++ с пустыми элементами

В C ++, если массив имеет размер n , мы можем хранить до n элементов в массиве. Однако что будет, если мы сохраним меньше n элементов.

Например,

  // храним только 3 элемента в массиве
int x [6] = {19, 10, 8};  

Здесь массив x имеет размер 6 .Однако мы инициализировали его всего с 3 элементами.

В таких случаях компилятор присваивает оставшимся местам случайные значения. Часто это случайное значение просто 0 .

Пустым элементам массива автоматически присваивается значение 0

Как вставлять и распечатывать элементы массива?

  int mark [5] = {19, 10, 8, 17, 9}

// меняем 4-й элемент на 9
отметка [3] = 9;

// принимаем ввод от пользователя
// сохраняем значение в третьей позиции
cin >> mark [2];


// принимаем ввод от пользователя
// вставляем в i-ю позицию
cin >> mark [i-1];

// выводим первый элемент массива
cout << mark [0];

// выводим i-й элемент массива
cout >> mark [i-1];  

Пример 1: Отображение элементов массива

  #include 
используя пространство имен std;

int main () {
    int числа [5] = {7, 5, 6, 12, 35};

    cout << "Цифры следующие:";

    // Печать элементов массива
    // использование диапазона для цикла
    for (const int & n: numbers) {
        cout << n << "";
    }


    cout << "\ nЦифры:";

    // Печать элементов массива
    // используя традиционный цикл for
    for (int i = 0; i <5; ++ i) {
        cout << числа [i] << "";
    }

    возврат 0;
}  

Выход

  Цифры: 7 5 6 12 35
Цифры: 7 5 6 12 35  

Здесь мы использовали цикл для , чтобы выполнить итерацию от i = 0 до i = 4 .На каждой итерации мы выводили чисел [i] .

Мы снова использовали цикл for, основанный на диапазоне, для вывода элементов массива. Чтобы узнать больше об этом цикле, проверьте C ++ Ranged for Loop.

Примечание: В нашем цикле на основе диапазона мы использовали код const int & n вместо int n в качестве объявления диапазона. Однако более предпочтительным является const int & n , потому что:

  1. Использование int n просто копирует элементы массива в переменную n во время каждой итерации.Это неэффективно с точки зрения памяти.

    & n , однако, использует адрес памяти элементов массива для доступа к их данным, не копируя их в новую переменную. Это эффективно с точки зрения памяти.

  2. Мы просто печатаем элементы массива, а не изменяем их. Поэтому мы используем const , чтобы случайно не изменить значения массива.

Пример 2: Получение входных данных от пользователя и сохранение их в массиве

  #include 
используя пространство имен std;

int main () {
    int числа [5];

    cout << "Введите 5 чисел:" << endl;

    // сохраняем ввод от пользователя в массив
    for (int i = 0; i <5; ++ i) {
        cin >> числа [i];
    }

    cout << "Цифры следующие:";

    // выводим элементы массива
    for (int n = 0; n <5; ++ n) {
        cout << числа [n] << "";
    }

    возврат 0;
}  

Выход

  Введите 5 цифр:
11
12
13
14
15
Цифры: 11 12 13 14 15  

И снова мы использовали цикл для , чтобы выполнить итерацию от i = 0 до i = 4 .На каждой итерации мы принимали ввод от пользователя и сохраняли его в числах [i] .

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


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

  #include 
используя пространство имен std;

int main () {
    
    // инициализируем массив без указания размера
    двойные числа [] = {7, 5, 6, 12, 35, 27};

    двойная сумма = 0;
    двойной счет = 0;
    двойное среднее;

    cout << "Цифры следующие:";

    // выводим элементы массива
    // использование цикла for на основе диапазона
    for (const double & n: числа) {
        cout << n << "";

        // вычисляем сумму
        сумма + = n;

        // подсчитываем количествоэлементов массива
        ++ count;
    }

    // выводим сумму
    cout << "\ nTheir Sum =" << sum << endl;

    // находим среднее
    среднее = сумма / количество;
    cout << "Их среднее значение =" << среднее << endl;

    возврат 0;
}  

Выход

  Цифры: 7 5 6 12 35 27
Их сумма = 92
Их среднее значение = 15,3333  

В этой программе:

  1. Мы инициализировали массив double с именем numbers , но без указания его размера.Мы также объявили три двойные переменные: сумма , количество и среднее значение .

    Здесь сумма = 0 и count = 0 .

  2. Затем мы использовали цикл на основе диапазона для для печати элементов массива. На каждой итерации цикла мы добавляем текущий элемент массива к сумме .
  3. Мы также увеличиваем значение count на 1 на каждой итерации, чтобы мы могли получить размер массива к концу цикла for.
  4. После печати всех элементов мы печатаем сумму и среднее значение всех чисел. Среднее значение чисел равно среднее = сумма / счет;

Примечание: Мы использовали диапазон для цикла вместо обычного для цикла .

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

Но диапазон для петли не требует таких спецификаций.


Массив C ++ за пределами границ

Если мы объявим массив размером 10, то массив будет содержать элементы с индекса 0 до 9.

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

.

Объявление массива - cppreference.com

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

[править] Синтаксис

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

[ статические (необязательно) квалификаторы (необязательно) выражение (необязательно) ] (1)
[ квалификаторы (необязательно) статические (необязательно) выражение (необязательно) ] (2)
[ квалификаторы (необязательно) * ] (3)

1,2) Общий синтаксис декларатора массива

3) Декларатор для VLA неопределенного размера (может появляться только в области видимости прототипа функции) где

выражение - любое выражение, кроме оператора запятой, обозначает количество элементов в массиве
квалификаторы - любая комбинация квалификаторов const, restrict или volatile, разрешенная только в списках параметров функций; это определяет тип указателя, в который преобразуется этот параметр массива
 float fa [11], * afp [17]; // fa - это массив из 11 чисел с плавающей запятой
                        // afp - это массив из 17 указателей на числа с плавающей запятой 

[править] Объяснение

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

[править] Массивы постоянного известного размера

Если выражение в деклараторе массива является целочисленным константным выражением со значением больше нуля, а тип элемента - это тип с известным постоянным размером (то есть элементы не являются VLA) (начиная с C99), то декларатор объявляет массив постоянного известного размера:

 int n [10]; // целочисленные константы - это постоянные выражения
char o [sizeof (двойной)]; // sizeof - постоянное выражение
перечисление {MAX_SZ = 100};
int n [MAX_SZ]; // константы перечисления являются постоянными выражениями 

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

 int a [5] = {1,2,3}; // объявляет int [5] инициализированным до 1,2,3,0,0
char str [] = "abc"; // объявляет char [4] инициализированным как 'a', 'b', 'c', '\ 0' 

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

В каждом вызове функции, в которой параметр типа массива использует ключевое слово static между [ и ] , значение фактического параметра должно быть действительным указателем на первый элемент массива, содержащий как минимум столько элементов, сколько указано в выражении:

 void fadd (double a [static 10], const double b [static 10])
{
    for (int i = 0; i <10; i ++) {
        если (a [i] <0,0) возврат;
        а [я] + = Ь [я];
    }
}
// вызов fadd может выполнить проверку границ времени компиляции
// а также разрешает оптимизацию, такую ​​как предварительная выборка 10 двойников
int main (пусто)
{
    дважды a [10] = {0}, b [20] = {0};
    причуда (а, б); // В ПОРЯДКЕ
    двойной x [5] = {0};
    fadd (x, b); // неопределенное поведение: аргумент массива слишком мал
} 

Если квалификаторы присутствуют, они определяют тип указателя, в который преобразуется тип параметра массива:

 int f (const int a [20])
{
 // в этой функции a имеет тип const int * (указатель на const int)
}
int g (const int a [const 20])
{
 // в этой функции a имеет тип const int * const (указатель const на const int)
} 

Обычно используется с квалификатором типа restrict:

 void fadd (double a [static restrict 10],
          const double b [статическое ограничение 10])
{
    for (int i = 0; i <10; i ++) {// цикл можно развернуть и переупорядочить
        если (а [я] <0.0) перерыв;
        а [я] + = Ь [я];
    }
} 
Массивы переменной длины

Если выражение не является целочисленным константным выражением, декларатор предназначен для массива переменного размера.

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

 {
   int n = 1;
этикетка:
   int a [n]; // перераспределение 10 раз, каждый с другим размером
   printf ("В массиве% элементов zu \ n", sizeof a / sizeof * a);
   if (n ++ <10) перейти к метке; // выход из области видимости VLA завершает свое время жизни
} 

Если размер составляет * , декларация предназначена для VLA неопределенного размера. Такое объявление может появляться только в области видимости прототипа функции и объявляет массив полного типа. Фактически, все деклараторы VLA в области прототипа функции обрабатываются так, как если бы выражение было заменено на * .

 void foo (size_t x, int a [*]);
void foo (size_t x, int a [x])
{
    printf ("% zu \ n", размер a); // то же, что и sizeof (int *)
} 

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

 extern int n;
int A [n]; // Ошибка: область файла VLA
внешний int (* p2) [n]; // Ошибка: область файла VM
int B [100]; // ОК: массив файловой области постоянного известного размера
void fvla (int m, int C [m] [m]); // ОК: прототип VLA 

VLA должен иметь автоматическую продолжительность хранения.Указатели на VLA, но не сами VLA, также могут иметь статическую продолжительность хранения. Никакой тип ВМ не может иметь связи.

 void fvla (int m, int C [m] [m]) // ОК: указатель области видимости блока / автоматической продолжительности на VLA
{
    typedef int VLA [м] [м]; // ОК: блокируем область видимости VLA
    int D [м]; // OK: область действия блока / автоматическая длительность VLA
// статический int E [m]; // Ошибка: статическая длительность VLA
// внешний int F [m]; // Ошибка: VLA с привязкой
    int (* s) [м]; // ОК: область действия блока / автоматическая длительность ВМ
// внешний int (* r) [m]; // Ошибка: ВМ с привязкой
    статический int (* q) [м] = & B; // ОК: область действия блока / статическая длительность ВМ}
} 

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

 struct tag {
    int z [n]; // Ошибка: член структуры VLA
    int (* y) [n]; // Ошибка: член структуры ВМ
}; 
(начиная с C99)

Если компилятор определяет макроконстанту __STDC_NO_VLA__ как целочисленную константу 1, то типы VLA и VM не поддерживаются.

(начиная с C11)
[править] Массивы неизвестного размера

Если выражение в деклараторе массива опущено, оно объявляет массив неизвестного размера.За исключением списков параметров функций (где такие массивы преобразуются в указатели) и когда доступен инициализатор, такой тип является неполным типом (обратите внимание, что VLA неопределенного размера, объявленный с размером * , является полным типом ) (начиная с C99):

 extern int x []; // тип x - "массив неизвестной границы int"
int a [] = {1,2,3}; // тип a - "массив из 3 int" 

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

 struct s {int n; двойной d []; }; // s.d - гибкий элемент массива
struct s * s1 = malloc (sizeof (struct s) + (sizeof (double) * 8)); // как если бы d было двойным d [8] 
(начиная с C99)

[править] Квалификаторы

Если тип массива объявлен с квалификатором const, volatile, restrict (начиная с C99) или _Atomic (начиная с C11) (что возможно с использованием typedef), тип массива не квалифицируется, но его тип элемента:

 typedef int A [2] [3];
const A a = {{4, 5, 6}, {7, 8, 9}}; // массив массива const int
int * pi = a [0]; // Ошибка: a [0] имеет тип const int * 
[править] Назначение

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

 int a [3] = {1,2,3}, b [3] = {4,5,6};
int (* p) [3] = & a; // хорошо, адрес можно взять
// a = b; // ошибка, a - массив
структура {int c [3]; } s1, s2 = {3,4,5};
s1 = s2; // хорошо: можно назначать структуры, содержащие элементы массива 
[править] Преобразование массива в указатель

Любое lvalue-выражение типа массива при использовании в любом контексте, кроме

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

Если массив был объявлен регистром, поведение программы, которая пытается такое преобразование, не определено.

 int a [3] = {1,2,3};
int * p = a;
printf ("% zu \ n", размер a); // выводит размер массива
printf ("% zu \ n", размер p); // выводит размер указателя 

Когда тип массива используется в списке параметров функции, он преобразуется в соответствующий тип указателя: int f (int a [2]) и int f (int * a) объявляют одну и ту же функцию. Поскольку фактический тип параметра функции является типом указателя, вызов функции с аргументом массива выполняет преобразование массива в указатель; размер массива аргументов недоступен для вызываемой функции и должен быть передан явно:

 void f (int a [], int sz) // фактически объявляет void f (int * a, int sz)
{
    для (int i = 0; i 
 
[править] Многомерные массивы

Когда тип элемента массива - другой массив, говорят, что массив является многомерным:

 // массив из 2 массивов по 3 int в каждом
int a [2] [3] = {{1,2,3}, // можно рассматривать как матрицу 2x3
               {4,5,6}}; // с макетом строк 

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

 int a [2] [3]; // матрица 2x3
int (* p1) [3] = a; // указатель на первую строку из 3 элементов
int b [3] [3] [3]; // куб 3x3x3
int (* p2) [3] [3] = b; // указатель на первую плоскость 3x3 

Многомерные массивы можно изменять в каждом измерении:

 int n = 10;
int a [n] [2 * n]; 
(начиная с C99)

[править] Примечания

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

Если выражение размера VLA имеет побочные эффекты, они гарантированно будут созданы, за исключением случаев, когда оно является частью выражения sizeof, результат которого не зависит от него:

 int n = 5;
size_t sz = sizeof (int (*) [n ++]); // может или не может увеличивать n 

[править] Ссылки

  • Стандарт C11 (ISO / IEC 9899: 2011):
  • 6.7.6.2 Деклараторы массивов (стр: 130-132)
  • Стандарт C99 (ISO / IEC 9899: 1999):
  • 6.7.5.2 Деклараторы массивов (стр. 116-118)
  • Стандарт C89 / C90 (ISO / IEC 9899: 1990):
  • 3.5.4.2 Деклараторы массивов

[править] См. Также

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Theme: Overlay by Kaira Extra Text
Cape Town, South Africa