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

Kak Inicializirovat Massivy V C



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

Методы инициализации массивов в C#

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







1: Инициализация массивов с использованием синтаксиса инициализатора массива

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



инт [ ] числа = { 1 , 2 , 3 , 4 , 5 } ;


В этом коде массив целых чисел с именем «numbers» создается и инициализируется значениями от 1 до 5. Точно так же вы можете использовать тот же синтаксис для инициализации многомерного массива.



инт [ , ] мой многомерный массив = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;


Вот пример кода, который использует синтаксис инициализатора для инициализации массива 1D и 2D в C#:





с помощью системы;

массив классов
{
статическая пустота Главная ( нить [ ] аргументы )
{
// Инициализация одномерного массива с использованием синтаксиса инициализатора
инт [ ] массив1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Значения в массиве1D:' ) ;
для ( я = 0 ; я < массив1D.Длина; я++ ) {
Console.WriteLine ( массив1D [ я ] ) ;
}
// Инициализация двумерного массива с использованием синтаксиса инициализатора
инт [ , ] массив2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Значения в массиве2D:' ) ;
для ( я = 0 ; я < array2D.GetLength ( 0 ) ; я++ ) {
для ( интервал j = 0 ; Дж < array2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , я, j, массив2D [ я, дж ] ) ;
}
}
}
}


В этом коде мы используем синтаксис инициализатора для инициализации одномерного целочисленного массива с именем array1D со значениями 1, 2, 3, 4 и 5.

Мы также используем синтаксис инициализатора для инициализации двумерного целочисленного массива с именем array2D со значениями {1, 2}, {3, 4} и {5, 6}.



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

2: Инициализация массивов с использованием нового ключевого слова

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

инт [ ] числа = новое целое число [ 5 ] ;


Этот код создает целочисленный массив с именем numbers размером 5 и инициализирует все элементы их значением по умолчанию, которое равно 0 для целочисленных массивов.

Вот синтаксис для инициализации многомерного массива с использованием нового ключевого слова в C#:

< тип > [ , ] < имя_массива > = новый < тип > [ < длина1 > , < длина2 > , ... ] { { < начальные значения > } } ;


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

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

