Обучение программированию. Часть 5c: перегрузка методов и рекурсия

ВНИМАНИЕ. Эта статья начинается гладко, а затем я врезаюсь в стену! Мне пришлось провести небольшое исследование, чтобы понять, чему меня учили, а затем задокументировать это. Первый элемент, который я использовал, не привел к пониманию, поэтому я продолжал поиск, пока не нашел ресурс, который мне подошёл. Во всяком случае, это продолжается какое-то время.

Перегрузка звучит как то, что вы не должны делать, но перегрузка методов полезна в C#, когда у вас есть несколько методов с одинаковыми именами, но разными параметры. Сначала я этого не понимал, пока не увидел код того, как это должно выглядеть. Моей первой мыслью было: не запутает ли программа несколько методов с одинаковыми именами? Как он узнает, какой из них запустить?

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

static void Print(int a) {
     Console.WriteLine(“Value: “ + a);
}
static void Print(double a) {
     Console.WriteLine(“Value: “ + a);
}

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

Кстати, приложение также объясняет знак плюс (+) как способ соединения слова Value: со значением переменной a. Это называется объединением.

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

Давайте добавим еще один метод с именем Print, который будет работать вместе с двумя предыдущими:

static void Print(string label, double a) {
     Console.WriteLine(label + a);
}

Далее наш метод Main будет выглядеть так:

static void Main(string[] args) {
     Print(11);
     Print(4.13);
     Print(“Average: “, 7.57);
}

Итак, вот что произойдет:

• первая строка метода Main вызывает метод Print, который будет соответствовать типу данных отправляемого аргумента. В данном случае это число 11, которое является целым числом. Таким образом, он вызовет первый метод с именем Print (с (int a) рядом с ним), а затем напечатает Value : 11 на экран.
• вторая строка метода Main вызывает метод Print, который будет соответствовать типу данных отправляемого аргумента. В данном случае это число 4,13, которое является двойным. Таким образом, он вызовет второй метод с именем Print (с (двойной a) рядом с ним), а затем напечатает Value : 4.13 на экран.
• Третья строка метода Main вызывает метод Print, который будет соответствовать типу данных отправляемого аргумента. В этом случае, поскольку есть два аргумента, он вызовет третий метод с именем Print (который имеет (label + a) рядом с ним ). Среднее: будет значение, присвоенное переменной с именем label (в качестве типа данных которой назначена string), и 7,57 будет назначено переменной с именем a (для которой в качестве типа данных назначен double). Затем он выведет на экран Среднее значение: 7,57.

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

int PrintName(int a) { }
float PrintName(int b) { }
double PrintName(int c) { }

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

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

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

Итак, это перегрузка методов. Наконец, как уже упоминалось, рекурсивный метод — это метод, который вызывает сам себя. Пример, который дает приложение SoloLearn относительно того, когда вам нужно это сделать, — это когда вы вычисляете факториал числа. Они описывают математический термин факториал следующим образом:

…произведение всех положительных целых чисел, которые меньше или равны определенному неотрицательному целому числу.

Факториал обозначается восклицательным знаком (!), например:

4! = 4 * 3 * 2 * 1, что равно 24.

Я хотел немного больше узнать о том, как это работает и почему вы хотите его использовать, и, немного погуглив, оказался на странице на веб-сайте c-sharpcorner.com. Чтобы перейти к концу, вы бы хотели использовать его, потому что это более чистый и эффективный способ написания кода. Например, без рекурсии метод, выполняющий процесс factorial, будет выглядеть так:

Примечание. Прежде чем я покажу это, скажем, в методе Main вы запросили у пользователя число, и это число было присвоено переменной с именем number с типом данных integer. Затем вызывается наш новый метод (называемый Factorial), ему отправляется значение переменной number и результат выполнения этого метода (называемый Factorial ) присваивается новой переменной с именем factorial, тип данных которой двойной.

public static double Factorial(int number) {
     if (number == 0)
     return 1;
     double factorial = 1;
     for (int i = number; i >= 1; i — ) {
          factorial = factorial * i;
     } return factorial;
}

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

