Объявление и инициализация строк

МАССИВЫ

Понятие массива

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

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

В языке С# массив определен как класс с именем Array. Следовательно, массив относится к ссылочным типам данных. Различают с точки зрения размерности:

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

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

- Массив массивов (массив ссылок на другие массивы).

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

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

Тип элементов[] ИмяМассива;

ИмяМассива = new Тип элементов[кол-во элементов];

int[] a; - описание массива (ссылка)

a=new int[3]; - формирование объекта

с помощью конструктора

new

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

int[] a;

a=new int[]{10, 20, 300};

Обратили внимание, что в квадратных скобках не указана размерность массива? При наличии инициализатора в фигурных скобках с перечислением всех значений массива, транслятор определяет размерность по факту- автоматически. Если укажете и размерность и инициализатор, ошибки не будет. Если инициализатор длиннее указанной размерности, будет фиксирована размерность по факту. Во избежание ошибки лучше задавая инциализатор без указания размерности. Далее фактический размер массива определяем с помощью свойства Length.

Операции

Операции с элементами – любые операции, определенные для того типа, к которому относятся элементы массива.

a[2]=a[0]+a[1]

В данном примере элементы массива – целые числа. Операция сложения возможна над целыми числами, т.е. и над элементами массива того же типа можно выполнять арифметические операции.

Нулевой элемент массива имеет значение 10, первый – значение 20. Сумма 10+20 присваивается второму элементы массива a[2]. В результате операции присваивания старое значение массива (300) переопределено, теперь значение равно 30.

Операции с массивом:

· присваивание (копируется значение ссылки)

· отношение (сравниваются значения ссылок)

int[] a, b, c; // описание массива и двух переменных

bool f1, f2; // описание двух логических переменных

a=new int[]{10, 20}; // сформирован объект – массив целых числе, размерность - 2

b=new int[]{10, 20};// сформирован объект – массив целых числе, размерность - 2

f1= a==b; //false, т.к. 100≠200 сравнение ссылок на массивы

	…

c=a;// присвоено с значение ссылки а

f2= c==a; //true 100=100, а и с указывают на одну область памяти. Т.е. номер ячейки

b=a;

Область памяти, на которую потеряна ссылка (в данном случае область памяти по адресу 200), ставится в очередь на освобождение. Эта память будет автоматически освобождена программой MSDN «Сборщик мусора».

Понятие строки

Строка предназначена для хранения текста в виде множества символов (кодировка Unicode: 1 символ – 2 байта).

Отличия от массива

- Хотя строка структурно подобна массиву, но формально строка не является массивом и имеет собственный тип данных string со своим набором свойств и методов.

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

- Операции с объектами типа строка содержательно выполняются не так, как операции с массивами.

Объявление и инициализация строк

String ИмяСтроки;

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

string s=”ИШ-ФДП”;

Имя строки, как и имя любого массива, указывает на первый ее элемент (адрес ячейки памяти, где расположен элемент с индексом 0). Все элементы строки располагаются в памяти в подряд идущих ячейках памяти, т.е. в непрерывной области памяти. Чем отличается массив символов от строки?

У строк последний элемент формируется автоматически и называется управляющий 0, ноль-символ, ил символ конца строки. Если к массиву символов дописать символьную константу ‘\n’, то мы получим строку (но массив должен быть объявлен как string).

Операции со строками

Операции над элементами строки – это все операции, определенные для типа char. Исключение: над элементом строки запрещена операция присваивания, т.е. значение элемента строки изменить непосредственно невозможно.

int Код; string s=”ABBA”; // объявление стоки с инициализацией строковой константой

Код=s[0]; // Код => код символа ‘A’=65 по таблице кодировки

s[0]=’Z’; // ошибка!

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

Операции над строками

- Присваивание:

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

string s1=”ВАСЯ”, s2;

s2=s1;

Т.е. в строках по адресу 100 и по адресу 200

располагаются одинаковые сроки. Скопирована в

результате операции s2=s1; строка.

Обратите внимание на инициализацию строк!

Строковая константа (литерал) заключается в кавычки.Символьные константы, напоминаем, - в апострофах (‘f’)

- Отношения:

Операции равно(= =) и неравно(!=) равносильны сравнению значений строк.

s2= =s1; //true ВАСЯ=ВАСЯ

