Зачем нужны друзья класса c
Перейти к содержимому

Зачем нужны друзья класса c

  • автор:

friend (C++)

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

Синтаксис

friend-declaration :
friend function-declaration
friend function-definition
friend elaborated-type-specifier ; ;
friend simple-type-specifier ;
friend typename-specifier ;

friend Объявления

Если вы объявляете friend функцию, которая не была объявлена ранее, эта функция экспортируется в заключающую неклассовую область.

Функции, объявленные в friend объявлении, рассматриваются как если бы они были объявлены с помощью extern ключевое слово. Дополнительные сведения см. в разделе extern .

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

class ForwardDeclared; // Class name is known. class HasFriends < friend int ForwardDeclared::IsAFriend(); // C2039 error expected >; 

В предыдущем примере имя ForwardDeclared класса вводится в область, но полное объявление (в частности, часть, объявляющая функцию IsAFriend ) не известна. friend Объявление в классе HasFriends создает ошибку.

В C++11 существует две формы объявлений друзей для класса:

friend class F; friend F; 

Первая форма представляет новый класс F, если существующий класс по имени не найден в самом внутреннем пространстве имен. C++11: вторая форма не вводит новый класс; его можно использовать, когда класс уже объявлен, и его необходимо использовать при объявлении параметра типа шаблона или typedef в качестве friend .

Используйте friend class F , когда указанный тип еще не объявлен:

namespace NS < class M < friend class F; // Introduces F but doesn't define it >; > 

Ошибка возникает, если вы используете friend с типом класса, который не был объявлен:

namespace NS < class M < friend F; // error C2433: 'NS::F': 'friend' not permitted on data declarations >; > 

В следующем примере friend F относится к F классу, объявленному за пределами область NS.

class F <>; namespace NS < class M < friend F; // OK >; > 

Используется friend F для объявления параметра шаблона в качестве друга:

template class my_class < friend T; //. >; 

Используется friend F для объявления типа в качестве друга:

class Foo <>; typedef Foo F; class G < friend F; // OK friend class F // Error C2371 -- redefinition >; 

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

Хотя весь второй класс должен быть дружественным для первого класса, можно выбрать, какие функции первого класса будут дружественными для второго класса.

дружественные функции

friend Функция — это функция, которая не является членом класса, но имеет доступ к частным и защищенным элементам класса. Другие функции не считаются членами класса; они являются обычными внешними функциями, которым предоставляются специальные привилегии доступа. Друзья не входят в область класса, и они не вызываются с помощью операторов выбора членов ( и —>), если они не являются членами другого класса. Функция friend объявляется классом, предоставляющим доступ. Объявление friend можно поместить в любое место в объявлении класса. Это не влияет на ключевое слово управления доступом.

В следующем примере показан класс Point и дружественная функция ChangePrivate . Функция friend имеет доступ к члену частных данных объекта, который Point он получает в качестве параметра.

// friend_functions.cpp // compile with: /EHsc #include using namespace std; class Point < friend void ChangePrivate( Point & ); public: Point( void ) : m_i(0) <>void PrintPrivate( void ) private: int m_i; >; void ChangePrivate ( Point &i ) < i.m_i++; >int main() < Point sPoint; sPoint.PrintPrivate(); ChangePrivate(sPoint); sPoint.PrintPrivate(); // Output: 0 1 >

Члены класса как дружественные элементы

Функции-члены класса могут быть объявлены в других классах как дружественные. Рассмотрим следующий пример:

// classes_as_friends1.cpp // compile with: /c class B; class A < public: int Func1( B& b ); private: int Func2( B& b ); >; class B < private: int _b; // A::Func1 is a friend function to class B // so A::Func1 has access to all members of B friend int A::Func1( B& ); >; int A::Func1( B& b ) < return b._b; >// OK int A::Func2( B& b ) < return b._b; >// C2248 

В предыдущем примере доступ к классу B предоставляется friend только функция A::Func1( B& ) . Поэтому доступ к частному члену _b является правильным в Func1 классе A , но не в Func2 .

Класс friend — это класс, все функции-члены которого являются friend функциями класса, т. е. функции-члены которых имеют доступ к частным и защищенным членам другого класса. Предположим, что в классе friend было следующее объявление B :

friend class A; 

В этом случае все функции-члены в классе A получили friend бы доступ к классу B . Следующий код является примером friend класса:

