C++ 使用父类的父类的向量指针，通过指向父类的指针访问映射成员变量

我的代码中有四个类：类数据、类示例、类节点和类树

class Data
{
private:
    map<string, double> m_DataVariables;

public:
    Data();
    Data(const Data &data);

    map<string, double> getDataVariables() const;
    void setDataVariables(const map<string, double> &value);
};

class Sample
{
private:
    Data *m_pData;         // Pointer To The Map Of DataVariables

public:
    virtual ~Sample()
    {
        delete m_pData;
    }

    Sample();
    Sample(const Sample &sample);

    // Data Variables      
    map<string, double> getDataVariables() const;
    void setDataVariables(const map<string, double> &value);
};

class Node
{
private:
    double m_numSamples;
    vector<Sample*> m_NodeSamples;

public:
   virtual ~Node()
   {
   }

   Node();

   // Number of samples for the node
   double getNumSamples() const;
   void setNumSamples(const double &value);

   // List of Samples
   vector<Sample*> getSamples() const;
   void setSamples(const vector<Sample*> &value);
};

class Tree
{
private:
    vector<Sample*> m_Samples;
    vector<Node*> m_nodes;

public:
    Tree(vector<Sample*> &Samples);

    // List of Sample
    vector<Sample*> getSamples() const;
    void setSamples(const vector<Sample*> &value);

    // List of Nodes
    vector<Node*> getNodes() const;
    void setNodes(const vector<Node*> &value);

    // List of Names that were used in building the tree
    vector<string> getPredictorNames() const;
    void setPredictorNames(const vector<string> &value);

    void CalcError(Node *node, const string &Name, double &error);

};

Data::Data()
{
    m_DataVariables = map<string, double>();
}

map<string, double> Data::getDataVariables() const
{
    return m_DataVariables;
}


Sample::Sample(const Sample &sample)
{
    m_pData                     = new Data(); //Map of Variables
    m_pData->getDataVariables() = sample.getDataVariables();
}

map<string, double> Sample::getDataVariables() const
{
    return m_pData->getDataVariables();
}

double Node::getNumSamples() const
{
    return m_numSamples;
}

vector<Sample*> Node::getSamples() const
{
    return m_NodeSamples;
}


void Tree::Tree()
{
    m_Samples = vector<Sample*>();
    m_nodes   = vector<Node*>();
}

vector<Sample*> Tree::getSamples() const
{
    return m_Samples;
}

vector<Node*> Tree::getNodes() const
{
    return m_nodes;
}

类数据
{
私人：
映射m_数据变量；
公众：
数据（）；
数据（常量数据和数据）；
map getDataVariables（）常量；
void setDataVariables（常量映射和值）；
};
类样本
{
私人：
Data*m_pData；//指向数据变量映射的指针
公众：
虚拟~Sample（）
{
删除m_pData；
}
样本（）；
样本（常量样本和样本）；
//数据变量
map getDataVariables（）常量；
void setDataVariables（常量映射和值）；
};
类节点
{
私人：
双m_数样本；
向量m_节点样本；
公众：
虚拟节点（）
{
}
Node（）；
//节点的样本数
双getNumSamples（）常量；
void setNumSamples（const double和value）；
//样本清单
向量getSamples（）常量；
无效设置样本（常数向量和值）；
};
类树
{
私人：
向量m_样本；
向量m_节点；
公众：
树（向量和样本）；
//样本清单
向量getSamples（）常量；
无效设置样本（常数向量和值）；
//节点列表
向量getNodes（）常量；
void setNodes（常量向量和值）；
//用于构建树的名称列表
向量getPredictNames（）常量；
void setpredictor名称（常量向量和值）；
void CalcError（节点*节点、常量字符串和名称、双精度和错误）；
};
数据：：数据（）
{
m_DataVariables=map（）；
}
映射数据：：getDataVariables（）常量
{
返回m_数据变量；
}
样本：：样本（常量样本和样本）
{
m_pData=new Data（）；//变量映射
m_pData->getDataVariables（）=sample.getDataVariables（）；
}
映射示例：：getDataVariables（）常量
{
返回m_pData->getDataVariables（）；
}
双节点：：getNumSamples（）常量
{
返回m_numSamples；
}
向量节点：：getSamples（）常量
{
返回m_节点示例；
}
void Tree:：Tree（）
{
m_样本=向量（）；
m_节点=向量（）；
}
向量树：：getSamples（）常量
{
返回m_样品；
}
向量树：：getNodes（）常量
{
返回m_节点；
}

