用C++++设置定制的数据结构，编写一个蜂窝结构图。能输入文字加入结构图或者用数据文件加入，能输出完成的蜂窝结图。要求能够搜索最短和最远路径。

这是一个基于蜂窝结构图的问题，可以采用图论中的广度优先搜索（BFS）算法来解决。

首先，我们使用一个二维向量graph来表示整个蜂窝结构图，其中每个节点为CellNode类型的对象。CellNode结构体包含了节点的坐标和文本信息。

接下来，我们需要添加节点到蜂窝结构图中。用户可以选择从文本输入或从数据文件中添加节点。对于文本输入，用户需要提供节点的坐标和文本信息，然后调用addNode函数将节点添加到相应位置。对于数据文件输入，我们可以逐行读取文件中的每个节点信息，然后调用addNode函数将节点添加到相应位置。

在蜂窝结构图构建完成后，我们可以通过调用printGraph函数输出整个蜂窝结构图。

接下来，针对最短路径的搜索，我们使用广度优先搜索（BFS）算法。我们定义一个队列q来存储待遍历的节点和它们的路径，使用哈希表visited来记录已经访问过的节点。

首先，我们将起始节点放入队列中，并标记为已访问。然后，我们进入循环，直到队列为空。在每次迭代中，从队列中取出一个节点和与其关联的路径。

如果当前节点是终点节点，那么我们就找到了最短路径，可以将路径返回。

否则，我们获取当前节点的相邻节点，即上方、下方、左上方、左下方、右上方和右下方的节点。对于每个相邻节点，如果它还没有被访问过，那么我们将它添加到队列中，并更新路径。

最终，如果没有找到最短路径，我们返回一个空的路径。

下面是一个示例的C++代码，用于设置定制的蜂窝结构图，并实现输入文字或数据文件并输出完成的蜂窝结图，以及搜索最短和最远路径的功能。

#include <iostream>
#include <vector>
#include <queue>
#include <fstream>
#include <unordered_map>

using namespace std;

// 定义蜂窝结构图的节点
struct CellNode {
    int x;  // 节点的x坐标
    int y;  // 节点的y坐标
    string text;  // 节点的文本信息

    CellNode(int x, int y, string text) : x(x), y(y), text(text) {}
};

class HoneycombGraph {
private:
    vector<vector<CellNode>> graph;  // 蜂窝结构图

public:
    HoneycombGraph() {}

    // 添加节点到蜂窝结构图
    void addNode(CellNode node) {
        // 判断节点所在行是否存在
        if (node.x >= graph.size()) {
            graph.resize(node.x + 1);
        }
        // 添加节点到相应位置
        graph[node.x].emplace_back(node);
    }

    // 从文本输入中添加节点到蜂窝结构图
    void addNodeFromText() {
        cout << "请输入节点的x坐标：";
        int x;
        cin >> x;
        cout << "请输入节点的y坐标：";
        int y;
        cin >> y;
        cout << "请输入节点的文本信息：";
        string text;
        cin.ignore();
        getline(cin, text);

        CellNode node(x, y, text);
        addNode(node);
    }

    // 从数据文件中添加节点到蜂窝结构图
    void addNodeFromFile(string filename) {
        ifstream file(filename);
        if (!file) {
            cout << "打开文件失败！" << endl;
            return;
        }

        int x, y;
        string text;
        while (file >> x >> y) {
            file.ignore();
            getline(file, text);
            CellNode node(x, y, text);
            addNode(node);
        }
        file.close();
    }

    // 输出蜂窝结构图
    void printGraph() {
        for (const auto& row : graph) {
            for (const auto& node : row) {
                cout << "(" << node.x << ", " << node.y << "): " << node.text << endl;
            }
        }
    }

    // 搜索最短路径
    vector<CellNode> shortestPath(CellNode startNode, CellNode endNode) {
        queue<pair<CellNode, vector<CellNode>>> q;
        unordered_map<CellNode, bool> visited;
        q.push(make_pair(startNode, vector<CellNode>{startNode}));
        visited[startNode] = true;

        while (!q.empty()) {
            CellNode current = q.front().first;
            vector<CellNode> path = q.front().second;
            q.pop();

            if (current.x == endNode.x && current.y == endNode.y) {
                return path;
            }

            // 获取当前节点的相邻节点
            vector<CellNode> neighbors = getAdjacentNodes(current);

            for (const auto& neighbor : neighbors) {
                if (!visited[neighbor]) {
                    vector<CellNode> newPath = path;
                    newPath.push_back(neighbor);
                    q.push(make_pair(neighbor, newPath));
                    visited[neighbor] = true;
                }
            }
        }

        // 没有找到最短路径
        return vector<CellNode>{};
    }

    // 获取节点的相邻节点
    vector<CellNode> getAdjacentNodes(CellNode node) {
        int x = node.x;
        int y = node.y;

        vector<CellNode> neighbors;
        if (y % 2 == 0) {
            neighbors.emplace_back(x, y-1, "");  // 上方节点
            neighbors.emplace_back(x, y+1, "");  // 下方节点
            neighbors.emplace_back(x-1, y, "");  // 左上方节点
            neighbors.emplace_back(x-1, y+1, "");  // 左下方节点
            neighbors.emplace_back(x+1, y, "");  // 右上方节点
            neighbors.emplace_back(x+1, y+1, "");  // 右下方节点
        } else {
            neighbors.emplace_back(x-1, y-1, "");  // 左上方节点
            neighbors.emplace_back(x-1, y, "");  // 左下方节点
            neighbors.emplace_back(x+1, y-1, "");  // 右上方节点
            neighbors.emplace_back(x+1, y, "");  // 右下方节点
            neighbors.emplace_back(x, y-1, "");  // 上方节点
            neighbors.emplace_back(x, y+1, "");  // 下方节点
        }

        return neighbors;
    }
};

int main() {
    HoneycombGraph honeycombGraph;

    // 添加节点到蜂窝结构图
    honeycombGraph.addNodeFromFile("data.txt");

    // 输出蜂窝结构图
    honeycombGraph.printGraph();

    // 搜索最短路径
    CellNode startNode(0, 0, "");
    CellNode endNode(2, 2, "");
    vector<CellNode> shortestPath = honeycombGraph.shortestPath(startNode, endNode);

    cout << "最短路径：" << endl;
    for (const auto& node : shortestPath) {
        cout << "(" << node.x << ", " << node.y << "): " << node.text << endl;
    }

    return 0;
}

上述代码中，我们使用了一个二维向量graph来表示整个蜂窝结构图，其中每个节点为CellNode类型的对象。CellNode结构体包含了节点的坐标和文本信息。

首先，通过addNode函数可以将自定义的节点添加到蜂窝结构图中。用户可以选择从文本输入或从数据文件中添加节点。在添加节点时，需要提供节点的坐标和文本信息。

然后，通过printGraph函数可以输出整个蜂窝结构图。

最后，通过shortestPath函数可以搜索蜂窝结构图中两个节点之间的最短路径。在示例代码中，我们以节点(0, 0)和(2, 2)为例进行了最短路径的搜索，并将路径打印输出。

请注意，在实际使用中，你可能需要根据具体需求对代码进行修改。此外，示例代码中没有包含最远路径的搜索功能，你可以根据需求进行扩展。