Как обратиться к функции в классе c
Перейти к содержимому

Как обратиться к функции в классе c

  • автор:

Как обратиться к функции в классе c

Дружественные функции — это функции, которые не являются членами класса, однако имеют доступ к его закрытым членам — переменным и функциям, которые имеют спецификатор private.

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

#include class Auto < friend void drive(const Auto&); friend void setPrice(Auto&, unsigned); public: Auto(std::string autoName, unsigned autoPrice) < name = autoName; price = autoPrice; >void print() < std::cout private: std::string name; // название автомобиля unsigned price; // цена автомобиля >; void drive(const Auto &car) < std::cout void setPrice(Auto &car, unsigned price) < car.price = price; >int main() < Auto tesla("Tesla", 5000); tesla.print(); // drive(tesla); setPrice(tesla, 8000); tesla.print(); // >

Здесь определен класс Auto, который представляет автомобиль. У этого класса определены приватные закрытые переменные name (название автомобиля) и price (цена автомобиля). Также в классе объявлены две дружественные функции: drive (функция вождения автомобиля) и setPrice (функция назначения цены). Обе этих функции принимают в качестве параметра ссылку на объект Auto.

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

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

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

Консольный вывод программы:

Tesla : 5000 Tesla is driven Tesla : 8000

Определение дружественных функций в классе

Дружественные функции могут определяться в другом классе. Например, определим класс Person, который использует объект Auto:

#include class Auto; // объявление класса Auto, чтобы Person видел этот класс class Person < public: Person(std::string p_name) < name = p_name; >void drive(const Auto&); void setPrice(Auto&, unsigned); private: std::string name; >; class Auto < // объявление дружественных функций friend void Person::drive(const Auto&); friend void Person::setPrice(Auto&, unsigned); public: Auto(std::string a_name, unsigned a_price) < name = a_name; price = a_price; >void print() < std::cout private: std::string name; // название автомобиля unsigned price; // цена автомобиля >; void Person::drive(const Auto &car) < std::cout void Person::setPrice(Auto &car, unsigned price) < car.price = price; >int main() < Auto tesla; Person tom; tom.drive(tesla); tom.setPrice(tesla, 8000); tesla.print(); >

Вначале определен класс Person, который представляет человека. Однако поскольку класс Person использует класс Auto, то перед классом Person идет объявление класса Auto.

Две функции из класса Person принимают ссылку на объект Auto:

void drive(const Auto&); void setPrice(Auto&, unsigned);

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

Класс Auto определяет дружественные функции с той же сигнатурой:

friend void Person::drive(Auto&); friend void Person::setPrice(Auto&, unsigned);

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

И поскольку в этих функциях предполагается использовать объект Auto, то ко времени определения этих функций все члены объекта Auto должны быть известны, поэтому определения функций находятся не в самом классе Person, а после класса Auto. И так как эти функции определены в классе Auto как дружественные, мы можем обратиться в этих функциях к закрытым членам класса Auto.

Консольный вывод программы:

Tom drives Tesla Tesla : 8000

Дружественные классы

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

#include class Auto; // объявление класса Auto, чтобы Person видел этот класс class Person < public: Person(std::string p_name) < name = p_name; >void drive(const Auto&); void setPrice(Auto&, unsigned); private: std::string name; >; class Auto < // объявление дружественного класса friend class Person; public: Auto(std::string a_name, unsigned a_price) < name = a_name; price = a_price; >void print() < std::cout private: std::string name; // название автомобиля unsigned price; // цена автомобиля >; void Person::drive(const Auto& car) < std::cout void Person::setPrice(Auto& car, unsigned price) < car.price = price; >int main() < Auto tesla; Person tom; tom.drive(tesla); tom.setPrice(tesla, 8000); tesla.print(); >

Единственное, что в данном случае изменилось по сравнению с предыдущим примером — это то, что в классе Auto определение дружественных функций было заменено определением дружественного класса:

friend class Person;

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

Как обратиться к функции в классе c

Кроме переменных и методов, которые относятся непосредственно к объекту, C++ позволяет определять переменные и методы, которые относятся непосредственно к классу или иначе говоря статические члены класса. Статические переменные и методы относят в целом ко всему классу. Для их определения используется ключевое слово static .

Статические поля

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

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

