访问姐妹类的实例

Access instance of a sister class

本文关键字：实例 姐妹 访问      更新时间：2023-10-16

我正在尝试创建一个以三个类为成员的结构，为了实现我的想法，我希望我的类的实例能够访问一个结构中的姐妹实例。假设在初始化struct之后，我希望我的custom_class_one能够调用初始化的sister custom_class_two的方法。有可能做到吗？这是我的头文件：

struct custom_wrapper
{
public:
    custom_wrapper();
    class custom_class_one
    {
    private:
        int number1;
    public:
        int getNumber1();
    };
   class custom_class_two
    {
    private:
        int number2;
    public:
        int getNumber2();
    };
    class custom_class_three
    {
    private:
        int number3;
    public:
        int getNumber3();
    };

}；

只要您的方法是可访问的，并且类之间可以相互查看（如果需要，可以向前声明），就可以完成：

struct custom_wrapper
{
public:
    custom_wrapper();
    class custom_class_two; // Forward declaration for inner class
    class custom_class_one
    {
    private:
        int number1;
    public:
        int getNumber1();
        int accessSisterMethods(custom_class_two& obj) {
         return obj.getNumber2();   
        }
    };
   class custom_class_two
    {
    private:
        int number2;
    public:
        int getNumber2() {
            return 42;
        }
    };
    class custom_class_three
    {
    private:
        int number3;
    public:
        int getNumber3();
    };
};

int main()
{
    custom_wrapper::custom_class_one obj1;
    custom_wrapper::custom_class_two obj2; // Need a sister object
    std::cout << obj1.accessSisterMethods(obj2);
}

示例

当然，您需要另一个姐妹类的实例（除非您正在调用静态方法，但我正在考虑您发布的代码）。

根据您的评论，我认为您混淆了一些概念：组合、嵌套类和实例。或者我误解了你的问题，将删除/编辑我的答案。

当你说"一个结构中姐妹的实例"时，我认为你真的在寻找组合。就像在中有一个关系。您不需要有嵌套类就可以进行组合。对于组合，您需要成员变量。

也许你真正想要的是这样的东西，如果我错了，请纠正我：

struct CustomClassA {
 private:
  int number;
 public:
  int getNumber() { return number; }
};
struct CustomClassB {
 private:
  int number;
 public:
  int getNumber() { return number; }
};
struct CustomClassC {
 private:
  int number;
 public:
  int getNumber() { return number; }
};
struct CustomWrapper {
 private:
  CustomClassA a;
  CustomClassB b;
  CustomClassC c;
};

因此，如果创建一个CustomWrapper的实例，则具有自定义类a、b和c的实例。它"拥有"它们。

然后您希望这三个自定义类能够相互通信。实现这一点有很多方法。自定义类可以具有指向其他姐妹类的指针。这些可以在CustomWrapper:的构造函数中设置

#include <iostream>
struct CustomClassB;  // Forward declaration for member pointer in CustomClassA.
struct CustomClassA {
 private:
  int           number;
  CustomClassB* b;  // Member pointer to CustomClassB.
 public:
  CustomClassA() : number(1), b(nullptr) {}  // Initialized sister b to nullptr.
  void setSisterB(CustomClassB *sister_b) { b = sister_b; }
  int  getNumber() { return number; }
};
struct CustomClassB {
 private:
  int           number;
  CustomClassA* a;
 public:
  CustomClassB() : number(2), a(nullptr) {}
  void setSisterA(CustomClassA *sister_a) { a = sister_a; }
  int  getNumber() {
    if (a)  // Check a is not null
      return a->getNumber() + number; // Use pointer to sister a 
    return number; 
  }
};
struct CustomClassC {
 private:
  int           number;
  CustomClassA* a;
  CustomClassB* b;
 public:
  CustomClassC() : number(4), a(nullptr), b(nullptr) {} 
  void setSisterA(CustomClassA* sister_a) { a = sister_a; }
  void setSisterB(CustomClassB* sister_b) { b = sister_b; }
  int  getNumber() { return number; }
};
struct CustomWrapper {
 private:
  CustomClassA a;
  CustomClassB b;
  CustomClassC c;
 public:
  CustomWrapper() {
    a.setSisterB(&b);  // Set the pointers to the sister custom
    b.setSisterA(&a);  // classes in each custom class in the 
    c.setSisterA(&a);  // constructor of CustomWrapper.
    c.setSisterB(&b);
  }
  int getAnswer() {
    return b.getNumber() + c.getNumber();
  }
};
int main() {
  CustomWrapper wrapper;
  std::cout << wrapper.getAnswer();
}

或者，自定义类可以有一个指向自定义包装器的指针，并通过包装器与它们的姐妹进行通信。

相关文章：