Find neighbor faces of selected face

Question

I'm trying to make an algorithm to find the neighbor faces of a selected face.

This is what I have so far that is not working:

vector<Face *> Face::DeterminarFacesVizinhas(vector<Face *> Faces){
    vector<Face *> Lista = {};
    bool flag = false;
    //cout << "\n" << endl;
    for (size_t x = 0; x < ReturnVertices().size(); x++)
        for (size_t i = 0; i < Faces.size(); i++)
            for (size_t j = 0; j < Faces[i]->ReturnVertices().size(); j++){
                if (Utils::CompararVertice(Faces[i]->ReturnVertices()[j], ReturnVertices()[x])) {
                    for (size_t v = 0; v < Lista.size(); v++)
                        if(Lista[v]->FaceID==Faces[i]->FaceID)
                            flag=true;
                    if(!flag)
                        Lista.push_back(Faces[i]);
                }

            }

    return Lista;
}

The output for a cube (quadrilateral faces instead of triangles) should me 4 in each face, but for some reason I get this (for loop):

vector<Face *> ListaFacesVizinhas = ModeloSG->ReturnFaces()[i]->DeterminarFacesVizinhas(ModeloSG->ReturnFaces());

sizeof(ListaFacesVizinhas) = 3
sizeof(ListaFacesVizinhas) = 3
sizeof(ListaFacesVizinhas) = 4
sizeof(ListaFacesVizinhas) = 4
sizeof(ListaFacesVizinhas) = 4
sizeof(ListaFacesVizinhas) = 4

I must compare the faces by vertices (each face has 4 vertices, each vertex is used by 2 other faces). If the face is already on the list it shall not be duplicated.

The work is using wavefront .obj files.

This is the code as it is (it's not finished yet): https://github.com/Karbust/Processing-Models-Generated-on-Blender/

Can someone point me in the right direction? I don't know what else to do...

Minimal Reproducible Example:

#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <vector>
#include <list>

using namespace std;


class Vertice {
private:
    float VerticeX, VerticeY, VerticeZ;
public:
    Vertice(float VertexX, float VertexY, float VertexZ) {
        VerticeX = VertexX;
        VerticeY = VertexY;
        VerticeZ = VertexZ;
    }
    float ReturnVX() { return VerticeX; };
    float ReturnVY() { return VerticeY; };
    float ReturnVZ() { return VerticeZ; };
    float ProdInterno(Vertice *V) const { return (VerticeX * V->ReturnVX()) + (VerticeY * V->ReturnVY()) + (VerticeZ * V->ReturnVZ()); }
};

class Utils {
public:
    bool CompararVertice(Vertice * V1, Vertice * V2) {
        return V1->ReturnVX() == V2->ReturnVX() && V1->ReturnVY() == V2->ReturnVY() && V1->ReturnVZ() == V2->ReturnVZ();
    }
};

class Face {
private:
    int FaceID{};
    vector<int> VerticeID;
    vector<Vertice *> Vertices;
public:
    vector<Face *> DeterminarFacesVizinhas(const vector<Face *>& Faces){
        vector<Face *> Lista = {};
        bool flag = false;
        Utils *U;
        for (size_t x = 0; x < ReturnVertices().size(); x++)
            for (size_t i = 0; i < Faces.size(); i++)
                for (size_t j = 0; j < Faces[i]->ReturnVertices().size(); j++){
                    if (U->CompararVertice(Faces[i]->ReturnVertices()[j], ReturnVertices()[x])) {
                        for (size_t v = 0; v < Lista.size(); v++)
                            if(Lista[v]->FaceID==Faces[i]->FaceID)
                                flag=true;
                        if(!flag)
                            Lista.push_back(Faces[i]);
                    }

                }

        return Lista;
    }
    void Add(int fID, int vID, Vertice *V){
        FaceID = fID;
        VerticeID.push_back(vID);
        Vertices.push_back(V);
    }
    int ReturnfID() { return FaceID; };
    vector<int> ReturnvID() { return VerticeID; };
    vector<Vertice *> ReturnVertices() { return Vertices; };
};

class Modelo {
private:
    string Nome;
    vector<Vertice *> Vertices;
    vector<Face *> Faces;
    Face *FaceMaiorCurvatura;

    void AddValueVertices(float VertexX, float VertexY, float VertexZ) {
        Vertices.push_back(new Vertice(VertexX, VertexY, VertexZ));
    }
public:
    Modelo(const string &fich){
        ifstream objeto (fich);

        if(objeto.fail())
            throw exception();

        string line, temp, v;
        int i = 0, w = 1;
        float VertexX = 0.0f, VertexY = 0.0f, VertexZ = 0.0f;

        while(!objeto.eof()){
            getline (objeto,line);
            if (line[0] == 'v'){
                istringstream iss(line);
                iss >> v >> VertexX >> VertexY >> VertexZ;
                AddValueVertices(VertexX, VertexY, VertexZ);
            }
            else if(line[0] == 'f'){
                istringstream iss(line);
                Face *novaFace = new Face();
                i = 0;
                while(iss >> temp){
                    if(i != 0)
                        novaFace->Add(w, stoi(temp), Vertices[stoi(temp)-1]);
                    i++;
                }

                temp.clear();            

                Faces.push_back(novaFace);

                w++;
            }
        }

        Nome = fich;
    }
    string ReturnNome() { return Nome; };    
    vector<Vertice *> ReturnVertices() { return Vertices; };
    vector<Face *> ReturnFaces() { return Faces; };    
    Face *ReturnFaceMaiorCurvatura() { return FaceMaiorCurvatura; };
};

class SGestao {
private:
    Modelo *ModeloSG;
public:
    Face *FaceMaiorCurvatura() {

        for(size_t i = 0; i < ModeloSG->ReturnFaces().size(); i++){
            vector<Face *> ListaFacesVizinhas = ModeloSG->ReturnFaces()[i]->DeterminarFacesVizinhas(ModeloSG->ReturnFaces());
            cout << "ListaFacesVizinhas = " << ListaFacesVizinhas.size() << endl;
        }

        Face *temp = ModeloSG->ReturnFaceMaiorCurvatura();

        return ModeloSG->ReturnFaces()[1];
    }

    void Load(const string &fich){
        auto *newModelo = new Modelo(fich);
        ModeloSG = newModelo;
    }
};


int main()
{
    auto *SG = new SGestao();
    SG->Load("cubo.obj");

    SG->FaceMaiorCurvatura();
}

cubo.obj:

# Blender v2.66 (sub 1) OBJ File: ''
# www.blender.org
mtllib cubo.mtl
o Cube.001
v -2.798875 4.114415 -0.012605
v -2.798875 4.114417 -8.241435
v 5.429955 4.114417 -8.241435
v 5.429954 4.114415 -0.012604
v -2.798877 -4.114415 -0.012609
v 5.429955 -4.114415 -0.012607
v 5.429956 -4.114414 -8.241436
v -2.798873 -4.114414 -8.241440
usemtl Material.001
s off
f 1 2 3 4
f 5 6 7 8
f 1 5 8 2
f 2 8 7 3
f 3 7 6 4
f 5 1 4 6

Thank you