Free(): invalid Pointer C++

Question

Guys, I don’t understand why this code doesn’t work. Do you have a problem returning Multiconjunto m in the union method? This is a university task, so I can’t use standard library and the set has to be a doubly chained cyclic list.

Main:

#include <iostream>
#include <string>

#include "multiconjunto.h"
#include "multiconjunto.cpp"

using std::cout;
using std::endl;
using std::string;
using std::to_string;

void Imprimir(Multiconjunto x) {
  if (x.vazio()) {
    cout << "{}" << endl;
  } else {
    cout << "{";
    while(x.cardinalidade() > 1){
      string e = x.elemento();
      cout << e << ", ";
      x = x - e;
    }
    cout << x.elemento() << "}" << endl;
  }
}

int main() {
  // x = {0, 0, 2, 4, 6, 8}.
  Multiconjunto x("0");
  for (int i = 0; i < 10; i += 2) {
    x = x.uniao(to_string(i));
  }
  cout << "x = ";
  Imprimir(x);
}

I think the problem is here Multiconjunto.cpp:

#include "multiconjunto.h"
#include "fila.h"
#include "fila.cpp"

#include <iostream>
using namespace std;

using std::string;

// Cria um conjunto vazio.
Multiconjunto::Multiconjunto(){
    fila_ = Fila();
    elemento_ = fila_.ponteiro_fim();
}

// Cria um conjunto unitário contendo s;
Multiconjunto::Multiconjunto(string s){
    fila_ = Fila();
    fila_.Inserir(s);
    elemento_ = fila_.ponteiro_fim();
}

// Cria um conjunto com os mesmos elementos de x;
Multiconjunto::Multiconjunto(const Multiconjunto& x){
    fila_ = Fila(x.fila());
    elemento_ = fila_.ponteiro_fim();
}

// Testa se o conjunto é vazio.
bool Multiconjunto::vazio() const{
    return fila_.vazia();
}

// Retorna a cardinalidade do conjunto.
int Multiconjunto::cardinalidade() const{

    if(fila_.vazia())
        return 0
    ;
    else
        return fila_.tamanho()
    ;
}

// Testa se s pertence ao conjunto.
bool Multiconjunto::pertence(string s) const{
    No* aux = fila_.ponteiro_fim();

    if(fila_.vazia())
        return false
    ;
    else{
        for(int i = 0; i < fila_.tamanho(); i++){
            if(aux->valor.compare(s) == 0)
                return true
            ;

            aux = aux->esquerda;
        }

        return false;
    }
}

// Retorna o número de ocorrências de s no conjunto.
int Multiconjunto::ocorrencias(string s) const{
    No* aux = fila_.ponteiro_fim();
    int counter = 0;

    if(this->pertence(s)){
        for(int i = 0; i < fila_.tamanho(); i++){
            if(aux->valor.compare(s) == 0){
                counter++;
            }

            aux = aux->esquerda;
        }
    }
    else
        return 0
    ;

    return counter;
}

// Retorna um elemento qualquer do conjunto.
// RECONDIÇÃO: o conjunto tem pelo menos um elemento.
string Multiconjunto::elemento(){

    if(fila_.vazia())
        return ""
    ;
    else{
        elemento_ = elemento_->esquerda;
        return elemento_->direita->valor;
    }
}

// Retorna a união de *this e x.
Multiconjunto Multiconjunto::uniao(const Multiconjunto& x){
    No* aux = x.fila().ponteiro_fim();
    Multiconjunto m(*this);

    for(int i = 0; i < x.fila().tamanho(); i++){

        fila_.Inserir(aux->valor);

        aux = aux->esquerda;
    }

    return m;
}

// Retorna a interseção de *this e x.
Multiconjunto Multiconjunto::intersecao(const Multiconjunto& x){
    No* aux = x.fila_.ponteiro_fim();
    Multiconjunto m;

    for(int i = 0; i < x.fila_.tamanho(); i++){
        if(this->pertence(aux->valor)){
            m.fila().Inserir(aux->valor);
        }

        aux = aux->esquerda;
    }

    return m;
}

// Retorna a diferença entre *this e x.
Multiconjunto Multiconjunto::operator-(const Multiconjunto& x){
    No* aux = fila_.ponteiro_fim();
    Multiconjunto m;

    for(int i = 0; i < fila_.tamanho(); i++){
        if(!x.pertence(aux->valor)){
            m.fila().Inserir(aux->valor);
        }

        aux = aux->esquerda;
    }

    return m;
}

// Testa se *this tem exatamente os mesmos elementos de x.
bool Multiconjunto::operator==(const Multiconjunto& x) const{
    No* aux = x.fila_.ponteiro_fim();

    for(int i = 0; i < x.fila_.tamanho(); i++){
        if(!(this->pertence(aux->valor)) || !(this->ocorrencias(aux->valor) == x.ocorrencias(aux->valor))){
            return false;
        }

        aux = aux->esquerda;
    }

    return true;
}

// Faz com que *this tenha os mesmos elementos de x.
void Multiconjunto::operator=(const Multiconjunto& x){
    fila_ = Fila(x.fila());
}

// Desaloca toda a memória alocada para o conjunto.
Multiconjunto::~Multiconjunto(){
    fila_.~Fila();
}

Fila Multiconjunto::fila() const{
    return fila_;
}

Multiconjunto. h:

#ifndef MULTICONJUNTO_H
#define MULTICONJUNTO_H

#include <string>
#include "fila.h"

using std::string;

// Implementa um conjunto com repetição de elementos.
class Multiconjunto {
 public:
  // Cria um conjunto vazio.
  Multiconjunto();

  // Cria um conjunto unitário contendo s;
  Multiconjunto(string s);

  // Cria um conjunto com os mesmos elementos de x;
  Multiconjunto(const Multiconjunto& x);

  // Testa se o conjunto é vazio.
  bool vazio() const;

  // Retorna a cardinalidade do conjunto.
  int cardinalidade() const;

  // Testa se s pertence ao conjunto.
  bool pertence(string s) const;

  // Retorna o número de ocorrências de s no conjunto.
  int ocorrencias(string s) const;

  // Retorna um elemento qualquer do conjunto.
  // RECONDIÇÃO: o cojunto tem pelo menos um elemento.
  string elemento();

  // Retorna a união de *this e x.
  Multiconjunto uniao(const Multiconjunto& x);
  Multiconjunto uniao(string s) {return uniao(Multiconjunto(s));}

  // Retorna a interseção de *this e x.
  Multiconjunto intersecao(const Multiconjunto& x);

  // Retorna a diferença entre *this e x.
  Multiconjunto operator-(const Multiconjunto& x);
  Multiconjunto operator-(string s) {return *this - Multiconjunto(s);}

  // Testa se *this tem exatamente os mesmos elementos de x.
  bool operator==(const Multiconjunto& x) const;

  // Faz com que *this tenha os mesmos elementos de x.
  void operator=(const Multiconjunto& x);

  // Desaloca toda a memória alocada para o conjunto.
  ~Multiconjunto();

  Fila fila() const;

 private:
  Fila fila_;
  No* elemento_;

  friend class Teste;
};

#endif  // MULTICONJUNTO_H

The class line I already know is right, so I’ll just put here the . h to make it more understandable what she does. queue. h:

#ifndef FILA_H
#define FILA_H

#include <string>

using std::string;

struct No{
    string valor;
    No* esquerda;
    No* direita;
};

class Fila {
 public:
  // Cria uma fila vazia.
  Fila();

  // Cria uma fila com os mesmos elementos de x (na mesma ordem).
  Fila(const Fila& x);

  // Testa se a fila está vazia.
  bool vazia() const;

  // Retorna o número de elementos na fila.
  int tamanho() const;

  // Retorna o primeiro elemento da fila.
  // PRECONDIÇÃO: A fila não pode estar vazia.
  string primeiro() const;

  // Insere um elemento no fim da fila.
  void Inserir(string s);

  // Retira o primeiro elemento da fila.
  // PRECONDIÇÃO: A fila não pode estar vazia.
  void RemoverPrimeiro();

  // Compara se *this tem os mesmos elementos que x (na mesma ordem)
  bool operator==(const Fila& x) const;

  // Faz *this ter os mesmos elementos que x (na mesma ordem).
  void operator=(const Fila& x);

  // Desaloca a memória alocada para a fila.
  ~Fila();

  No* ponteiro_fim() const;

 private:

  No* fim_;  // Ponteiro para o sentinela da lista encadeada.
  int tamanho_;  // Número de elementos na fila;

  friend class Teste;
};

#endif  // FILA_H