码迷,mamicode.com
首页 > 编程语言 > 详细

C++ 虚函数和友元

时间:2020-03-06 17:14:47      阅读:98      评论:0      收藏:0      [点我收藏+]

标签:bsp   virtual   strong   col   不能   转换   amp   无法   并且   

虚函数具有动态联编性,在类族中有强大功能;友元函数具有跨类访问的功能,本质却是一种对封装的破坏。

先看这样一个例子:

#include<iostream>
using namespace std;
class A;
class B
{
private:
    int x;
    void print()
    {
        cout<<x<<endl;
    }
public:
    B(int i = 0)
    {
        x = i;
    }
    friend class A;
};
class A
{
public:
    void func(B b)
    {
        b.print();
    }
};
class D: public B
{
public:
    D(int i):B(i) {}
};
int main()
{
    cout<<sizeof(A)<<" "<<sizeof(B)<<" "<<sizeof(D)<<endl;
    D d(99);
    A a;
    a.func(d);
    return 0;
}

程序执行结果为:
        1 4 4
        99
上例中,A是B的友元类,A中的所有成员函数都为B的友元函数,可访问B的私有成员函数。友元类A大小为1,基类和派生类大小都是4,友元类A不是基类B的一部分,更不是派生类D的一部分。

 从上例看,友元似乎能够被继承,A的函数func这能访问B的派生类D嘛!这不基类的友元函数或友元类能够访问派生类的私有成员!

但若将上例中的继承关系改为私有继承,则:

   class D: private B
   a.func(d);  // error C2243: “类型转换”: 从“D *”到“const B &”的转换存在,但无法访问   

我们知道:public继承是一种“is a”的关系,即一个派生类对象可看成一个基类对象。所以,上例中不是基类的友元被继承了,而是派生类被识别为基类了

再比如这样一个例子

#include<iostream>
using namespace std;
class B;
class A
{
private:
    void print()
    {
        cout<<"A::print"<<endl;
    }
public:
    friend class B;
};
class B
{
public:
    void func(A a)
    {
        a.print();
    }
};
class D: public B { };

int main()
{
    A a;
    D d;
    d.func(a);
    return 0;
}

程序执行结果为:
        A::print
上例中,B为A的友元类,D是B的派生类,D继承了基类B的友元函数func,它能访问A的私有成员。由此可知一个友元类的派生类,可以通过其基类接口去访问设置其基类为友元类的类的私有成员,也就是说一个类的友元类的派生类,某种意义上还是其友元类
但若在上例D中新增加个成员函数,该函数是不能访问A私有成员的。

class D: public B
{
public:
        void test(A a){ a.print(); } // error C2248: “A::print”: 无法访问 private 成员(在“A”类中声明)
};

 

#include<iostream>
using namespace std;
class A;
class B
{
private:
    void print()
    {
        cout<<"B::print"<<endl;
    }
public:
    friend class A;
};
class A
{
public:
    void func(B b)
    {
        b.print();
    }
};
class D: public B
{
private:
    void print()
    {
        cout<<"D::print"<<endl;
    }
};
int main()
{
    D d;
    A a;
    a.func(d);
    return 0;
}

程序执行结果为:
    B::print
和前两例类似,友元关系并没有被继承,仅是派生类对象当成了一个基类对象来用,因此输出“B::print”。
若将上例print函数改为虚函数并通过多态来访问,就可以达到类似于友元可以继承的效果。

class A;
class B
{
private:
    virtual void print()
    {
        cout<<"B::print"<<endl;
    }
public:
    friend class A;
};
class A
{
public:
    void func(B* pb)
    {
        pb->print();
    }
};
class D: public B
{
private:
    virtual void print()
    {
        cout<<"D::print"<<endl;
    }
};

int main()
{
    D d;
    A a;
    a.func(&d);
    return 0;
}

 这本质上就是满足了多态的三个条件:

必须存在继承关系;   

继承关系中必须有同名的虚函数,并且它们是覆盖关系。  

存在基类的指针,通过该指针调用虚函数。

C++ 虚函数和友元

标签:bsp   virtual   strong   col   不能   转换   amp   无法   并且   

原文地址:https://www.cnblogs.com/wkfvawl/p/12427496.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!