友元函数
类的友元函数一般定义在类外部,可以是定义在全局的函数,也可以是其他类的成员函数,但他们有权访问类的所有私有(private)成员和保护(protected)成员。
尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。
- 友元定义在全局的函数
//类声明
class example_A
{
private: //私有成员
int a; //成员
int b; //成员
friend void Frend_A(example_A* p);//声明友元函数(不作为其成员函数)
public: //公有成员
example_A(int x , int y); //构造函数
~example_A(); //析构函数
protected: //保护成员
};
//函数声明
void Frend_A(example_A *p); //此处注意,函数声明必须放在类定义声明之后
//函数定义
void Frend_A(example_A* p)
{
int c = p->a + p->b; //a,b作为私有成员正常的外部函数是不可以直接调用的
cout << c << endl;
}
- 友元其他类的成员函数
class example_A
{
private: //私有成员
int a; //成员
int b; //成员
friend void example_B::see_b(example_A* p);//声明友元函数
public: //公有成员
example_A(int x , int y); //构造函数
~example_A(); //析构函数
protected: //保护成员
};
class example_B
{
private: //私有成员
int x; //成员
public: //公有成员
void see_b(example_A *p)
{
int c = (p->a) + (p->b); //a,b作为私有成员正常的其他类的函数是不可以直接调用的
cout << c << endl;
}
example_B(int y) :x(y) { } //构造函数
~example_B(); //析构函数
protected: //保护成员
};
友元类
同理下的友元类,A与B是两个不同的类,类 A 可以将类 B 声明为自己的友元,类 B 的所有成员函数就都可以获得访问类 A 对象的私有成员的权限。
- 将刚写过的友元其他类的成员稍作修改得到友元类
class example_A
{
private: //私有成员
int a; //成员
int b; //成员
friend class example_B;//声明友元类
public: //公有成员
example_A(int x , int y); //构造函数
~example_A(); //析构函数
protected: //保护成员
};
class example_B
{
private: //私有成员
int x; //成员
public: //公有成员
void see_b(example_A *p)
{
int c = (p->a) + (p->b); //a,b作为私有成员正常的其他类的成员函数是不可以直接调用的
cout << c << endl;
}
example_B(int y) :x(y) { } //构造函数
~example_B(); //析构函数
protected: //保护成员
};
友元的优缺点
- 优点:
使用友元后,因为友元对象可以直接调用类里的私有函数,从而可以提高调用的效率,使语句表达显得简单、清晰。友元一般使用在运算符重载的某些场合下(后续运算符重载中会讲),还可以用在两个需要共享数据的类之间。 - 缺点:
友元一种破坏数据封装和数据隐藏的机制。建议尽量不使用或少使用友元,除非不得已的情况下才使用友元函数。
友元还有一个注意点就是,如果A->B友元,B->C友元,A和C并不是友元,C++中朋友的朋友不会是朋友。
继承
面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类,他允许程序员在保持原有类的特性上进行功能拓展,还不会对原有类产生影响,同时达到了重用代码功能和提高执行效率的效果。
基类 ——派生类
在我们对一个类进行继承时候,作为依据的这个已有的类称为基类,同时依据基类产生的新的的类称为派生类。通常我们称基类为父类,派生类为子类。
class example_A
{
private: //私有成员
int a; //成员
int b; //成员
public: //公有成员
example_A(int x , int y); //构造函数
~example_A(); //析构函数
protected: //保护成员
};
class example_B : public example_A//继承
{
private: //私有成员
int x; //成员
public: //公有成员
example_B(int y) :x(y) { } //构造函数
~example_B(); //析构函数
};
继承类型及继承访问限制
任何继承下,保护成员都是不可继承的,就像继承家产时,父亲的不部分物品属于他私人的,不可继承给孩子一样
公有继承(public): 子类可以继承父类的公有成员和私有成员,父类的公有成员/私有成员在子类中依旧以公有成员/私有成员存在,也就是说,依旧需要成员函数才能做到对父类继承过来的私有成员的访问。
**保护继承(protected):**父类的公有成员和私有成员都被以公有成员的形式继承到子类中去。
**私有继承(private):**同理于保护继承,父类的公有私有成员都以私有成员的形式,存在于子类中;
- 用代码形式展现
class example_A
{
private: //私有成员
int a; //成员变量
int b; //成员变量
public: //公有成员
char c; //成员变量
example_A(int x , int y); //构造函数
~example_A(); //析构函数
protected: //保护成员
float l;
};
class example_B : public example_A//公有继承
{
public:
example_B(); //构造函数
~example_B(); //析构函数
};
class example_C : protected example_A//保护继承
{
public: //公有成员
example_C(); //构造函数
~example_C(); //析构函数
};
class example_D :private example_A//私有继承
{
public: //公有成员
example_D(); //构造函数
~example_D(); //析构函数
};
- 公有继承后的example_B相当于
class example_B :
{
private: //私有成员
int a; //成员变量
int b; //成员变量
public: //公有成员
char c; //成员变量
example_B(); //构造函数
~example_B(); //析构函数
};
- 保护继承后的example_C相当于
class example_C :
{
public: //公有成员
int a; //成员变量
int b; //成员变量
char c; //成员变量
example_C(); //构造函数
~example_C(); //析构函数
};
- 私有继承后的example_D相当于
class example_D :
{
private: //私有成员
int a; //成员变量
int b; //成员变量
char c; //成员变量
public: //公有成员
example_D(); //构造函数
~example_D(); //析构函数
};
多继承
多继承即一个子类可以有多个父类,它继承了多个父类的特性。(就是一个儿子可以有很多爸爸)
class example_A
{
public:
void Width(int w)
{
width = w;
}
void Height(int h)
{
height = h;
}
protected:
int width;
int height;
};
// 基类 PaintCost
class example_B
{
public:
int getC(int area)
{
return area * 70;
}
};
// 派生类
class example_C: public example_A, protected: example_B
{
public:
int getA()
{
return (width * height);
}
};