Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?

[C++] Lista pojedyńczo wiązana - Konstruktor przypisania i kopiujący.

Ostatnio zmodyfikowano 2012-06-01 02:00
Autor Wiadomość
Sparrow-hawk
Temat założony przez niniejszego użytkownika
[C++] Lista pojedyńczo wiązana - Konstruktor przypisania i kopiujący.
» 2012-05-30 11:42:12
Witam wszystkich.

Piszę program w C++, który ma stworzyć stos na bazie listy pojedyńczo wiązanej. Zmienna _pSzczyt zawiera adres do ostatniego odłożonego na stosie elementu.

struct Ogniwo
{
    Ogniwo(int n, Ogniwo* p): _dane(n), _p_nastepny(p){}
    int _dane;
    Ogniwo* _p_nastepny;
};

class Stos
{
    public:
    Stos(Stos const&);
    Stos& operator= (Stos const&);

    private:
    Ogniwo* _pSzczyt;
    size_t _size;
};

Oczywiście klasa Stos zawiera stosowne konstruktory w sekcji Public. Problemem stało się dla mnie utworzenie konstruktora kopiującego i przeciążenie operatora=. Co do operatora "=", rozumiem, że najpierw należy sprawdzić, czy nie przyrównuję tych samych obiektów, następnie, czy są równe. I teraz, jeśli ich długości są różne, to rozumiem, że trzeba powiększyć mniejszą listę, jeżeli występuje jako argument z lewej strony operatora. No i teraz powinienem już wpisać elementy z listy po prawej stronie operatora, do listy po lewej, ale brakło mi już koncepcji.
P-57487
Admixior
» 2012-05-31 20:37:29
Mogą być błędy pisałem bez żadnego sprawdzania kompilatorem tym bardziej debuggera (może się coś za mało usuwać lub za dużo)
C/C++
Stos & operator =( Stos const & x )
{
    if( _pSzczyt == x._pSzczyt ) return x;
   
    int rozmiar_drugiego = x.GetSize();
   
    if( _size == 0 )
    {
        _pSzczyt = new Ogniwo;
    }
    Ogniwo * help_this = _pSczyt, help_x = x._p_szczyt;
   
    //kopiowanie do pamieci ktora jest zarezerwowana
    for( int i = 0; i < _size; i++ )
    {
        help_this._dane = help_x._dane;
        help_this = help_this._p_nastepny;
        help_x = help_x._p_nastepny;
    }
   
    if( rozmiar_drugiego < _size )
    {
        //usuwanie niepotrzebnej
        Ogniwo * save;
        for( int i = rozmiar_drugiego; i < _size; i++ )
        {
            save = help_this._p_nastepny;
            help_this = help_this._p_nastepny;
            delete save; //lub inna funkcja usuwająca
        }
    }
    else
    {
        //dodawanie elementow (jesli nie bedzie potrzebne to funkcja sie nie wykona)
        for( int i = _size; i < rozmiar_drugiego; i++ )
        {
            help_this = new Ogniwo;
            help_this.dane = help_x.dane;
            help_this = help_this._p_nastepny;
            help_x = help_x._p_nastepny;
        }
    }
}
P-57558
Sparrow-hawk
Temat założony przez niniejszego użytkownika
» 2012-06-01 02:00:18
Dzięki za podpowiedz. Przyznam, że sam doszedłem do rozwiązania operatora =, w sytuacji gdy rozmiary były identyczne. Nie testowałem twojego rozwiązania, ale na jego podstawie zrobiłem swoje, które wygląda tak:

C/C++
Stos & Stos::operator =( Stos const & rhs )
{
    if( this == & rhs )
         return * this;
   
    if( rhs._size < _size )
    {
        for( size_t i = rhs._size; i < _size; ++i )
             _pSzczyt = _pSzczyt->_p_nastepny;
       
    }
   
    if( _size < rhs._size )
    {
        for( size_t i = _size; i < rhs._size; ++i )
             _pSzczyt = new Ogniwo( 0, _pSzczyt );
       
    }
   
    _size = rhs._size;
    Ogniwo * adr = _pSzczyt;
    Ogniwo * rhs_adr = rhs._pSzczyt;
   
    for( size_t i = 0; i < _size; ++i )
    {
        adr->_dane = rhs_adr->_dane;
        adr = adr->_p_nastepny;
        rhs_adr = rhs_adr->_p_nastepny;
    }
    return * this;
}


Nie wiem, czy moje rozwiązanie jest optymalne, ale z całą pewnością działa :)
Teraz już tylko kopiowanie.
P-57588
« 1 »
  Strona 1 z 1