#include class Person < public: Person(std::string p_name, unsigned p_age) < ++count; // при создании нового объекта увеличиваем счетчик name = p_name; age = p_age; >void print_count() < std::cout private: std::string name; unsigned age; static inline unsigned count<>; // статическое поле - счетчик объектов Person >; int main() < Person tom; Person bob; Person sam; tom.print_count(); bob.print_count(); sam.print_count(); >

Здесь в классе Person определена статическая переменная count с помощью ключевого слова static :

static inline unsigned count<>; // инициализируем нулем

Обратите внимание, после static идет ключевое слово inline . Это ключевое слово в принципе необязательно для статических переменных и необходимо конкретно в данном случае для инициализации переменной count. В данном случае нулем.

При создании каждого нового объекта в конструкторе увеличиваем счетчик на единицу:

Person(std::string p_name, unsigned p_age) < ++count; // при создании нового объекта увеличиваем счетчик

В функциях класса Person мы можем обращаться к этой статической переменной. Например, в функции print_count выводим ее значение на консоль:

void print_count()

Для теста в функции main создаем три объекта Person и затем у каждого вызываем функцию print_count:

tom.print_count(); bob.print_count(); sam.print_count();

Но поскольку переменная count статическая и относится ко всему классу в целом и не зависит от конкретного объекта, во всех трех случаях будет вывtдено число 3.

Статические функции

Статические функции также принадлежат классу в целом и не зависят от любого отдельного объекта класса. Обычно статические функции-члены используются для работы со статическими переменными. Например, в примере выше функция print_count() выводит значение статической переменной count и никак не зависит от конкретного объекта, не использует и не изменяет переменные и функции объектов. Поэтому такую функцию можно и даже лучше сделать статической:

#include class Person < public: Person(std::string p_name, unsigned p_age) < ++count; // при создании нового объекта увеличиваем счетчик name = p_name; age = p_age; >// статическая функция static void print_count() < std::cout private: std::string name; unsigned age; static inline unsigned count<>; // статическое поле - счетчик объектов Person >; int main() < Person tom; Person bob; Person sam; tom.print_count(); // Created 3 objects >

Для определения статической функции перед ней также указывается ключевое слово static :

static void print_count()

К подобным функциям также можно обращаться через имя объекта:

tom.print_count();

Обращение к статическим членам класса

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

класс::член_класса

После имени класса идет оператор :: и имя статического компонента класса. Например:

#include class Person < public: static inline unsigned maxAge; // статическая публичная переменная Person(std::string p_name, unsigned p_age) < ++count; name = p_name; if(p_age < maxAge) // если значение не больше максимального age = p_age; >// статическая функция static void print_count() < std::cout private: std::string name; unsigned age; static inline unsigned count<>; // статическая приватная переменная >; int main() < Person tom; Person bob; Person sam; // обращаемся к статической функции print_count Person::print_count(); // обращаемся к статической переменной maxAge std::cout << "Max age: " << Person::maxAge << std::endl; // изменяем статическую переменную maxAge Person::maxAge = 110; std::cout

Здесь добавлена публичная статическая переменная maxAge , которая представляет максимальный возраст. Поскольку этот показатель не зависит от определенного объекта и относится в целом к классу объектов Person (справедливо для всех людей), то определяем такую переменную как статическую. В конструкторе используем эту переменную для верификации переданного в конструктор возраста. Если он больше максимального, то возраст получает значение по умолчанию - 1.

Далее в функции main мы можем по имени класса обратиться к статической функции print_count и переменной maxAge:

Person::print_count(); Person::maxAge

Консольный вывод программы:

Created 3 objects Max age: 120 Max age: 110

Статические константы

Также можно определять статические константы. Так, в примере выше маловероятно, что значение maxAge будет меняться. Поэтому мы можем определить ее как константу. Ее значения нельзя будет изменить, а во остальном работа с ней идет также как и со статическими переменными:

