C++ 将指针传递给self_C++ - Fatal编程技术网

C++ 将指针传递给self

c++

C++ 将指针传递给self,c++,C++,C++我有一个窗口类parent，它创建了几个选项卡窗口child1、child2等。。父窗口具有每个子窗口的成员变量。我想从child1访问child2，我想我可以在child1的构造函数中传递一个指向父对象的指针，并使用父对象的指针访问child2。我甚至不知道如何开始。我尝试了以下类似的方法，但它没有编译，从包含（*this）的行开始我想知道是否有人能帮上忙 1.在不太改变结构的情况下编译 2.关于建立此关系的更好方法的建议。使用子项的初始值设定项列表，并传递此。但是，请注意，this

C++我有一个窗口类parent，它创建了几个选项卡窗口child1、child2等。。父窗口具有每个子窗口的成员变量。我想从child1访问child2，我想我可以在child1的构造函数中传递一个指向父对象的指针，并使用父对象的指针访问child2。我甚至不知道如何开始。我尝试了以下类似的方法，但它没有编译，从包含（*this）的行开始

我想知道是否有人能帮上忙 1.在不太改变结构的情况下编译

2.关于建立此关系的更好方法的建议。

使用子项的初始值设定项列表，并传递此

。但是，请注意，this
的某些用法在初始值设定项列表中是不正确的（因为对象仍在构造中，一些成员尚未初始化）
如果m_Child1
需要使用m_Child2
，则应将m_Child2
放在类定义的m_Child1
上方，以便首先对其进行初始化。然后，您可以将this
指针传递到m_Child2
，如下所示：
struct CParent {
    CParent() : m_Child1( this ) { }
private:
    CChild2 m_Child2;
    CChild1 m_Child1;
};

struct CChild2;  // Forward declare the class so CChild1 can accept it
struct CChild1 { // Define CChild1 first because CParent uses it for a member
    CChild1( CChild2 &child2 );
    // ...
};
// ...
struct CParent {
    CParent() : m_Child1( m_Child2 ) { }
private:
    CChild2 m_Child2;
    CChild1 m_Child1;
};

您可以考虑将<代码> MyPald2 > <代码> MyHealth1，以使数据依赖项显式化，给出一个提示：为什么代码> MyPald2必须先出现，并且不提供对正在构建的对象的引用。看起来是这样的：
struct CParent {
    CParent() : m_Child1( this ) { }
private:
    CChild2 m_Child2;
    CChild1 m_Child1;
};

struct CChild2;  // Forward declare the class so CChild1 can accept it
struct CChild1 { // Define CChild1 first because CParent uses it for a member
    CChild1( CChild2 &child2 );
    // ...
};
// ...
struct CParent {
    CParent() : m_Child1( m_Child2 ) { }
private:
    CChild2 m_Child2;
    CChild1 m_Child1;
};

使用子项的初始值设定项列表并传递this
。但是，请注意，this
的某些用法在初始值设定项列表中是不正确的（因为对象仍在构造中，一些成员尚未初始化）
如果m_Child1
需要使用m_Child2
，则应将m_Child2
放在类定义的m_Child1
上方，以便首先对其进行初始化。然后，您可以将this
指针传递到m_Child2
，如下所示：
struct CParent {
    CParent() : m_Child1( this ) { }
private:
    CChild2 m_Child2;
    CChild1 m_Child1;
};

struct CChild2;  // Forward declare the class so CChild1 can accept it
struct CChild1 { // Define CChild1 first because CParent uses it for a member
    CChild1( CChild2 &child2 );
    // ...
};
// ...
struct CParent {
    CParent() : m_Child1( m_Child2 ) { }
private:
    CChild2 m_Child2;
    CChild1 m_Child1;
};

您可以考虑将<代码> MyPald2 > <代码> MyHealth1，以使数据依赖项显式化，给出一个提示：为什么代码> MyPald2必须先出现，并且不提供对正在构建的对象的引用。看起来是这样的：
struct CParent {
    CParent() : m_Child1( this ) { }
private:
    CChild2 m_Child2;
    CChild1 m_Child1;
};

struct CChild2;  // Forward declare the class so CChild1 can accept it
struct CChild1 { // Define CChild1 first because CParent uses it for a member
    CChild1( CChild2 &child2 );
    // ...
};
// ...
struct CParent {
    CParent() : m_Child1( m_Child2 ) { }
private:
    CChild2 m_Child2;
    CChild1 m_Child1;
};

<>你的代码有几个关于声明和定义语法、成员初始化等严重的问题。我的建议是继续使用C++基础知识。
我建议为您的孩子使用动态存储，因为您的问题暗示可能有两个以上的问题
class CParent;

class CChild
{
public:
  CChild (CParent * p_parent);
  int get_other_child_number(size_t const other_child);
  int number (void) { return m_number; }
private:
  CParent * m_parent;
  int m_number;
};

class CParent
{
public:
  CParent (void) { }
  void add_child (void) { m_children.emplace_back(this); }
  CChild & child (size_t const child_num) { return m_children.at(child_num); }
  CChild const & child (size_t const child_num) const { return m_children.at(child_num); }
  size_t num_childs (void) const { return m_children.size(); }
private:
  std::vector<CChild> m_children;
};

