Что обычно делается для возврата более одного значения из функции

Обновлено: 02.07.2024

Поделитесь, какими способами вы пользуетесь при необходимости возврата функцией нескольких значений. И почему.

Зависит от.
Если надо возвращать корректность работы (что функция отработала корректно), то на мой взгляд удобнее возврат Истина/ложь, а параметры в структуре параметров.
Если корректность не имеет смысла - то можно параметрами, можно структурой.
Опять же вопрос - как потом будут использоваться значения. Может как раз структурой для дальнейшего использования удобнее

(6) а какая разница как будут использоваться значения?
задача - функция должна вернуть больше одного значения, которые будут использоваться

(6) Вообще, считаю, идеологически правильнее не изменять формальные параметры функцией. Функция в математическом смысле однонаправлена. И у неё четко разделены вход и выход.
А если надо менять параметры внутри - надо создавать процедуру.

(8) > Вообще, считаю, идеологически правильнее не изменять формальные параметры функцией. Функция в математическом смысле однонаправлена. И у неё четко разделены вход и выход.

Простой пример: код модуля стал очень сложным, хочется раскидать разные части по отдельным функциям.

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

(9) Всё так, но вместо функций тут правильнее юзать процедуры. Идеологическая мешанина процедур и функций - тяжкое наследия языка Си)

(7) Ну вот пример - функция должна вернуть несколько значений, которые потом будут использовать как фильтрующие параметры. Можно вернуть список значений, а можно передать менеджер и сделать временную таблицу

Возврат какого-нибудь списка значений тоже не ахти вариант. Сложней в разборе результата функции. Нет подсказки по возвращаемому значению. Легко перепутать "имена" возвращаемых значений. Было бы понятие типа "структуры" - вопросов бы не возникало.

(19) И что, через полгодика вы вспомните, что функция возвращает в [0]? А тем более, если кто-то другой читать код будет. Варианты типа [0] крайне не рекомендуются во всех приличных местах/языках. Варианты типа ["НомерСтелажа"] тоже, слишком велика вероятность опечатки.

(22) Где написано? В коде вы видите что-то типа:
Ну и как этот код читать? За такое в приличных местах уволить нафиг могут.

(21) Список значений с представлениями позволяет обращаться по имени представления. По сути имитация структуры, которой в семерке нет.

(25) (26) Ага-ага. А когда-нибудь потом, через полгодика, вы узнаете, что в каком-то нечасто выполняющемся куске кода вместо "Количество" вы написали "Клоичество". И хорошо еще если эта ошибка будет быстро замечена, а не приведёт к постоянным косякам за большой период.
По моему, функции, изменяющие свои параметры, это плохо, но возврат списка или структуры - еще хуже.
Если бы в языке был соответствующий тип вроде сишного union - тогда метод возврата структуры был бы хорош.

По частоте использования:
1. Структура, например, если нужно получить что-то связанное с объектом (периодические значения), но получать сам объект не имеет смысла.
2. Функция с параметром, определяющим значение чего будет возвращено.
3. Несколько функций.

(28) Исключение в данном случае благо. Может привести к неверной работе алгоритма, без ошибок времени выплонения.

winapi стаил. Функция возвращает истина/ложь (удачно/не удачно). А в параметры кладем значения возврата. В 1с аналог свойство() для структуры.

(28) Структура плоха тем что:
1. Нельзя использовать автодополнение, выше вероятность опечатки
2. Что бы при чтении кода понять, какие параметры могут возвращаться, приходится переходить к определению функции и читать комментарии к ней. Если они еще есть.
3. На опечатки нельзя проверить формально, надеемся на то, что упомянутое вами исключение выскочит при тестировании у разработчика, а не повалит у пользователей в том куске, который разработчик недостаточно протестировал.
3.1. А бывают еще любители избыточного использование Попытка Исключение. Получается вообще взрывоопасная смесь.
4. При рефакторинге могут возникнуть большие проблемы по переделке кучи мест в коде. Не решаемые полуинтеллектуальным поиском с заменой и прочими подобными инструментами.
. можно еще продолжать про недостатки, но юзверя звонят.

Если нужно вернуть все перестановки какого -либо множества, то лучше сделать так, чтобы следующая перестановка возвращалась на основании предыдущей без изменения каких либо параметров.
Если нужно вернуть линейный размеры объект - тогда лучше структура (а еще лучше - сам объект)
А если нужно вернуть сто случайных значений от 0 до 1, то лучше всего возвращать массив.
Т.е. что лучше зависит от контекста вопроса больше, чем от самого вопроса.