#include class Person < public: static inline const unsigned maxAge; // статическая константа Person(std::string p_name, unsigned p_age) < ++count; name = p_name; if(p_age < maxAge) // если значение не больше максимального age = p_age; >// статическая функция static void print_count() < std::cout private: std::string name; unsigned age; static inline unsigned count<>; // статическая приватная переменная >; int main() < Person tom; Person bob; // обращаемся к статическим компонентам класса Person::print_count(); std::cout

  • Глава 1. Введение в С++
    • Язык программирования С++
    • Первая программа на Windows. Компилятор g++
    • Первая программа на Windows. Компилятор Clang
    • Первая программа на Windows. Компилятор Microsoft Visual C++
    • Первая программа на Linux. Компилятор g++
    • Первая программа на MacOS. Компилятор Clang
    • Настройка параметров компиляции
    • Локализация и кириллица в консоли
    • Структура программы
    • Переменные
    • Типы данных
    • Константы
    • Ввод и вывод в консоли
    • using. Подключение пространств имен и определение псевдонимов
    • Арифметические операции
    • Статическая типизация и преобразования типов
    • Поразрядные операции
    • Операции присваивания
    • Условные выражения
    • Конструкция if-else и тернарный оператор
    • Конструкция switch-case
    • Циклы
    • Ссылки
    • Массивы
    • Многомерные массивы
    • Массивы символов
    • Введение в строки
    • Что такое указатели
    • Операции с указателями
    • Арифметика указателей
    • Константы и указатели
    • Указатели и массивы
    • Определение и объявление функций
    • Область видимости объектов
    • Параметры функции
    • Передача аргументов по значению и по ссылке
    • Константные параметры
    • Оператор return и возвращение результата
    • Указатели в параметрах функции
    • Массивы в параметрах функции
    • Параметры функции main
    • Возвращение указателей и ссылок
    • Перегрузка функций
    • Рекурсивные функции
    • Рекурсия на примере быстрой сортировки
    • Указатели на функции
    • Указатели на функции как параметры
    • Тип функции
    • Указатель на функцию как возвращаемое значение
    • Разделение программы на файлы
    • Внешние объекты
    • Динамические объекты
    • Динамические массивы
    • unique_ptr
    • shared_ptr
    • Определение классов
    • Конструкторы и инициализация объектов
    • Управление доступом. Инкапсуляция
    • Объявление и определение функций класса
    • Конструктор копирования
    • Константные объекты и функции
    • Ключевое слово this
    • Дружественные функции и классы
    • Статические члены класса
    • Деструктор
    • Структуры
    • Перечисления
    • Наследование
    • Управление доступом в базовых и производных классах
    • Скрытие функционала базового класса
    • Множественное наследование
    • Виртуальные функции и их переопределение
    • Преобразование типов
    • Динамическое преобразование
    • Особенности динамического связывания
    • Чистые виртуальные функции и абстрактные классы
    • Перегрузка операторов
    • Операторы преобразования типов
    • Оператор индексирования
    • Переопределение оператора присваивания
    • Пространства имен
    • Вложенные классы
    • Обработка исключений
    • Вложенные try-catch
    • Создание своих типов исключений
    • Тип exception
    • Типы исключений
    • Шаблоны функций
    • Шаблон класса
    • Специализация шаблона класса
    • Наследование и шаблоны классов
    • Типы контейнеров
    • Вектор
    • Итераторы
    • Операции с векторами
    • Array
    • List
    • Forward_list
    • Deque
    • Стек std::stack
    • Очередь std::queue
    • Очередь приоритетов std::priority_queue
    • Множества
    • Словарь std::map
    • Span
    • Определение строк
    • Строки с поддержкой Unicode
    • Преобразование типов и строки
    • Сравнение строк
    • Получение подстроки и проверка начала и конца строки
    • Поиск подстроки
    • Изменение строки
    • Операции с символами
    • Программа подсчета слов
    • Тип std:string_view
    • rvalue
    • Конструктор перемещения
    • Оператор присваивания с перемещением
    • Роль noexcept при перемещении
    • Объекты функций
    • Лямбда-выражения
    • Захват внешних значений в лямбда-выражениях
    • Шаблон std::function<>
    • Минимальный и максимальный элементы
    • Поиск элементов
    • Копирование элементов
    • Удаление элементов и идиома Remove-Erase Idiom
    • Сортировка
    • Представления. Фильтрация
    • Проекция данных
    • Пропуск элементов. drop_view и drop_while_view
    • Извлечение диапазона элементов. take_view и take_while_view
    • Цепочки представлений
    • Оператор requires
    • Концепты
    • Выражение requires
    • Ограничения типа для auto
    • Базовые типы для работы с потоками
    • Файловые потоки. Открытие и закрытие
    • Чтение и запись текстовых файлов
    • Переопределение операторов ввода и вывода
    • Математические константы и операции
    • Форматирование строк и функция format
    • std::optional
    • Управление ресурсами. Идиома RAII
    • Идиома копирования и замены
    • Идиома Move-and-Swap
    • Первая программа в Visual Studio
    • Первая программа в Qt Creator

    Помощь сайту
    410011174743222
    Перевод на карту
    Номер карты:
    4048415020898850

    Контакты для связи: metanit22@mail.ru

    Copyright © metanit.com, 2024. Все права защищены.

    Методы (Руководство по программированию на C#)

    Метод — это блок кода, содержащий ряд инструкций. Программа инициирует выполнение инструкций, вызывая метод и указывая все аргументы, необходимые для этого метода. В C# все инструкции выполняются в контексте метода.

    Метод Main является точкой входа для каждого приложения C# и вызывается общеязыковой средой выполнения (CLR) при запуске программы. В приложении, использующем инструкции верхнего уровня, метод Main создается компилятором и содержит все инструкции верхнего уровня.

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

    Сигнатуры методов

    Методы объявляются в классе, структуре или интерфейсе путем указания уровня доступа, такого как public или private , необязательных модификаторов, таких как abstract или sealed , возвращаемого значения, имени метода и всех параметров этого метода. Все эти части вместе представляют собой сигнатуру метода.

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

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

    abstract class Motorcycle < // Anyone can call this. public void StartEngine() // Only derived classes can call this. protected void AddGas(int gallons) < /* Method statements here */ >// Derived classes can override the base class implementation. public virtual int Drive(int miles, int speed) < /* Method statements here */ return 1; >// Derived classes must implement this. public abstract double GetTopSpeed(); > 

    Доступ к методу

    Вызов метода в объекте аналогичен доступу к полю. После имени объекта добавьте точку, имя метода и круглые скобки. Аргументы перечисляются в этих скобках и разделяются запятыми. Таким образом, методы класса Motorcycle могут вызываться, как показано в следующем примере:

    class TestMotorcycle : Motorcycle < public override double GetTopSpeed() < return 108.4; >static void Main() < TestMotorcycle moto = new TestMotorcycle(); moto.StartEngine(); moto.AddGas(15); moto.Drive(5, 20); double speed = moto.GetTopSpeed(); Console.WriteLine("My top speed is ", speed); > > 

    Параметры и аргументы метода

    Определение метода задает имена и типы всех необходимых параметров. Когда вызывающий код вызывает метод, он предоставляет конкретные значения, называемые аргументами, для каждого параметра. Аргументы должны быть совместимы с типом параметра, но имя аргумента (если есть), используемое в вызывающем коде, не обязательно должно совпадать с именем параметра, указанным в методе. Например:

    public void Caller() < int numA = 4; // Call with an int variable. int productA = Square(numA); int numB = 32; // Call with another int variable. int productB = Square(numB); // Call with an integer literal. int productC = Square(12); // Call with an expression that evaluates to int. productC = Square(productA * 3); >int Square(int i) < // Store input argument in a local variable. int input = i; return input * input; >

    Передача по ссылке и передача по значению

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

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

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

    public class SampleRefType

    Теперь, если передать объект, основанный на этом типе, в метод, то будет передана ссылка на объект. В следующем примере объект типа SampleRefType передается в метод ModifyObject :

    public static void TestRefType() < SampleRefType rt = new SampleRefType(); rt.value = 44; ModifyObject(rt); Console.WriteLine(rt.value); >static void ModifyObject(SampleRefType obj)

    В этом примере, в сущности, делается то же, что и в предыдущем примере, — аргумент по значению передается в метод. Но поскольку здесь используется ссылочный тип, результат будет другим. В данном случае в методе ModifyObject изменено поле value параметра obj , а также изменено поле value аргумента, rt в методе TestRefType . В качестве выходных данных метод TestRefType отображает 33.

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

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

    Методы могут возвращать значение вызывающему объекту. Если тип возврата, указываемый перед именем метода, не void , этот метод может возвращать значение с помощью оператора return . Инструкция с ключевым словом return , за которым следует значение, соответствующее типу возврата, будет возвращать это значение объекту, вызвавшему метод.

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

    public ref double GetEstimatedDistance()

    Ключевое слове return также останавливает выполнение метода. Если тип возврата — void , инструкцию return без значения по-прежнему можно использовать для завершения выполнения метода. Без ключевого слова return этот метод будет останавливать выполнение при достижении конца блока кода. Методы с типом возврата, отличным от void, должны использовать ключевое слово return для возврата значения. Например, в следующих двух методах ключевое слово return используется для возврата целочисленных значений.

    class SimpleMath < public int AddTwoNumbers(int number1, int number2) < return number1 + number2; >public int SquareANumber(int number) < return number * number; >> 

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

    int result = obj.AddTwoNumbers(1, 2); result = obj.SquareANumber(result); // The result is 9. Console.WriteLine(result); 
    result = obj.SquareANumber(obj.AddTwoNumbers(1, 2)); // The result is 9. Console.WriteLine(result); 

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

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

    ref double distance = ref Planet.GetEstimatedDistance(); 

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

    static void Main(string[] args) < int[,] matrix = new int[2, 2]; FillMatrix(matrix); // matrix is now full of -1 >public static void FillMatrix(int[,] matrix) < for (int i = 0; i < matrix.GetLength(0); i++) < for (int j = 0; j < matrix.GetLength(1); j++) < matrix[i, j] = -1; >> > 

    Асинхронные методы

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

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

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

    В следующем примере метод Main служит примером асинхронного метода с типом возврата Task. Он переходит к методу DoSomethingAsync и, поскольку он выражается в одной строке, он может опустить ключевые слова async и await . Поскольку DoSomethingAsync является асинхронным методом, задача для вызова DoSomethingAsync должна быть ожидаемой, как показывает следующая инструкция: await DoSomethingAsync(); .

    class Program < static Task Main() =>DoSomethingAsync(); static async Task DoSomethingAsync() < TaskdelayTask = DelayAsync(); int result = await delayTask; // The previous two statements may be combined into // the following statement. //int result = await DelayAsync(); Console.WriteLine($"Result: "); > static async Task DelayAsync() < await Task.Delay(100); return 5; >> // Example output: // Result: 5 

    Асинхронный метод не может объявить все параметры ref или out , но может вызывать методы, которые имеют такие параметры.

    Определения текста выражений

    Часто используются определения методов, которые просто немедленно возвращаются с результатом выражения или которые имеют единственную инструкцию в тексте метода. Для определения таких методов существует сокращенный синтаксис с использованием => :

    public Point Move(int dx, int dy) => new Point(x + dx, y + dy); public void Print() => Console.WriteLine(First + " " + Last); // Works with operators, properties, and indexers too. public static Complex operator +(Complex a, Complex b) => a.Add(b); public string Name => First + " " + Last; public Customer this[long id] => store.LookupCustomer(id); 

    Если метод возвращает void или является асинхронным методом, то текст метода должен быть выражением инструкции (так же, как при использовании лямбда-выражений). Свойства и индексаторы должны быть только для чтения, и вы не должны использовать ключевое слово get метода доступа.

    Итераторы

    Итератор выполняет настраиваемую итерацию по коллекции, например по списку или массиву. Итератор использует инструкцию yield return для возврата всех элементов по одному. При достижении инструкции yield return текущее расположение в коде запоминается. При следующем вызове итератора выполнение возобновляется с этого места.

    Итератор вызывается из клиентского кода с помощью инструкции foreach .

    Дополнительные сведения см. в разделе Итераторы.

    Спецификация языка C#

    Дополнительные сведения см. в спецификации языка C#. Спецификация языка является предписывающим источником информации о синтаксисе и использовании языка C#.

    См. также

    • Система типов C#
    • Модификаторы доступа
    • Статические классы и члены статических классов
    • Наследование
    • Абстрактные и запечатанные классы и члены классов
    • params
    • out
    • ref;
    • Параметры методов

    Совместная работа с нами на GitHub

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

    Как вызвать функцию из функции, которая в классе?

    У методов по умолчанию задается параметр self , который незаметно перекладывается при вызове метода объектом:

    # В test будет передана ссылка на launch, т.е. self это launch launch.test() 

    Поэтому, для функции test1 нужно вручную передавать параметр, раз его объявили:

     def test1(self): print(self.name) test1(self) 

    Либо, не указывайте в test1 ничего и обращайтесь к self , т.к. область действия происходит внутри метода и self будет доступен:

     def test1(): print(self.name) test1() 

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *