Массивы

именем.

С#-массивы относятся к ссылочным типам данных, реализованы как объекты.

Имя массива

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

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

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

того же типа, объединенных общим именем, где каждый элемент имеет

свой номер.

Объявляется ссылочная переменная на массив

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

int[] myArray = { 0, 1, 2, 3,

4, 5, 6, 7, 8, 9 };
int i;
for (i = 0; i < 10; ++i)
Console.WriteLine(myArray[i]);
}


static void Main()
{
int[] myArray = new int[10];
int i;
for (i = 0; i < 10; i++)
myArray[i] = i * i;
for (i = 0; i < 10; i++)
Console.WriteLine(myArray[i]);
}

[ ] myArray = new int [ ] { 99,

10, 100, 18, 78, 23, 163, 9, 87, 49 };



static void Main()
{
int[] myArray = { 0, 1, 2, 3, 4, 5};
int i;
for (i = 0; i < 10; i++)
Console.Write(" "+myArray[i]);
Console.WriteLine("\nНовый массив: ");
myArray = new int[] { 99, 10, 100, 18, 78, 23, 163, 9, 87, 49 };
for (i = 0; i < 10; i++)
Console.Write(" " + myArray[i]);
}

1.переменная myArray ссылалась на 6-ти элементный массив.
2.переменной myArray была присвоена ссылка на новый 10-элементный массив, в результате чего исходный массив оказался неиспользуемым, т.к. на него теперь не ссылается ни один объект.
3.он автоматически будет удален сборщиком мусора.

int[] myArray = { 0, 1,

2, 3, 4, 5, 6, 7, 8, 9 };
int i;
try
{
for (i = 0; i <= 10; i++) Console.WriteLine(myArray[i]);
}
catch (IndexOutOfRangeException)
{
Console.WriteLine("Exception: Выход за границу диапазона");
}
}

Выход за границы массива в C# расценивается как ошибка, в ответ на которую генерируется исключение - IndexOutOfRangeException

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

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

Print(int n, int[] a) //n – размерность массива, а –

ссылка на массив
{
for (int i = 0; i < n; i++) Console.Write("{0} ", a[i]);
Console.WriteLine(); }
 
static void Change(int n, int[] a)
{
for (int i = 0; i < n; i++)
if (a[i] > 0) a[i] = 0; // изменяются элементы массива
}
 
static void Main()
{
int[] myArray = { 0, -1, -2, 3, 4, 5, -6, -7, 8, -9 };
Print(10, myArray);
Change(10, myArray);
Print(10, myArray); }
}

статическому методу Sort класса Array и передача данному методу в качестве параметра

объект myArray - экземпляр класса Array*/
Array.Sort(myArray)

Обращение к свойству или вызов экземплярного метода производится через обращение к экземпляру класса
Например:
myArray.Length
или
myArray.GetValue(i)

{

try {
int[] MyArray;
Console.Write("Введите размерность массива: ");
int n = int.Parse(Console.ReadLine());
MyArray = new int[n];
for (int i = 0; i < MyArray.Length; ++i)
{ Console.Write("a[{0}]=",i);
MyArray[i] = int.Parse(Console.ReadLine()); }
PrintArray("исходный массив:", MyArray);
Array.Sort(MyArray);
PrintArray("массив отсортирован по возрастанию", MyArray);
Array.Reverse(MyArray);
PrintArray("массив отсортирован по убыванию", MyArray); }
catch (FormatException) {
Console.WriteLine("неверный формат ввода данных"); }
catch (OverflowException)
{ Console.WriteLine("переполнение"); }
catch (OutOfMemoryException) {
Console.WriteLine("недостаточно памяти для создания нового объекта"); } }
static void PrintArray(string a, int[] mas) { Console.WriteLine(a);
for (int i = 0; i < mas.Length; i++) Console.Write("{0} ", mas[i]);
Console.WriteLine(); } } }

размер2];

тип [,] имя__массива={{элементы 1-ой строки}, … , {элементы n-ой строки}};

тип

[,] имя__массива= new тип [,]{{элементы 1-ой строки}, … ,{элементы n-ой строки}};

Например:
int [,] a;

int [,] a= new int [3, 4];

int [,] a={{0, 1, 2}, {3, 4, 5}};

int [,] a= new int [,]{{0, 1, 2}, {3, 4, 5}};

0; i < mas.GetLength(0); i++)
{ for (int j = 0; j

< mas.GetLength(1); j++)
Console.Write("{0} ", mas[i, j]);
Console.WriteLine(); }
}
  static void Change(int[,] mas) {
for (int i = 0; i < mas.GetLength(0); i++)
for (int j = 0; j < mas.GetLength(1); j++)
if (mas[i, j] % 2 == 0) mas[i, j] = 0; }
  static void Main(){
try { int[,] MyArray ={ { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
PrintArray("исходный массив:", MyArray);
Change(MyArray);
PrintArray("итоговый массив", MyArray); }
catch (FormatException)
{ Console.WriteLine("неверный формат ввода данных"); }
catch (OverflowException)
{ Console.WriteLine("переполнение"); }
catch (OutOfMemoryException)
{ Console.WriteLine("недостаточно памяти для создания нового объекта"); } } }

[ ] [ ] jagged = new int [ 3

] [ ] ;
jagged [0] = new int [ 4 ] ;
jagged [1] = new int [ 3 ] ;
jagged [2] = new int [ 5 ] ;

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

{
try

{ int[][] MyArray; Console.Write("Ввведите количесвто строк: ");
int n = int.Parse(Console.ReadLine()); MyArray = new int[n][];
for (int i = 0; i < MyArray.Length; i++)
{ Console.Write("введите количество элементов в {0} строке: ", i);
int j = int.Parse(Console.ReadLine()); MyArray[i] = new int[j];
for (j = 0; j < MyArray[i].Length; j++)
{ Console.Write("a[{0}][{1}]= ", i, j); MyArray[i][j] = int.Parse(Console.ReadLine()); } }
PrintArray("исходный массив:", MyArray);
for (int i = 0; i < MyArray.Length; i++) Array.Sort(MyArray[i]);
PrintArray("измененный массив", MyArray); }
catch (FormatException)
{ Console.WriteLine("неверный формат ввода данных"); }
catch (OverflowException)
{ Console.WriteLine("переполнение"); }
catch (OutOfMemoryException)
{ Console.WriteLine("недостаточно памяти для создания нового объекта"); } }
  static void PrintArray(string a, int[][] mas) {
Console.WriteLine(a);
for (int i = 0; i < mas.Length; i++)
{ for (int j = 0; j < mas[i].Length; j++) Console.Write("{0} ", mas[i][j]); Console.WriteLine(); } } }

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

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

foreach (<тип> <имя> in <группа>) <тело цикла>
 
где имя определяет локальную по отношению к циклу переменную, которая будет по очереди принимать все значения из указанной группы, а тип соответствует базовому типу элементов группы.

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

a, int [] mas)
{

Console.WriteLine(a);
foreach (int x in mas)Console.Write("{0} ", x);
Console.WriteLine(); }

2) для работы с двумерными массивами:
static int Sum (int [,] mas)
{
int s=0;
foreach (int x in mas) s += x;
return s; }
 
3) для работы со ступенчатыми массивами:
static void PrintArray3(string a, int[][] mas)
{
Console.WriteLine(a);
for (int i = 0; i < mas.Length; i++)
{
foreach (int x in mas[i]) Console.Write("{0} ", x);
Console.WriteLine(); } }