// classes_as_friends2.cpp // compile with: /EHsc #include using namespace std; class YourClass < friend class YourOtherClass; // Declare a friend class public: YourClass() : topSecret(0)<>void printMember() < cout private: int topSecret; >; class YourOtherClass < public: void change( YourClass& yc, int x )>; int main()

Дружба не является взаимной, если только явно не указано как таковое. В приведенном выше примере функции-члены YourClass не могут получить доступ к частным членам YourOtherClass .

Управляемый тип (в C++/CLI) не может иметь функций friend , friend классов или friend интерфейсов.

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

На следующем рисунке показаны объявления 4 классов: Base , Derived , aFriend и anotherFriend . Только класс aFriend имеет прямой доступ к закрытым членам класса Base (и к любым возможным унаследованным членам класса Base ).

На схеме показано, что класс anotherFriend не имеет отношения друг с базой классов, которую друзья класс aFriend. Класс aFriend друг от класса Base, но у него нет отношения друг с классом Производное, даже если класс Производно наследует от Base. Это показывает, что наследование не означает, что производный класс имеет те же друзья, что и базовый класс.

Встроенные friend определения

Пользовательские функции можно определить (в соответствии с телом функции) внутри объявлений классов. Эти функции являются встроенными функциями. Как и встроенные функции-члены, они ведут себя так, как будто они были определены сразу после того, как все члены класса были замечены, но до закрытия класса область (в конце объявления класса). Функции-друзья, определенные внутри объявлений классов, находятся в область заключенного класса.

Дружественные функции С++

Самым важным, но и, скорее всего, самым непонятным для вас сейчас станет определение дружественной функции. Дружественная функция — это функция, которая не является членом класса, но имеет доступ к членам класса, объявленным в полях private или protected . Долго не вникайте в суть этого определения, а лучше сразу переходите к следующему абзацу. Обещаю, что после прочтения статьи вы вернетесь к этому определению и вас посетит мысль: «Ну да — так и есть! Тут все понятно!»

Приступим к основному занятию программиста — практике! В примере запрограммируем следующее: создадим класс Woman25 , который, используя дружественные функции и обычные методы класса, будет получать данные об объекте (имя и вес) и выводить их на экран. Методы и friend -функции будут выполнять аналогичные действия. В этом и есть особенная польза данного примера — вы сможете посмотреть отличия в объявлении и определении дружественных функций от обычных методов класса. На основании полученных данных, программа даст пользователю совет относительно корректировки его веса. Ну что-же, лучше один раз увидеть…

#include #include using namespace std; class Woman25 < private: char *name;//имя int weight;//вес friend void setData(char *, int, Woman25&);//объявление дружественных функций friend void getData(Woman25&); public: Woman25()//конструктор < name = new char [20]; strcpy(name, "Норма"); weight = 60; >~Woman25()//деструктор < delete [] name; cout void setData(char*, int);//объявление методов класса void getData(); void advise(); >; void setData(char *n, int w, Woman25& object)//определяем friend-функцию setData < strcpy(object.name, n);//////////// object.weight = w; >void getData(Woman25& object)//определяем friend-функцию getData < cout void Woman25::setData(char *n, int w)//определяем set-метод класса < strcpy(name, n); weight = w; >void Woman25::getData()//определяем get-метод класса < cout void Woman25::advise()//определяем метод класса Совет (advise) < if(weight < 55)< //если вес меньше 55 кг cout else if(weight >= 55 && weight else < //если вес >65 кг cout > int main() < setlocale(LC_ALL, "rus"); Woman25 Norm; //создаем объект Norm, сработает конструктор и weight будет = 60, name - Норма Norm.getData(); //вызов метода класса cout 

Комментарии к исходному коду. В строках 6 — 30 создаем класс Woman25 . Он содержит два приватных элемента класса: char *name; и int weight; . В private также объявим дружественные функции friend void setData(char *, int, Woman25&); и friend void getData(Woman25&); . Хотя их можно объявлять и определять в любом поле класса, будь то private , public или protected , но об этом поговорим позже. Так мы сделали, чтобы показать, что несмотря на объявление дружественных функций в поле private , к ним можно обращаться напрямую из функции main() . Тогда, когда методы класса должны располагаться в поле public всегда , если мы собираемся вызывать их вне класса . Объявление дружественных функций отличается от объявления методов класса еще и тем, что перед типом возвращаемого функцией значения используется зарезервированное слово friend . Обратите внимание, что в виде параметра мы передаем этим функциям ссылку на объект нашего класса — Woman25& . В обычных методах этого не будет. В поле public расположился конструктор класса — строки 15 — 20 . В нем мы задаем значение нормального веса — 60 кг, а так же, с помощью функции strcpy(name, "Норма"); , вносим данные в элемент класса name . Затем в строках 21 — 25 определяем деструктор класса ~Woman25() . Его задача, освободить, выделенную конструктором, динамическую память. А для того, чтобы убедиться, что он сработал и удалил динамическую память всех созданных объектов класса при завершении работы программы, мы добавили в него строку cout Строки 27 — 29 — объявление обычных методов класса.

