Правильный способ написать конструктор копирования и оператор присваивания - PullRequest
Новая
       29

Правильный способ написать конструктор копирования и оператор присваивания

0 голосов
/ 26 мая 2019

У меня есть структура данных, где у меня есть функция Ins (ключ, значение), которая вставляет их в структуру данных. Я пытаюсь написать конструктор копирования и оператор присваивания. Я не знаю, будет ли достаточно только этой части кода, я могу добавить и остальное. Почему-то в этом коде есть ошибка.

Проблема с Ins (temp -> m_Key, temp -> m_Val); оба раза. 

CHash(const CHash & src)
{
  m_Table = new TItem * [src.m_Size];
  TItem * temp = src.m_FirstOrder;
  while (temp != NULL)
  {
    Ins(temp -> m_Key, temp -> m_Val);
    temp = temp -> m_NextOrder;
  }
}

CHash & operator = (const CHash & src)
{
  TItem * temp = m_FirstOrder;
  while (temp != NULL)
  {
    TItem * tmp = temp;
    temp = temp -> m_NextOrder;
    delete tmp;
  }
  delete [] m_Table;

  m_Table = new TItem * [src.m_Size];
  TItem * tmp1 = src.m_FirstOrder;
  while (tmp1 != NULL)
  {
    Ins(tmp1 -> m_Key, tmp1 -> m_Val);
    tmp1 = tmp1 -> m_NextOrder;
  }
}

Я пробую это в главном и получаю segfault. 

CHash hashtable(100);
CHash hash2(50);
hash2 = hashtable;
hashtable.printAll();
hash2.printAll();
CHash b(hash2);
b.printAll();

Это полный код: 

#include <string>
#include <iostream>
#include <bits/stdc++.h>
using namespace std;

struct TItem {
    TItem(string key, string val, TItem* nextHash,TItem* nextOrd, TItem * prevOrd)
    :m_Key(key),m_Val(val),m_NextHash(nextHash),m_NextOrder(nextOrd),m_PrevOrder(prevOrd){}

    string m_Key,m_Val;
    TItem * m_NextHash, * m_NextOrder, * m_PrevOrder;
};

class CHash{
public:
    CHash (int m) : m_Table(NULL),m_Size(m),m_FirstOrder(NULL),m_LastOrder(NULL)
    {
      m_Table = new TItem * [m];
      for (int i = 0; i < m; i++)
        m_Table[i] = NULL;
    }

    ~CHash()
    {
      TItem * temp = m_FirstOrder;
      while (temp != NULL)
      {
        TItem * tmp = temp;
        temp = temp -> m_NextOrder;
        delete tmp;
      }
      delete [] m_Table;
    }

    bool IsSet(string key)
    {
      TItem * temp = m_Table[hashFn(key)];
      if (temp == NULL)
      {
        return false;
      }
      while (temp != NULL)
      {
        if (temp -> m_Key == key)
        {
          return true;
        }
        temp = temp -> m_NextHash;
      }
      return false;
    }

    CHash(const CHash & src)
    {
      m_Size = src.m_Size;
      m_Table = new TItem * [src.m_Size];
      for (int i = 0; i < src.m_Size; i++)
        m_Table[i] = NULL;
      TItem * temp = src.m_FirstOrder;
      while (temp != NULL)
      {
        Ins(temp -> m_Key, temp -> m_Val);
        temp = temp -> m_NextOrder;
      }
    }

    CHash & operator = (const CHash & src)
    {
      m_Size = src.m_Size;
      TItem * temp = m_FirstOrder;
      while (temp != NULL)
      {
        TItem * tmp = temp;
        temp = temp -> m_NextOrder;
        delete tmp;
      }
      delete [] m_Table;

      m_Table = new TItem * [src.m_Size];
      for (int i = 0; i < src.m_Size; i++)
        m_Table[i] = NULL;
      TItem * tmp1 = src.m_FirstOrder;
      while (tmp1 != NULL)
      {
        Ins(tmp1 -> m_Key, tmp1 -> m_Val);
        tmp1 = tmp1 -> m_NextOrder;
      }
    }

