ДАГ Lloyd: Ладно.
Так что теперь давайте возьмемся действительно большая тема, функции.
До сих пор в процессе, все Программы, которые мы были пишущие
были написаны внутри основной.
Они довольно простые программы.
Вам не нужно, чтобы все эти филиалы и вещей происходит.
Мы можем просто уместить его внутри основной и
не получить страшно подавляющим.
Но, как курс продолжается и как вы начнете разрабатывать программы
самостоятельно, они, вероятно, будет чтобы начать, чтобы получить гораздо больше, чем 10
или 15 строк.
Вы можете получить сотни или тысячи или десятки тысяч строк кода.
И это на самом деле не что с ума мысль.
Как таковая, она, вероятно, не очень хорошая идея сохранить все внутри основной.
Это может стать немного трудно найти то, что вы ищете, если вы сделаете это.
>> К счастью, хотя C, и в значительной степени каждый язык программирования, который
может работать, позволяет нам написать функции.
И я просто хочу, чтобы Возьмите быстрый сторону здесь
отметить, что функций одна область информатики.
И вы будете видеть больше из них в различные точки на протяжении всего курса
и если вы будете продолжать дальше.
Там, где есть много синонимы одного и того же слова.
Так мы называем функции.
Но вы могли бы также услышать их упоминается как процедур,
или методы, в частности, если вы когда-либо сделать любой объектно-ориентированного программирования
before-- и не беспокоиться если у вас нет, не
большой deal-- но в аудиторские ориентированные языки
часто называемые методами.
Иногда они называются подпрограммами.
Но они на самом деле все они относятся к тому же основной идеи.
>> Давайте посмотрим, что эта идея.
Что такое функция?
Ну функция действительно не более, чем черный ящик.
Черный ящик, который имеет множество нулевой или более входов и один выход.
Так, например, эта может быть функцией.
Эта функция называется функ.
И это занимает три входа A, B и С.
И внутри этого черного ящика, мы не знаю точно, что он делает,
но он обрабатывает входы в некотором роде, а затем он
дает один выход, в этом случае, г.
Теперь, чтобы сделать его немного менее абстрактным, мы
Можно сказать, что, возможно, мы есть функция под названием
Добавим, что занимает три входа A, B, и С и обрабатывает выходные данные в некотором роде
внутри черного ящика к производить один выход.
Таким образом, в этом случае, если добавить занимает 3, 6, и 7.
Где-то внутри добавить функцию, мы бы
ожидать, что они будут добавлены вместе для получения выходного сигнала, который
3 плюс 6 плюс 7 или 16.
>> Точно так же, у вас есть функция под названием мульт, который принимает два входа, а и б,
обрабатывает их в некотором роде такой что выход функции
является продуктом двух входов.
Два входа перемножаются.
4 и 5 передается в Mult, что-то случится, выход мы ожидаем
20.
Почему мы называем это черный ящик?
Ну, если мы не написания Функции себя, что
мы сделали совсем немного до сих пор CS50.
Мы видели печати F, например, что это функция, которую мы не написать
сами, но мы используем все время.
Если мы не пишем функции сами,
мы на самом деле не нужно знать, как это на самом деле реализованы под капотом.
>> Так, например, черный ящик I только что показал вам для умножения,
сть а, б может быть defined-- и это только
некоторые pseudocode-- может быть определяется как выход через раз б.
Это имеет смысл, верно.
Если у нас есть функция под названием мульт, который принимает два входа.
Мы бы ожидать, что результат будет быть два входа перемножаются,
а раз б.
Но мульт также может быть реализованы, как это,
мы имеем переменную счетчика на получить набор внутри Mult 0.
А потом мы повторяем этот процесс б раз добавить к счетчику.
Например, если мы умножим 3а по 5б, мы могли бы сказать установить счетчик на 0,
повторить пять раз, добавить 3 до прилавка.
Итак, мы начинаем с 0, а затем мы делаем Это в пять раз 3, 6, 9, 12, 15.
Это тот же самый результат. Мы до сих пор получить 3 раз 5 раз
реализация отличается.
>> Это означает, что мы когда мы говорим, черный ящик.
Это просто означает, что мы действительно не заботятся как это реализовано под капотом
тех пор, пока выход, что мы ожидаем.
На самом деле, это часть договора использования функции, в частности,
Функции, которые пишут другие.
Поведение всегда будет типичными, непредсказуемый
на основе имени функции.
И вот почему это действительно важно, когда вы пишете функции
или когда другие люди пишут Функции, которые вы могли бы использовать,
что эти функции имеют ясно, относительно очевидные имена,
и хорошо документированы.
Что, конечно, случай для функции, как печать ф.
>> Так почему же мы используем функции?
Ну, как я сказал ранее, если мы пишем весь наш код внутри главных
можете получить действительно громоздким и действительно сложная.
Функции позволяют нам способность организовать вещи и разбить
очень сложная задача в много более управляемые части суб.
Функции также позволяют нам упростить процесс кодирования.
Это намного проще отладить 10 Функция линия против линии 100
функция или функция в 1000 линия.
Если у нас есть только для отладки маленькие кусочки в то время,
или написать небольшие кусочки в то время, это делает этот опыт программирования
намного лучше.
Доверься мне в этом.
>> Наконец, если мы пишем функции мы можно повторно использовать эти различные части.
Функции могут быть переработаны.
Они могут быть использованы в одна программа или другой.
Вы уже написали функция, все, что вам
нужно сделать, это сказать, что программа где найти эту функцию.
Мы утилизации и использования печатать е более 40 лет.
Но это было только один раз написано.
Довольно полезно, правильно.
Все в порядке.
Так функции велики.
Мы знаем это.
Теперь давайте начнем писать их.
Давайте начнем получать их в наших программах.
Для того, чтобы сделать это, первый что мы делаем, это объявить функцию.
Когда вы объявляете функцию то, что вы делаете в основном
говорит компилятору, эй, только так вы знаете,
Я собираюсь писать функция позже
и вот что он будет выглядеть.
Причина этого в том, что компиляторы могут
сделать некоторые странные вещи, если они видят набор символов
что они не знакомы.
Таким образом, мы просто дать компилятору возглавляет, я создаю функцию
и он собирается сделать это.
Объявления функций обычно если Вы организует свой код таким образом,
что другие смогут понять и использовать,
Вы вообще хотите, чтобы положить все Ваши объявления функций
на самом верху вашего кода, прямо прежде чем начать писать основной даже.
И удобно, есть очень стандартная форма
что каждая функция декларация следующим образом.
Они все в значительной степени выглядеть следующим.
Есть три части к функции Декларация, возвращаемый тип, имя,
и список аргументов.
>> Теперь тип возвращение Каких Переменная выход функции воли.
Так, например, если мы вспомним Минуту назад к умножения двух
Функция номера, то, что мы ожидаем, если умножим целое число целое число
выход будет вероятно, целое, право.
Умножается два целых числа вместе, вы получите целое число.
Так тип возвращаемого что Функция будет Int.
Имя это то, что вы хотите обратить ваше функции.
Это, вероятно, наименее важным часть функции декларации,
с точки зрения функциональности.
Но на самом деле, вероятно, один из наиболее важных частей
в объявлении функции в условиях зная, что на самом деле функция
делает.
Если вы назвать вашу функцию F или г или ч или тайна или что-то подобное,
вы, вероятно, собирается получить немного споткнулся, пытаясь
вспомнить, что эти функции делают.
Поэтому важно, чтобы дать вашей осмысленные имена функции.
>> Наконец, список аргументов разделенные запятой
всех входов в вашей функции, каждый из которых имеет тип и имя.
Так что не только у вас есть, чтобы указать, какой тип переменной
выход функция, Вы также хотите, чтобы указать
какой тип и типы переменных в Функция будет принимать в качестве входных.
Так давайте сделаем пример здесь.
Давайте просто посмотрим в более конкретном один.
Так вот пример функции Заявление для функции,
хотел бы добавить два целых числа вместе.
Сумма двух целых чисел будет быть целым числом, а также, как мы только что
обсуждается.
И поэтому тип возврата здесь, в зеленый, будет Int.
Это просто говорит нам, что добавить два целых собирается, в конце концов,
выход, или выплюнуть обратно к нам, целое число.
Учитывая то, что эта функция делает мы хочу, чтобы дать ему значимое имя.
Добавить два целых кажется целесообразно, учитывая
мы берем два целых числа в качестве входных и, надеюсь, добавив их вместе.
Это может быть немного громоздким Имя и откровенно эта функция
Вероятно, нет необходимости так как мы имеем добавление
Оператор, если вы помните из нашего обсуждение операторов, ранее.
Но давайте просто скажем, ради Аргумент, что эта функция полезна
и так мы будем называть его добавить два целых.
Наконец, эта функция принимает два входа.
Каждый из которых является целым числом.
Итак, мы имеем эту запятую список разделенных входов.
Теперь мы обычно хотят дать имя каждому из них
таким образом, что они могут быть использованы в функции.
Имена не страшно важно.
>> В этом случае, мы не обязательно есть какой-то смысл, прикрепленный к ним.
Таким образом, мы можем просто назвать их и б.
Это совершенно нормально.
Однако, если вы найдете самостоятельно в ситуации,
где имена переменных действительно может быть важным,
Вы можете называть их что-то другое, чем а и Ь
чтобы дать им что-то больше символически значимым.
Но в данном случае, мы на самом деле не знаете что-нибудь еще о функции.
Мы просто хотим, чтобы добавить два целых числа.
Таким образом, мы просто позвонить тех, целые числа а и б.
Вот один пример.
>> Почему бы вам не взять второй думать об этом,
как бы вы написать функцию Заявление для функции,
умножает двух чисел с плавающей запятой?
Вы помните, что такое число с плавающей запятой?
Что бы эта функция Заявление выглядит?
Я на самом деле рекомендуем Вам приостановить видео сюда и сколько времени вам нужно.
Подумайте о том, что это Объявление функции будет?
Что бы тип возвращаемого быть?
Что бы значимое имя будет?
Что бы входы быть?
Так почему бы вам не сделать паузу видео здесь и написать план функцию декларацию
для функции, которая будет умножать два плавающей запятой вместе.
Надеюсь, вы паузу видео.
>> Итак, давайте взглянем на пример одной из возможных декларации.
Поплавок Mult два реала плавать х, у поплавка.
Произведение двух чисел с плавающей точкой,
которые являются вспомнить, как мы представляют реальные цифры
или номера с десятичными значениями в С, будет число с плавающей точкой.
Когда вы умножаете десятичной в десятичном,
вы, вероятно, собирается получить десятичной.
Вы хотите, чтобы дать ему соответствующую имя.
Умножьте два реала кажется нормально.
Но вы могли бы действительно назвать это Mult двумя поплавками, или Mult поплавки.
Ничего подобного, до тех пор, как это дал ему актуальное значение на то, что
это черный ящик собирался сделать.
И опять же, в этом случае, мы не кажется, есть какой-то смысл придает
на именами переменные мы переходящие в,
так что мы просто называем их х и у.
Теперь, если вы их называете что-то еще, что это совершенно нормально.
В самом деле, если вы сделали эта декларация, а
вместо этого используя двойников поплавков, если вспомнить,
что удваивается это другая способ более точно
указать реальные цифры или с плавающей запятой переменные.
Это совершенно нормально тоже.
Либо один из тех, было бы прекрасно.
На самом деле, есть несколько различные комбинации
способов заявить эту функцию.
Но эти две довольно хорошие.
Мы объявили функцию, это здорово.
Мы сказали, что это компилятор является то, что мы собираемся делать.
Теперь давайте на самом деле писать эту функцию.
Давайте дадим ему определение, таким образом, что внутри черного ящика
предсказуемое поведение происходит.
На самом деле, мы умножения двух действительных номера вместе, или добавление номера
вместе, или делать то, что это что мы попросили нашу функцию общего.
>> Таким образом, в самом деле, давайте попробуем определить и умножить два реала, который мы только что
говорили о второй назад.
Теперь начало определение функции
выглядит почти точно так же, как функция декларации.
У меня есть и из них.
В верхней части находится объявление функции, тип, название, разделенные запятой аргумент
Список, точка с запятой.
Точка с запятой указывает, что что объявление функции.
Начало функции определение выглядит почти в точности
то же самое, тип, имя, разделенные запятой Список аргументов, нет запятой,
открыть фигурную скобку.
Открытая фигурная скобка, как мы делали с основной,
означает, что мы сейчас начинает определять
что происходит внутри черного ящика, что мы решили назвать Несколько два реала.
Вот один из способов, чтобы его реализовать.
Мы могли бы сказать, что мы могли бы объявить новый переменная типа поплавка называется продукт
и назначить эту переменную в стоимость х раз у.
А потом вернуться продукт.
Что означает возвращение здесь.
Ну возвращение путь укажем, что, как
мы передаем выход обратно.
Так что-то вернуть, так же, как, это выход черного ящика.
Так вот, как вы это делаете.
Вот еще один способ ее реализации.
Мы могли бы просто вернуть х раз у.
х поплавок.
у с плавающей точкой.
Так х раз у также поплавок.
Мы даже не нужно создать еще одну переменную.
Так что это другой способ осуществить тот же черный ящик.
>> Теперь воспользоваться моментом, приостановить видео еще раз,
и попытаться определить добавить два целых, который является другой функции, что мы
говорили о минуту назад.
Опять здесь, я положил функции Декларация, и так как точка с запятой,
и открытая фигурная скобка и закрытым вьющиеся
скобка, чтобы указать, где мы будем заполнять в содержимом добавить два целых,
так что мы определяем частности Поведение внутри черного ящика.
Так приостановить видео.
И взять столько времени, сколько Вы должны попробовать и определить
реализация добавить два целых, например что, когда функция выводит значение,
он делает, на самом деле, возвращение сумма двух входов.
Так же, как и в предыдущем примере, Есть несколько различных способов
что вы могли бы реализовать добавить два целых.
Вот один.
В здесь, в оранжевый У меня просто были некоторые comments--
Я просто добавил некоторые комментарии, чтобы указать,
что происходит в каждой строке кода.
Так что я объявить переменную называется сумма типа Int.
Я говорю сумма равна плюс б.
Вот где мы на самом деле делаем работа добавления А и В вместе.
И я вернусь сумму.
И, что имеет смысл, поскольку сумма переменная типа Int.
И то, что тип данных, что это функция сообщает мне, что собирается вывести?
Int.
Так я возвращаюсь сумму, которая является целой переменной.
И, что имеет смысл, учитывая то, что мы Объявление и определение нашу функцию
делать.
>> Теперь вы можете также определить функция таким образом,
INT сумма равна плюс В- пропустить что в первую очередь, а затем step--, вернуться сумму.
Теперь вы могли бы также реализованы это так,
который я очень не рекомендую.
Это плохой стиль для одного что и в самом деле плохой дизайн,
но это, на самом деле, работы.
Если вы берете этот код, который INT добавить плохую сумматор точка C, и использовать его.
Это на самом деле добавить два числа вместе.
Это очень плохая реализация этого конкретного поведения.
Но он работает.
Это просто здесь для иллюстрации и дело, что мы на самом деле не
все равно, что происходит внутри черный ящик, пока
как это имеет вывод, который мы ожидали.
Это плохо разработаны черный ящик.
Но в конце концов, это делает еще выход сумма плюс б.
Все в порядке.
Так мы объявили функций.
И мы определили функцию.
Так что это действительно хорошо.
Теперь давайте начнем использовать функции что мы объявили и мы определили.
Для вызова function-- это на самом деле довольно easy-- все, что вам нужно сделать,
это передать его соответствующими аргументами, Аргументы типа данных
что он ожидает, и затем назначить возвращение
Значение этой функции и this-- оправдание me--
присвоить возвращаемое значение этой функции к чему-то правильного типа.
>> Итак, давайте посмотрим на На практике это в файле
называется сумматор 1 точка С, У меня в CS50 IDE.
Так вот гадюка 1 точка гр.
В начале вы видите, я мой включает в себя, фунт включают,
Стандарт И.О., и CS50 точка ч.
А потом у меня объявление функции.
Это где я говорит компилятор Я
будет написания Функция называется добавить два целых.
Это происходит для вывода целая переменная типа.
Это то, что эта часть прямо здесь.
А то у меня два входа к нему и б, каждый из которых представляет собой целое число.
Внутри главного, я прошу у пользователя вход говоря, дай мне целое.
И они предложено забыть INT, которая является функцией, что
включен в библиотеке CS50.
И, что сохраняется в х, целая переменная.
>> Тогда мы подтолкнуть их еще целого.
Мы получаем еще целое и хранить, что в у.
А потом, здесь, на линии 28, является где мы делаем нашу вызов функции.
Мы говорим, Int Z равных добавить 2 Интс х запятой у.
Вы видите, почему это имеет смысл?
х является переменной целого типа и у является переменной целого типа.
Так что это хорошо.
Это имеет смысл с какой нашей функции Декларация о соответствии 17 выглядит.
Список ввода разделенные запятой ожидает два целых числа, а и б.
В этом случае, мы можем назвать им, что мы хотим.
Это просто ожидает два целых числа.
И х представляет собой целое число, и у является целым числом.
Это работает.
>> И мы знаем, что функция будет Для вывода числа, а также.
И таким образом, мы сохраняем выход функции,
добавить два целых, в целое типа Переменная, которая мы называем г.
И тогда мы можем говорить, что сумма процентов я и процентов я это я процентов.
х, у и г соответственно заполнения в тех процентов я годов.
Что является определение добавить два целых выглядеть?
Это довольно просто.
Это один из тех, что мы только что видел секунду назад,
INT сумма равняется б обратный плюс сумму.
Это работает?
Давайте сохранить файл.
И тогда здесь, на моем терминале Я собираюсь сделать сумматор 1,
и я очистить экран.
Я собираюсь увеличить потому что я знаю это немного трудно увидеть.
>> Так мы собираем эту программу в качестве сумматора 1.
Таким образом, мы можем сделать точка слэш сумматор 1.
Дайте мне целое, 10.
Дайте мне еще целое, 20.
Сумма 10 и 20 30.
Таким образом, мы сделали вызов успешный функцию.
Вы можете запустить функцию снова, отрицательный 10, 17 сумма отрицательного 10 и 17 7.
Эта функция работает.
Он имеет поведение что мы ожидаем его.
И таким образом, мы сделали успешный Функция, определение, заявление,
и вызов успешным функция.
Пара разное пункты о функциях
прежде, чем мы закончим этот раздел.
Напомним, из нашего обсуждение типов данных,
Ранее, что функции не может занять ни один вход.
Если это так, то мы объявить функцию
как имеющий список аргументов недействительными.
Помнишь вам, что Наиболее общая функция
мы видели до сих пор, что происходит список аргументов пустота?
Это главный.
Напомним также, что функция иногда на самом деле не имеют выход.
В этом случае, мы объявляем функцию как имеющие тип возвращаемого недействительным.
Давайте закончим этот параграф решения проблемы практики.
>> Так вот проблема выложил.
Я хочу, чтобы вы написать функцию называется действительным треугольник.
Что эта функция должна делать это взять три реальные цифры
которые представляют длины три стороны треугольника, как ее параметров,
или его аргументы, или его inputs-- другой набор синонимов
что вы можете столкнуться.
Эта функция должна либо выход истинным или ложным
в зависимости от того этих трех длин способны сделать треугольник.
Вы помните, что тип данных мы использовали, чтобы указать, верно или неверно?
Теперь, как вы это реализовать?
Ну знаете, есть пара правил, касающихся треугольников
что на самом деле полезно знать.
Треугольник может иметь только Стороны с положительной длины.
В этом есть смысл.
Вы, наверное, сказав, хм.
Другая вещь, к сведению хотя, является то, что сумма
длин любой Стороны треугольника
должен быть больше, чем Длина третьей стороны.
Это на самом деле так.
Вы не можете иметь треугольник сторон 1, 2 и 4, например, из-за 1 плюс 2
не больше, чем 4.
Так что те правила, которые определить, действительно ли три
Входы могут, предположительно, образуют треугольник.
Так что через пару минут и объявить, а затем определить
эта функция называется действительным треугольника, так, что он на самом деле
имеет поведение указанный здесь.
>> Это будет справедливо, если выход этих трех сторон способны содержащая треугольник,
и ложь в противном случае Готовы увидеть, как вы сделали?
Вот одна реализация из действительна треугольник.
Это не только один.
Ваш может незначительно отличаться.
Но это делает, на самом деле, есть поведение, которое мы ожидаем.
Мы заявляем, что наше функцию на очень сверху, BOOL действительный треугольник
плавать х флоат у поплавка г.
Итак, еще раз, эта функция принимает три реальные цифры
в качестве аргументов, плавающие точка значение переменных,
и выводит истинным или ложным значение, которое является логическим, напомним.
Так вот почему тип возвращаемого значения BOOL.
Затем мы определяем функцию.
Первое, что мы делаем, это проверить, чтобы убедиться, что все стороны положительны.
Если х меньше или равно 0, или если у равно 0,
или если г меньше или равно 0, что не может быть треугольником.
Они не имеют и положительные стороны.
И так мы можем вернуться ложь в этой ситуации.
Далее, мы проверяем, чтобы убедиться, что каждая пара входов
больше, чем третий.
>> Так что, если х плюс у менее или равным г,
или если х плюс г меньше или равным Y,
или если у плюс г, меньше или равно х, что также не может быть допустимым треугольник.
Таким образом, мы снова вернуться ложным.
Предположим, что мы прошли обе проверки хотя, то мы можем вернуться правда.
Потому что те, с трех сторон способны returning--
создания действительный треугольник.
Вот и все.
Теперь вы объявлены и определены.
И вы можете быть в состоянии в настоящее время для использовать и вызвать эту функцию.
Отличная работа.
Я Дуг Ллойд.
Это CS50.