当基类要访问继承类的成员时

这是我的情况:

我正在用c++编写一个由节点和边缘组成的数据结构。节点之间通过边连接。

我有不同类型的节点，例如文本节点或int节点。文本节点连接到文本节点，int节点连接到int节点。我使用继承来实现不同类型的节点，因为它是有意义的:基本上，所有节点都与其他节点相连，所以Node是基类，和TxtNode, IntNode是继承类，它们共享节点的基本属性。

然而，当我试图从继承节点获取连接的继承节点时，这会给我带来问题，因为获取函数(检索连接到调用节点的特定节点的函数)是在基类node中定义的。例如，从TextNode调用这个fetch函数返回TextNode的基本版本，它缺少额外的信息。

我不确定在这里做什么是明智的编码实践。我之所以选择这样编码，是因为必须为所有不同类型的节点定义不同的连接获取函数似乎没有意义。

如果还有什么我可以透露的，请告诉我。

这是我的代码，我试图打印一个继承节点的伙伴，但它会导致打印基本节点。

Node.cpp

#include "Node.h"
#include "Edge.h"
#include "common.h"
#include <vector>
#include <cassert>
#include <cstddef>
#include <stdint.h>
#include <iostream>
Node::Node() {
    id = (intptr_t)this;
    edges.clear();
}
int Node::connect(Node* dst) {
    // establish link between calling node
    // and dst node, first linkage will
    // edge between each other, links after
    // increments strength. returns number of
    // links
    // fetch edge connecting this node and 
    // dst node
    Edge* edge = findDstEdge(dst);
    // if the branch isn't established yet,
    // then make connection
    if (edge==NULL) {
        establishConnection(dst, 1);
        return 0;
    } else {
        edge->strengthenConnection();
        return 1;
    }
}
Edge* Node::findDstEdge(Node* dst) {
    // fetches edge corresponding
    // to destination node
    // walk through vector of edges to find
    // edge connecting to dst
    vector<Edge*>::iterator iter = edges.begin();
while(iter!=edges.end()) {
    Edge* e = *iter;
    Node* partner = e->getPartner(this);
    if (partner->getID() == dst->getID())
        return e;
    iter++;
    }
    // not found
    return NULL;
}
void Node::establishConnection(Node* dst, int str) {
    // low level node addition
    // establish a new edge between
    // nodes which don't know each other
    Edge* e = new Edge(this, dst, str);
    this->manuallyConnect(e);
    dst->manuallyConnect(e);
}
void Node::manuallyConnect(Edge* e) {
    edges.push_back(e);
}
ostream& operator<<(ostream& stream,Node n) {
    vector<Edge*>::iterator iter = n.edges.begin();
    while(iter!=n.edges.end()) {
        Edge* e = *iter;
        stream << *e << endl;
        iter++;
    }
    return stream;
}

Node.h

#ifndef _NODE_H_
#define _NODE_H_
#include "common.h"
#include <vector>
#include <string>
#include <stdint.h>
class Edge;
using namespace std;
class Node {  
  protected:
    vector<Edge*> edges;
    intptr_t id;
  public:
    Node();
    // manipulation
    void establishConnection(Node* dst,
           int str);
    int connect(Node* dst);
    Edge* findDstEdge(Node* dst);
    // fetchers
    intptr_t getID() {return id;}
    vector<Edge*> getEdges() {return edges;}
    void manuallyConnect(Edge* e);
    friend ostream& operator<<(ostream& stream, Node n);
};
#endif

TxtNode.cpp

#include "TxtNode.h"
#include "Edge.h"
#include "common.h"
#include <iostream>
TxtNode::TxtNode(char c): Node()  {
    _c = c;
}
ostream& operator<<(ostream& stream, TxtNode tn) {
    // print out character of this TxtNode
    stream << "char: " << tn._c << endl;
    stream << "id: " << tn.id << endl;
    // print out all connections and its
    // strength
    vector<Edge*>::iterator iter = tn.edges.begin();
    while(iter!=tn.edges.end()) {
        Edge* e = *iter;
        stream << *e << endl;
        iter++;
    }
    return stream;
}

Edge.cpp

#include "Edge.h"
#include "Node.h"
#include "common.h"
#include <cassert>
#include <iostream>
using namespace std;
Edge::Edge(Node* a, Node* b, int str) {
    node_a = a;
    node_b = b;
    strength = str;
}
void Edge::strengthenConnection() {
    strength++;
}
Node* Edge::getPartner(Node* src) {
    uint src_ID = src->getID();
    if (node_a->getID() == src_ID)
        return node_b;
    else if (node_b->getID() == src_ID)
        return node_a;
    assert(false);
}
ostream& operator<<(ostream& stream, Edge e) {
    stream << "strength: "
           << e.strength
           << endl;
    stream << "node_a: "
           << e.node_a->getID()
           << endl;
    stream << "node_b: "
           << e.node_b->getID()
           << endl;
    return stream;
}

目前我只有代码来打印ID，这是一个intptr_t，因为我发现我不能从基类访问继承类的成员。

我倾向于从基类访问继承类的成员，因为边缘类处理基节点类。