Вызывается при утилизации объекта.
~Destruct() {
Console.WriteLine("Уничтожить " + x);
}
// Создает объект и тут же уничтожает его.
public void Generator(int i) {
Destruct о = new Destruct(i);
}
}
class DestructDemo {
static void Main() {
int count;
Destruct ob = new Destruct(0);
/* А теперь создать большое число объектов.
В какой-то момент произойдет "сборка мусора".
Примечание: для того чтобы активизировать
"сборку мусора", возможно, придется
увеличить число создаваемых объектов. */
for(count = 1; count < 100000; count++)
ob.Generator(count);
Console.WriteLine("Готово!");
}
}
Эта программа работает следующим образом. Конструктор инициализирует переменную х известным значением. В данном примере переменная х служит в качестве идентификатора объекта. А деструктор выводит значение переменной х, когда объект утилизируется. Особый интерес вызывает метод Generator(), который создает и тут же уничтожает объект типа Destruct. Сначала в классе DestructDemo создается исходный объект ob типа Destruct, а затем осуществляется поочередное создание и уничтожение 100 тыс. объектов. В разные моменты этого процесса происходит "сборка мусора". Насколько часто она происходит — зависит от нескольких факторов, в том числе от первоначального объема свободной памяти, типа используемой операционной системы и т.д. Тем не менее в какой-то момент начинают появляться сообщения, формируемые деструктором. Если же они не появятся до окончания программы, т.е. до того момента, когда будет выдано сообщение "Готово!", попробуйте увеличить число создаваемых объектов, повысив предельное количество подсчитываемых шагов в цикле for.
|
|
|
И еще одно важное замечание: метод WriteLine() вызывается в деструкторе ~Destruct() исключительно ради наглядности данного примера его использования. Как правило, деструктор должен воздействовать только на переменные экземпляра, определенные в его классе.
В силу того что порядок вызова деструкторов не определен точно, их не следует применять для выполнения действий, которые должны происходить в определенный момент выполнения программы. В то же время имеется возможность запрашивать "сборку мусора", как будет показано в части II этой книги при рассмотрении библиотеки классов С#. Тем не менее инициализация "сборки мусора" вручную в большинстве случаев не рекомендуется, поскольку это может привести к снижению эффективности программы. Кроме того, у системы "сборки мусора" имеются свои особенности — даже если запросить "сборку мусора" явным образом, все равно нельзя заранее знать, когда именно будет утилизирован конкретный объект.
Ключевое слово this
Прежде чем завершать эту главу, необходимо представить ключевое слово this. Когда метод вызывается, ему автоматически передается ссылка на вызывающий объект, т.е. тот объект, для которого вызывается данный метод. Эта ссылка обозначается ключевым словом this. Следовательно, ключевое слово this обозначает именно тот объект, по ссылке на который действует вызываемый метод. Для того чтобы стало яснее назначение ключевого слова this, рассмотрим сначала пример программы, в которой создается класс Rect, инкапсулирующий ширину и высоту прямоугольника и включающий в себя метод Area(), возвращающий площадь прямоугольника.
|
|
|
using System;
class Rect {
public int Width;
public int Height;
public Rect(int w, int h) {
Width = w;
Height = h;
}
public int Area() {
return Width * Height;
}
}
class UseRect {
static void Main() {
Rect rl = new Rect(4, 5);
Rect r2 = new Rect(7, 9);
Console.WriteLine("Площадь прямоугольника rl: " + rl.Area());
Console.WriteLine("Площадь прямоугольника r2: " + r2.Area());
}
}
Как вам должно уже быть известно, другие члены класса могут быть доступны непосредственно без дополнительного уточнения имени объекта или класса. Поэтому оператор
return Width * Height;
в методе Area() означает, что копии переменных Width и Height, связанные с вызывающим объектом, будут перемножены, а метод возвратит их произведение. Но тот же самый оператор можно написать следующим образом.
|
|
|
return this.Width * this.Height;
В этом операторе ключевое слово this обозначает объект, для которого вызван метод Area(). Следовательно, в выражении this.Width делается ссылка на копию переменной Width данного объекта, а в выражении this.Height — ссылка на копию переменной Height этого же объекта. Так, если бы метод Area() был вызван для объекта х, то ключевое слово this в приведенном выше операторе обозначало бы ссылку на объект х. Написание оператора без ключевого слова this представляет собой не более чем сокращенную форму записи.
Ключевое слово this можно также использовать в конструкторе. В этом случае оно обозначает объект, который конструируется. Например, следующие операторы в методе Rect()
Width = w;
Height = h;
можно было бы написать таким образом.
this.Width = w;
this.Height = h;
Разумеется, такой способ записи не дает в данном случае никаких преимуществ. Ради примера ниже приведен весь класс Rect, написанный с использованием ссылки this.
using System;
class Rect {
public int Width;
public int Height;
public Rect(int w, int h) {
this.Width = w;
this.Height = h;
}
public int Area() {
return this.Width * this.Height;
}
}
class UseRect {
static void Main() {
Rect rl = new Rect(4, 5);
|
|
|
Rect r2 = new Rect(7, 9);
Console.WriteLine("Площадь прямоугольника rl: " + rl.Area());
Console.WriteLine("Площадь прямоугольника r2: " + r2.Area());
}
}
В действительности ключевое слово this не используется приведенным выше способом в программировании на С#, поскольку это практически ничего не дает, да и стандартная форма записи намного проще и понятнее. Тем не менее ключевому слову this можно найти не одно полезное применение. Например, в синтаксисе C# допускается называть параметр или локальную переменную тем же именем, что и у переменной экземпляра. В этом случае имя локальной переменной скрывает переменную экземпляра. Для доступа к скрытой переменной экземпляра и служит ключевое слово this. Например, приведенный ниже код является правильным с точки зрения синтаксиса C# способом написания конструктора Rect().
public Rect(int Width, int Height) {
this.Width = Width; this.Height = Height;
}
В этом варианте написания конструктора Rect() имена параметров совпадают с именами переменных экземпляра, а следовательно, скрывают их. Но для "обнаружения" скрытых переменных служит ключевое слово this.
ГЛАВА 7 Массивы и строки
В этой главе речь вновь пойдет о типах данных в С#. В ней рассматриваются массивы и тип string, а также оператор цикла foreach.
Массивы
Массив представляет собой совокупность переменных одного типа с общим для обращения к ним именем. В C# массивы могут быть как одномерными, так и многомерными, хотя чаще всего применяются одномерные массивы. Массивы служат самым разным целям, поскольку они предоставляют удобные средства для объединения связанных вместе переменных. Например, в массиве можно хранить максимальные суточные температуры, зарегистрированные в течение месяца, перечень биржевых курсов или же названия книг по программированию из домашней библиотеки.
Главное преимущество массива — в организации данных таким образом, чтобы ими было проще манипулировать. Так, если имеется массив, содержащий дивиденды, выплачиваемые по определенной группе акций, то, организовав циклическое обращение к элементам этого массива, можно без особого труда рассчитать средний доход от этих акций. Кроме того, массивы позволяют организовать данные таким образом, чтобы легко отсортировать их.
Массивами в C# можно пользоваться практически так же, как и в других языках программирования. Тем не менее у них имеется одна особенность: они реализованы в виде объектов. Именно поэтому их рассмотрение было отложено до тех пор, пока в этой книге не были представлены
объекты. Реализация массивов в виде объектов дает ряд существенных преимуществ, и далеко не самым последним среди них является возможность утилизировать неиспользуемые массивы средствам "сборки мусора".
Одномерные массивы
Одномерный массив представляет собой список связанных переменных. Такие списки часто применяются в программировании. Например, в одномерном массиве можно хранить учетные номера активных пользователей сети или текущие средние уровни достижений бейсбольной команды.
Для тoгo чтобы воспользоваться массивом в программе, требуется двухэтапная процедура, поскольку в C# массивы реализованы в виде объектов. Во-первых, необходимо объявить переменную, которая может обращаться к массиву. И во-вторых, нужно создать экземпляр массива, используя оператор new. Так, для объявления одномерного массива обычно применяется следующая общая форма:
тип[] имя_массива = new тип[размер] ;
где тип объявляет конкретный тип элемента массива. Тип элемента определяет тип данных каждого элемента, составляющего массив. Обратите внимание на квадратные скобки, которые сопровождают тип. Они указывают на то, что объявляется одномерный массив. А размер определяет число элементов массива.
-----------------------------------------------
ПРИМЕЧАНИЕ
Если у вас имеется некоторый опыт программирования на С иди C++, обратите особое внимание на то, как объявляются массивы в С#. В частности, квадратные скобки следуют после названия типа, а не имени массива.
-----------------------------------------------
Обратимся к конкретному примеру. В приведенной ниже строке кода создается массив типа int, который составляется из десяти элементов и связывается с переменной ссылки на массив, именуемой sample.
int[] sample = new int[10];
В переменной sample хранится ссылка на область памяти, выделяемой для массива оператором new. Эта область памяти должна быть достаточно большой, чтобы в ней могли храниться десять элементов массива типа int.
Как и при создании экземпляра класса, приведенное выше объявление массива можно разделить на два отдельных оператора. Например:
int[] sample;
sample = new int[10];
В данном случае переменная sample не ссылается на какой-то определенный физический объект, когда она создается в первом операторе. И лишь после выполнения второго оператора эта переменная ссылается на массив.
Доступ к отдельному элементу массива осуществляется по индексу: Индекс обозначает положение элемента в массиве. В языке C# индекс первого элемента всех массивов оказывается нулевым. В частности, массив sample состоит из 10 элементов с индексами от 0 до 9. Для индексирования массива достаточно указать номер требуемого элемента в квадратных скобках. Так, первый элемент массива sample обозначается как sample [ 0 ], а последний его элемент — как sample [ 9 ]. Ниже приведен пример программы, в которой заполняются все 10 элементов массива sample.
// Продемонстрировать одномерный массив.
using System;
class ArrayDemo {
static void Main() {
int[] sample = new int[10];
int i;
for(i =0; i < 10; i = i + 1) sample[i] = i;
for(i = 0; i < 10; i = i + 1)
Console.WriteLine("sample[" + i + "]: " + sample[i]);
}
}
При выполнении этой программы получается следующий результат.
sample[0]: 0
sample[1]: 1
sample[2]: 2
sample[3]: 3
sample[4]: 4
sample[5]: 5
sample[6]: 6
sample[7]: 7
sample[8]: 8
sample[9]: 9
Схематически массив sample можно представить таким образом.
Массивы часто применяются в программировании потому, что они дают возможность легко обращаться с большим числом взаимосвязанных переменных. Например, в приведенной ниже программе выявляется среднее арифметическое ряда значений, хранящихся в массиве nums, который циклически опрашивается с помощью оператора цикла for.
// Вычислить среднее арифметическое ряда значений.
using System;
class Average {
static void Main() {
int[] nums = new int[10];
int avg = 0;
nums[0] = 99;
nums[1] = 10;
nums[2] = 100;
nums[3] = 18;
nums[4] = 78;
nums[5] = 23;
nums[6] = 63;
nums[7] = 9;
nums[8] = 87;
nums[9] = 49;
for (int i=0; i < 10; i++) avg = avg + nums[i];
avg = avg / 10;
Console.WriteLine("Среднее: " + avg);
}
}
Результат выполнения этой программы выглядит следующим образом.
Среднее: 53
Инициализация массива
В приведенной выше программе первоначальные значения были заданы для элементов массива nums вручную в десяти отдельных операторах присваивания. Конечно, такая инициализация массива совершенно правильна, но то же самое можно сделать намного проще. Ведь массивы могут инициализироваться, когда они создаются. Ниже приведена общая форма инициализации одномерного массива:
тип[] имя_массива = {val1, val2, val3, ..., valN) ;
где val1 -valN обозначают первоначальные значения, которые присваиваются по очереди, слева направо и по порядку индексирования. Для хранения инициализаторов массива в C# автоматически распределяется достаточный объем памяти. А необходимость пользоваться оператором new явным образом отпадает сама собой. В качестве примера ниже приведен улучшенный вариант программы, вычисляющей среднее арифметическое.
// Вычислить среднее арифметическое ряда значений.
using System;
class Average {
static void Main() {
int[] nums = { 99, 10, 100, 18, 78, 23,
63, 9, 87, 49 };
int avg = 0;
for(int i=0; i < 10; i++) avg = avg + nums[i];
avg = avg /10;
Console.WriteLine("Среднее: " + avg);
}
}
Любопытно, что при инициализации массива можно также воспользоваться оператором new, хотя особой надобности в этом нет. Например, приведенный ниже фрагмент кода считается верным, но избыточным для инициализации массива nums в упомянутой выше программе.
int[] nums = new int[] { 99, 10, 100, 18, 78, 23,
63, 9, 87, 49 };
Несмотря на свою избыточность, форма инициализации массива с оператором new оказывается полезной в том случае, если новый массив присваивается уже существующей переменной ссылки на массив. Например:
int[] nums;
nums = new int[] {99,10,100,18,78, 23,
63, 9, 87, 49 };
В данном случае переменная nums объявляется в первом операторе и инициализируется во втором.
И последнее замечание: при инициализации массива его размер можно указывать явным образом, но этот размер должен совпадать с числом инициализаторов. В качестве примера ниже приведен еще один способ инициализации массива nums.
int[] nums = new int[10] {99, 10, 100, 18, 78, 23,
63, 9, 87, 49 };
В этом объявлении размер массива nums задается равным 10 явно.
Соблюдение границ массива
Границы массива в C# строго соблюдаются. Если границы массива не достигаются или же превышаются, то возникает ошибка при выполнении. Для того чтобы убедиться в этом, попробуйте выполнить приведенную ниже программу, в которой намеренно превышаются границы массива.
// Продемонстрировать превышение границ массива.
using System;
class ArrayErr {
static void Main() {
int[] sample = new int[10];
int i;
// Воссоздать превышение границ массива.
for(i =0; i < 100; i = i+1)
sample[i] = i;
}
}
Как только значение переменной i достигает 10, возникнет исключительная ситуация типа IndexOutOfRangeException, связанная с выходом за пределы индексирования массива, и программа преждевременно завершится. (Подробнее об исключительных ситуациях и их обработке речь пойдет в главе 13.)
Многомерные массивы
В программировании чаще всего применяются одномерные массивы, хотя и многомерные не так уж и редки. Многомерным называется такой массив, который отличается двумя или более измерениями, причем доступ к каждому элементу такого массива осуществляется с помощью определенной комбинации двух или более индексов.
Двумерные массивы
Простейшей формой многомерного массива является двумерный массив. Местоположение любого элемента в двумерном массиве обозначается двумя индексами. Такой массив можно представить в виде таблицы, на строки которой указывает один индекс, а на столбцы — другой.
В следующей строке кода объявляется двумерный массив integer размерами 10x20.
int[,] table = new int[10, 20];
Обратите особое внимание на объявление этого массива. Как видите, оба его размера разделяются запятой. В первой части этого объявления синтаксическое обозначение [,] означает, что создается переменная ссылки на двумерный массив. Если же память распределяется для массива с помощью оператора new, то используется следующее синтаксическое обозначение.
int[10, 20]
В данном объявлении создается массив размерами 10x20, но и в этом случае его размеры разделяются запятой.
Для доступа к элементу двумерного массива следует указать оба индекса, разделив их запятой. Например, в следующей строке кода элементу массива table с координатами местоположения (3,5) присваивается значение 10.
table[3, 5] = 10;
Ниже приведен более наглядный пример в виде небольшой программы, в которой двумерный массив сначала заполняется числами от 1 до 12, а затем выводится его содержимое.
// Продемонстрировать двумерный массив.
using System;
class TwoD {
static void Main() {
int t, i;
int[,] table = new int[3, 4];
for(t=0; t < 3; ++t) {
for(i=0; i < 4; ++i) {
table[t,i] = (t*4)+i+1;
Console.Write(table[t, i] + " ");
}
Console.WriteLine();
}
}
}
В данном примере элемент массива 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# они разделяются запятой.
------------------------------------------
Дата добавления: 2019-02-12; просмотров: 267; Мы поможем в написании вашей работы! |
Мы поможем в написании ваших работ!