CChild::CChild (CParent * p_parent) : m_parent(p_parent), m_number(p_parent->num_childs()) { }
int CChild::get_other_child_number(size_t const other_child)
{ 
  return m_parent->child(other_child).number(); 
}


int main()
{
  CParent par;
  par.add_child();
  par.add_child();
  cout << "Number of Child 0 is " << par.child(0).number() << endl;
  cout << "Number of Child 1 is " << par.child(1).number() << endl;
  cout << "Number of Child 0 from Child 1 is " << par.child(1).get_other_child_number(0) << endl;
  cout << "Number of Child 1 from Child 0 is " << par.child(0).get_other_child_number(1) << endl;
}

class；
儿童班
{
公众：
儿童（家长*家长）；
int get_other_child_编号（大小常数other_child）；
整数（void）{返回m_数；}
私人：
CParent*m_父母；
整数m_数；
};
类租金
{
公众：
CParent（无效）{}
void add_child（void）{m_children.emplace_back（this）；}
CChild&child（size_t const child_num）{返回m_childs.at（child_num）}
CChild const&child（size_t const child_num）const{return m_children.at（child_num）；}
size_t num_childs（void）const{return m_childs.size（）；}
私人：
性病：：媒介m_儿童；
};
CChild:：CChild（CParent*p_parent）：m_parent（p_parent），m_number（p_parent->num_childs（））{}
int CChild:：获取其他子项编号（大小常数其他子项）
{ 
返回m_parent->child（other_child）.number（）；
}
int main（）
{
亲本；
PAR.ADDIX子集（）；
PAR.ADDIX子集（）；
CUT< P>你的代码有关于声明和定义语法、成员初始化等几个严重问题。我的建议是继续使用C++基础知识。
我建议为您的孩子使用动态存储，因为您的问题暗示可能有两个以上的问题
class CParent;

class CChild
{
public:
  CChild (CParent * p_parent);
  int get_other_child_number(size_t const other_child);
  int number (void) { return m_number; }
private:
  CParent * m_parent;
  int m_number;
};

class CParent
{
public:
  CParent (void) { }
  void add_child (void) { m_children.emplace_back(this); }
  CChild & child (size_t const child_num) { return m_children.at(child_num); }
  CChild const & child (size_t const child_num) const { return m_children.at(child_num); }
  size_t num_childs (void) const { return m_children.size(); }
private:
  std::vector<CChild> m_children;
};

CChild::CChild (CParent * p_parent) : m_parent(p_parent), m_number(p_parent->num_childs()) { }
int CChild::get_other_child_number(size_t const other_child)
{ 
  return m_parent->child(other_child).number(); 
}


int main()
{
  CParent par;
  par.add_child();
  par.add_child();
  cout << "Number of Child 0 is " << par.child(0).number() << endl;
  cout << "Number of Child 1 is " << par.child(1).number() << endl;
  cout << "Number of Child 0 from Child 1 is " << par.child(1).get_other_child_number(0) << endl;
  cout << "Number of Child 1 from Child 0 is " << par.child(0).get_other_child_number(1) << endl;
}

class；
儿童班
{
公众：
儿童（家长*家长）；
int get_other_child_编号（大小常数other_child）；
整数（void）{返回m_数；}
私人：
CParent*m_父母；
整数m_数；
};
类租金
{
公众：
CParent（无效）{}
void add_child（void）{m_children.emplace_back（this）；}
CChild&child（size_t const child_num）{返回m_childs.at（child_num）}
CChild const&child（size_t const child_num）const{return m_children.at（child_num）；}
size_t num_childs（void）const{return m_childs.size（）；}
私人：
性病：：媒介m_儿童；
};
CChild:：CChild（CParent*p_parent）：m_parent（p_parent），m_number（p_parent->num_childs（））{}
int CChild:：获取其他子项编号（大小常数其他子项）
{ 
返回m_parent->child（other_child）.number（）；
}
int main（）
{
亲本；
PAR.ADDIX子集（）；
PAR.ADDIX子集（）；
你是从哪里得到这段代码的？你是自己从头开始写的吗？你为什么不通过阅读一本书来学习呢？好吧，除此之外，你对这段代码的理解是完全错误的。这段代码是一个CParent*
，这是构造器所期望的。你取消引用它，结果是一个CParent，这是错误的。作为数据点，您尝试执行的操作将创建依赖循环（例如CParent->CChild1->CParent
）最好把共享状态放在一个单独的类中，并将它通过代码> > SyddYpTr>代码>给每个子类。我绝对建议您进一步学习C++语言的概念和特征，尤其是封装、继承、多态性和标准模板容器。这个代码是从哪里来的？是你自己从头开始写的吗？你为什么不通过阅读一本书来学习呢？好吧，除了别的以外，你对这个
是什么的理解是完全错误的。这个
是一个CParent*
，这是构造函数所期望的。你取消引用它，结果是一个CParent
，这是错误的.作为一个数据点，您尝试执行的操作将创建依赖循环（例如，CParent->CChild1->CParent
）。您