I'm having some issues with C++ using it with binary tests, i'm learning binary search trees, i'm getting these erros, note : i didn't code the functions, i'm first trying to compile it with random returns.
:\msys64\mingw64\bin\g++.exe -g "C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL Árvore Binária\main.cpp" -o "C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL Árvore Binária\testVpl.exe" -lgtest -std=c++20
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp: In member function 'virtual void ArvoreBinariaBuscaTest_Inicializacao_Test::TestBody()':
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp:6:49: error: invalid new-expression of abstract class type 'MinhaArvoreDeBuscaBinaria<int>'
6 | ArvoreDeBuscaBinaria<int>* const arvore{new MinhaArvoreDeBuscaBinaria<int>};
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp:2:
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\MinhaArvoreDeBuscaBinaria.hpp:14:7: note: because the following virtual functions are pure within 'MinhaArvoreDeBuscaBinaria<int>':
14 | class MinhaArvoreDeBuscaBinaria : public ArvoreDeBuscaBinaria<T>
| ^~~~~~~~~~~~~~~~~~~~~~~~~
In file included from C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\MinhaArvoreDeBuscaBinaria.hpp:4,
from C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp:2:
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\ArvoreDeBuscaBinaria.hpp:30:18: note: 'bool ArvoreDeBuscaBinaria<T>::vazia() const [with T = int]'
30 | virtual bool vazia() const = 0;
| ^~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\ArvoreDeBuscaBinaria.hpp:36:17: note: 'int ArvoreDeBuscaBinaria<T>::quantidade() const [with T = int]'
36 | virtual int quantidade() const = 0;
| ^~~~~~~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\ArvoreDeBuscaBinaria.hpp:43:18: note: 'bool ArvoreDeBuscaBinaria<T>::contem(T) const [with T = int]'
43 | virtual bool contem(T chave) const = 0;
| ^~~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\ArvoreDeBuscaBinaria.hpp:50:32: note: 'std::optional<int> ArvoreDeBuscaBinaria<T>::altura(T) const [with T = int]'
50 | virtual std::optional<int> altura(T chave) const = 0;
| ^~~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\ArvoreDeBuscaBinaria.hpp:70:30: note: 'std::optional<_Tp> ArvoreDeBuscaBinaria<T>::filhoEsquerdaDe(T) const [with T = int]'
70 | virtual std::optional<T> filhoEsquerdaDe(T chave) const = 0;
| ^~~~~~~~~~~~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\ArvoreDeBuscaBinaria.hpp:77:30: note: 'std::optional<_Tp> ArvoreDeBuscaBinaria<T>::filhoDireitaDe(T) const [with T = int]'
77 | virtual std::optional<T> filhoDireitaDe(T chave) const = 0;
| ^~~~~~~~~~~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\ArvoreDeBuscaBinaria.hpp:83:40: note: 'ListaEncadeadaAbstrata<T>* ArvoreDeBuscaBinaria<T>::emOrdem() const [with T = int]'
83 | virtual ListaEncadeadaAbstrata<T>* emOrdem() const = 0;
| ^~~~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\ArvoreDeBuscaBinaria.hpp:89:40: note: 'ListaEncadeadaAbstrata<T>* ArvoreDeBuscaBinaria<T>::preOrdem() const [with T = int]'
89 | virtual ListaEncadeadaAbstrata<T>* preOrdem() const = 0;
| ^~~~~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\ArvoreDeBuscaBinaria.hpp:95:40: note: 'ListaEncadeadaAbstrata<T>* ArvoreDeBuscaBinaria<T>::posOrdem() const [with T = int]'
95 | virtual ListaEncadeadaAbstrata<T>* posOrdem() const = 0;
| ^~~~~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp: In member function 'virtual void ArvoreBinariaBuscaTest_PreOrdem_Test::TestBody()':
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp:36:49: error: invalid new-expression of abstract class type 'MinhaArvoreDeBuscaBinaria<int>'
36 | ArvoreDeBuscaBinaria<int>* const arvore{new MinhaArvoreDeBuscaBinaria<int>};
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp: In member function 'virtual void ArvoreBinariaBuscaTest_EmOrdem_Test::TestBody()':
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp:53:49: error: invalid new-expression of abstract class type 'MinhaArvoreDeBuscaBinaria<int>'
53 | ArvoreDeBuscaBinaria<int>* const arvore{new MinhaArvoreDeBuscaBinaria<int>};
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp: In member function 'virtual void ArvoreBinariaBuscaTest_PosOrdem_Test::TestBody()':
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp:70:49: error: invalid new-expression of abstract class type 'MinhaArvoreDeBuscaBinaria<int>'
70 | ArvoreDeBuscaBinaria<int>* const arvore{new MinhaArvoreDeBuscaBinaria<int>};
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp: In member function 'virtual void ArvoreBinariaBuscaTest_Insercao_Test::TestBody()':
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp:87:49: error: invalid new-expression of abstract class type 'MinhaArvoreDeBuscaBinaria<int>'
87 | ArvoreDeBuscaBinaria<int>* const arvore{new MinhaArvoreDeBuscaBinaria<int>};
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp: In member function 'virtual void ArvoreBinariaBuscaTest_Remocao_Test::TestBody()':
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp:135:43: error: invalid new-expression of abstract class type 'MinhaArvoreDeBuscaBinaria<int>'
135 | ArvoreDeBuscaBinaria<int>* arvore{new MinhaArvoreDeBuscaBinaria<int>};
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
C:\Users\Saint\Dropbox\PC\Documents\UFSC\Estrutura de Dados\VPL �rvore Bin�ria\main.cpp:183:18: error: invalid new-expression of abstract class type 'MinhaArvoreDeBuscaBinaria<int>'
183 | arvore = new MinhaArvoreDeBuscaBinaria<int>;
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
These are my errors
these are the files
The hpp file
#define ARVORE_DE_BUSCA_BINARIA_HPP
#include "MinhaListaEncadeada.hpp"
#include <optional>
template<typename T>
struct Nodo
{
T chave;
int altura{0};
Nodo* filhoEsquerda{nullptr};
Nodo* filhoDireita{nullptr};
};
template<typename T>
class ArvoreDeBuscaBinaria
{
protected:
Nodo<T>* _raiz;
public:
ArvoreDeBuscaBinaria();
virtual ~ArvoreDeBuscaBinaria();
/**
* @brief Verifica se a arvore esta vazia
* @return Verdade se a arvore esta vazia.
*/
virtual bool vazia() const = 0;
/**
* @brief Retornar quantidade de chaves na arvore
* @return Numero natural que representa a quantidade de chaves na arvore
*/
virtual int quantidade() const = 0;
/**
* @brief Verifica se a arvore contem uma chave
* @param chave chave a ser procurada na arvore
* @return Verdade se a arvore contem a chave
*/
virtual bool contem(T chave) const = 0;
/**
* @brief Retorna a altura da (sub)arvore
* @param chave chave que é raiz da (sub)arvore cuja altura queremos. Se chave é nula, retorna a altura da arvore.
* @return Numero inteiro representando a altura da (subarvore). Se chave nao esta na arvore, retorna std::nullopt
*/
virtual std::optional<int> altura(T chave) const = 0;
/**
* @brief Insere uma chave na arvore
* @param chave chave a ser inserida
*/
virtual void inserir(T chave) = 0;
/**
* @brief Remove uma chave da arvore
* @param chave chave a removida
* @return Retorna a chave removida ou nullptr se a chave nao esta na arvore
*/
virtual void remover(T chave) = 0;
/**
* @brief Busca a chave do filho a esquerda de uma (sub)arvore
* @param chave chave da arvore que eh pai do filho a esquerda
* @return Chave do filho a esquerda. Se chave nao esta na arvore, retorna std::nullopt
*/
virtual std::optional<T> filhoEsquerdaDe(T chave) const = 0;
/**
* @brief Busca a chave do filho a direita de uma (sub)arvore
* @param chave chave da arvore que eh pai do filho a direita
* @return Chave do filho a direita. Se chave nao esta na arvore, retorna nullptr
*/
virtual std::optional<T> filhoDireitaDe(T chave) const = 0;
/**
* @brief Lista chaves visitando a arvore em ordem
* @return Lista encadeada contendo as chaves em ordem.
*/
virtual ListaEncadeadaAbstrata<T>* emOrdem() const = 0;
/**
* @brief Lista chaves visitando a arvore em pre-ordem
* @return Lista encadeada contendo as chaves em pre-ordem.
*/
virtual ListaEncadeadaAbstrata<T>* preOrdem() const = 0;
/**
* @brief Lista chaves visitando a arvore em pos-ordem
* @return Lista encadeada contendo as chaves em pos ordem.
*/
virtual ListaEncadeadaAbstrata<T>* posOrdem() const = 0;
};
template<typename T>
ArvoreDeBuscaBinaria<T>::ArvoreDeBuscaBinaria():
_raiz{} // instancia _raiz com nullptr. Equivalente a _raiz{nullptr}
{}
template<typename T>
ArvoreDeBuscaBinaria<T>::~ArvoreDeBuscaBinaria() = default; //atribui destrutor padrao do C++.
#endif
That is my file, i didn't finish to code, but everytime i try to write i keep getting the same error.
#define MINHAARVOREDEBUSCABINARIA_HPP
#include "ArvoreDeBuscaBinaria.hpp"
#include <cassert>
#include <utility>
/**
* @brief Representa uma árvore binária de busca.
*
* @tparam T O tipo de dado guardado na árvore.
*/
template<typename T>
class MinhaArvoreDeBuscaBinaria : public ArvoreDeBuscaBinaria<T>
{
bool vazia()
{
if (ArvoreDeBuscaBinaria<T>::raiz == nullptr)
{
return true;
}
else return false;
};
int quantidade()
{
return 5;
};
bool contem(T chave)
{
return true;
}
std::optional<int> altura(T chave)
{
return 5;
};
void inserir(T chave)
{
Nodo<T> * novo_nodo = new Nodo<T>();
novo_nodo->chave = chave;
novo_nodo->filhoDireita = nullptr;
novo_nodo->filhoEsquerda = nullptr;
Nodo<T>* raiz_da_arvore = ArvoreDeBuscaBinaria<T>::_raiz; //Pegando a raiz da árvore binária
if(raiz_da_arvore == NULL)
{
raiz_da_arvore = novo_nodo;
}
};
void remover(T chave)
{
};
std::optional<int> filhoEsquerdaDe(T chave)
{
return 5;
};
std::optional<int> filhoDireitaDe(T chave)
{
return 5;
};
ListaEncadeadaAbstrata<T>* emOrdem()
{
};
ListaEncadeadaAbstrata<T>* preOrdem()
{
};
ListaEncadeadaAbstrata<T>* posOrdem()
{
};
};
#endif
These are the binary tests. i should not change it.
#include "MinhaArvoreDeBuscaBinaria.hpp"
TEST(ArvoreBinariaBuscaTest, Inicializacao)
{
ArvoreDeBuscaBinaria<int>* const arvore{new MinhaArvoreDeBuscaBinaria<int>};
ASSERT_TRUE(arvore->vazia());
ASSERT_EQ(arvore->quantidade(), 0);
ASSERT_TRUE(!arvore->contem(1));
ASSERT_TRUE(!arvore->altura(1));
ASSERT_TRUE(!arvore->filhoEsquerdaDe(1));
ASSERT_TRUE(!arvore->filhoDireitaDe(1));
ListaEncadeadaAbstrata<int>* lista{arvore->emOrdem()};
ASSERT_TRUE(lista != nullptr);
ASSERT_TRUE(lista->estaVazia());
delete lista;
lista = arvore->preOrdem();
ASSERT_TRUE(lista != nullptr);
ASSERT_TRUE(lista->estaVazia());
delete lista;
lista = arvore->posOrdem();
ASSERT_TRUE(lista != nullptr);
ASSERT_TRUE(lista->estaVazia());
delete lista;
delete arvore;
}
TEST(ArvoreBinariaBuscaTest, PreOrdem)
{
ArvoreDeBuscaBinaria<int>* const arvore{new MinhaArvoreDeBuscaBinaria<int>};
for (int const e : {5, 3, 7, 2, 4, 6, 9})
arvore->inserir(e);
ListaEncadeadaAbstrata<int>* const lista{arvore->preOrdem()};
for (int const e : {5, 3, 2, 4, 7, 6, 9})
ASSERT_EQ(lista->retiraDoInicio(), e);
delete lista;
delete arvore;
}
TEST(ArvoreBinariaBuscaTest, EmOrdem)
{
ArvoreDeBuscaBinaria<int>* const arvore{new MinhaArvoreDeBuscaBinaria<int>};
for (int const e : {5, 3, 7, 2, 4, 6, 9})
arvore->inserir(e);
ListaEncadeadaAbstrata<int>* const lista{arvore->emOrdem()};
for (int const e : {2, 3, 4, 5, 6, 7, 9})
ASSERT_EQ(lista->retiraDoInicio(), e);
delete lista;
delete arvore;
}
TEST(ArvoreBinariaBuscaTest, PosOrdem)
{
ArvoreDeBuscaBinaria<int>* const arvore{new MinhaArvoreDeBuscaBinaria<int>};
for (int const e : {5, 3, 7, 2, 4, 6, 9})
arvore->inserir(e);
ListaEncadeadaAbstrata<int>* const lista{arvore->posOrdem()};
for (int const e : {2, 4, 3, 6, 9, 7, 5})
ASSERT_EQ(lista->retiraDoInicio(), e);
delete lista;
delete arvore;
}
TEST(ArvoreBinariaBuscaTest, Insercao)
{
ArvoreDeBuscaBinaria<int>* const arvore{new MinhaArvoreDeBuscaBinaria<int>};
for (int const e : {5, 3, 7, 2, 4, 6, 9})
arvore->inserir(e);
ASSERT_TRUE(!arvore->vazia());
ASSERT_EQ(arvore->quantidade(), 7);
ASSERT_TRUE(arvore->contem(5));
ASSERT_EQ(*arvore->altura(5), 2);
ASSERT_EQ(*arvore->filhoDireitaDe(5), 7);
ASSERT_EQ(*arvore->filhoEsquerdaDe(5), 3);
ASSERT_TRUE(arvore->contem(3));
ASSERT_EQ(*arvore->altura(3), 1);
ASSERT_EQ(*arvore->filhoDireitaDe(3), 4);
ASSERT_EQ(*arvore->filhoEsquerdaDe(3), 2);
ASSERT_TRUE(arvore->contem(7));
ASSERT_EQ(*arvore->altura(7), 1);
ASSERT_EQ(*arvore->filhoDireitaDe(7), 9);
ASSERT_EQ(*arvore->filhoEsquerdaDe(7), 6);
ASSERT_TRUE(arvore->contem(2));
ASSERT_EQ(*arvore->altura(2), 0);
ASSERT_TRUE(!arvore->filhoDireitaDe(2));
ASSERT_TRUE(!arvore->filhoEsquerdaDe(2));
ASSERT_TRUE(arvore->contem(4));
ASSERT_EQ(*arvore->altura(4), 0);
ASSERT_TRUE(!arvore->filhoDireitaDe(4));
ASSERT_TRUE(!arvore->filhoEsquerdaDe(4));
ASSERT_TRUE(arvore->contem(6));
ASSERT_EQ(*arvore->altura(6), 0);
ASSERT_TRUE(!arvore->filhoDireitaDe(6));
ASSERT_TRUE(!arvore->filhoEsquerdaDe(6));
ASSERT_TRUE(arvore->contem(9));
ASSERT_EQ(*arvore->altura(9), 0);
ASSERT_TRUE(!arvore->filhoDireitaDe(9));
ASSERT_TRUE(!arvore->filhoEsquerdaDe(9));
delete arvore;
}
TEST(ArvoreBinariaBuscaTest, Remocao)
{
ArvoreDeBuscaBinaria<int>* arvore{new MinhaArvoreDeBuscaBinaria<int>};
for (int const e : {5, 3, 7, 2, 4, 6, 9})
arvore->inserir(e);
//Testa remover folha
arvore->remover(9);
ASSERT_TRUE(!arvore->contem(9));
ASSERT_EQ(arvore->quantidade(), 6);
ASSERT_TRUE(!arvore->filhoDireitaDe(7));
//Testa remover folha
arvore->remover(6);
ASSERT_TRUE(!arvore->contem(6));
ASSERT_EQ(arvore->quantidade(), 5);
ASSERT_TRUE(!arvore->filhoDireitaDe(7));
ASSERT_TRUE(!arvore->filhoEsquerdaDe(7));
//Testa remover raiz
arvore->inserir(6);
arvore->inserir(9);
arvore->remover(5);
ASSERT_TRUE(!arvore->contem(5));
ASSERT_EQ(arvore->quantidade(), 6);
ASSERT_EQ(*arvore->filhoDireitaDe(6), 7);
ASSERT_EQ(*arvore->filhoEsquerdaDe(6), 3);
ASSERT_EQ(*arvore->filhoDireitaDe(7), 9);
ASSERT_TRUE(!arvore->filhoEsquerdaDe(7));
//Testa remover nodo com filhoDireita sem descendente a esquerda
arvore->inserir(5);
ASSERT_EQ(*arvore->filhoDireitaDe(4), 5);
ASSERT_EQ(*arvore->altura(6), 3);
ASSERT_EQ(*arvore->altura(4), 1);
arvore->remover(3);
ASSERT_TRUE(!arvore->contem(3));
ASSERT_EQ(arvore->quantidade(), 6);
ASSERT_EQ(*arvore->filhoEsquerdaDe(6), 4);
ASSERT_EQ(*arvore->filhoDireitaDe(6), 7);
ASSERT_EQ(*arvore->altura(6), 2);
ASSERT_EQ(*arvore->filhoDireitaDe(4), 5);
ASSERT_EQ(*arvore->filhoEsquerdaDe(4), 2);
delete arvore;
// Testa esvaziar a árvore.
arvore = new MinhaArvoreDeBuscaBinaria<int>;
for (int const e : {3, 2, 4})
arvore->inserir(e);
ASSERT_EQ(arvore->quantidade(), 3);
for (int const e : {3, 2, 4})
arvore->remover(e);
ASSERT_EQ(arvore->quantidade(), 0);
// Testa remover item não contido na árvore.
arvore->inserir(2);
ASSERT_TRUE(arvore->contem(2));
ASSERT_EQ(arvore->quantidade(), 1);
arvore->remover(3);
ASSERT_TRUE(arvore->contem(2));
ASSERT_EQ(arvore->quantidade(), 1);
delete arvore;
}
int main(int argc, char **argv)
{
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
from Recent Questions - Stack Overflow https://ift.tt/3ff5h4i
https://ift.tt/eA8V8J
No comments:
Post a Comment