• Объявлен метод с именем Factorial, который является общедоступным (что означает, что любой класс может получить к нему доступ), является статическим ( что означает, что он не может создавать какие-либо экземпляры самого себя), вернет значение с типом данных double, и, когда он отправит аргумент, значение этого аргумента будет хранится в переменной с именем число, тип данных которой — целое число.
• Далее выполняется проверка, равно ли значение переменной number 0. Если оно равно равно 0, то метод возвращает значение 1 в то место, где он был вызван. По-видимому, в «математике» факториал 0 равен 1… и все. Это не кажется логичным, но это так. Если значение number равно не 0, выполняется переход к следующей строке.
• Создается переменная с именем factorial, которой присваивается тип данных double и значение 1.

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

цикл for начинается с создания переменной с именем i, установки ее типа данных на integer и присвоения ее значения, равного значению переменная номер. Он устанавливает условие для проверки, а именно, является ли значение i больше или равно 1. Если это так, он проходит через следующую строку, а затем уменьшает текущее значение i на 1. Если это не так, то текущее значение переменной factorial устанавливается обратно в то место, где оно было вызвано. Продолжим, вспомнив, что пользователь ввел значение 5, которое затем было присвоено переменной с именем number:

• Вновь созданной целочисленной переменной с именем i присваивается значение переменной с именем число (которое равно 5), поэтому i = 5.
• Условие, что i больше или равно 1, проверяется, то есть 5 больше или равно 1? И ответ да. Итак, переходим к следующей строке.
• Переменная factorial с типом данных double теперь устанавливается равной текущему значению переменной factorial, равное 1, умноженное на текущее значение i, равное 5. Итак, факториал переменной равен 5 * 1 или 5. Значение i теперь уменьшено на 1, что означает 5–1, поэтому i теперь равно 4.
• Условие того, является ли i больше или равным 1, проверяется снова, то есть 4 больше или равно 1? ответ по-прежнему да, поэтому мы переходим к следующей строке.
• Переменная factorial теперь устанавливается равной текущему значению переменной factorial, которое равно 5, умноженному на на текущее значение i, равное 4. Итак, факториал переменной равен 5 * 4 или 20. Значение i теперь уменьшается на 1, что означает 4–1, поэтому i теперь равно 3.
• Условие того, является ли i больше или равным 1, проверяется снова, то есть 3 больше или равно 1? ответ по-прежнему да, поэтому мы переходим к следующей строке.
• Переменная factorial теперь устанавливается равной текущему значению переменной factorial, которое равно 20, умноженному на на текущее значение i, равное 3. Итак, переменная factorial равна 20 * 3 или 60. Значение i теперь уменьшено на 1, что означает 3–1, поэтому i теперь равно 2.
• Условие того, является ли i больше или равным 1, проверяется снова, то есть 2 больше или равно 1? ответ по-прежнему да, поэтому мы переходим к следующей строке.
• Переменная factorial теперь устанавливается равной текущему значению переменной factorial, которое равно 60, умноженному на на текущее значение i, равное 2. Таким образом, переменная factorial равна 60 * 2 или 120. Значение i теперь уменьшается на 1, что означает 2–1, поэтому i теперь равно 1.
• Условие того, является ли i больше или равным 1, проверяется снова, то есть является ли 1 больше или равным 1? ответ по-прежнему да, поэтому мы переходим к следующей строке.
• Переменная factorial теперь устанавливается равной текущему значению переменной factorial, которое равно 120, умноженному на на текущее значение i, равное 1. Таким образом, переменная factorial равна 120 * 1 или 120. Значение i теперь уменьшено на 1, что означает 1–1, поэтому i теперь равно 0.
• Условие того, что i больше или равно 1, проверяется снова, то есть 0 больше или равно 1? теперь ответ нет, поэтому мы переходим к следующей строке после цикла for.
• текущее значение переменной factorial, равное 120, возвращается в точку, где оно было вызвано.

if (number == 0)
     return 1;
     return number * Factorial(number-1);

return number * Factorial(((Factorial(Factorial(Factorial(Factorial-1)-1)-1)-1))-1);

int factorial (int n) {
     if (n == 1) {
          return 1;
     }
     else {
          return n * factorial(n-1);
     }
}
void Main () {
     int f = factorial(4);
}

static int factorial (int n) {
     Console.WriteLine(n);
     if (n == 1) {
          return 1;
     }
     else {
          int result = n * factorial(n-1);
          Console.WriteLine(n);
          return result;
     }
}
void Main () {
     int f = factorial(4);
     Console.WriteLine(f);
}