    bool Ins(const string & key, const string & val)
    {
      string help = key;
      if (IsSet(help))
        return false;
      //first element added ever
      if (m_FirstOrder == NULL)
      {
        TItem * tmp01 = new TItem(key, val, NULL, NULL, NULL);
        m_Table[hashFn(help)] = tmp01;
        m_FirstOrder = m_LastOrder = tmp01;
      }
      else
      {
        TItem * temp = m_Table[hashFn(help)];
        //first added to that hash
        if (temp == NULL)
        {
          TItem * tmp02 = new TItem(key, val, NULL, NULL, m_LastOrder);
          m_Table[hashFn(help)] = tmp02;
          m_LastOrder -> m_NextOrder = tmp02;
          m_LastOrder = tmp02;
        }
        else
        {
          while (temp -> m_NextHash != NULL)
          {
            temp = temp -> m_NextHash;
          }
          TItem * tmp03 = new TItem(key, val, NULL, NULL, m_LastOrder);
          temp -> m_NextHash = tmp03;
          m_LastOrder -> m_NextOrder = tmp03;
          m_LastOrder = tmp03;
        }
      }
      return true;
    }

    bool Del (const string & key)
    {
      string help = key;
      if (!IsSet(help))
        return false;

      TItem * temp = m_Table[hashFn(help)];

      if (temp == NULL)
        return false;


      while (temp != NULL)
      {
        if (temp -> m_Key == key)
          break;
        temp = temp -> m_NextHash;
      }

      if (temp == NULL)
        return false;

      if (m_FirstOrder == temp)
        m_FirstOrder = m_FirstOrder -> m_NextOrder;
      else
        temp -> m_PrevOrder -> m_NextOrder = temp -> m_NextOrder;
      if (m_LastOrder == temp)
        m_LastOrder = m_LastOrder -> m_PrevOrder;

      m_Table[hashFn(help)] = temp -> m_NextHash;
      delete temp;
      return true;
    }

    template <typename func>
    void ForEach(func f)
    {

    }
    void printAll()
    {
      cout << "PRINTING" << endl;
      TItem * temp = m_FirstOrder;
      while (temp != NULL)
      {
        cout << "  :  " << temp -> m_Val << " : ";
        temp = temp -> m_NextOrder;
      }
      cout << endl;
    }

private:
    TItem **        m_Table;
    unsigned int    m_Size;
    TItem *         m_FirstOrder, * m_LastOrder;
    unsigned int hashFn(string & str){
        std::hash<std::string> hash_fn;
        return hash_fn(str)%m_Size;
    }
};

int main(int argc, char** argv) {

    CHash hashtable(100);
    CHash hash2(50);
    hashtable.Ins("h1","car");
    assert ( !hashtable.Ins("h1","phone"));
    hashtable.Ins("h2","field");
    hashtable.Ins("h3","house");
    hashtable.Ins("h4","tree");
    hashtable.printAll();
    assert ( hashtable.Del("h3") );
    assert ( !hashtable.Ins("h4","tree") );
    assert(!hashtable.Del("h4d"));
    assert(hashtable.Del("h1"));
    assert(!hashtable.Del("h3"));
    assert(!hashtable.Del("h1"));
    hash2 = hashtable;
    hashtable.printAll();
    hash2.printAll();
    CHash b(hash2);
    b.printAll();


    hashtable.ForEach([](TItem * it ){
        cout<<it->m_Key<<" - "<<it->m_Val<<endl;
    });

    return 0;
}

Я запускаю это так: g ++ -std = c ++ 11 -g filename.cpp

1 Ответ

0 голосов
/ 26 мая 2019

Я вижу несколько проблем в вашем коде.

  1. Оператор присваивания не возвращает *this.
  2. Конструктор копирования не инициализирует m_FirstOrder и m_LastOrder.
  3. Много копий, делающих код трудным для чтения и подверженным ошибкам.

Если мы исправим проблемы, мы получим: 

class CHash{
public:
    CHash (int m)
    {
      initialize(m);
    }

    ~CHash()
    {
      finalize();
    }

    CHash(const CHash & src)
    {
      initialize(src.m_Size);
      copy(src.m_FirstOrder);
    }

    CHash & operator = (const CHash & src)
    {
      if (&src == this)
        return;
      finalize();
      initialize(src.m_Size);
      copy(src.m_FirstOrder);
      return *this;
    }

    ...

private:
    ...

    void initialize(int m)
    {
      m_Size = m;
      m_Table = new TItem * [m];
      for (int i = 0; i < m; i++)
        m_Table[i] = NULL;
      m_FirstOrder = NULL;
      m_LastOrder  = NULL;
    }

    void finalize()
    {
      TItem * temp = m_FirstOrder;
      while (temp != NULL)
      {
        TItem * tmp = temp;
        temp = temp -> m_NextOrder;
        delete tmp;
      }
      delete [] m_Table;
    }

    void copy(TItem *src)
    {
      while (src != NULL)
      {
        Ins(src -> m_Key, src -> m_Val);
        src = src -> m_NextOrder;
      }
    }
};

Интересно, почему вы не используете nullptr вместо NULL и std::vector<TItem*> вместо TItem** ...

...