使用GDB的C ++中的分段错误

Question

我用C ++创建了一个程序，在构建和运行$程序时出现了段错误（记录的核心映像），我使用GDB $进行了调试，并返回了以下信息：

$＃0 in std :: vector> :: size（this = $ 0x555555a3b6c8）at / usr / include / c ++ // bits / stl_vector.h：671

$＃1在Grafo ::匹配（this = 0x7fffffffde20） $ at src / matching.cpp：29

$＃2在main（）中的src / main.cpp：18

匹配：

   #include "../headers/grafo.h"
   #include <vector>
   #include <utility>


using namespace std;

int soma(vector<int>& vetor){
int soma=0;
for(int i=0; i<(int)vetor.size(); i++){
    soma += vetor[i];
}
return soma;
   }

vector<pair<int, int> > Grafo::matching(){

vector<int> escola(this->escolas.size(), -1);
vector<pair<int, int> > pares(this->escolas.size());
int esc_atual = 0, qtd_pares = 0;

while(qtd_pares < 70){

    for(int i=0; i<(int)profs.size(); i++ ){
        if(profs[i].empregado) continue;

        for(int j=0; j<=4; j++){
            esc_atual = this->profs[i].preferencia[j];

            if(this->escolas[*esc_atual].vagas.size() == 2){
                if(escola[esc_atual] < 1){
                    if(pares[esc_atual].first == 0 && this->escolas[esc_atual].vagas[0] <= this->profs[i].habilitacoes){
                        profs[i].empregado = true;
                        escola[esc_atual]++;
                        pares[esc_atual].first = i+1;
                        qtd_pares++;
                        break;
                    }else if(pares[esc_atual].second == 0 && this->escolas[esc_atual].vagas[1] <= this->profs[i].habilitacoes){
                        profs[i].empregado = true;
                        escola[esc_atual]++;
                        pares[esc_atual].second = i+1;
                        qtd_pares++;
                        break;
                    }
                }else if(escola[esc_atual] == 1){
                    if(this->escolas[esc_atual].vagas[0] <= this->profs[i].habilitacoes && this->profs[pares[esc_atual].first].habilitacoes < this->profs[i].habilitacoes){//vendo se é mais qualificado doq o prof atual da primeira vaga
                        profs[pares[esc_atual].first].empregado = false;
                        pares[esc_atual].first = i+1;
                        profs[i].empregado = true;
                        //cout << "caso duas vagas, nenhuma livre mas trocou primeira" << endl<< endl << endl;
                        //cout << "pares[esc_atual].first depois: " << pares[esc_atual].first << endl << "pares[esc_atual].second depois: " << pares[esc_atual].second << endl;
                        break;
                    }else if(this->escolas[esc_atual].vagas[1] <= this->profs[i].habilitacoes && this->profs[pares[esc_atual].second].habilitacoes < this->profs[i].habilitacoes){//vendo se é mais qualificado doq o prof atual da segunda vaga
                        profs[pares[esc_atual].second].empregado = false;
                        pares[esc_atual].second = i+1;
                        profs[i].empregado = true;
                        //cout << "caso duas vagas, nenhuma livre mas trocou segunda" << endl<< endl << endl;
                        //cout << "pares[esc_atual].first depois: " << pares[esc_atual].first << endl << "pares[esc_atual].second depois: " << pares[esc_atual].second << endl;
                        break;
                    }
                }
            }else if(this->escolas[esc_atual].vagas.size() == 1){//caso só tenha uma vaga, não necessariamente livre
                if(escola[esc_atual] < 1){//caso ela esteja livre
                    if(this->escolas[esc_atual].vagas[0] <= this->profs[i].habilitacoes){//caso eu seja capacitado pra essa vaga
                        profs[i].empregado = true;
                        escola[esc_atual]++;
                        escola[esc_atual]++;//incrementar 2x pois -1 == totalmente vazia, 0 == uma vaga preenchida e 1 == totalmente preenchida. por ter só uma vaga, ao se preencher já está totalmente preenchida
                        qtd_pares++;
                        pares[esc_atual].first = i+1;
                        //cout << "caso só uma vaga, ela livre" << endl<< endl << endl;
                        //cout << "pares[esc_atual].first depois: " << pares[esc_atual].first << endl << "pares[esc_atual].second depois: " << pares[esc_atual].second << endl;
                        break;
                    }
                }else if(escola[esc_atual] == 1){//caso ela não esteja livre
                    if(this->escolas[esc_atual].vagas[0] <= this->profs[i].habilitacoes && this->profs[pares[esc_atual].first].habilitacoes < this->profs[i].habilitacoes){//vendo se é mais qualificado doq o prof atual da vaga
                        profs[pares[esc_atual].first].empregado = false;
                        pares[esc_atual].first = i+1;
                        profs[i].empregado = true;
                        //cout << "caso só uma vaga ocupada, mas trocou" << endl<< endl << endl;
                        //cout << "pares[esc_atual].first depois: " << pares[esc_atual].first << endl << "pares[esc_atual].second depois: " << pares[esc_atual].second << endl;
                        break;
                    }
                }
            }
        }
    }
}
return pares;
}

