CSBasicCourse2ndedPodbelsky / CSBasicCourse2ndedPodbelsky

int[ ] ar2 = { 1, 2, 3 };

Обращение change1(ar1, ar2); не изменяет ссылок, ar1 останется связанной с массивом из 7-ми элементов, ar2 будет ссылаться, как и ранее, на массив из трёх элементов.

При вызове change2(ref ar1, ref ar2); ссылки обменяются значениями – ar1

будет ссылаться на массив из трёх элементов, ar2 будет адресовать массив из 7-ми элементов.

На этом примере мы убедились, что аргумент с типом ссылки (так же как аргумент с типом значения) может изменить своё значение при выполнении тела метода только в том случае, когда он передан методу по ссылке, то есть имеет модификатор ref или out.

Итак, параметр ссылочного типа может быть снабжен модификатором ref. Без него – аргумент всегда "смотрит" на свой объект (внешний), может его менять, но не может изменить своего значения. С ref аргумент с типом ссылки может сменить своё значение и "отцепиться" от своего объекта.

В ряде случаев интересно иметь метод, который пригоден не для одного фиксированного типа параметра, а до некоторой степени универсален и допускает подстановку вместо параметра аргументов разных типов "аргумент:аргументы разных типов" . Так как все типы языка C# являются производными от одного базового класса Object, то метод для обмена значений двух ссылок можно написать

так (программа 09_09.cs):

static void change(ref Object ob1, ref Object ob2)

{

Object temp; temp = ob1; ob1 = ob2; ob2 = temp;

}

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

System.String

System.Int32

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

Во-первых, метод может вернуть ссылку на этот объект как значение,

возвращаемое функцией (методом) в точку вызова. Во-вторых, в методе можно использовать параметр с типом ссылки, снабженный модификатором ref либо out.

Первый способ иллюстрирует следующая программа.

// 09_11.cs – ссылка как возвращаемое значение using System;

class Program

{

static int[ ] newAr(uint numb)

{

int [ ] temp = new int[numb]; for (int i = 0; i < numb; i++) temp[i] = (i + 1) * (i + 1);

return temp;

}

static void Main( )

{

int[ ] vector = newAr(6); foreach (int el in vector)

Console.Write(el+" "); Console.WriteLine( );

}

}

Результаты выполнения программы:

1 4 9 16 25 36

В программе метод (функция) newAr(), получив в качестве аргумента целое неотрицательное значение, создаёт одномерный целочисленный массив, присваивает его элементам значения квадратов натуральных чисел и возвращает в точку вызова ссылку на сформированный массив. В методе Main() определена переменная-ссылка vector на целочисленный массив и ей присвоен результат вызова метода newAr().

Результаты выполнения программы иллюстрируют сказанное.

9.4. Методы с переменным числом аргументов

У параметра с модификатором params "параметр: с модификатором params"

назначение особое – он представляет в методе список аргументов неопределённой

(заранее не фиксированной) длины. Его тип – одномерный массив с элементами типа, указанного в спецификации параметра.

Как уже сказано, этот параметр может быть только последним (или единственным) в списке параметров. В обращении к методу этот параметр

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

В качестве примера приведём программу с методом для вычисления значений полинома Pn(x)=a0*xn+a1*xn-1+...+an-1*x+an:

//09_12.cs – массив-параметр using System;

class Program

{

//Вычисляет значение полинома c целыми коэффициентами: static double polynom(double x, params int [] coef)

{

double result = 0.0;

for (int i = 0; i < coef.Length; i++) result = result * x + coef[i];

return result;

}

static void Main()

{

Console.WriteLine(polynom(3.0, 3, 1, 2));

}

}

Результат выполнения программы:

32

Метод polynom() возвращает значение типа double, то есть играет роль

функции. Первый параметр double x представляет значение аргумента полинома.

Второй параметр params int [ ] coef даёт возможность передать в метод список

коэффициентов полинома a 0, a1. ..an-1, an. Все коэффициенты должны иметь

целочисленные значения. Их реальное количество, то есть степень полинома, при обращении определяется числом использованных аргументов, а в теле метода – значением поля coef.Length. В теле метода:

coef[0]=a0, coef[1]=a1, ..., coef[n]=an.

Для вычисления полинома использована схема Горнера, позволяющая заменить явные возведения в степень последовательными умножениями:

Pn(x)=(...(a0*x+a1)*x+a2)*x+...+an-1)*x+an

В том случае, когда требуется метод, принимающий произвольное число параметров любых разных типов, Дж. Рихтер [10] предлагает использовать параметр вида params Object[ ]. Он приводит в качестве примера метод, который выводит обозначения (наименования) типов всех переданных методу аргументов.

Вот программа с этим методом:

//09_13.cs - массив-параметр "универсального" типа using System;