В этом заключается отличие строки от массива - для массивов сравниваются ссылки.

Операции больше(>), больше или равно(>=), меньше(<), меньше или равно(<=) равносильны сравнению ссылок.

s2>=s1; //false 100>=200

При выполнении указанных операций отличий между массивом и строкой нет – в обоих случаях сравниваются ссылки.

Для того, чтобы сравнить строки на предмет больше/меньше по значению необходимо использовать метод CompareTo.

- Сцепление строк:

строка1+строка2=>новая строка - объединение исходных

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

int a=10, b=20;

string s1, s2, s3;

s1=”Итого:”+a; // Итого:10

s2=” Итого:”+a+b; // Итого:1020

s3=a+b+”= Итого”; //30= Итого

Методы обработки строк.

Понятие строки и операции со строками были рассмотрены ранее. Остановимся на дополнительных возможностях, которые предоставляются методами класса string.

Методы объекта:

сравнение строк на предмет больше-меньше

ИмяСтроки.CompareTo(строка, с которой сравниваем)

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

-1, если строка < той, с которой сравниваем

0, если строка = той, с которой сравниваем

+1, если строка > той, с которой сравниваем

Замена в вызывающей строке всех подстрок s1 на новую подстроку s2.

Вставка в вызывающую строку строки s1 с заданной позиции.

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

Разбиение вызывающей строки на слова. Возможные разделители между словами указываются в массиве символов.

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

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

Массив строк

Метод Join - статический

string s1=”око , за”;

string[] word;

char[] sep; // массив разделителей

sep = new char[]{‘ ’, ‘,’};

s1=s1.Insert(8, “_око”);

// с 8-й позиции массива s1 дописывается массив “_око”

s1=s1.Replace(“око”, “зуб”); s1 зуб,_за_ зуб

//заменили око на зуб

word=s1.Split(sep);

// из строки получили массив строк

s1=string.Join (“>”, word);

Форматирование строки

Класс string содержит статический метод Format(), с помощью которого можно сформировать строку на основе заданных значений в заданной программистом форме.

Метод Format имеет две группы параметрова:

Вид форматирования:

- обычные символы (копируются в строку)

- спецификаторы

{номер значения<,ширина поля><:Вид Кол-во знаков>}

Вид спецификации:

· D или d - целое число

· F или f – вещественное число в форме F

· E или e – веществ. число в форме E (мантисса и порядок)

· Nилиn – вещественное число с выделением тысячи

· Xилиx – целое 16-ричное число

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

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

double a=1234.5678;

long b=3456;

short c=65;

string s1, s2, s3;