在CalcError（Node*Node，const string&name，double&error）中，我希望对于NodeSamples In class节点中的每个示例，迭代类数据中的DataVariables映射，并将传递的名称与映射中的键进行比较。如果名称与键匹配，则读取与键关联的值并将其存储在集合中。目前我无法使用C++11的功能。我可以使用C++98

在visual studio下的C#中，这很简单，可以使用：

List Values=node.Samples.Select（s=>s.DataVariables[name]）.OrderBy（v=>v.ToList（）

<>但是在C++中我不知道如何实现这一点。我从以下几点开始：

void Tree::CalcError(Node *node, const string &name, double &error)
{
    vector<double> Values;

    for (vector<TrainingSample*>::iterator SampleIt = node->getTrainingSamples().begin(); SampleIt != node->getTrainingSamples().end(); SampleIt++)
    {
        for (map<string, double>::iterator map_iter = **Not sure how to access the map....** map_iter++)
        {
            if (name.compare(**Not sure how to access the key in the map**) == 0)
            {
                Values.push_back(**Not sure how to access the value in the map**);
            }
        }
    }
}

void Tree:：CalcError（节点*节点，常量字符串和名称，双精度和错误）
{
向量值；
对于（vector:：iterator SampleIt=node->getTrainingSamples（）.begin（）；SampleIt！=node->getTrainingSamples（）.end（）；SampleIt++）
{
for（map:：iterator map\u iter=**不确定如何访问map…**map\u iter++）
{
if（name.compare（**不确定如何访问映射中的键**）=0）
{
值。推回（**不确定如何访问映射中的值**）；
}
}
}
}

---

任何帮助都将不胜感激。

映射迭代器基本上会生成一个

std:：pair

，因此您可以访问以下内容：

for (map<string, double>::iterator map_iter = DataVariables.begin();
     map_iter != DataVariables.end();
     ++map_iter) {
    if (name.compare(map_iter->first) == 0) {
                  // ^^^^^^^^^^^^^^^ Access the key
        Values.push_back(map_iter->second);
                      // ^^^^^^^^^^^^^^^^ Access the value
    }
}

for（map:：iterator map_iter=DataVariables.begin（）；
map_iter！=DataVariables.end（）；
++图（国际热核聚变实验堆）{
if（name.compare（map_iter->first）=0）{
//^^^^^^^^^^^^^^^^^^访问密钥
值。向后推（映射iter->second）；
//^^^^^^^^^^^^^^^^^^^^访问该值
}
}

您可以使用

map:：find

:

void Tree::CalcError(Node* node, const string& name, double& error)
{
    vector<double> Values;
    const vector<TrainingSample*>& samples = node->getTrainingSamples();

    for (vector<TrainingSample*>::const_iterator SampleIt = samples.begin();
         SampleIt != samples.end();
         ++SampleIt)
    {
        const TrainingSample& sample = **SampleIt;
        const std::map<string, double>& m = sample.getDataVariables();
        std::map<string, double>::const_iterator map_iter = m.find(name);

        if (map_iter != m.end())
        {
            Values.push_back(map_iter->second);
        }
    }
    // ...
}

void Tree:：CalcError（节点*节点，常量字符串和名称，双精度和错误）
{
向量值；
const vector&samples=node->getTrainingSamples（）；
for（vector:：const_iterator SampleIt=samples.begin（）；
SampleIt！=samples.end（）；
++（样本）
{
常量训练样本和样本=**样本；
const std:：map&m=sample.getDataVariables（）；
std:：map:：const\u迭代器map\u iter=m.find（名称）；
if（map_iter！=m.end（））
{
值。向后推（映射iter->second）；
}
}
// ...
}

您的getter应该返回const引用以避免复制（因此使用同一容器的迭代器）。您不必显式构造

向量

或

映射

，它们的默认构造函数就足够了。@Jarod42已修复。