class Program {

//Метод выводит названия типов аргументов:

static void DisplayTypes(params Object[ ] objects) { foreach (Object o in objects)

Console.WriteLine(o.GetType( ));

}

static void Main( ) {

DisplayTypes("yes", 432, new Object( ));

}

}

Результат выполнения программы:

System.String

System.Int32

System.Object

Обратим внимание, что параметр, снабжённый модификатором params,

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

Следующая программа иллюстрирует это правило.

// 09_14.cs - переменное число аргументов using System;

class Program

{

static void varParams(params int[ ] var) { for (int i = 0; i < var.Length; i++) {

var[i] *= 2;

Console.Write("var[{0}]={1} ", i, var[i]);

}

}

static void Main( ) { int a = 2, b = 3, c = 5; varParams(a, b, c);

Console.WriteLine("\na={0}, b={1}, c={2}", a, b, c);

}

}

Результат выполнения программы: var[0]=4 var[1]=6 var[2]=10

a=2, b=3, c=5

Значения переменных a, b, c после их использования в качестве аргументов метода varParams( ) не изменились, хотя в теле метода элементы массива-параметра присвоены новые значения.

9.5. Перегрузка методов

Перегрузка методов "метод:перегрузка методов" представляет собой ещё один частный случай полиморфизма.

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

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

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

случае говорят о перегрузке "операции:перегрузка операций" или

распространении действия операций на объекты новых классов. Этому виду полиморфизма нужно уделить особое внимание при изучении пользовательских классов. А сейчас вернёмся к полиморфизму перегрузки методов.

В программе (и в классе) одно имя (идентификатор) может относиться к разным методам, реализующим в общем случае совершенно разные алгоритмы.

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

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

сигнатурами "сигнатура" .

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

Вариант 1 – известны длины основания (d) и высоты (h):

S=(d*h)/2;

Вариант 2 – известны длины сторон (a,b,c): S=(p(p-a)(p-b)(p-c))0.5 , где p=(a+b+c)/2;

Вариант 3 – известны длины сторон (a,b,c) и радиус (R) описанной около

треугольника окружности:

S=(a*b*c)/(4*R).

Три метода, реализующие приведённые варианты вычисления площади треугольника, можно обозначить одним именем. Методы будут отличаться спецификациями параметров и алгоритмами вычислений. Объявить методы можно

так:

static double area(double d, double h) { return d*h/2;}

static double area(double a, double b, double c) { double p=(a+b+c)/2;

return Math.Sqrt(p*(p-a)*(p-b)*(p-c)); }

static double area(double a, double b, double c, double R) { return(a*b*c)/(4*R); }

В данном примере предполагается, что все методы являются методами одного класса. В функции Main() того же класса (программа 09_15.cs) можно так

обратиться к каждому из них:

Console.WriteLine("area1="+ area(4.0,3.0)); Console.WriteLine("area2="+ area(3.0,4.0,5.0)); Console.WriteLine("area3="+ area(3.0,4.0,5.0,2.5));

которому относится метод. Кроме того имя класса, в котором объявлен метод, и

модификаторы параметров out и ref входят в сигнатуру, а модификаторы метода

(например, static public) в сигнатуру не входят.

Обратите внимание, что тип возвращаемого методом значения не входит в его сигнатуру.

9.6. Рекурсивные методы

Рекурсивным называют метод, который прямо (непосредственно) или косвенно вызывает самого себя. Метод называют косвенно рекурсивным "метод:косвенно рекурсивный" , если он содержит обращение к другому методу, содержащему прямой или косвенный вызов определяемого (первого) метода. В случае косвенной рекурсивности по тексту определения метода его рекурсивность может быть не видна. Если в теле метода явно используется обращение к этому методу, то имеет место прямая рекурсия "прямая рекурсия" . В этом случае говорят, что метод

самовызывающий (self-calling). Именно самовызывающие методы будем называть рекурсивными, а для методов с косвенной рекурсией будем использовать термин косвенно рекурсивные методы "метод:косвенно рекурсивный " .

Классический пример рекурсивного метода – функция для вычисления факториала неотрицательного целого числа. На языке C# её можно записать таким

образом (программа 09_16.cs): static long fact(int k)

{

if (k < 0) return 0;

if (k == 0 || k == 1) return 1; return k * fact(k - 1);

}

Для отрицательного аргумента результат (по определению факториала) не существует. В этом случае функция возвращает нулевое значение (можно было бы возвращать, например, отрицательное значение). Для нулевого и единичного аргумента, по определению факториала, возвращаемое значение равно 1. Если k>1,

то вызывается та же функция с уменьшенным на 1 значением и возвращаемое ею значение умножается на текущее значение аргумента k. Тем самым организуется вычисление произведения 1*2*3*...*(k-2)*(k-1)*k.

При проектировании рекурсивного метода нужно убедиться

–что он может завершить работу, т.е. невозможно возникновение зацикливания;

–что метод приводит к получению правильных результатов.

Для удовлетворения первого требования должны соблюдаться два правила:

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

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