Если функции надо вернуть несколько РАЗНЫХ значений, не объединенных семантически в какое-то целое, значит у тебя косяк в архитектуре и это две функции, а не одна.

А, если эти значения - это атрибуты какого-то одного объекта, то возвращай структуру да и всё.

(38)
> 1. Нельзя использовать автодополнение, выше вероятность опечатки
Автодополнение в 1с много где нет? это вопрос тестирования

> 2. Что бы при чтении кода понять, какие параметры могут возвращаться, приходится переходить к определению функции и читать комментарии к ней. Если они еще есть.
Для этого можно в начале функции инициировать структуру, которая нужно вернуть независимо от успешности функции

> 3. На опечатки нельзя проверить формально, надеемся на то, что упомянутое вами исключение выскочит при тестировании у разработчика, а не повалит у пользователей в том куске, который разработчик недостаточно протестировал.
Это совсем другой вопрос - вопрос тестирования.

> 3.1. А бывают еще любители избыточного использование Попытка Исключение. Получается вообще взрывоопасная смесь.

> 4. При рефакторинге могут возникнуть большие проблемы по переделке кучи мест в коде. Не решаемые полуинтеллектуальным поиском с заменой и прочими подобными инструментами.
Например какие проблемы?

(44) пример такой:
функция возвращает ссылку на объект
если вернуть ссылку не получилось, то также нужно вернуть текст ошибки

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

(48) А возвращать в параметрах ещё отстойней.

(52) Кратко пересказать книжки М.Фаулера и Р.Мартина ?

(47) Если функция не нашла значение потому что его нет - возвращается пустое значение, если возникла ошибка из-за неверных параметров, функция должна генерить исключение. Как это исключение будет обрабатывать вызывающая сторона - уже пофиг. Если вызывающая сторона подходит ответственно к параметрам вызова функции, она не должна париться над текстом в принципе.

(54) Там много опирается на то, что функция должна делать что-то одно. А если функция должна делать что-то одно, откуда взяться чему-то второму что можно вернуть?

(58) См(55). Если не убедил - просто посмотри как работает типовая Справочник.XXX.НайтиПоКоду() и аналогичные. Ни одна функция в здравом уме не возвращает текст ошибки и т.п.

(59) а если речь идет о взаимодействии между системами?
1с - драйвер оборудования
1с - 1с по веб-сервсису
и т.п.

Чаще всего использую возврат структуры, но бывает, что в параметрах возвращал значение, а сама функция возвращала статус успешное завершения функции.

В общем случае, возврат нескольких значений - это массив, соответственно, структура, список и т.п. это более упрощённое понимание массива.
Но, реального возврата нескольких значений из функции всё равно нет - вы возвращаете один объект. И, самое главное, что он создаётся, а потом разрушается, что медленнее, чем если передавать эти несколько параметров в функцию или процедуру по ссылке.

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

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

(8) Математически операция А = А + 1 недопустима. Так что не стоит математику переносить на программирование.

(10) В Си процедур не бывает. Только функции с возвратом типа void. Так что и мешанины быть просто не может.

(27) Ну создавай структуру с нужными строками в общем модуле отдельной функцией. Тогда очепятка или будет везде, или нигде.

Вставлю своё имхо:
Когда нужно передавать по ссылке и там менять:
1. Когда меняешь движения, дописываешь данные в таблицу, список.
2. Когда у тебя есть большая структура, которая содержит несколько параметров, которые ты будешь использовать и тебе нужно дополнить её.
3. Когда передаёшь "Отказ" и там меняешь его на Ложь.
4. Когда передаёшь форму и добавляешь на неё свои элементы.
5. Когда передаёшь МенеджерВременных таблиц.

Это то, что смог вспомнить.

Во всех остальных случаях нужно возвращать.

(76) из всех примеров возврат значения в параметре только там где "отказ" (отстойная конструкция этот отказ). В остальных случаях это изменение состояния существующего объекта, которое в отсутствие ООП приходится выполнять именно так.

(72) Я знаю. Именно это и создает мешанину в мозгах, когда сишник садится писать на более структурированных языках. У него уже в прошивке отложилось что функция может и должна менять параметры.

