c friend -- 友元

友元用于突破protected 或者 private 保护的限制,首先要做的是在被访问者的类中声明是友元函数或者友元类。代码如下

  1. #include <iostream>
  2. using namespace std;
  3. class Square{
  4. private:
  5. int side;
  6. public:
  7. Square(int a):side(a){}
  8. friend class Rectangle ; //declare the Class is friend
  9. };
  10. class Rectangle {
  11. private:
  12. int width, height;
  13. public:
  14. Rectangle(int a, int b):width(a),height(b){}
  15. void set_values (int a, int b){
  16. width = a;
  17. height = b;
  18. }
  19. int girth();
  20. friend int area (Rectangle &); //declare the friend function here
  21. int get_width(){return width;}
  22. int get_height(){return height;}
  23. void conver_from_square(Square &s){
  24. width = height = s.side; //access so easily
  25. }
  26. };
  27. //implement the function here , access easily ,too
  28. int area (Rectangle &r){ return ( r.width * r.height); }
  29. int r_area(Rectangle &r){ return r.get_width() * r.get_height();}
  30. int Rectangle::girth(){return width + width + height + height; }
  31. int main () {
  32. test_sizeof:
  33. cout << "sizeof: Square " << sizeof(Square)
  34. << ",\tRectangle " << sizeof(Rectangle) << "\n\n" ;
  35. test_access:
  36. Rectangle r(2,3);
  37. cout << "area:" << area(r) << "\tgirth:" << r.girth() << endl;
  38. cout << "onather way:area " << r_area(r) << endl;
  39. Rectangle r1(2,3);
  40. Square s(5);
  41. r1.conver_from_square(s);
  42. cout << "rectangle convering from square , girth is " << r1.girth() << endl;
  43. return 0;
  44. }

结果

  1. sizeof: Square 4, Rectangle 8
  2. area:6 girth:10
  3. onather way:area 6
  4. rectangle convering from square , girth is 20

看函数

  • area
  • r_area
  • girth

如果不是友元函数或类,访问情况如 r_area()函数,友元函数就可以直接访问成员。但是和成员函数比起来还是要有区别的,看函数girth()

看看size,友元类或者友元函数并不增加类的大小,只是声明一下。

时间: 2024-12-14 22:29:07

c friend -- 友元的相关文章

模板类的友元重载

模板类的友元重载和普通类的友元重载有不同之处,可以参考这篇CSDN博客http://blog.csdn.net/ozwarld/article/details/7770808 #include <iostream> using namespace std; template <class T> class Test; // 模板类前置声明 template<class T> ostream& operator << (ostream& out

c++类模板之间友元函数调用

1 #include <stdio.h> 2 #include <iostream> 3 4 using namespace std; 5 6 template<typename T> class BTree; 7 8 /***************************节点类模板*********************************/ 9 template<typename T> 10 class BTreeNode{ 11 friend

C++ 友元函数总结

1.为什么要引入友元函数:在实现类之间数据共享时,减少系统开销,提高效率 具体来说:为了使其他类的成员函数直接访问该类的私有变量 即:允许外面的类或函数去访问类的私有变量和保护变量,从而使两个类共享同一函数 优点:能够提高效率,表达简单.清晰 缺点:友元函数破环了封装机制,尽量不使用成员函数,除非不得已的情况下才使用友元函数. 2.什么时候使用友元函数: 1)运算符重载的某些场合需要使用友元. 2)两个类要共享数据的时候 3.怎么使用友元函数: 友元函数的参数: 因为友元函数没有this指针,则

c++的友元类、方法及其益处

在java中,我们知道除了public和private,protected外,还有默认的包可见性访问级别,虽然如此,很多时候出于早期设计缺陷的原因,我们需要访问一些包或者protected可见性级别的方法,这个时候就比较麻烦了,要是选择和目标服务在相同包中,总看起来很奇怪,如果作为子类继承,则更加奇怪.但是我们又不想把该接口服务的可见性声明为public. c++中,这一点做的就比较好,我们知道在c++中,有友元类.方法的特性,该特性相当于白名单的作用,当一个类或者成员函数.非OO函数被声明为目

c++ 中的友元函数的普通用法

C++中友元函数的调用,一般分为三种方式: 1.一般的友元函数 2.类A作为类B的友元类,则类A的成员函数都是类B的友元函数. 3.一个类的成员函数作为另外一个类的友元函数 //分为友元函数的例子 类A 作为测试的类,类B 是类A的友元类.class A{public: A() {  a = 100;  b = 10; } friend class B; //这儿公私均可,常常用到的是变为私有变量,类B是类A的友元类.友元的第二种方式,需要带class int getA() {  return

C++友元函数

1. 1 #include <iostream> 2 using namespace std; 3 4 class Time{ 5 friend void func(Time &t); // 声明全局函数为一个友元函数 6 public: 7 Time(int h, int m, int s) : i_mHour(h), i_mMin(m), i_mSecon(s) { } // 构造函数 8 private: 9 int i_mHour; 10 int i_mMin; 11 int

模板类的约束模板友元函数:template friend functions

本来这篇博客是不打算写的,内容不是很难,对于我自己来讲,更多的是为了突出细节. 所谓template friend functions,就是使友元函数本身成为模板.基本步骤:1,在类定义的前面声明每个模板函数.eg:template <typename T> void counts(); template <typename T> void report<>(T &);2,在类声明中再次将模板声明为友元. template <typename TT>

C++ 类模板二(类模版与友元函数)

//类模版与友元函数 #include<iostream> using namespace std; template<typename T> class Complex{ public: Complex(T a,T b); void Print() const//const修饰的是this指针 { cout << this->Real << ":" <<this->Image<< endl; } /*

4 C++基础4 类 const函数 转全局函数 返回*this 数组类。友元 函数 类 操作符重载

1,请问类中函数 const修饰的谁? [email protected]:~/c++$ cat main.cpp  #include <iostream> #include <stdlib.h> using namespace std; class A { public: //const的三种写法 //const void fun(int a,int b) //void const fun(int a,int b) //void fun(int a,int b) const vo

函数模板友元

;函数模板友元 (即一个类友元的是一个全局函数模板而不是原先的全局函数,需注意类模板传入的类型) 标准带类模板参数 friend void fun1(A<T>& obj); 指定这个A<T>类型的模板有一个这样的朋友函数,那么也就意味着这个函数内部只能由A<T>类型的模板 实例化的类 实例化出来的对象可以访问这个对象的数据成员,不是这个类型的类模板就不能访问 ;code template<typename T> class A{ public: A(