1、友元函数
成都网络公司-成都网站建设公司创新互联十余年经验成就非凡,专业从事网站制作、成都做网站,成都网页设计,成都网页制作,软文发布平台,广告投放等。十余年来已成功提供全面的成都网站建设方案,打造行业特色的成都网站建设案例,建站热线:18982081108,我们期待您的来电!
在类中一般的成员函数具备:
(1)、该函数能访问类中的私有部分
(2)、该函数位于类的作用域之中
(3)、该函数必须经由一个对象去激活,也就是说有一个this指针;
友元函数不同之处:
(1)、在#include
class Test; void fun(); //有元函数的声明
但是在#include
(2)、在类内必须声明是朋友,friend(关键字),函数声明
class Test{ friend void fun(); //朋友没有公有,私有,保护之分,所以限定修饰符在这不起任何作用 };
(3)、在类外实现方法的定义,此时不用再加friend了;
void fun(){ .......... }
有元函数具有的特性:该函数能访问类的私有数据;不是该类的成员函数,也不需要对象驱动;
还有友元类,跟其使用一样,类中所有函数均可调用其朋友的私有数据;
2、运算符的重载(个人认为C++中运算符的重载很有用,也很重要)
相当于函数的调用,对其的另一种更加人文化的解释,并告诉 C++编译器,遇到该重载运算符时调用此函数。
定义运算符重载的一般格式:
返回值类型 类名::operator重载的运算符(参数列表);
假如出现复数类:
Complex{ public: ..... private: int real; int p_w_picpath; };
//主函数中: Complex t1(1, 2); Complex t2(2, 3); Complex t3; t3 = t1 + t2;
此时t1和t2的类型不定,就得对+进行运算符的重载;使其更符合人文化,其本质不变,t1.operator+(t2);
对象的类型不定,编译器不知道怎么输出,自己就得对<<和>>运算符进行重载,以达到输出对象的目的。还必须是友元函数;
class Complex; //这是第一步,类外声明。 ostream& operator<<(ostream &out, const Complex &c); istream& operator>>(istream &in, Complex &c); class Complex{ //这是第二步,对其在类内说明是朋友。 friend ostream& operator<<(ostream &out, const Complex &c); friend istream& operator>>(istream &in, Complex &c); }; ostream& operator<<(ostream &out, const Complex &c){ out<<"("<>(istream &in, Complex &c){ in>>c.m_real>>c.m_imag; return in; }
关于这个<<对应一个要输出的值,在定义时,不用endl,回车。
对于Complate类的补充,t1 = t2 + 10; //成员方法重载即可。内部有一个隐藏参数
t1 = 10 + t2; //没有对象驱动,还要10.operator+(t2);是错的,所以此时用友元函数,传两个参数就是有两个参数。
运算符的重载要注意:
(1)、operator后面是一个合法的运算符,将右操作数做为函数的实参;
(2)、++ --前后的问题,用函数重载区分,后加的(int)参数;
(3)、?: . .* :: sizeof不能重载,其它的应该都可以进行重载;
例1:++i 和 i++有什么区别?
对其进行重载,如下:
#includeusing namespace std; class Int; ostream& operator<<(ostream &out, const Int &s); class Int{ friend ostream& operator<<(ostream &out, const Int &s); public: Int(int m = 0) : t(m){} ~Int(){} public: Int& operator++()//++t 先加1,再将此对象的引用返回 { t++; return *this; } Int operator++(int) //t++ 后加的要有一个参数int区分, { Int tmp(t); //创建一个临时对象, t++; //原有对象加了一下, return tmp; //返回临时对象,后加。 } private: int t; }; ostream& operator<<(ostream &out, const Int &s){ out< 运行结果如下:
从结果可以看出,确是实现了,这块的本质是运算符对++的重载。
前加,返回的是引用,后加还得调用构造函数和拷贝构造;所以前加++i;效率更高,运行速度也更快。
例2、String类
#include#include #include using namespace std; class String; ostream& operator<<(ostream &out, const String &str); class String{ friend ostream& operator<<(ostream &out, const String &str); public: String(const char *str = ""){ if(str == NULL){ data = new char[1]; data[0] = 0; }else{ data = new char[strlen(str) + 1]; strcpy(data, str); } } //String(const String &str){} String& operator=(const String &str){ if(this != &str){ delete []data; data = new char[strlen(str.data) + 1]; strcpy(data, str.data); } return *this; } ~String(){ delete []data; } public: String operator+(const String &str){ char *tmp; tmp = new char[strlen(data) + strlen(str.data) + 1]; strcpy(tmp, data); strcat(tmp, str.data); return String(tmp); } void operator+=(const String &str){ char *new_data = new char[strlen(data) + strlen(str.data) + 1]; strcpy(new_data, data); strcat(new_data, str.data); delete []data; data = new_data; /* realloc(data, strlen(data) + strlen(str.data) + 1); //此时对原有的数组空间进行动态扩长, // 给谁扩长 加上原先,一共要有多长 即原有值不变。 strcat(data, str.data); */ } char operator[](int pos){ assert(pos >= 0 && pos < strlen(data)); return data[pos]; } char operator*(){ return data[0]; } bool operator==(const String &str){ return strcmp(data, str.data) ? false : true; } bool operator!=(const String &str){ return !(*this == str); //调用==这个编写过的函数 } private: char *data; }; ostream& operator<<(ostream &out, const String &str){ out< 对其+,+=,[],*,==,!=进行了运算符的重载,结果如下:
3、const和static在C++中const是非常重要的,现在说明常函数之间的关系:普通函数可以调用常函数,常函数不能调用普通函数(因为没有this);
void fun()const{}
void fun(){} //一个有const,一个没有,参数类型不一样,所以这是函数的重载!
static在C++中有成员和方法,静态成员的在类外初始化;类的静态成员为所有对象所共享。
静态方法: (1)、可以调用该类的私有成员,(2)、应该位于类的作用域之中;(3)、类名直接调用,可以不用方法;
静态方法只能调用静态成员,和静态函数;非静态的可以调用静态成员或方法。
网页题目:友元函数运算符重载conststatic
URL链接:http://scpingwu.com/article/ipdisd.html