(79) В Си как раз все замечательно. Объявил параметр const - значит менять нельзя. Не объявил - значит он может быть изменен. Потому что с учетом требований с скорости работы может потребоваться и результат вернуть, и параметры поменять.

(79) (80) В Си как раз всё просто - если параметр передан по значению (засунут в стек), то в функции будет его копия, а если по указателю, то в функции будет указатель на переменную, которую по указателю можно менять.
А вот в Си++ появились ссылки, когда передаётся как бы значение, но внутри это реализовано как указатель - то есть то, что мы имеем в 1С, если не написали Знач.

И не забываем, что написав Знач, мы получим копию строки - и, если она очень длинная, то можно получить существенное замедление работы.

(81) Суть не в механизме передачи параметров, а именно в том что в Си нет процедур, и для изменения параметров приходится использовать функцию. Именно поэтому пришедшие из Си и создают функции, меняющие параметры. Паскалисты бы так поступать не стали, а написали бы процедуру.

(83) Дык а если надо и параметры изменить, и значение вернуть? Что использовать? А если надо вернуть значение, параметры не менять, но поменять не параметры (например, добавить записи в базу)? Деление на процедуры и функции чисто условное, иначе сам ЯП не давал бы менять параметры в функции.

А лучше бы не давал. С точки зрения парадигмы функционального программирования изменение формальных параметров - жуткая ересь)

(88) А ты с многопоточным программированием и реентрантностью работал? Когда один и тот же код и одни и те же переменные могут использоваться одновременно несколькими потоками? И тогда единственный способ не конфликтовать потокам - это передавать указатель на некую структуру со всем контекстом потока в качестве параметра функции? И, соответственно, параметр там в процессе работы меняется.

(90) В том-то и дело, что как только начинается реальная жизнь - вся академичность летит к чертям. Так зачем все усложнять? В процедуре априори должен выполняться код, который не может сгенерировать ошибку (возврат результата через перереданные параметры - это же неакадемично, для возврата результата предназначена функция). Много такого кода в реальных задачах?

(91) Но, в той же java прекрасно как параметры передаются объекты-контейнеры (BOX) в которых можно менять содержимое, не меняя самого контейнера, то есть так они реализовали указатели.

Что касается передачи параметра в функцию по указателю, то в том же Си всё остаётся на уровне функции - указатель, как бы мы его не меняли, обратно не возвращается, то если является обычным входным параметром, а вот про то, на что он указывает, никто не говорил - его можно менять, получая доступ к ячейке памяти по указателю.

(88) Начнём с того, что во многих языках деление на процедуры и функции чисто условно, так как и те и другие могут иметь как выходные так и выходные параметры.
Просто у функции есть основной параметр, который только выходной.
А если смотреть на низком уровне, то все высокоуровневые процедуры и функции - это вызов кода, возвращающего код ошибки исполнения, а все параметры и результаты хранятся в отдельной области памяти.

(93) Там просто сборка мусора работает тогда, когда памяти стало очень мало - в результате - если память есть, то её будут жрать, пока не надоест. Но, есть ключи запуска, где всё это можно ограничить. И ваша java побыстрее 1С будет.

(89) Я дико извиняюсь, а в каком языке программирования практикуется подход обращения к общим переменным из разных потоков?

