[C++] Optymalizacja, wielomian, przeładowanie operatora -

Odpowiedz Nowy wątek
2009-11-08 10:21
0

Napisałem dwie wersje odejmowania wielomianów:

  • pierwsza wykorzystuje zapisane już wcześniej dodawanie
  • druga jest oddzielną funkcją, niezależną od dodawania
  1. Wielomian Wielomian::operator-(const Wielomian & w) const
    {
    Wielomian temp(w);
    
    for(int a=0; a<=w.stopien; a++)
        temp.wiel[a]*=-1;
    
    Wielomian roznica=*this+temp;
    return roznica;
    }
  2. Wielomian Wielomian::operator-(const Wielomian & w) const
    {
    int stop=stopien>=w.stopien?stopien:w.stopien;
    Wielomian roznica(stop);
    
    if(stopien>=w.stopien)
    {
    
        int u;
        for(u=0; u<=w.stopien; u++)
            roznica.wiel[u]=wiel[u]-w.wiel[u];
    
        for(; u<=stopien; u++)
            roznica.wiel[u]=wiel[u];
    }
    
    else
    {
    
        int u;
        for(u=0; u<=stopien; u++)
            roznica.wiel[u]=wiel[u]-w.wiel[u];
    
        for(; u<=w.stopien; u++)
            roznica.wiel[u]=-w.wiel[u];
    
    }
    roznica.zmniejsz_stopien();
    return roznica;
    }

Pierwszy sposób tworzy dwa tymczasowe obiekty: jeden tylko po to, żeby przemnożyć drugi wielomian przez -1. Przekazuję ten drugi jako stały [const] więc nie mogę go zmienić); jeśli dobrze rozumiem działanie tego co napisałem, to drugi jest tworzony dlatego że używam *this. Poza tym sposób jest bardzo krótki i wygodny w zapisie.

Drugi nie tworzy żadnych tymczasowych obiektów, jednak ma w sobie ifa i kilka forów - dłuższy w zapisie.

Który z nich jest lepszy? Mam na myśli ogólnie przyjęte zasady pisania programów i szybkość ich wykonywania. Działanie funkcji jest chyba jasne, wiel[] to tablica przechowująca współczynniki wielomianu.


Pozostało 580 znaków

2009-11-08 11:15
0

Ja zawsze definiuje operatory tak:

MojaKlasa& operator+=(MojaKlasa a, const & MojaKlasa b)
{
      a.zmienStopien(max(a.stopien(), b.stopien()));

      ....

      a.weryfikujSopien(); // bo najstarszy wyraz może wyjść zero
      return a;
}

MojaKlasa& operator-=(MojaKlasa a, const & MojaKlasa b)
{
      a.zmienStopien(max(a.stopien(), b.stopien()));

      ....

      a.weryfikujSopien(); // bo najstarszy wyraz może wyjść zero
      return a;
}

MojaKlasa operator+(const & MojaKlasa a, const & MojaKlasa b)
{
      MojaKlasa sum(a); // w twoim wypadku dobre by było sprawdzić tu który wielomian
                                  // ma wyższy stopień
      return sum+=b;
}

MojaKlasa operator-(const & MojaKlasa a, const & MojaKlasa b)
{
      MojaKlasa diff(a);
      return diff-=b;
}

W ten sposób oszczędzam sobie sporo pisania i testowania.


Jeśli chcesz pomocy, NIE pisz na priva, ale zadaj dobre pytanie na forum.

Pozostało 580 znaków

2009-11-13 12:01
0

Dzięki za odpowiedź. Co do funkcji zmien_stopien, to zastanawiam się jak ją napisać, skoro tworze tablice w taki sposób:

    wiel = new int[stopien+1];

Jedyne co mi teraz przychodzi na myśl to utworzenie tablicy tymczasowej, skopiowanie zawartości wiel[], zniszczenie wiel[], stworzenie nowej wiel[], przekopiowanie starych wartości i dopisanie nowych, skasowanie tymczasowej. Jest jakiś prostszy sposób?


Pozostało 580 znaków

2009-11-13 16:12
0

A po co kopiować 2 razy?

void Wielomian::zmienStopien(int nowyStopien)
{
     zastap = new int[nowyStopien+1];
     int copyCount = std::min(nowyStopien, stopien)+1;
     std::copy(wiel,wiel+copyCount, zastap );

     if(nowyStopien>stopien) {
         std::fill(zastap+copyCount,zastap+nowyStopien+1, 0);
     }

     delete [] wiel;
     wiel = zastap;
     stopien = nowyStopien;
}

Jeśli chcesz pomocy, NIE pisz na priva, ale zadaj dobre pytanie na forum.

Pozostało 580 znaków

Odpowiedz
Liczba odpowiedzi na stronę

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0