主要：

#include "../headers/grafo.h"
#include "../headers/vertice.h"
#include "../headers/lerArquivo.h"
#include "../headers/matching.h"
#include <iostream>
#include <vector>
#include <utility>

using namespace std;

int main() {
    Grafo grafo;

    lerArquivo(grafo, "entradaProj3TAG.txt");
    cout << grafo << endl;

    vector<pair<int, int> > pares = grafo.matching();

    for(int i=0; i<(int)pares.size(); i++){
        cout << "escola " << i+1 << " contratou professor " << 
pares[i+1].first << " pra vaga 1";
        if(pares[i+1].second != 0){
            cout << " e professor " << pares[i+1].second << " pra     vaga 
    2";
       }
        cout << endl;
   }

   return 0;
    }

图：

#include "../headers/grafo.h"
#include <vector>
#include <exception>
#include <iterator>
#include <iostream>

using namespace std;

Grafo::Grafo(){}

void Grafo::addVertice(Escola e) {
    if (!existeEscola(e.id))
        escolas.push_back(e);
    else
        cout << "Escola [E"<< e.id <<"] já existe no grafo.";   
}

void Grafo::addVertice(Professor p) {
    if (!existeProf(p.id))
        profs.push_back(p);
    else
        cout << "Professor [P"<< p.id <<"] já existe no grafo.";
}

bool Grafo::existeEscola(int id) {
    vector<Escola>::iterator it;
    for (it = escolas.begin(); it != escolas.end(); it++)
        if((*it).id == id)
            return true;

    return false;
}

bool Grafo::existeProf(int id) {
    vector<Professor>::iterator it;
    for (it = profs.begin(); it != profs.end(); it++)
        if((*it).id == id)
            return true;

    return false;
}

    Vertice& Grafo::findEscola(int id) {
    vector<Escola>::iterator it;
    for (it = escolas.begin(); it != escolas.end(); it++)
        if((*it).id == id)
            return *it;

    throw "Argumento invalido."; 
}

Vertice& Grafo::findProf(int id) {
    vector<Professor>::iterator it;
    for (it = profs.begin(); it != profs.end(); it++)
        if((*it).id == id)
            return *it;

    throw "Argumento invalido."; 
}

bool Grafo::existeAresta(int id_esc, int id_prof) {
    Vertice* v1 = &findEscola(id_esc);
    Vertice* v2 = &findProf(id_prof);

    return (v1->existeAresta(v2));
}

void Grafo::addAresta(int id_esc, int id_prof) {
    Vertice* v1 = &findEscola(id_esc);
    Vertice* v2 = &findProf(id_prof);
    v1->push_back(v2);
    v2->push_back(v1);
}

void Grafo::removeAresta(int id_esc, int id_prof) {
    if (existeAresta(id_esc, id_prof)) {
        Vertice* v1 = &findEscola(id_esc);
        Vertice* v2 = &findProf(id_prof);
        v1->removeAresta(v2);
        v2->removeAresta(v1);
    }
    else cout << "Aresta ("<< id_esc <<", "<< id_prof << ") não     existe." << endl;
}

ostream& operator <<(ostream& os, const Grafo& grafo) {
    os << "\nESCOLAS:\n";
    for(const Escola& v: grafo.escolas)
        os << v;

    os << "\nPROFESSORES:\n";
    for(const Professor& v: grafo.profs)
        os << v;

    os << endl;
    return os;
}

Matching.H

#ifndef _matching_
#define _matching_

#include "../headers/grafo.h"
#include <bits/stdc++.h>

using namespace std;

vector<pair<int, int> > matching(Grafo& grafo);
int soma(vector<int>& vetor);

#endif

Grafos.H

#ifndef _GRAFO_H_
#define _GRAFO_H_

#include "vertice.h"
#include <vector>
#include <iostream>

using namespace std;


class Grafo {
public:
    vector<Escola> escolas;
    vector<Professor> profs;

    Grafo();

    void addVertice(Escola v);

    void addVertice(Professor v);


    bool existeEscola(int id);


    bool existeProf(int id);

    Vertice& findEscola(int id);

    Vertice& findProf(int id);


    bool existeAresta(int id_esc, int id_prof);


    void addAresta(int id_esc, int id_prof);


    void removeAresta(int id_esc, int id_prof);

    vector< pair<int,int> > matching();


    friend ostream& operator <<(ostream& os, const Grafo& grafo);

};
#endif