初始化"；嵌套的；boost:：共享的\u ptr类成员 我试图编写一个C++程序，它有3个抽象类（ BaseA A/CODE >， BaseBu/和 BaseB.C/代码>，它们每个都有一个派生类（分别是代码>派生类A < /COD>，派生B B/COD>和派生-C ）。

现在，我想创建一个对象

z

，它是

派生的_C

（通过

boost:：shared_ptr

）。要初始化

z

我想使用

y

（通过

boost:：shared_ptr

），它是

Derived_B

的成员，要初始化

y

我想使用

x

（通过

boost:：shared_ptr

），它又是

Derived_a

的成员

我面临的问题是，我想要检索成员

K

，它属于类

Derived\u B

，但是下面一行

std::cout << z->barC->K << std::endl;

//-----A.cpp-----

//------------------------------------------------------------------------------

//-----B.h-----

class Base\u B{
公众：
双S；
双K；
boost：：共享的食物；
Base_B（）{}；
虚~Base_B（）{}；
//其他纯虚拟函数。。。
};
类派生的\u B：公共基\u B{
公众：
双S；
双K；
促进：共享食物；
派生B（const double&_K，boost：：共享食物）；
~Derived_B（）{}；
//纯虚函数的声明。。。
};

//-----B.cpp-----

Derived_B:：Derived_B（const double&_K，boost:：shared_ptr_食物）
：K（_K）{
食物=促进：共享食物；
};

//-----------------------------------------------------------------------------

//-----C.h-----

class Base\u C{
公众：
boost：：共享_ptr倒钩；
Base_C（）{}；
虚~Base_C（）{}；
//其他纯虚拟函数。。。
};
类派生的\u C：公共基\u C{
公众：
boost：：共享_ptr barC；
派生的_C（boost:：shared_ptr_barC）；
~Derived_C（）{}；
//纯虚函数的声明。。。
};

//-----C.cpp-----

Derived_C:：Derived_C（boost:：shared_ptr_barC）{
barC=_barC；
};

//------------------------------------------------------------------------------

//-----Main.cpp-----

void main（）{
双K=50.0；
双S=100.0；
boost:：shared_ptr x（新派生的_A（K））；
boost:：shared_ptr y（新派生的_B（K，x））；
boost:：shared_ptr z（新派生的_C（y））；
我还没有测试过这个答案

您似乎在每个类中重新声明
double K；
。每个新声明都会屏蔽父类中的
K

你不是从
Base_A
读
K
你可能是从
Derived_B
读到的，但是指针
z->barC
指向A
Base_B
谢谢@Zan Lynx，我已经更改了
Derived_B
的构造函数，现在看起来像
Derived_B（boost:：shared_ptr_fooD）{barC=\barC；}所以在
main
中，我创建了一个
Derived_B
成员
作为
boost:：shared_pty（new-Derived_B（x））；
。现在：
std:：cout fooD->K K K fooD->K
class Base_A{  
public:  
  double K;  

  Base_A(){};
  Base_A(const double& _K);
  virtual ~Base_A(){};

  virtual double operator()(const double& _S) const = 0;
};

class Derived_A :public Base_A{
public:
  double K;

  Derived_A(const double& _K);
  ~Derived_A(){};

  double operator()(const double& _S)const;
};

Base_A::Base_A(const double& _K)
  :K(_K){};

Derived_A::Derived_A(const double& _K)
  :K(_K){};

double Derived_A::operator()(const double& _S) const {
  return std::max(_S - K, 0.0);
}

class Base_B{
public:
  double S;
  double K;
  boost::shared_ptr<Base_A> fooB;

  Base_B(){};
  virtual ~Base_B(){};

  // other pure virtual functions...
};

class Derived_B :public Base_B{
public:
   double S;
   double K;
   boost::shared_ptr<Derived_A> fooD;

   Derived_B(const double& _K, boost::shared_ptr<Derived_A> _fooD);
   ~Derived_B(){};

   // declaration of the pure virtual functions...
};

Derived_B::Derived_B(const double& _K, boost::shared_ptr<Derived_A> _fooD)
  :K(_K){
  fooD = boost::shared_ptr<Derived_A>(_fooD);
};

class Base_C{
public:
  boost::shared_ptr<Base_B> barB;

  Base_C(){};
  virtual ~Base_C(){};

  // other pure virtual functions...
};

class Derived_C :public Base_C{
public:
  boost::shared_ptr<Base_B> barC;

  Derived_C(boost::shared_ptr<Base_B> _barC);
  ~Derived_C(){};
  // declaration of the pure virtual functions...
};

Derived_C::Derived_C(boost::shared_ptr<Base_B> _barC){

  barC = _barC;
};

void main(){

  double K= 50.0;
  double S= 100.0;

  boost::shared_ptr<Derived_A> x(new Derived_A(K));

  boost::shared_ptr<Derived_B> y(new Derived_B(K,x));

  boost::shared_ptr<Derived_C> z(new Derived_C(y));

  std::cout << z->barC->K << std::endl; // returns 0.0 instead of 50.0
}