错误LNK2001：我有一个简单的Source.cpp和Graphs.h，即使Source.cpp具有`#include“ Graphs.h”`，我也会收到外部符号错误

如何解决错误LNK2001：我有一个简单的Source.cpp和Graphs.h，即使Source.cpp具有`#include“ Graphs.h”`，我也会收到外部符号错误

我有一个非常基本的Graphs算法程序，带有.cpp和标头。所有必需品都在那。我正在使用Visual Studio 2019 16.7.1 Windows 10 2004和Release x64且已启用多核（是/ Mp）。 我想念什么吗？我需要下载/安装任何东西吗？更改项目属性？我在黑暗中摸索着……

Source.cpp

#include <iostream>
#include <fstream>
#include <sstream>
#include "Grafos.h"

using namespace std;

int main()
{
    //+++++Matriz-Lista Adyacencia+++++
    //+++++Prim+++++
    //Ejes de salida del nodo:<costo,nodo_adyacente>

    cout << "Main: " << endl;
    Grafos grafoCiudades;
    cout << "grafoCiudades: " << endl;
    Grafos::v_par_ints desdeSJ = { {5,23},{9,45} };
    cout << "desdeSJ: " << endl;
    Grafos::v_par_ints desdeC = { {5,12},{12,45} };
    cout << "desdeC: " << endl;
    Grafos::v_par_ints desdeAlj = { {9,23} };
    cout << "desdeAlj: " << endl;

    int cant_nodos = 3; //Nodos SJ (12),Cartago (23) y Alajuela (45)
    cout << "cant_nodos: " << endl;

    vector<Grafos::v_par_ints> grafoPRIM;
    cout << "grafoPRIM: " << endl;
    grafoPRIM.resize(cant_nodos);
    cout << "grafoPRIM.resize(cant_nodos): " << endl;

    grafoPRIM[0] = desdeSJ;
    cout << "grafoPRIM[0] = desdeSJ: " << endl;
    grafoPRIM[1] = desdeC;
    cout << "grafoPRIM[1] = desdeC: " << endl;
    grafoPRIM[2] = desdeAlj;
    cout << "grafoPRIM[2] = desdeAlj: " << endl;

    //Agrega nodos al AEM (raiz SJ)
    cout << "Costo del Prim AEM: " << grafoCiudades.Grafos::PrimAEM(0,grafoPRIM) << endl;
    cin.get();

    //+++++Kruskal+++++
    //+++++Dijkstra+++++
    //+++++Ptos. de Articulacion+++++

    return 0;
}

Grafos.h

#pragma once
#include <queue>
#include <vector>
#include <algorithm>

using namespace std;

class Eje {
public:
    int nodo_origen = 0;
    int nodo_final = 0;
    int costo = 0;
    Eje() {}
    Eje(int nodo_rev1,int nodo_rev2,int costo_eje) : nodo_origen(nodo_rev1),nodo_final(nodo_rev2),costo(costo_eje) {}
};

class Grafos {
public:
    typedef pair<int,int> par_ints;
    typedef vector<par_ints> v_par_ints;
    int cant_nodos = 0;
    vector <Eje> lista_ejes;
    vector <int> padre;
    vector <int> rango;

    Grafos() {}

    Grafos(int cant_nodos) {
        this->cant_nodos = cant_nodos;
        padre.resize(cant_nodos);
        rango.resize(cant_nodos);
    }

    int ListaAdyacencia();
    void AgregaEjes(Eje eje);
    int EncuentraPadre(int nodo);
    void KruskalAEM(vector<Eje>&);
    int PrimAEM(int nodoRaiz,vector<v_par_ints>& grafo);

    int Dijkstra();
    int PuntosArticulacion();
};

bool ComparaCosto(const Eje x,const Eje y) {
    return x.costo < y.costo;
}

int Grafos::ListaAdyacencia()
{
    return 0;
}

void Grafos::AgregaEjes(Eje eje) {
    lista_ejes.push_back(eje);
}

int Grafos::EncuentraPadre(int nodo) {
    if (padre[nodo] == nodo)
        return nodo;
    else
        EncuentraPadre(padre[nodo]);
}

void Grafos::KruskalAEM(vector<Eje>& result) {
    for (int i = 0; i < cant_nodos; i++) {
        padre[i] = i;
        rango[i] = 0;
    }
    sort(lista_ejes.begin(),lista_ejes.end(),ComparaCosto);

    for (auto& e : lista_ejes) {
        int raiz1 = EncuentraPadre(e.nodo_origen);
        int raiz2 = EncuentraPadre(e.nodo_final);

        if (raiz1 != raiz2) {
            result.push_back(e);
            if (rango[raiz1] < rango[raiz2]) {
                padre[raiz1] = raiz2;
                rango[raiz2]++;
            }
            else {
                padre[raiz2] = raiz1;
                rango[raiz1]++;
            }
        }
    }
}

int Grafos::PrimAEM(int nodoRaiz,vector<v_par_ints>& grafo)
{
    //priority_queue guarda el pair<peso,nodo>
    priority_queue<par_ints,vector<par_ints>,greater<par_ints>> q;
    //q es el nombre de toda esta variable std tipo queue

    //El costo de un nodo raiz al mismo es 0
    q.push(make_pair(0,nodoRaiz));

    //Codigo relativamente complicado de entender.
    //Determina el tamaño de memoria para alocar para el bool agregado
    //que determina si el nodo fue agregado o no al AEM
    bool* agregado = (bool*)::operator new(sizeof * agregado * grafo.size());
    //memset(agregado,false,sizeof(bool) * grafo.size());
    int costoAEM = 0;

    while (!q.empty()) {
        //Selecciona el par <costo,nodo> con el menor costo
        par_ints par;
        par = q.top();
        q.pop();

        int costo = par.first;
        int nodo = par.second;

        //Si el nodo es un nodo agregado al AEM entonces agregue
        //e incremente el costo.
        if (agregado != NULL) {
            if (!agregado[nodo]) {
                costoAEM += costo;
                agregado[nodo] = true;

                //Itera
                for (auto& par_costo_nodo : grafo[nodo]) {
                    int nodo_adyacente = par_costo_nodo.second;
                    if (agregado[nodo_adyacente] == false) {
                        q.push(par_costo_nodo);
                    }
                }
            }
        }
    }
    ::operator delete(agregado);
    return costoAEM;
}

int Grafos::Dijkstra()
{
    return 0;
}

int Grafos::PuntosArticulacion()
{
    return 0;
}

输出：

1>Source.obj : error LNK2001: unresolved external symbol __CxxFrameHandler4
1>Source.obj : error LNK2001: unresolved external symbol __std_exception_destroy
1>MSVCRT.lib(throw_bad_alloc.obj) : error LNK2001: unresolved external symbol __std_exception_destroy
1>Source.obj : error LNK2001: unresolved external symbol __std_exception_copy
1>MSVCRT.lib(throw_bad_alloc.obj) : error LNK2001: unresolved external symbol __std_exception_copy
1>Source.obj : error LNK2001: unresolved external symbol __std_terminate
1>Source.obj : error LNK2001: unresolved external symbol __imp__invalid_parameter_noinfo_noreturn
1>MSVCRT.lib(new_scalar.obj) : error LNK2001: unresolved external symbol _callnewh
1>MSVCRT.lib(new_scalar.obj) : error LNK2001: unresolved external symbol malloc
1>MSVCRT.lib(delete_scalar.obj) : error LNK2001: unresolved external symbol free
1>MSVCRT.lib(throw_bad_alloc.obj) : error LNK2001: unresolved external symbol _CxxThrowException