(95) Это скорее особенность компилятора. Локальная переменная функции адресуется по контретному смещению (типа [EDI + 0x10h]. Т.о. если 2 процессора выполняют один и тот же код с одним и тем же значением регистра EDI - физически 2 потока будут обращаться к одной и той же ячейке памяти. В принципе, можно для каждого потока использовать свое значение регистра EDI - но тогда для каждого потока придется создавать свою копию всего контекста приложения.

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

(98) Может быть потому что эта локальная переменная (переменная-член класса) была объявлена, как static?

(0) Все зависит от ситуации.
Если нужно "набрать" несколько значений, то Структурой их очень удобно возвращать.
В другой случае, через параметры принимаем значение, и через них же возвращаем (типа по ссылки).

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

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

Итак, давайте напишем программу для этого:

Хотя эта программа – хорошая попытка решения, она не совсем работает.

Когда вызывается функция getValueFromUser , пользователя просят ввести целое число, как и ожидалось. Но введенное им значение теряется, когда getValueFromUser завершает работу и управление возвращается к main . Переменная num никогда не инициализируется значением, введенным пользователем, поэтому программа всегда печатает ответ 0.

Чего нам не хватает, так это того, чтобы getValueFromUser могла вернуть значение, введенное пользователем, обратно в main , чтобы main могла использовать эти данные.

Возвращаемые значения

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

Во-первых, ваша функция должна указать, значение какого типа будет возвращено. Это делается путем установки типа возвращаемого значения функции, который является типом, определенным перед именем функции. В приведенном выше примере функция getValueFromUser имеет тип возвращаемого значения void , а функция main имеет тип возвращаемого значения int . Обратите внимание, что это не определяет, какое конкретное значение будет возвращено – только тип значения.

Во-вторых, внутри функции, которая будет возвращать значение, мы используем инструкцию return , чтобы указать конкретное значение, возвращаемое вызывающей стороне. Конкретное значение, возвращаемое функцией, называется возвращаемым значением. Когда инструкция return выполняется, возвращаемое значение копируется из функции обратно в вызывающую функцию. Этот процесс называется возвратом по значению.

Давайте рассмотрим простую функцию, которая возвращает целочисленное значение, и пример программы, которая ее вызывает:

При запуске эта программа печатает:

Выполнение начинается с верхней части main . В первой инструкции вычисляется вызов функции returnFive , в результате чего вызывается функция returnFive . Функция returnFive возвращает конкретное значение 5 обратно вызывающей стороне, которое затем выводится в консоль через std::cout .

Во второй инструкции вычисляется вызов функции returnFive , что приводит к повторному вызову функции returnFive . Функция returnFive возвращает значение 5 обратно вызывающей стороне. Выражение 5 + 2 вычисляется для получения результата 7, который затем выводится в консоль через std::cout .

В третьей инструкции функция returnFive вызывается снова, в результате чего значение 5 возвращается обратно вызывающей стороне. Однако функция main ничего не делает с возвращаемым значением, поэтому больше ничего не происходит (возвращаемое значение игнорируется).

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

Исправляем нашу тестовую программу

Когда эта программа выполняется, первая инструкция в main создаст переменную типа int с именем num . Когда программа перейдет к инициализации num , она увидит, что есть вызов функции getValueFromUser , поэтому она выполнит эту функцию. Функция getValueFromUser просит пользователя ввести значение, а затем возвращает это значение вызывающей функции ( main ). Это возвращенное значение используется как значение для инициализации переменной num .

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

Отсутствие возвращаемого значения

Функции не обязаны возвращать значение. Чтобы сообщить компилятору, что функция не возвращает значение, используется тип возвращаемого значения void . Давайте посмотрим на функцию doPrint() из предыдущего урока:

Эта функция имеет тип возвращаемого значения void , что указывает на то, что она не возвращает значение вызывающей стороне. Поскольку она не возвращает значение, инструкция return не требуется (попытка вернуть конкретное значение из функции с типом возврата void приведет к ошибке компиляции).

Вот еще один пример функции, ничего не возвращающей, и пример программы, которая ее вызывает:

Возвращаясь к main

Теперь у вас есть концептуальные инструменты, чтобы понять, как на самом деле работает функция main . Когда программа выполняется, операционная система вызывает функцию main . Затем выполнение переходит в начало main . Инструкции в main выполняются последовательно. Наконец, main возвращает целочисленное значение (обычно 0), и ваша программа завершается. Значение, возвращаемое из main , иногда называют кодом состояния (также иногда называемым кодом выхода или, реже, кодом возврата), поскольку оно используется, чтобы указать, успешно ли была выполнена программа.

По определению, код состояния 0 означает, что программа выполнена успешно.

Лучшая практика

Ваша функция main должна возвращать 0, если программа работает нормально.

Код состояния, отличный от нуля, часто используется для обозначения сбоя (и хотя он отлично работает в большинстве операционных систем, строго говоря, его портируемость не гарантируется).

Для продвинутых читателей

Стандарт C++ определяет значение только трех кодов состояния: 0, EXIT_SUCCESS и EXIT_FAILURE . 0 и EXIT_SUCCESS означают, что программа выполнена успешно. EXIT_FAILURE означает, что программа не была успешно выполнена.

EXIT_SUCCESS и EXIT_FAILURE определены в заголовочном файле :

Если вы хотите максимизировать портируемость, вы должны использовать только 0 или EXIT_SUCCESS , чтобы указать на успешное завершение, или EXIT_FAILURE , чтобы указать на неудачное завершение.

C++ запрещает явный вызов функции main .

На данный момент вы также должны определять свою функцию main внизу исходного файла кода, под другими функциями.

Несколько дополнительных замечаний о возвращаемых значениях

Во-первых, если функция имеет тип возврата, являющийся не- void , она должна возвращать значение этого типа (используя инструкцию return ). Несоблюдение этого правила приведет к неопределенному поведению. Единственное исключение из этого правила – функция main() , которая, если возвращаемое значение не указано явно, примет, что оно равно 0. Тем не менее, рекомендуется явно возвращать значение из main , как для демонстрации вашего намерения, так и для согласованности с другими функциями (что не позволит вам опустить возвращаемое значение).

Лучшая практика

Всегда явно указывайте возвращаемое значение для любой функции, которая имеет тип возврата не- void .

Предупреждение

Неспособность вернуть значение из функции с типом возврата не- void (кроме main ) приведет к неопределенному поведению.

Во-вторых, когда выполняется инструкция return , функция немедленно, в этой точке, возвращается в вызывающую функцию. Любой дополнительный код в функции игнорируется.

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

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

Повторное использование функций

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

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

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

Лучшая практика

Заключение

Возвращаемые значения позволяют функциям возвращать одно значение обратно вызывающей функции.

Функции позволяют минимизировать избыточность наших программ.

Небольшой тест

Вопрос 1

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

Эта программа печатает число 16.

Эта программа не компилируется. Вложенные функции не допускаются.

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

Эта программа печатает буквы A и B в отдельных строках.

Эта программа напечатает 5 дважды (в отдельных строках). Оба раза, когда вызывается функция getNumbers() , возвращается значение 5. Когда выполняется инструкция return 5; , функция немедленно завершается, поэтому инструкция return 7; никогда не выполняется.

1h) Чуть сложнее.

