Question

我有一个派生自派生类的接口和友元类的类。我想访问实例化为接口的派生类的成员。它看起来像这样：

接口：

class AInterface
{
public:
   virtual ~AInterface() = default;
   virtual void set(int a) = 0;
};

带朋友类B的派生类A：

class B;
class A : public AInterface
{
public:
   ~A() override {}
   void set(int a) override
   {
      mem = a;
   }
private:
   friend class B;

   int mem = 0;
};

B级：

class B
{
public:
   B() 
   {
     a = new A();
     a->set(3);
   }

   int get_a()
   {
      // Access mem since it's a friend class
      return a->mem;
   }

private:
    AInterface *a;
}

主：

int main()
{
    B *b = new B();
    std::cout << b->get_a() << std::endl;
    return 0;
}

程序没有编译说AInterface没有名为'mem'的成员。我是否需要在界面中使用getter函数并在A中实现它以实现此功能，还是有其他方法可以实现？

Answer 1

现在工作

def f1():
  return tf.assign(var1, var1 + 1) * 1.1

被儿童覆盖并且纯粹的方法应该是虚拟的。
如果每个班级（孩子）final = tf.cond(training, lambda: tf.assign(var1, var1 + 1) * 1.1, lambda: var1 * 1.1)，变量#include <iostream> using namespace std; class AInterface { public: virtual ~AInterface() = default; int getMem() { return mem; } virtual void set(int a) = 0; protected: int mem = 0; }; class A : public AInterface { public: ~A() override {} void set(int a) override { mem = a; } }; class B { public: B() { a = new A{}; a->set(3); } int get_a() { // Access mem since it's a friend class return a->getMem(); } private: AInterface *a; }; int main() { B *b = new B(); std::cout << b->get_a() << std::endl; return 0; }都应在界面中受到保护。现在工作正常，就像你想要的那样。
添加getter Interface

带有int mem

getMem()

Answer 2

在你的B班。

class B
{
  //...
   int get_a()
   {
      return a->mem;   // but a is a AInterface*  !!!
   }

private:
    AInterface *a;     // That's not an A*, but an AInterface*
};

您有2个选项。

使用dynamic_cast<>

 int B::get_a()
 {
     A* p = dynamic_cast<A*>(a);
     if (p)
       return p->mem;  
     // a is not an A*, it's another AInterface*-type object !!!  
                                   // What should you do?
     throw something_or_other();   // throw?
     return -1;                    // return an error code?
   }
   // or maybe add..  so you can check for errors before calling get_a()
   A* B::get_A_ptr() const 
   { 
      return dynamic_cast<A*>(a); 
   }

dynamic_cast工作正常，但如果您需要频繁阅读a->mem，可能会降低您的应用速度。

将a存储在A*中，这可能是您从一开始就打算做的......

class B
{
  // ...
private:
  A* a;    // now a->A::mem is visible.
};

由于您在B＆＃39的构造函数中明确调用new A，我认为选项2更适合您的情况。

访问使用interface实例化的类的私有成员

2 个答案: