"Undefined reference" error in g ++

When compiling the algorithm with g ++, I got the following problem:

  

CMakeFiles / libTest.dir / source / mainDaMalha.cpp.o: in function    CriteriosDeParada::test_method()': mainDaMalha.cpp:(.text+0x1840f): referência indefinida para CriterionDeparture :: CriterionDeparate (int,   double, std :: vector & gt ;,   std :: vector >) '   mainDaMalha.cpp: (. text + 0x18492): indefinite reference to   'Parameter Criteria :: Parameter Criteria (int, double, std :: vector>, std :: vector

     

    

) 'mainDaMalha.cpp: (. text + 0x184bc): undefined reference for CriteriodeParada::getFlagDeCriterioAtingido()' mainDaMalha.cpp:(.text+0x185b3): referência indefinida para Criteria_Parade :: getFlagCriteriaAct ()' collect2: error: ld     returned 1 exit status libTest / CMakeFiles / libTest.dir / build.make: 183:     recipe for target 'bin / Release / libTest' failed make [2]: *     [bin / Release / libTest] Error 1 CMakeFiles / Makefile2: 140: recipe for     target 'libTest / CMakeFiles / libTest.dir / all' failed make [1]: *     [libTest / CMakeFiles / libTest.dir / all] Error 2 Makefile: 83: recipe for     target 'all' failed make: *** [all] Error 2

  

Here is the main program, which is in boost library test mode:

{
#include < vector >
#include < iostream >
#include < string >
#include < iomanip >
#include "CriteriodeParada.h"

#define BOOST_TEST_MODULE TestModule

#include "Test.h"
TestCase( CriteriosDeParada )
{
    vector<double> TemperaturasAtuais1;
    vector<double> TemperaturasAtuais2;
    vector<double> TemperaturasAnteriores;
    double criterio = 1;

    TemperaturasAtuais1.push_back(300);
    TemperaturasAtuais1.push_back(301);
    TemperaturasAtuais1.push_back(302);
    TemperaturasAtuais1.push_back(303);

    TemperaturasAtuais2.push_back(304.5);
    TemperaturasAtuais2.push_back(305.6);
    TemperaturasAtuais2.push_back(307.2);
    TemperaturasAtuais2.push_back(307.7);

    TemperaturasAnteriores.push_back(305);
    TemperaturasAnteriores.push_back(306);
    TemperaturasAnteriores.push_back(307);
    TemperaturasAnteriores.push_back(308);

    for(int i=1; i<=5; i++)
    {
        bool FlagCerto;
        bool FlagErrado;
        CriteriodeParada criterioTesteCerto(i,criterio,TemperaturasAtuais2, TemperaturasAnteriores);
        CriteriodeParada criterioTesteErrado(i,criterio,TemperaturasAtuais1, TemperaturasAnteriores);
        FlagCerto = criterioTesteCerto.getFlagDeCriterioAtingido();
        checkEqual(FlagCerto, true);
        FlagErrado = criterioTesteErrado.getFlagDeCriterioAtingido();
        checkEqual(FlagErrado, false);
    }
}
}

The header file:

{
#include < vector >
#include < iostream >

using namespace std;

class CriteriodeParada
{
    public:
        CriteriodeParada(int TipodeCriterio,double CriterioDeParada,vector<double>TemperaturasAtuais,vector<double>TemperaturasAnteriores);

        bool getFlagDeCriterioAtingido();
    private:
        void maxDiferencaSimples(double CriterioDeParada,vector<double>TemperaturasAtuais, vector<double>TemperaturasAnteriores);
        void maxDiferencaRelativa(double CriterioDeParada,vector<double>TemperaturasAtuais, vector<double>TemperaturasAnteriores);
        void DiferencasQuadradasSobreNVC(double CriterioDeParada,vector<double>TemperaturasAtuais, vector<double>TemperaturasAnteriores);
        void ModulodasDiferencasSobreNVC(double CriterioDeParada,vector<double>TemperaturasAtuais, vector<double>TemperaturasAnteriores);
        void ModulodasDiferencasRelativas(double CriterioDeParada,vector<double>TemperaturasAtuais, vector<double>TemperaturasAnteriores);
        void ResiduosQuadrados();

        double ProcuraTmax(vector<double> TemperaturasAtuais);
        double ProcuraTmin(vector<double> TemperaturasAtuais);

        bool FlagDeCriterioAtingido=false;

};
}