Эта программа будет скомпилирована, но функция не будет вызвана, потому что при вызове функции отсутствуют круглые скобки. То, что на самом деле будет выведено, зависит от компилятора.

Вопрос 2

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

Вариант состоит в том, чтобы вернуть одно значение и передать другое через опорный параметр:

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

Является ли один из этих способов вообще предпочтительным, или есть другие предложения?

Изменить: в реальном коде может быть более двух результатов. Они также могут быть разных типов.

Решение

Для возврата двух значений я использую std::pair (обычно typedef’d). Вы должны посмотреть на boost::tuple (в C ++ 11 и новее есть std::tuple ) более двух возвращаемых результатов.

С введением структурированного связывания в C ++ 17, возвращая std::tuple должно стать общепринятым стандартом.

Другие решения

В C ++ 11 вы можете:

или со структурами:

Лично мне вообще не нравятся возвращаемые параметры по ряду причин:

У меня также есть некоторые оговорки о технике пар / кортежей. В основном, часто нет естественного порядка возвращаемых значений. Как читатель кода узнает, является ли result.first частным или остатком? И разработчик может изменить порядок, что нарушит существующий код. Это особенно коварно, если значения имеют один и тот же тип, чтобы не возникало ошибок или предупреждений компилятора. На самом деле, эти аргументы применимы и к возвращаемым параметрам.

Вот еще один пример кода, этот чуть менее тривиален:

Имеет ли этот отпечаток скорость и курс или курс и скорость? Это не очевидно.

Сравните с этим:

Я думаю, что это понятнее.

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

std :: pair — это, по сути, ваше структурное решение, но оно уже определено для вас и готово для адаптации к любым двум типам данных.

Это полностью зависит от фактической функции и значения нескольких значений, а также их размеров:

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

Решение OO для этого состоит в том, чтобы создать класс отношений. Это не потребовало бы никакого дополнительного кода (сэкономило бы немного), было бы значительно чище / яснее, и дало бы вам некоторые дополнительные рефакторинги, позволяющие вам очистить код и вне этого класса.

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

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

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

Хорошая вещь об этом, что это гарантированно не вызывает любой копирование или перемещение. Вы можете сделать пример many структура variadic тоже. Больше деталей:

Существует прецедент для возврата структур в стандарте C (и, следовательно, C ++) с div , ldiv (а в С99 lldiv ) функции от (или же ).

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

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

Чистая функция, это функция, которая:

является детерминированной;
не обладает побочными эффектами.