Теперь начинается, пожалуй, самое интересное — определение вне класса наших дружественных функций и обычных методов класса. Все это располагается в строках 32 — 66. Смотрите, когда мы определяем дружественные функции , строки 32 — 36 и 38 — 41, мы не используем оператор :: двойное двоеточие (область видимости метода). Это уже говорит нам о том, что дружественная функция не принадлежит классу, не является его компонентом. А при определении остальных методов использование оператора :: является обязательным. Метод класса advise() , на основании полученных данных о весе, дает пользователю один из советов либо сообщает, что вес в норме.

Переходим в главную функцию — строки 68 — 87. Тут мы создаем объект класса Woman25 Norm; , при создании которого сработает конструктор и инициализирует элементы name и weight . Вызываем метод класса Norm.getData(); чтобы вывести на экран значение нормы. Со вторым созданным объектом Woman25 Anna; работаем, вызывая обычные set и get — методы класса, а с третьим объектом Woman25 Inna; — вызывая дружественные функции. Как видите, вызываются они как функции, которые не принадлежат классу. Объект класса мы передаем, как параметр.

Запускаем программу и видим следующее.

CppStudio.com

. Деструктор .
. Деструктор .
. Деструктор .

Для продолжения нажмите любую клавишу . . .

И friend-функции, и методы класса справились со своими задачами, а мы с вами увидели отличия в их объявлении и определении. Так же мы увидели, что деструктор класса, как положено, сработал 3 раза (т.е. при уничтожении каждого созданного объекта). Если у вас возникает вопрос «Собственно, а зачем все это, если методы класса и так прекрасно работают?» — это хорошо! Ответ такой — «Представьте, что у нас есть еще десяток классов. Например Girl6_7 , Girl8_9 , Man25 и т.д., Используя дружественные функции, нам не придется для каждого класса определять set и get -методы. Это в нашей программе они короткие! А если бы они занимали 20 — 30 строк? А так достаточно определить метод в одном из классов или вообще определить функцию, как глобальную, а в остальные классы прописать ее прототип, как дружественной функции (используя слово friend ). Мы экономим массу времени и наш код становится намного короче.»

Теперь, как всегда, немного теории, для закрепления материала:

  • Дружественная функция может располагаться в любом поле класса – private , public или protected . Она при любых обстоятельствах будет иметь доступ к private -элементам класса и, даже если она сама находится в поле private (как в нашем примере), к ней можно будет обратиться вне класса, не используя специальных методов.
  • Когда мы определяем дружественную функцию, элементы класса необходимо явно передавать в нее в виде параметров функции. Так как она не является компонентом класса, она не получает указатель this .
  • В виде параметра, в дружественную функцию так же надо передать указатель или ссылку на объект класса. Иначе она не увидит данные какого класса ей принять и обработать.
  • Функция может использоваться, как дружественная к нескольким классам.
  • Вызываются дружественные функции, как обычные функции. Т.е не используется такой способ — Объект_класса.функция() . После внесения всех необходимых параметров в нее при вызове, она сама увидит с элементами какого класса и объекта надо работать.

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

К сожалению, для данной темы пока нет подходящих задач. Если у вас есть таковые на примете, отправте их по адресу: admin@cppstudio.com. Мы их опубликуем!

Зачем нужны друзья класса 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 из любых функций.

Дружественные функции

Функция, не являющаяся членом класса, может иметь доступ к его частным членам в случае, если она объявлена другом (friend) класса. Например, в следующем примере функция frd() объявлена другом класса cl:

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