The source file:

{
#include "CriteriodeParada.h"
#include < vector >
#include < iostream >
#include < math.h >

using namespace std;

CriteriodeParada::CriteriodeParada(int TipodeCriterio,double CriterioDeParada,vector< double >TemperaturasAtuais, vector< double >TemperaturasAnteriores)
{
    if(CriterioDeParada>0&&TemperaturasAtuais.size()==TemperaturasAnteriores.size())
    {
        if(TipodeCriterio==1)
        {
            maxDiferencaSimples(CriterioDeParada,TemperaturasAtuais,TemperaturasAnteriores);
        }
        else
        {
            if(TipodeCriterio==2)
            {
                maxDiferencaRelativa(CriterioDeParada,TemperaturasAtuais,TemperaturasAnteriores);
            }
            else
            {
                if(TipodeCriterio==3)
                {
                    DiferencasQuadradasSobreNVC(CriterioDeParada,TemperaturasAtuais,TemperaturasAnteriores);
                }
                else
                {
                    if(TipodeCriterio==4)
                    {
                        ModulodasDiferencasSobreNVC(CriterioDeParada,TemperaturasAtuais,TemperaturasAnteriores);
                    }
                    else
                    {
                        if(TipodeCriterio==5)
                        {
                            ModulodasDiferencasRelativas(CriterioDeParada,TemperaturasAtuais,TemperaturasAnteriores);
                        }
                        else
                        {
                            if(TipodeCriterio==6)
                            {
                                cout<<endl<<endl<<"Para Criterio com Residuos, setar matriz e vetores na funcao correspondente."<<endl<<endl;
                            }
                            else
                            {
                                cout<<endl<<endl<<"Problema! Tipo de criterio escolhido invalido! Escolha entre criterio 1 e 6."<<endl<<endl;
                            }
                        }
                    }
                }
            }
        }
    }
    else
    {
        cout<<endl<<endl<<"Problema! Vetores de TemperaturasAnteriores e TemperaturasAtuais com tamanhos diferentes!"<<endl<<endl;
    }
}
bool CriteriodeParada::getFlagDeCriterioAtingido()
{
    return(this->FlagDeCriterioAtingido);
}
void CriteriodeParada::maxDiferencaSimples(double CriterioDeParada,vector<double>TemperaturasAtuais, vector<double>TemperaturasAnteriores)
{
    double ErroMax;
    ErroMax = fabs(TemperaturasAtuais[0]-TemperaturasAnteriores[0]);
    for(int i = 1; i<TemperaturasAnteriores.size(); i++)
    {
        if(ErroMax<fabs(TemperaturasAtuais[i]-TemperaturasAnteriores[i]))
        {
            ErroMax = fabs(TemperaturasAtuais[i]-TemperaturasAnteriores[i]); 
        }
    }
    if(CriterioDeParada>ErroMax)
    {
        this->FlagDeCriterioAtingido=true;
    }
}
void CriteriodeParada::maxDiferencaRelativa(double CriterioDeParada,vector<double>TemperaturasAtuais, vector<double>TemperaturasAnteriores)
{
    double ErroMax;
    double Tmax;
    double Tmin;
    Tmax = ProcuraTmax(TemperaturasAtuais);
    Tmin = ProcuraTmin(TemperaturasAtuais);
    ErroMax = fabs(TemperaturasAtuais[0]-TemperaturasAnteriores[0])/(Tmax-Tmin);
    for(int i = 1; i<TemperaturasAnteriores.size(); i++)
    {
        if(ErroMax<fabs(TemperaturasAtuais[i]-TemperaturasAnteriores[i])/(Tmax-Tmin))
        {
            ErroMax = fabs(TemperaturasAtuais[i]-TemperaturasAnteriores[i])/(Tmax-Tmin);
        }
    }
    if(CriterioDeParada>ErroMax)
    {
        this->FlagDeCriterioAtingido=true;
    }
}
void CriteriodeParada::DiferencasQuadradasSobreNVC(double CriterioDeParada,vector<double>TemperaturasAtuais, vector<double>TemperaturasAnteriores)
{
    double Erro;
    double SomaDiferencasdeTemperatura = 0;
    int NVC = TemperaturasAtuais.size();
    for(int i = 0; i<TemperaturasAnteriores.size(); i++)
    {
        SomaDiferencasdeTemperatura = SomaDiferencasdeTemperatura + pow(TemperaturasAtuais[i]-TemperaturasAnteriores[i],2);
    }
    Erro = pow(SomaDiferencasdeTemperatura/NVC,0.5);
    if(CriterioDeParada>Erro)
    {
        this->FlagDeCriterioAtingido=true;
    }
}
void CriteriodeParada::ModulodasDiferencasSobreNVC(double CriterioDeParada,vector<double>TemperaturasAtuais, vector<double>TemperaturasAnteriores)
{
    double Erro;
    double SomaDiferencasdeTemperatura = 0;
    int NVC = TemperaturasAtuais.size();
    for(int i = 0; i<TemperaturasAnteriores.size(); i++)
    {
        SomaDiferencasdeTemperatura = SomaDiferencasdeTemperatura + fabs(TemperaturasAtuais[i]-TemperaturasAnteriores[i]);
    }
    Erro = SomaDiferencasdeTemperatura/NVC;
    if(CriterioDeParada>Erro)
    {
        this->FlagDeCriterioAtingido=true;
    }
}
void CriteriodeParada::ModulodasDiferencasRelativas(double CriterioDeParada,vector<double>TemperaturasAtuais, vector<double>TemperaturasAnteriores)
{
    double Erro;
    double Tmax;
    double Tmin;
    double SomaDiferencasdeTemperatura = 0;
    int NVC = TemperaturasAtuais.size();
    Tmax = ProcuraTmax(TemperaturasAtuais);
    Tmin = ProcuraTmin(TemperaturasAtuais);
    for(int i = 0; i<TemperaturasAnteriores.size(); i++)
    {
        SomaDiferencasdeTemperatura = SomaDiferencasdeTemperatura + fabs(TemperaturasAtuais[i]-TemperaturasAnteriores[i])/(Tmax-Tmin);
    }
    Erro = SomaDiferencasdeTemperatura/NVC;
    if(CriterioDeParada>Erro)
    {
        this->FlagDeCriterioAtingido=true;
    }
}
void CriteriodeParada::ResiduosQuadrados()
{

}
double CriteriodeParada::ProcuraTmax(vector<double> TemperaturasAtuais)
{
    double Tmax = TemperaturasAtuais[0];
    for(int i=1; i<TemperaturasAtuais.size(); i++)
    {
        if(TemperaturasAtuais[i]>Tmax)
        {
            Tmax = TemperaturasAtuais[i];
        }
    }
    return(Tmax);
}
double CriteriodeParada::ProcuraTmin(vector<double> TemperaturasAtuais)
{
    double Tmin = TemperaturasAtuais[0];
    for(int i=1; i<TemperaturasAtuais.size(); i++)
    {
        if(TemperaturasAtuais[i]<Tmin)
        {
            Tmin = TemperaturasAtuais[i];
        }
    }
    return(Tmin);
}
}

I could not find the error, albeit with a lot of work. Can anyone help me?