C++中无向图算法中查找周期的实现.

所以基本上我想在C++中实现这个在无向图中查找所有循环（唯一的区别是图是加权的），但这不是我现在的问题，因为我以后可能会处理它。

我试图重写 C# 代码以C++，但我仍然对我的 OOP C++没有信心，我不太明白我做错了什么。我使用了调试器，我的程序甚至没有进入findNewCycles函数，我也非常确定还有更多问题，但目前我想找出如何启动。我的 Path 类的构造函数有问题（至少调试器建议我这样做），但我不明白为什么。你能帮帮我吗？这是我的代码：

#include <iostream>
#include <utility>
#include <vector>
#include <algorithm>
using namespace std;
class Graph {
        struct Edge {
                int vert[2];
                double value;
            public:
                Edge(int vec1, int vec2, double w) {
                    vert[0] = vec1;
                    vert[1] = vec2;
                    value = w;
                };
        };
        struct Path {
                vector<int> vertices;
                double totalValue;
            public:
                Path() : totalValue(0) {};
                Path(vector<int> v, double tv) : vertices(v), totalValue(tv) {};
                Path(const Path &a) {
                    totalValue = a.totalValue;
                    vertices = a.vertices;
                }
        };
        int vortexCount, edgeCount, cycleCount;
        vector<Path> cycles;
        vector<Edge> edges;
        void findNewCycles(Path a) {
            int n = a.vertices[0];
            int x;
            Path sub(a);
            for(int i = 0; i < edgeCount; i++) {
                for(int j = 0; j <=1; j++) {
                    if (edges[i].vert[j] == n) {
                        x = edges[i].vert[(j+1)%2];
                        if (!visited(x, a)) {
                            sub.totalValue += edges[i].value;
                            sub.vertices.insert(sub.vertices.begin(), x);
                            findNewCycles(sub);
                        }
                        else if ((a.vertices.size() > 2) && (x == a.vertices[a.vertices.size() - 1])) {
                            Path normal = normalize(a);
                            Path inv = invert(normal);
                            if(isNew(normal) && isNew(inv)) cycles.push_back(normal);
                        }
                    }
                }
            }
        }
        bool equals(Path a, Path b) {
            if((a.vertices.size() == b.vertices.size()) && (a.totalValue == b.totalValue)) {
                for (unsigned i=0; i < a.vertices.size(); i++) {
                    if(a.vertices[i] != b.vertices[i]) return false;
                }
                return true;
            }
            else return false;
        }
        Path invert(Path a) {
            Path inverted(a);
            reverse(inverted.vertices.begin(), inverted.vertices.end());
            return normalize(inverted);
        }
        Path normalize(Path a) {
            Path normalized(a);
            vector<int>::iterator smallest = min_element(normalized.vertices.begin(), normalized.vertices.end());
            std::rotate(normalized.vertices.begin(), smallest, normalized.vertices.end());
            return normalized;
        }
        bool isNew(Path a) {
            for(int i=0; i<cycleCount; i++) {
                if(equals(cycles[i], a)) {
                    return false;
                }
            }
            return true;
        }
        bool visited(int n, Path a) {
            for (unsigned i=0; i < a.vertices.size(); i++) {
                if(a.vertices[i] == n) return true;
            }
            return false;
        }
    public:
        Graph(int size) : vortexCount(size), edgeCount(0), cycleCount(0) {};
        ~Graph() {};
        vector<Edge>::iterator findEdge(int v1, int v2) {
            if(v1 == v2 || v1 > vortexCount || v2 > vortexCount) return edges.end();
            vector<Edge>::iterator iter;
            for(iter = edges.begin(); iter != edges.end(); ++iter) {
                if(iter->vert[0] == v1 && iter->vert[1] == v2) return iter;
                if(iter->vert[1] == v1 && iter->vert[0] == v2) return iter;
            }
            return edges.end();
        }
        bool addEdge(int v1, int v2, double value) {
            if(v1 == v2 || v1 > vortexCount || v2 > vortexCount) return false;
            vector<Edge>::iterator p = findEdge(v1, v2);
            if(p != edges.end()) {
                p->value = value;
            }
            else {
                Edge edge(v1, v2, value);
                edges.push_back(edge);
                edgeCount++;
            }
            return true;
        }
        void runCycleSearch() {
            for (int i = 0; i < edgeCount; i++) {
                for (int j = 0; j < 2; j++) {
                    cout << i << " " << j;
                    Path searchPath;
                    searchPath.vertices.push_back(edges[i].vert[j]);
                    findNewCycles(searchPath);
                }
            }
            for(int i=0; i<cycleCount; i++) {
                for(unsigned j=0; j<cycles[i].vertices.size(); j++) {
                    cout << cycles[i].vertices[j] << " ";
                }
                cout << cycles[i].totalValue;
            }
        }
};
int main() {
    int n, v1, v2;
    double val;
    bool control = true;
    cin >> n;
    Graph graph(n);
    while(control) {
        cin >> v1;
        if(v1 == -1) break;
        cin >> v2 >> val;
        control = graph.addEdge(v1, v2, val);
    }
    graph.runCycleSearch();
}