Одна из причин, почему язык С++ допускает существование функций-друзей, связана с той ситуацией, когда два класса должны использовать одну и ту же функцию. В качестве примера рассмотрим программу, в которой определяются два класса — line и box. Класс line содержит все необходимые данные и код для начертания горизонтальной пунктирной линии любой заданной длины, начиная с указанной точки с координатами х и у и с использованием заданного цвета. Класс box содержит необходимый код и данные для того, чтобы изобразить прямоугольник с заданными левой верхней и правой нижней точками, причем использовать для этого указанный цвет. Оба класса используют функцию same_color() для того, чтобы определить, нарисованы ли линия и прямоугольник одним и тем же цветом. Объявление этих классов выполнено в следую­щем фрагменте программы:

class line;
class box int color; // цвет прямоугольника
int upx, upy; // левый верхний угол
int lowx, lowy; // правый нижний угол
public:
friend int same_color (line l, box b);
void set_color(int c);
void define_box (int x1, int y1, int x2, int y2);
void show_box();
>;
class line int color;
int startx, starty;
int len;
public:
friend int same_color (line I, box b);
void set_color(int c);
void define_line (int x, int y, int I);
void show_line();
>;

Функция same_color() не является членом ни одного из классов, но является другом обоих. Она возвращает истину, если объект типа line и объект типа box нарисованы одним и тем же цветом, и значение 0 — в противном случае. Следующий код определяет функцию same_color():

// возвращает истину, если линия и прямоугольник имеют одинаковый цвет
int same_color (line I, box b)
if (l.color == b.color) return 1;
return 0;
>

Как можно видеть, функция same_color() должна иметь доступ к частным частям обоих классов line и box. Поскольку она является другом каждого из классов, то она имеет право такого досту­па. Более того, обратим внимание, что поскольку функция same_color() не является членом, то для ее использования нет необходимости в операторе области видимости или в использовании имени класса. Обратим внимание, что для тех же целей можно было создать функцию-член со спецификатором доступа public, которая возвращала бы цвета объектов типа line и box, а также еще одну функцию для сравнения этих цветов. Однако такой подход потребовал бы дополнитель­ных вызовов функций, что в некоторых случаях неэффективно.

Обратим внимание на пустое объявление класса line, предшествующее объявлениям обоих клас­сов box и line. Поскольку функция same_color() в классе box ссылается на объект типа line до того, как класс line будет определен, то необходима предварительная (forward) ссылка на класс line. Если этого не будет сделано, то компилятор не поймет, что такое line, когда будет анализи­ровать объявление класса box. В языке С++ предварительная ссылка на класс состоит из ключево­го слова class, после которого следует имя класса.

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

#include
#include
class line;
class box int color; // цвет прямоугольника
int upx, upy; // верхний левый угол
int lowx, lowy; // правый нижний угол
public:
friend int same_color (line l, box b);
void set_color(int c);
void define_box (int x1, int y1, int x2, int y2);
void show_box();
>;
class line int color;
int startx, starty;
int len;
public:
friend int same_color (line I, box b);
void set_color(int c);
void define_line (int x, int y, int I);
void show_line();
>;
// возвращает истину, если линия и прямоугольник имеют одинаковый цвет
int same_color (line I, box b)
if (l.color == b.color) return 1;
return 0;
>
void box::set_color(int c)
color = c;
>
void line::set_color(int c)
color = c;
>
void box::define_box (int x1, int y1, int x2, int y2)
upx = x1;
upy = y1;
lowx = x2;
lowy = y2;
>
void box::show_box()
int i;
textcolor(color);
gotoxy(upx, upy);
for (i=upx; i gotoxy(upx, lowy-1);
for (i=upx; i gotoxy(upx, upy);
for (i=upy; i <=lowy; i++) cprintf (" | ");
gotoxy(upx , i);
>
gotoxy(lowx, upy);
for (i=upy; i <=lowy; i++) cprintf ("I");
gotoxy(lowx, i);
>
>
void line::define_line (int x, int y, int I)
startx = x;
starty = y;
len = I;
>
void line::show_line()
int i;
textcolor(color);
gotoxy(startx, starty);
for (i=0; i >
int main()
box b;
line I;
b.define_box (10, 10, 15, 15);
b.set_color(3);
b.show_box();
l.define_line (2, 2, 10);
l.set_color(2);
l.show_line();
if ( !same_color (I, b) ) cout cout getch ();
// теперь делаем линию и прямоугольник одного цвета
l.define_line(2, 2, 10);
l.set_color (3);
I.show_line();
if (same_color (l, b) ) cout return 0;
>

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

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

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