Текст книги "C# 4.0: полное руководство"
Автор книги: Герберт Шилдт
Жанр:
Программирование
сообщить о нарушении
Текущая страница: 16 (всего у книги 83 страниц)
Как пояснялось выше, аргументы простых типов, например int или char, передаются методу по значению. Это означает, что изменения, вносимые в параметр, принимающий значение, не будут оказывать никакого влияния на аргумент, используемый для вызова. Но такое поведение можно изменить, используя ключевые слова ref и out для передачи значений обычных типов по ссылке. Это позволяет изменить в самом методе аргумент, указываемый при его вызове.
Прежде чем переходить к особенностям использования ключевых слов ref и out, полезно уяснить причины, по которым значение простого типа иногда требуется передавать по ссылке. В общем, для этого существуют две причины: разрешить методу изменить содержимое его аргументов или же возвратить несколько значений. Рассмотрим каждую из этих причин более подробно.
Нередко требуется, чтобы метод оперировал теми аргументами, которые ему передаются. Характерным тому примером служит метод Swap(), осуществляющий перестановку значений своих аргументов. Но поскольку аргументы простых типов передаются по значению, то, используя выбираемый в C# по умолчанию механизм вызова по значению для передачи аргумента параметру, невозможно написать метод, меняющий местами значения двух его аргументов, например типа int. Это затруднение разрешает модификатор ref.
Как вам должно быть уже известно, значение возвращается из метода вызывающей части программы с помощью оператора return. Но метод может одновременно возвратить лишь одно значение. А что, если из метода требуется возвратить два или более фрагментов информации, например, целую и дробную части числового значения с плавающей точкой? Такой метод можно написать, используя модификатор out.
Использование модификатора параметра ref
Модификатор параметра ref принудительно организует вызов по ссылке, а не по значению. Этот модификатор указывается как при объявлении, так и при вызове метода. Для начала рассмотрим простой пример. В приведенной ниже программе создается метод Sqr(), возвращающий вместо своего аргумента квадрат его целочисленного значения. Обратите особое внимание на применение и местоположение модификатора ref.
// Использовать модификатор ref для
// передачи значения обычного типа по ссылке.
using System;
class RefTest {
// Этот метод изменяет свой аргумент. Обратите
// внимание на применение модификатора ref.
public void Sqr(ref int i) {
i = i * i;
}
}
class RefDemo {
static void Main() {
RefTest ob = new RefTest();
int a = 10;
Console.WriteLine("а до вызрва: " + a);
ob.Sqr(ref a);
// обратите внимание на применение модификатора ref
Console.WriteLine("а после вызова: " + а);
}
}
Как видите, модификатор ref указывается перед объявлением параметра в самом методе и перед аргументом при вызове метода. Ниже приведен результат выполнения данной программы, который подтверждает, что значение аргумента а действительно было изменено с помощью метода Sqr().
а до вызова: 10
а после вызова: 100
Теперь, используя модификатор ref, можно написать метод, переставляющий местами значения двух своих аргументов простого типа. В качестве примера ниже приведена программа, в которой метод Swap() выполняет перестановку значений двух своих целочисленных аргументов, когда он вызывается.
// Поменять местами два значения.
using System;
class ValueSwap {
// Этот метод меняет местами свои аргументы,
public void Swap(ref int a, ref int b) {
int t;
t = a;
a = b;
b = t;
}
}
class ValueSwapDemo {
static void Main() {
ValueSwap ob = new ValueSwap();
int x=10, у = 20;
Console.WriteLine("x и у до вызова: " + x + " " + у);
ob.Swap(ref x, ref у);
Console.WriteLine("x и у после вызова: " + x + " " + у);
}
}
Вот к какому результату приводит выполнение этой программы.
х и у до вызова: 10 20
х и у после вызова: 20 10
В отношении модификатора ref необходимо иметь в виду следующее. Аргументу, передаваемому по ссылке с помощью этого модификатора, должно быть присвоено значение до вызова метода. Дело в том, что в методе, получающем такой аргумент в качестве параметра, предполагается, что параметр ссылается на действительное значение. Следовательно, при использовании модификатора ref в методе нельзя задать первоначальное значение аргумента.
Использование модификатора параметра out
Иногда ссылочный параметр требуется использовать для получения значения из метода, а не для передачи ему значения. Допустим, что имеется метод, выполняющий некоторую функцию, например, открытие сетевого сокета и возврат кода успешного или неудачного завершения данной операции в качестве ссылочного параметра. В этом случае методу не передается никакой информации, но в то же время он должен возвратить определенную информацию. Главная трудность при этом состоит в том, что параметр типа ref должен быть инициализирован определенным значением до вызова метода. Следовательно, чтобы воспользоваться параметром типа ref, придется задать для аргумента фиктивное значение и тем самым преодолеть данное ограничение. Правда, в C# имеется более подходящий вариант выхода из подобного затруднения – воспользоваться модификатором параметра out.
Модификатор параметра out подобен модификатору ref, за одним исключением: он служит только для передачи значения за пределы метода. Поэтому переменной, используемой в качестве параметра out, не нужно (да и бесполезно) присваивать какое-то значение. Более того, в методе параметр out считается неинициализированным, т.е. предполагается, что у него отсутствует первоначальное значение. Это означает, что значение должно быть присвоено данному параметру в методе до его завершения. Следовательно, после вызова метода параметр out будет содержать некоторое значение.
Ниже приведен пример применения модификатора параметра out. В этом примере программы для разделения числа с плавающей точкой на целую и дробную части используется метод GetParts() из класса Decompose. Обратите внимание на то, как возвращается каждая часть исходного числа.
// Использовать модификатор параметра out.
using System;
class Decompose {
/* Разделить числовое значение с плавающей точкой на целую и дробную части. */
public int GetParts(double n, out double frac) {
int whole;
whole = (int) n;
frac = n – whole; // передать дробную часть числа через параметр frac
return whole; // возвратить целую часть числа
}
}
class UseOut {
static void Main() {
Decompose ob = new Decompose();
int i;
double f;
i = ob.GetParts(10.125, out f) ;
Console.WriteLine("Целая часть числа равна " + i);
Console.WriteLine("Дробная часть числа равна " + f);
}
}
Выполнение этой программы дает следующий результат.
Целая часть числа равна 10
Дробная часть числа равна 0.125
Метод GetParts() возвращает два фрагмента информации. Во-первых, целую часть исходного числового значения переменной n обычным образом с помощью оператора return. И во-вторых, дробную часть этого значения посредством параметра fгас типа out. Как показывает данный пример, используя модификатор параметра out, можно организовать возврат двух значений из одного и того же метода.
Разумеется, никаких ограничений на применение параметров out в одном методе не существует. С их помощью из метода можно возвратить сколько угодно фрагментов информации. Рассмотрим пример применения двух параметров out. В этом примере программы метод HasComFactor() выполняет две функции. Во-первых, он определяет общий множитель (кроме 1) для двух целых чисел, возвращая логическое значение true, если у них имеется общий множитель, а иначе – логическое значение false. И во-вторых, он возвращает посредством параметров типа out наименьший и наибольший общий множитель двух чисел, если таковые обнаруживаются.
// Использовать два параметра типа out.
using System;
class Num {
/* Определить, имеется ли у числовых значений переменных х и v общий множитель. Если имеется, то * возвратить наименьший и наибольший множители посредством параметров типа out. */
public bool HasComFactor(int x, int y,
out int least, out int greatest) {
int i;
int max = x < у ? x : y;
bool first = true;
least = 1;
greatest = 1;
// Найти наименьший и наибольший общий множитель.
for(i=2; i <= max/2 + 1; i++) {
if( ((y%i)==0) & ((x%i)==0) ) {
if (first) {
least = i;
first = false;
}
greatest = i;
}
}
if(least != 1)
return true;
else
return false;
}
}
class DemoOut {
static void Main() {
Num ob = new Num();
int lcf, gcf;
if(ob.HasComFactor(231, 105, out lcf, out gcf)) {
Console.WriteLine("Наименьший общий множитель " +
"чисел 231 и 105 равен " + lcf) ;
Console.WriteLine("Наибольший общий множитель " +
"чисел 231 и 105 равен " + gcf);
}
else
Console.WriteLine(«Общий множитель у чисел 35 и 49 отсутствует.»);
if(ob.HasComFactor(35, 51, out lcf, out gcf)) {
Console.WriteLine("Наименьший общий множитель " +
"чисел 35 и 51 равен " + lcf);
Console.WriteLine("Наибольший общий множитель " +
"чисел 35 и 51 равен " + gcf);
}
else
Console.WriteLine(«Общий множитель у чисел 35 и 51 отсутствует.»);
}
}
Обратите внимание на то, что значения присваиваются переменным lcf и gcf в методе Main() до вызова метода HasComFactor(). Если бы параметры метода HasComFactor() были типа ref, а не out, это привело бы к ошибке. Данный метод возвращает логическое значение true или false, в зависимости от того, имеется ли общий множитель у двух целых чисел. Если он имеется, то посредством параметров типа out возвращаются наименьший и наибольший общий множитель этих чисел. Ниже приведен результат выполнения данной программы.
Наименьший общий множитель чисел 231 и 105 равен 3
Наибольший общий множитель чисел 231 и 105 равен 21
Общий множитель у чисел 35 и 51 отсутствует.
Использование модификаторов ref и out для ссылок на объекты
Применение модификаторов ref и out не ограничивается только передачей значений обычных типов. С их помощью можно также передавать ссылки на объекты. Если модификатор ref или out указывает на ссылку, то сама ссылка передается по ссылке. Это позволяет изменить в методе объект, на который указывает ссылка. Рассмотрим в качестве примера следующую программу, в которой ссылочные параметры типа ref служат для смены объектов, на которые указывают ссылки.
// Поменять местами две ссылки.
using System;
class RefSwap {
int a, b;
public RefSwap(int i, int j) {
a = i;
b = j;
}
public void Show() {
Console.WriteLine(«a: {0}, b: {1}», a, b);
}
// Этот метод изменяет свои аргументы.
public void Swap(ref RefSwap ob1, ref RefSwap ob2) {
RefSwap t;
t = ob1;
ob1 = ob2;
ob2 = t;
}
}
class RefSwapDemo {
static void Main() {
RefSwap x = new RefSwap(1, 2);
RefSwap у = new RefSwap(3, 4);
Console.Write("x до вызова: ") ;
x.Show();
Console.Write("у до вызова: ");
у.Show();
Console.WriteLine() ;
// Смена объектов, на которые ссылаются аргументы х и у.
x.Swap (ref x, ref у);
Console.Write("х после вызова: ");
x.Show();
Console.Write("у после вызова: ") ;
у.Show();
}
}
При выполнении этой программы получается следующий результат.
х до вызова: а: 1, b: 2
у до вызова: а: 3, b: 4
х после вызова: а: 3, b: 4
у после вызова: а: 1, b: 2
В данном примере в методе Swap() выполняется смена объектов, на которые ссылаются два его аргумента. До вызова метода Swap() аргумент х ссылается на объект, содержащий значения 1 и 2, тогда как аргумент у ссылается на объект, содержащий значения 3 и 4. А после вызова метода Swap() аргумент х ссылается на объект, содержащий значения 3 и 4, тогда как аргумент у ссылается на объект, содержащий значения 1 и 2. Если бы не параметры типа ref, то перестановка в методе Swap() не имела бы никаких последствий за пределами этого метода. Для того чтобы убедиться в этом, исключите параметры типа ref из метода Swap().
При создании метода обычно заранее известно число аргументов, которые будут переданы ему, но так бывает не всегда. Иногда возникает потребность создать метод, которому можно было бы передать произвольное число аргументов. Допустим, что требуется метод, обнаруживающий наименьшее среди ряда значений. Такому методу можно было бы передать не менее двух, трех, четырех или еще больше значений. Но в любом случае метод должен возвратить наименьшее из этих значений. Такой метод нельзя создать, используя обычные параметры. Вместо этого придется воспользоваться специальным типом параметра, обозначающим произвольное число параметров. И это делается с помощью создаваемого параметра типа params.
Для объявления массива параметров, способного принимать от нуля до нескольких аргументов, служит модификатор params. Число элементов массива параметров будет равно числу аргументов, передаваемых методу. А для получения аргументов в программе организуется доступ к данному массиву.
Ниже приведен пример программы, в которой модификатор params используется для создания метода MinVal(), возвращающего наименьшее среди ряда заданных значений.
// Продемонстрировать применение модификатора params.
using System;
class Min {
public int MinVal(params int[] nums) {
int m;
if(nums.Length ==0) {
Console.WriteLine(«Ошибка: нет аргументов.»);
return 0;
}
m = nums[0];
for(int i=1; i < nums.Length; i++)
if(nums[i] < m) m = nums[i];
return m;
}
}
class ParamsDemo {
static void Main() {
Min ob = new Min();
int min;
int a = 10, b = 20;
// Вызвать метод с двумя значениями,
min = ob.MinVal(a, b);
Console.WriteLine("Наименьшее значение равно " + min);
// Вызвать метод с тремя значениями,
min = ob.MinVal(a, b, -1);
Console.WriteLine("Наименьшее значение равно " + min);
// Вызвать метод с пятью значениями,
min = ob.MinVal(18, 23, 3, 14, 25);
Console.WriteLine("Наименьшее значение равно " + min);
// Вызвать метод с массивом целых значений,
int[] args = { 45, 67, 34, 9, 112, 8 };
min = ob.MinVal(args);
Console.WriteLine("Наименьшее значение равно " + min);
}
}
При выполнении этой программы получается следующий результат.
Наименьшее значение равно 10
Наименьшее значение равно -1
Наименьшее значение равно 3
Наименьшее значение равно 8
Всякий раз, когда вызывается метод MinVal(), ему передаются аргументы в массиве nums. Длина этого массива равна числу передаваемых аргументов. Поэтому с помощью метода MinVal() можно обнаружить наименьшее среди любого числа значений.
Обратите внимание на последний вызов метода MinVal(). Вместо отдельных значений в данном случае передается массив, содержащий ряд значений. И такая передача аргументов вполне допустима. Когда создается параметр типа params, он воспринимает список аргументов переменной длины или же массив, содержащий аргументы.
Несмотря на то что параметру типа params может быть передано любое число аргументов, все они должны иметь тип массива, указываемый этим параметром. Например, вызов метода MinVal()
min = ob.MinVal(1, 2.2); // Неверно!
считается недопустимым, поскольку нельзя автоматически преобразовать тип double (значение 2.2) в тип int, указанный для массива nums в методе MinVal().
Пользоваться модификатором params следует осторожно, соблюдая граничные условия, так как параметр типа params может принимать любое число аргументов – даже нулевое! Например, вызов метода MinVal() в приведенном ниже фрагменте кода считается правильным с точки зрения синтаксиса С#.
min = ob.MinVal(); // нет аргументов
min = ob.MinVal(3); // 1 аргумент
Именно поэтому в методе MinVal() организована проверка на наличие в массиве nums хотя бы одного элемента перед тем, как пытаться получить доступ к этому элементу. Если бы такой проверки не было, то при вызове метода MinVal() без аргументов возникла бы исключительная ситуация во время выполнения. (Подробнее об исключительных ситуациях речь пойдет в главе 13.) Больше того, код метода MinVal() написан таким образом, чтобы его можно было вызывать с одним аргументом. В этом случае возвращается этот единственный аргумент.
У метода могут быть как обычные параметры, так и параметр переменной длины. В качестве примера ниже приведена программа, в которой метод ShowArgs() принимает один параметр типа string, а также целочисленный массив в качестве параметра типа params.
// Использовать обычный параметр вместе с параметром
// переменной длины типа params.
using System;
class MyClass {
public void ShowArgs(string msg, params int[] nums) {
Console.Write(msg + ": ");
foreach(int i in nums)
Console.Write (i + " ") ;
Console.WriteLine();
}
}
class ParamsDemo2 {
static void Main() {
MyClass ob = new MyClass();
ob.ShowArgs(«Это ряд целых чисел»,
1, 2, 3, 4, 5);
ob.ShowArgs("А это еще два целых числа ",
17, 20);
}
}
Вот какой результат дает выполнение этой программы.
Это ряд целых чисел: 1, 2, 3, 4, 5
А это еще два целых числа: 17, 20
В тех случаях, когда у метода имеются обычные параметры, а также параметр переменной длины типа params, он должен быть указан последним в списке параметров данного метода. Но в любом случае параметр типа params должен быть единственным.
Метод может возвратить данные любого типа, в том числе и тип класса. Ниже в качестве примера приведен вариант класса Rect, содержащий метод Enlarge(), в котором строится прямоугольник с теми же сторонами, что и у вызывающего объекта прямоугольника, но пропорционально увеличенными на указанный коэффициент.
// Возвратить объект из метода.
using System;
class Rect {
int width;
int height;
public Rect(int w, int h) {
width = w;
height = h;
}
public int Area() {
return width * height;
}
public void Show() {
Console.WriteLine(width + " " + height);
}
/* Метод возвращает прямоугольник со сторонами, пропорционально увеличенными на указанный коэффициент по сравнению с вызывающим объектом прямоугольника. */
public Rect Enlarge(int factor) {
return new Rect(width * factor, height * factor);
}
}
class RetObj {
static void Main() {
Rect rl = new Rect(4, 5);
Console.Write("Размеры прямоугольника rl: ");
rl.Show();
Console.WriteLine("Площадь прямоугольника rl: " + rl.Area());
Console.WriteLine();
// Создать прямоугольник в два раза больший прямоугольника rl.
Rect r2 = rl.Enlarge(2);
Console.Write("Размеры прямоугольника r2: "); r2.Show();
Console.WriteLine("Площадь прямоугольника r2: " + r2.Area());
}
}
Выполнение этой программы дает следующий результат.
Размеры прямоугольника r1: 4 5
Площадь прямоугольника r1: 20
Размеры прямоугольника г2: 8 10
Площадь прямоугольника г2: 80
Когда метод возвращает объект, последний продолжает существовать до тех пор, пока не останется ссылок на него. После этого он подлежит сборке как «мусор». Следовательно, объект не уничтожается только потому, что завершается создавший его метод.
Одним из практических примеров применения возвращаемых данных типа объектов служит фабрика класса, которая представляет собой метод, предназначенный для построения объектов его же класса. В ряде случаев предоставлять пользователям класса доступ к его конструктору нежелательно из соображений безопасности или же потому, что построение объекта зависит от некоторых внешних факторов. В подобных случаях для построения объектов используется фабрика класса. Обратимся к простому примеру.
// Использовать фабрику класса.
using System;
class MyClass {
int a, b; // закрытые члены класса
// Создать фабрику для класса MyClass.
public MyClass Factory(int i, int j) {
MyClass t = new MyClass();
t.a = i;
t.b = j;
return t; // возвратить объект
}
public void Show() {
Console.WriteLine("а и b: " + a + " " + b);
}
}
class MakeObjects {
static void Main() {
MyClass ob = new MyClass();
int i, j;
// Сформировать объекты, используя фабрику класса.
for(i=0, j =10; i < 10; i++, j–) {
MyClass anotherOb = ob.Factory(i, j); // создать объект
anotherOb.Show();
}
Console.WriteLine() ;
}
}
Вот к какому результату приводит выполнение этого кода.
а и b: 0 10
а и b: 1 9
а и b: 2 8
а и b: 3 7
а и b: 4 6
а и b: 5 5
а и b: 6 4
а и b: 7 3
а и b: 8 2
а и b: 9 1
Рассмотрим данный пример более подробно. В этом примере конструктор для класса МуСlass не определяется, и поэтому доступен только конструктор, вызываемый по умолчанию. Это означает, что значения переменных а и b нельзя задать с помощью конструктора. Но в фабрике класса Factory() можно создать объекты, в которых задаются значения переменных а и b. Более того, переменные а и b являются закрытыми, и поэтому их значения могут быть заданы только с помощью фабрики класса Factory().
В методе Main() получается экземпляр объекта класса МуСlass, а его фабричный метод используется в цикле for для создания десяти других объектов. Ниже приведена строка кода, в которой создаются эти объекты.
MyClass anotherOb = ob.Factory(i, j); // создать объект
На каждом шаге итерации цикла создается переменная ссылки на объект anotherOb, которой присваивается ссылка на объект, формируемый фабрикой класса. По завершении каждого шага итерации цикла переменная anotherOb выходит за пределы области своего действия, а объект, на который она ссылается, утилизируется.
Возврат массива из метода
В C# массивы реализованы в виде объектов, а это означает, что метод может также возвратить массив. (В этом отношении C# отличается от C++, где не допускается возврат массивов из методов.) В качестве примера ниже приведена программа, в которой метод FindFactors() возвращает массив, содержащий множители переданного ему аргумента.
// Возвратить массив из метода,
using System;
class Factor {
/* Метод возвращает массив facts, содержащий множители аргумента num. При возврате из метода параметр numfactors типа out будет содержать количество обнаруженных множителей. */
public int[] FindFactors(int num, out int numfactors) {
int[] facts = new int[80]; // размер массива 80 выбран произвольно
int i, j;
// Найти множители и поместить их в массив facts.
for(i=2, j=0; i < num/2 + 1; i++)
if( (num%i)==0 ) {
facts[j] = i;
j++;
}
numfactors = j ; return facts;
}
}
class FindFactors {
static void Main() {
Factor f = new Factor();
int numfactors;
int[] factors;
factors = f.FindFactors(1000, out numfactors);
Console.WriteLine("Множители числа 1000: ");
for(int i=0; i < numfactors; i++)
Console.Write(factors[i] + " ") ;
Console.WriteLine() ;
}
}
При выполнении этой программы получается следующий результат.
Множители числа 1000:
2 4 5 8 10 20 25 40 50 100 125 200 250 500
В классе Factor метод FindFactors() объявляется следующим образом.
public int[] FindFactors(int num, out int numfactors) {
Обратите внимание на то, как указывается возвращаемый массив типа int. Этот синтаксис можно обобщить. Всякий раз, когда метод возвращает массив, он указывается аналогичным образом, но с учетом его типа и размерности. Например, в следующей строке кода объявляется метод someMeth(), возвращающий двумерный массив типа double.
public double[,] someMeth() { // ...