int f(int x) int y = 0;
int z = 0;
y = 2 * x;
z = y + 1;
return z / 3;
>

Возврат нескольких разнотипных значений

Что делать, если функции нужно вернуть сразу два или три значения, причем, возможно, разных типов?

Увы, просто так этого сделать нельзя.

Такие ситуации можно разделить на два характерных случая:

Возвращаемые значения фактически представляют собой единый объект.
Пример 1: функции getPixelColor(x, y) передаются координаты точки на текстуре, возвращается ее цвет.
Возвращаемые данные не вполне связаны между собой (являются различными объектами или просто набором слабо связанных данных).
Пример 2: функция getStudentMark() получает с клавиатуры строчку с фамилией студента и его оценку по информатике.

Пример 1

Итак, функции getPixelColor(x, y) передаются координаты точки на текстуре, надо вернуть ее цвет.

Цвет в модели RGB TrueColor описывается тремя целыми беззнаковыми числами в диапазоне от 0 до 255.

Здесь цвет точки однозначно представляет собой объект, который должен быть выделен в структуру данных.

typedef struct unsigned char r, g, b; //компоненты цвета red, green, blue
> tColor;

Как только создана такая Си-структура, вопрос передачи цвета из функции решен:

tColor getPixelColor(int x, int y)
tColor color; //локальная переменная, куда будем доставать цвет.
//. достать цвет с текстуры (без подробностей)
return color;
>

Пример 2

Функция getStudentMark() должна получить с клавиатуры строчку с фамилией студента и его оценку по информатике. При этом для студентов уже существует структура данных:

typedef struct int studentID; //идентификатор студента
char lastName[30]; //фамилия
char name[30]; //имя
unsigned int groupNumber; //номер группы
> tStudent;

Заметим, что эта структура нам для возврата значения не подходит. Мы возвращаем лишь фамилию и оценку.

Фамилия -- лишь часть этой структуры данных, остальное нам в этой функции заполнить неоткуда. Заполнить пустыми значениями? А вдруг мы в месте вызова забудем, что в возвращенном экземпляре структуры правдива лишь фамилия?

Оценку по информатике можно было бы внести в эту структуру, но, согласитесь, будет странно, если оценка будет атрибутом самого студента, а не его строчки в журнале. Это не логично, особенно если учесть, что другая функция, работающая со списком студентов, будет вынуждена "выдумывать" теперь уже оценку.

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

typedef struct char lastName[30]; //фамилия
unsigned int mark; //оценка
> tStudentMark;

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

Функция будет выглядеть так:

tStudentMark getStudentMark()
tStudentMark studentMark; //локальная переменная, куда будем доставать фамилию и оценку.
//. достать фамилию и оценку (без подробностей)
return studentMark;
>

char lastName[20];
int mark;
tStudentMark studentMark; //переменная, которая нужна только для разбора значений из функции
studentMark = getStudentMark();
lastName = studentMark.lastName;
mark = studentMark.mark;

Текста получилось много, зато мы сохранили "чистоту функции".

Передача через нарушение чистоты функции

Есть еще два способа вернуть из функции значение:

Передавать параметры не по значению, а по адресу, а изнутри функции просто менять их значения.
Пример: функция getStudentMark() получает в качестве параметров адреса строки и оценки, считывает с клавиатуры строчку с фамилией студента и его оценку по информатике, и сохраняет в параметры.
Сохранять возвращаемые значения в глобальных переменных.
Стандартной функции open(filename, O_RDONLY) передается имя файла и флаги доступа, функция возвращает открывает файл, и возвращает его дескриптор (число-идентификатор, необходимое для последующих обращений к открытому файлу), однако может случиться ошибка доступа, причем код ошибки важен.

Пример

Итак, функция getStudentMark() получает в качестве параметров адрес строки и адрес оценки, считывает с клавиатуры строчку с фамилией студента и его оценку по информатике, и сохраняет в параметры.

Попробуем написать функцию с таким заголовком:

void getStudentMark(char lastName[], int *mark)
scanf("%s%d", lastName, mark);
>

char lastName[20];
int mark;
getStudentMark(lastName, &mark);

Плюсы: отказались от "одноразовой" структуры данных, уменьшили длину кода.

Минусы: корректность памяти определяется местом вызова. Внутри функции хорошо бы проверять корректность данных адресов памяти.

Читайте также: