我如何循环通过存储在映射中的对象向量?c++

我有一个函数类，其vector变量存储其他函数对象。每个函数都映射到一个网络类中。

std::map<std::string, Function> functions;

当我输出一个对象时，它在映射函数后显示该对象的向量变量(next_func)。

cout << network.functions.at("C");

(FUNCTION: id=C, next_func=[D])

然而，当我尝试遍历映射以尝试为每个映射函数显示vector变量时，它显示一个空vector变量。

for (auto element : network.functions) {
    cout << element.second << "n";
}

(FUNCTION: id=C, next_func=[])
(FUNCTION: id=D, next_func=[])
(FUNCTION: id=E, next_func=[])

我不确定这是否与我的类结构有关，或者如果我没有使用适当的迭代形式来完成我需要做的事情。

我如何循环通过映射对象来显示/操作向量变量内的对象?

工作的例子:

Function.h

#ifndef Function_H
#define Function_H
#include <vector>
#include <iterator>
#include <iostream>
#include <string>
using namespace std;
class Function {
public:
    string name;
    std::vector<Function*> func_pre;
    std::vector<Function*> func_next;
public:  
    Function();
    Function(const string& id, int duration);
    Function(const Function&);
    ~Function();
    Function& operator=(const Function& t);
    string name_() const;
    void addNext(Function& s);
    void addPre(Function& p);
    std::string toString() const;
    friend std::ostream& operator<<(std::ostream&, const Function&);
};
#endif

Function.cpp

#include <sstream>
#include "Function.h"
using namespace std;
Function::Function() {
    name = "";
}
Function::Function(const string& id, int duration) {
    this->name = id;
}
Function::Function(const Function& t) {
    this->name = t.name_();
}
Function::~Function() {}
Function& Function::operator=(const Function& t) {
    if (this != &t) {
        name = t.name;
    }
    return *this;
}
string Function::name_() const {
    return this->name;
}
void Function::addNext(Function& s) {
    Function* e = &s;
    func_next.push_back(e);
}
void Function::addPre(Function& p) {
    Function* e = &p;
    func_pre.push_back(e);
}
std::ostream& operator<<(std::ostream& s, const Function& e) {
    s << e.toString();
    return s;
}
std::string Function::toString() const {
    std::string s = "(Function: id=" + name +" ,to=";
    s = s+"[";
    for(unsigned int i = 0; i < func_next.size(); i++)
        s = s + func_next[i]->name_() + " ";
    s = s+"], from=[";
    for(unsigned int i = 0; i < func_pre.size(); i++)
        s = s + func_pre[i]->name_() + " ";
    s = s + "])";
    return s;
}

Map.h

#ifndef Map_H
#define Map_H
#include <map>
#include <vector>
#include <string>
#include "Function.h"
class Map{
public:
    std::map<std::string, Function> fucntions;
public:
    explicit Map();
    Map(const Map& n);
    ~Map();
    Map& operator=(const Map& i);
    void addFunction(const string id, int x);
    void addDep(const string& from, const string& to);
    std::string toString()const;
};
#endif

Map.cpp

#include "Map.h"
#include <iterator>
#include <iostream>
#include <iterator>
using namespace std;
Map::Map() {
    fucntions = {};
}
Map::Map(const Map& n) {
    this->fucntions = n.fucntions;
}
Map::~Map() {
}
Map& Map::operator=(const Map& i) {
    if (this != &i) {
        fucntions = i.fucntions;
    }
    return *this;
}
void Map::addFunction(const string id, int x) {
    Function t(id, x);
    fucntions[t.name_()] = t;
}
void Map::addDep(const string& from, const string& to) {
    fucntions.at(from).addNext(fucntions.at(to));
    fucntions.at(to).addPre(fucntions.at(from));
}
std::string Map::toString() const {
    std::string s = "(n";
    std::map<std::string, Function>::const_iterator i = fucntions.begin();
    std::map<std::string, Function>::const_iterator end = fucntions.end();
    if (i == end)
        s += "<Empty>";
    else
        do{
            s += (*i).second.toString();
            if (++i != end) s+= ",n";
        }while (!(i==end));
    s +="n)";
    return s;
}

main.cpp

#include <iostream>
#include "Map.h"
#include "Function.h"
using namespace std;
int main(){
    Map m;
    m.addFunction("A", 10);
    m.addFunction("B", 30);
    m.addFunction("C", 20);
    m.addFunction("D", 40);
    m.addFunction("E", 20);
    m.addDep("A", "B");
    m.addDep("A", "C");
    m.addDep("B", "D");
    m.addDep("D", "E");
    m.addDep("C", "E");
    m.addDep("B", "C");
    cout << m.fucntions.at("C") << "nn";
    for (auto& element : m.fucntions) {
        cout << "Predecessor counts: " << element.first
                << " : "<< element.second << "n";
    }
}