C++ 为什么会出现错误：与‘；操作员<<’；内部功能？

为运算符添加了覆盖，因为编译器线性读取代码，它不知道

运算符的重载是您代码中的顺序吗？然后，您尝试在定义运算符之前使用它。尝试的断言发生在
Pete Becker，谢谢您的工作“如果我尝试使用此代码，一切都会按预期工作”——真的吗？如果你用你说的有效的代码替换了导致错误的代码行，它就开始工作了？不知何故，我对此表示怀疑。测试时，您所说的“有效”代码无疑不在
add
函数中，在
操作之后，您还可以在尝试使用这些函数之前，向前声明这些类并为这些函数添加原型。
  Edge edge1("A", "B", 3);
  Edge* edge2 = new Edge("A", "B", 3);
  cout << edge1 << endl;
  cout << *edge2 << endl;

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Node {
  public:
  string name;
  Node() {}
  Node(string name):name(name) {}

  bool operator==(const Node& other) {
    return name == other.name;
  }
};

class Edge {
  public:
  Node x;
  Node y;
  int cost;
  Edge(string x_name, string y_name, int cost) {
    this->x = Node(x_name);
    this->y = Node(y_name);
    this->cost = cost;
  }
  Edge(Node x, Node y, int cost):x(x),y(y) {}

  bool operator==(const Edge& other) {
    return x == other.x && x == other.y && cost == other.cost;
  }
};

class Graph {
  public:
  vector<Edge> edges;
  vector<Node> nodes;

  bool has_node(Node node) {
    return find(nodes.begin(), nodes.end(), node) != nodes.end();
  }

  bool has_edge(Edge edge) {
    return find(edges.begin(), edges.end(), edge) != edges.end();
  }

  void add(string x_name, string y_name, int cost) {
    Node x(x_name);
    Node y(y_name);
    bool has_not_x = !has_node(x);
    bool has_not_y = !has_node(y);
    if (has_not_x) {
      nodes.push_back(x);
    }
    if (has_not_y) {
      nodes.push_back(y);
    }
    if (has_not_x || has_not_y) {
      add(x, y, cost);
    }
  }

  void add(Node x, Node y, int cost) {
    Edge edge(x, y, cost);
    if (!has_edge(edge)) {
      cout << "Adding: " << edge;
      edges.push_back(edge);
    }
  }
};

ostream& operator<<(ostream& os, const Node& node)
{
    os << "(" << node.name << ")";
    return os;
}

ostream& operator<<(ostream& os, const Edge& edge)
{
    os << edge.x << "-" << edge.cost << "-" << edge.y;
    return os;
}

int main()
{
  Graph* graph = new Graph();
  graph->add("A", "C", 1);

  return 0;
}

// Place the function declaration before the class
// to inform the compiler of the overload's existence.
ostream& operator<<(ostream& os, const Edge& edge);

class Graph {
    public:
        vector<Edge> edges;
        vector<Node> nodes;
// and so on...