инт [ , ] мой массив = новый интервал [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;


В этом примере мы инициализируем двумерный целочисленный массив с именем myArray с 3 строками и 2 столбцами, используя ключевое слово new. Мы также предоставляем начальные значения для каждого элемента массива, используя синтаксис двойных фигурных скобок. Значения {1, 2}, {3, 4} и {5, 6} соответствуют элементам в каждой строке.

Вот пример того, как использовать ключевое слово new для инициализации одномерного и двумерного массива в C#, а также код для вывода значений в каждом массиве:

с помощью системы;

массив классов
{
статическая пустота Главная ( нить [ ] аргументы )
{
// Инициализация 1 -мерный массив
инт [ ] myArray1D = новое целое число [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Значения в myArray1D:' ) ;
для ( я = 0 ; я < мойМассив1D.Длина; я++ )
{
Console.WriteLine ( мой массив1D [ я ] ) ;
}
// Инициализация 2 -мерный массив
инт [ , ] myArray2D = новый интервал [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Значения в myArray2D:' ) ;
для ( я = 0 ; я < myArray2D.GetLength ( 0 ) ; я++ )
{
для ( интервал j = 0 ; Дж < myArray2D.GetLength ( 1 ) ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , я, j, мой массив2D [ я, дж ] ) ;
}
}
}
}


В этом коде мы используем ключевое слово new для инициализации одномерного целочисленного массива с именем мой массив1D со значениями 1, 2, 3, 4 и 5, а также двумерный целочисленный массив, называемый мой массив2D со значениями {1, 2}, {3, 4} и {5, 6}.

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

3. Инициализация массивов с помощью циклов

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

инт [ ] числа = новое целое число [ 5 ] ;
для ( я = 0 ; я < числа.Длина; я++ )
{
числа [ я ] = я + 1 ;
}


Этот код создает именованный массив целых чисел с размером 5 и присваивает каждому элементу значение, равное его индексу плюс 1. Вот пример того, как инициализировать двумерный массив целых чисел в C# с помощью циклов:

инт [ , ] мой массив = новый интервал [ 3 , 2 ] ;
для ( я = 0 ; я < 3 ; я++ )
{
для ( интервал j = 0 ; Дж < 2 ; j++ )
{
мой массив [ я, дж ] = я + j;
}
}


В этом примере мы используем вложенные циклы for для перебора каждого элемента двумерного целочисленного массива с именем мой массив , который имеет 3 строки и 2 столбца. Для каждого элемента мы устанавливаем его значение как сумму его индексов строки и столбца, используя выражение i + j.

Вот пример того, как использовать циклы для инициализации одномерного и двумерного массива в C#, а также код для вывода значений в каждом массиве:

с помощью системы;

массив классов
{
статическая пустота Главная ( нить [ ] аргументы )
{
// Инициализация 1 -мерный массив с использованием цикла
инт [ ] myArray1D = новое целое число [ 5 ] ;
для ( я = 0 ; я < мойМассив1D.Длина; я++ )
{
мой массив1D [ я ] = я + 1 ;
}
Console.WriteLine ( 'Значения в myArray1D:' ) ;
для ( я = 0 ; я < мойМассив1D.Длина; я++ )
{
Console.WriteLine ( мой массив1D [ я ] ) ;
}
// Инициализация 2 -мерный массив с использованием вложенных циклов
инт [ , ] myArray2D = новый интервал [ 3 , 2 ] ;
для ( я = 0 ; я < 3 ; я++ )
{
для ( интервал j = 0 ; Дж < 2 ; j++ )
{
мой массив2D [ я, дж ] = я + j;
}
}
Console.WriteLine ( 'Значения в myArray2D:' ) ;
для ( я = 0 ; я < 3 ; я++ )
{
для ( интервал j = 0 ; Дж < 2 ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , я, j, мой массив2D [ я, дж ] ) ;
}
}
}
}


В этом коде мы используем цикл for для инициализации одномерного целочисленного массива с именем myArray1D со значениями 1, 2, 3, 4 и 5. Мы также используем вложенные циклы for для инициализации двумерного целочисленного массива с именем myArray2D со значениями {0, 1}, {1, 2} и {2, 3}, используя выражение i + j.

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

4: Инициализация массивов с помощью Array.Copy()

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

инт [ ] источник '=' { 1 , 2 , 3 , 4 , 5 } ;
инт [ ] цель = новое целое [ источник.Длина ] ;
Массив.Копировать ( источник , цель, источник.Длина ) ;


Этот код создает массив целых чисел с именем source со значениями от 1 до 5, создает новый массив целых чисел с именем target с тем же размером, что и источник, а затем копирует элементы из источника в место назначения.

Позвольте мне представить пример, демонстрирующий использование Array.Copy для инициализации двумерного целочисленного массива в C#:

инт [ , ] исходный массив = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
инт [ , ] targetArray = новое целое число [ 3 , 2 ] ;

Массив.Копировать ( исходный массив, целевой массив, исходный массив. Длина ) ;


В этом примере у нас есть двумерный целочисленный массив с именем исходный массив с 3 строками и 2 столбцами. мы используем Массив.Копировать() чтобы скопировать содержимое sourceArray в новый двумерный целочисленный массив с именем destinationArray, который также имеет 3 строки и 2 столбца.

Массив.Копировать() метод принимает три аргумента : исходный массив , целевой массив , и длина копируемых данных. В данном случае мы копируем все содержимое исходный массив в назначениемассив , так что проходим sourceArray.Длина в качестве третьего аргумента.

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

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

Вот полный код, который использует Массив.Копировать() функция для инициализации массива в C#:

с помощью системы;

массив классов
{
статическая пустота Главная ( нить [ ] аргументы )
{
// Инициализация 1 -размерный массив с использованием Array.Copy
инт [ ] исходный массив1D = { 1 , 2 , 3 , 4 , 5 } ;
инт [ ] назначениеArray1D = новое целое [ 5 ] ;
Массив.Копировать ( sourceArray1D, targetArray1D, sourceArray1D.Length ) ;
Console.WriteLine ( 'Значения в массиве назначения1D:' ) ;
для ( я = 0 ; я < назначениеArray1D.Длина; я++ ) {
Console.WriteLine ( назначениеArray1D [ я ] ) ;
}
// Инициализация 2 -размерный массив с использованием Array.Copy
инт [ , ] исходный массив2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
инт [ , ] назначениеArray2D = новое целое [ 3 , 2 ] ;
Массив.Копировать ( sourceArray2D, targetArray2D, sourceArray2D.Length ) ;
Console.WriteLine ( 'Значения в targetArray2D:' ) ;
для ( я = 0 ; я < назначениеArray2D.GetLength ( 0 ) ; я++ ) {
для ( интервал j = 0 ; Дж < назначениеArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , я, j, назначениеArray2D [ я, дж ] ) ;
}
}
}
}


В этом коде мы используем Массив.Копировать() для инициализации одномерного целочисленного массива с именем destinationArray1D со значениями 1, 2, 3, 4 и 5 из исходного массива с именем sourceArray1D.

Мы также используем Массив.Копировать() для инициализации двумерного целочисленного массива с именем destinationArray2D со значениями {1, 2}, {3, 4} и {5, 6} из исходного массива с именем sourceArray2D.

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

Заключение

В этой статье мы рассмотрели различные способы инициализации массивов в C#. Мы рассмотрели синтаксис инициализатора массива, используя ключевое слово new, инициализацию массивов с помощью циклов и метод Array.Copy(). В зависимости от конкретного варианта использования каждый из этих методов обладает своим набором преимуществ и недостатков. Знакомство с этими разнообразными подходами позволит вам выбрать наиболее подходящий для ваших конкретных требований.