s1=string.Format(“{0,8:f2}#{1,8:n2},a,a);

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

s1=string.Format(“{0,-8:d}#{1,8:d6},b,b);

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

Одномерный массив - набор элементов одного типа, тип элементов стандартный или определен в разрабатываемой программе.

double[] a;

a=new double[3];

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

string[] w;

w=new string[]{“МОСКВА”, “МАРСЕЛЬ”, “РИМ”};// в массиве три строки

w =>

string s=“”; // пустая строка

s=s+w[0][0]+w[2][1]+w[1][2]; // s => МИР

Здесь применена конкатенация ссылки s с элементами массива строк w. А именно: w[0][0 ] – нулевой элемент в нулевой строке массива. Нулевая стока массива – «МОСКВА», ее нулевой элемент символ ‘М ‘.w[2][1] - вторая строка, первый элемент. Это строка «РИМ», ее первый элемент символ ‘ И‘.

Тип массива определен как классArray(т.е. ссылочный тип) в пространстве имен System.

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

Дополнительные возможности определяются полями и методами.

Для массива определено поле объекта – Length, определяющее количество элементов в массиве.

Статические методы:

void

- Sort

- Reverse

Метод Copyвыполняет копирование элементов из массива оригинала в массив копию. Метод Sort сортирует заданную часть массива по возрастанию значения элементов. Метод Reverse выполняет переворот заданной части массива.

int[] a,b; //массивы a и b, ссылки

a=new int[]{10,20,30,40};// инициализация объекта

b=new int[a.Length]; // 2-ой массив той же длины

Array.Copy (a, 1, b, 0, 2); // копирование из а с 1-й позиции в b с нулевой 2-х эл-в

Array.Sort (b, 0, b.Length); // отсортировали все элементы из b

Array.Reverse (b, 1, 2);

//Массив a: 10 20 30 40

//Массив b после копирования: 20 30 0 0 - оставшиеся эл-ы нули

//Массив b после сортировки: 0 0 20 30

//Массив b после переворота: 0 20 0 30- переворот b с 1-й позиции двух значений

Динамические массивы

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

Альтернативой массиву в этом случае является динамический массив. Динамический массив определен как класс ArrayList в пространстве имен System.Collections.

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

Поле объекта: Count– количество элементов в динамическом массиве

Методы объекта для добавления элементов в массив:

Add (значение) // добавление элемента в конец массива

AddRange (массив) // добавление массива в конец массива

Insert (номер позиции, значение) //добавление элемента в заданную позицию

InsertRange (номер позиции, массив) // добавление массива с заданной позиции

Методы объекта для удаления элементов из массива:

Remove (значение)

RemoveAt (номер позиции)

RemoveRange (номер позиции, количествово элементов)

Clear ()// удаление всех элементов

Пример:

ArrayList_a;

int[] b,c;

b=new int[]{10, 20}; // создан объект – массив целых чисел 10 20

c=new int[100]; // создан объект – массив из 100 элементов

a=new ArrayList(); // создан объект, но еще не инициализирован

a.Add(5); // 5

a.Insert(0,77); // в позицию 0 массива занесено значение 77 : 77 5

a.AddRange (b); // Добавляет элементы в конец объекта типа ArrayList: 77 5 10 20

a.Clear(); // пусто 0

Еще пример с использованием Add (вместо массива указан список):

using System;

using System.Collections.Generic;

class Program

{

static void Main()

{

List<int> a = new List<int>();

a.Add(1);

a.Add(2);

a.Add(5);

a.Add(6);

// Список содержит элементы 1 2 5 6

// 2

// 5

// 6

int[] b = new int[3];

b[0] = 7;

b[1] = 6;

b[2] = 7;

a.AddRange(b);

// Contains:

// 1

// 2

// 5

// 6

// 7 [added]

// 6 [added]

// 7 [added]

foreach (int i in a)// поэлементный вывод списка на экран

{

Console.WriteLine(i);

}

}

}

Вывод:

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

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

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

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

динамический массив(a) → обычный массив(b)

a.CopyTo (позиция в дин.мас-ве ,обычный массив, позиция в обычном массиве, кол-во элементов)

обычный массив(b) → динамический массив(a)

a.AddRange (b) //добавление обычного массива в пустой динамический

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

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

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

Объявление двумерного массива:

Тип элементов [,] ИмяМассива;

ИмяМассива=new Тип элементов [кол-во строк, кол-во столбцов];

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

int[,] a, b; a b

a=new int[3,2];

b=new int[,] {{1,2}, {3,4}, {5,6}};

Свойство Length применительно к двумерному массиву соответствует общему количеству элементов: b.Length => 6. Признак массива – квадратные скобки. Запятая внутри скобок говорит о том, что у массива два измерения. Это таблица. Так как массив ане инициализирован и не имеет присвоенных значений, по умолчанию все его элементы обнулены. В инициализаторе массива b каждая строка заключена в фигурные скобки. Поэтому мы и не указали размерность. Если размерность указана, а инициализаторы строк короче, то оставшиеся позиции имеют нулевое значение.

Пример:

Сформировать и выдать на экран целочисленную единичную матрицу размером m×n.

int [,] a;

int i,j; //номера строк и столбцов, их называют индексными переменными

string s; //строка, формирующая символьное значение строки матрицы

int n=5;

a=new int [n,n];// определен объект – матрица 5 х 5

for (i=0; i<n; i++)

a [i,i]=1;

for (i=0; i<n; i++)

{ s=””;

for (j=0; j<n; j++)

s=s + a[i,j] + “_”;

Console.WriteLine (s);

Console. ReadLine ();

Задание: скопируйте в новый проект в тело модуля Main() код, отладьте задачу и определите вывод

Массив массивов

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

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

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

Массив

Строка

Элементы количество элементов в разных строках массива может быть разным.

Массивы с переменной длиной строк называют «рваными». Пример такого массива:

1первая строка массива

1 2вторая строка массива

1 2 3третья строка массива

При этом помните: строка, которую мы называем первой, имеет индекс 0.