Fatal编程技术网
  • cplusplus/
  • C++ c++；派生基类友元函数访问父级上的私有？ 请考虑下面的场景： class A { friend void B::Itemfunction(); private: int number; int size; public: Randomfunction(); } class B : public A { private: string Random; public: void Itemfunction(); void CheckLog(); }

C++ c++；派生基类友元函数访问父级上的私有？ 请考虑下面的场景： class A { friend void B::Itemfunction(); private: int number; int size; public: Randomfunction(); } class B : public A { private: string Random; public: void Itemfunction(); void CheckLog(); }

c++ inheritance visual-c++

C++ c++；派生基类友元函数访问父级上的私有？ 请考虑下面的场景： class A { friend void B::Itemfunction(); private: int number; int size; public: Randomfunction(); } class B : public A { private: string Random; public: void Itemfunction(); void CheckLog(); },c++,inheritance,visual-c++,friend,C++,Inheritance,Visual C++,Friend,在类型A的Itemfunction中生成的对象是否可以访问obj的私有数据成员？例如： void B::Itemfunction(){ A obj; //Possible to do... obj.number = 2; } 我知道派生类B可以访问A的所有公共部分，但是如果我只需要一个函数（Itemfunction）来访问私有部分，这是正确的方法吗？我只是想看看我的理解是否正确 干杯在代码中，当您实现Itemfunction时，您正在本地创建一个类型为a

在类型A的Itemfunction中生成的对象是否可以访问obj的私有数据成员？例如：

    void B::Itemfunction(){
    A obj;
    //Possible to do...
    obj.number = 2;
    }
我知道派生类B可以访问A的所有公共部分，但是如果我只需要一个函数（Itemfunction）来访问私有部分，这是正确的方法吗？我只是想看看我的理解是否正确

干杯

在代码中，当您实现
Itemfunction
时，您正在本地创建一个类型为
a
的完全无关的新对象。在继承中，
B
对象具有类型为
A
的内部子对象。您可以直接在
B
中访问
A
的字段。但是，您不能访问私人成员。你的友谊把戏不会奏效；在看到
B
s定义之前，您不能声明
B
的方法为好友，但是
B
在定义
a
之前无法定义，正如您所看到的，我们正在兜圈子。您可以做的是保护该成员：

class A 
{ 
  protected:
  int number;
  private:
  int size;
  public:
  Randomfunction();
}

void B::Itemfunction() {
  number = 2;
}
在代码中，在实现
Itemfunction
的地方，您正在本地创建一个类型为
a
的完全无关的新对象。在继承中，
B
对象具有类型为
A
的内部子对象。您可以直接在
B
中访问
A
的字段。但是，您不能访问私人成员。你的友谊把戏不会奏效；在看到
B
s定义之前，您不能声明
B
的方法为好友，但是
B
在定义
a
之前无法定义，正如您所看到的，我们正在兜圈子。您可以做的是保护该成员：

class A 
{ 
  protected:
  int number;
  private:
  int size;
  public:
  Randomfunction();
}

void B::Itemfunction() {
  number = 2;
}
不，不可能。对于尚未完全声明的类，不能将类成员函数交给好友

在这种情况下（因为
类B
需要一个完全声明的
类a
来继承），唯一的方法是向前声明
类B和全班同学的朋友：


#include <iostream>
#include <string>

    class B;

    class A 
    { 
     // friend void B::Itemfunction();
     friend class B;
     private:
     int number;
     int size;
     public:
     void Randomfunction();
    };

    class B : public A
    {
     private:
     std::string Random;
     public:
     void Itemfunction();
     void CheckLog();

    };

int main()
{   
}



#包括
#包括
乙级;；
甲级
{ 
//friend void B:：Itemfunction（）；
B级朋友；
私人：
整数；
整数大小；
公众：
void函数（）；
};
B类：公共A
{
私人：
std：：字符串随机；
公众：
void item函数（）；
void CheckLog（）；
};
int main（）
{   
}



不，这是不可能的。对于尚未完全声明的类，不能将类成员函数交给好友

在这种情况下（因为
类B
需要一个完全声明的
类a
来继承），唯一的方法是向前声明
类B和全班同学的朋友：


#include <iostream>
#include <string>

    class B;

    class A 
    { 
     // friend void B::Itemfunction();
     friend class B;
     private:
     int number;
     int size;
     public:
     void Randomfunction();
    };

    class B : public A
    {
     private:
     std::string Random;
     public:
     void Itemfunction();
     void CheckLog();

    };

int main()
{   
}



#包括
#包括
乙级;；
甲级
{ 
//friend void B:：Itemfunction（）；
B级朋友；
私人：
整数；
整数大小；
公众：
void函数（）；
};
B类：公共A
{
私人：
std：：字符串随机；
公众：
void item函数（）；
void CheckLog（）；
};
int main（）
{   
}



这是一个鸡和蛋的问题。必须完全定义
B
，才能让
A
看到
B:：Itemfunction


class A
{
    friend void B::Itemfunction(); <-- Itemfunction does not exist yet
private:
    int number;
    int size;
public:
    int Randomfunction();
};

class B: public A
{
private:
    std::string Random;
public:
    void Itemfunction();
    void CheckLog();

};


解决方案1是向前定义
类B
，因此编译器知道B存在，即使它对B一无所知，然后
friend
整个类，因为
A
只知道
B
存在。OP的
朋友关系得到维护


class B; <-- forward definition of B
class A
{
    friend class B; <-- friending all of B, not just the function 
private:
    int number;
    int size;
public:
    int Randomfunction();
};

class B: public A
{
private:
    std::string Random;
public:
    void Itemfunction();
    void CheckLog();

};



B
和
C
可以访问
A:：number
，并可以使用
A:：getSize
查看
size
的值<代码>编号
可以通过
B
和
C
更改，但
大小
不能更改。如果您担心调用函数读取
大小的成本，请不要担心。当编译器使用
A:：getSize
完成时，您甚至不知道它在那里。可能不是。这有鸡和蛋的问题。必须完全定义
B
，才能让
A
看到
B:：Itemfunction


class A
{
    friend void B::Itemfunction(); <-- Itemfunction does not exist yet
private:
    int number;
    int size;
public:
    int Randomfunction();
};

class B: public A
{
private:
    std::string Random;
public:
    void Itemfunction();
    void CheckLog();

};


解决方案1是向前定义
类B
，因此编译器知道B存在，即使它对B一无所知，然后
friend
整个类，因为
A
只知道
B
存在。OP的
朋友关系得到维护


class B; <-- forward definition of B
class A
{
    friend class B; <-- friending all of B, not just the function 
private:
    int number;
    int size;
public:
    int Randomfunction();
};

class B: public A
{
private:
    std::string Random;
public:
    void Itemfunction();
    void CheckLog();

};



B
和
C
可以访问
A:：number
，并可以使用
A:：getSize
查看
size
的值<代码>编号
可以通过
B
和
C
更改，但
大小
不能更改。如果您担心调用函数读取
大小的成本，请不要担心。当编译器使用
A:：getSize
完成时，您甚至不知道它在那里。可能不是。
谢谢您的回复，啊，我现在看到了兜圈子的问题。我想除了你所描述的解决方案之外，让B班成为a班的朋友也应该有效，对吗？或者作为派生类和朋友会有问题吗？想想你的程序的需要。如果
A
friends
B
使
B
具有访问权限，那么儿童
C
或
D
又如何呢？友谊不会随着您添加子类而扩展，如果这就是你想要的。@afc_1995
protected
就是为了解决这个问题而设计的，所以你应该真正使用
protected
。如果
B
是
A
的好友，它可以访问所有内容，包括私人成员。保护儿童和保护儿童的全部目的是让儿童能够决定其子女可以获得什么。你有什么理由喜欢友谊而不是保护吗？谢谢你的回复，啊，我现在看到了转圈的问题。我想除了解决方案之外，你