Przeładowanie operatora + i konstruktor

Moja klasa przedstawia wielomiany o współczynnikach całkowitych. Chcę przeładować operator + tak, aby dodawał dwa wielomiany.

Cały kod programu jest tutaj: http://pastebin.com/m5b50e209. Na forum wrzucę to, co najważniejsze. Chodzi mianowicie o sposób dodawania i miejsce w którym powinienem zainicjować tablicę przechowującą współczynniki.

Konstruktor:

Wielomian::Wielomian(const int st)
{
    stopien=st;
    il_elem=st+1;
    wiel = new int[il_elem];

    ile_obiektow++;
    cout << "Tworze nowy, licznik: " << ile_obiektow << endl;
}

Dodawanie:

Wielomian Wielomian::operator+(const Wielomian & w) const
{
    int stop, stop1;
    stop=stopien>=w.stopien?stopien:w.stopien;
    stop1=stopien>w.stopien?w.stopien:stopien;

    Wielomian suma(stop);

    if(stopien>=w.stopien)
    {
        for(int u=0; u<=stop; u++)
        {
            if(u<=stop1)
            {
                suma.wiel[u]=wiel[u]+w.wiel[u];
                cout << "Dodaje '" << wiel[u] << "' do '" << w.wiel[u] << "'" << endl;
            }
            else
                suma.wiel[u]=wiel[u];
        }
    }
    else if(w.stopien>stopien)
    {
        for(int u=0; u<=stop; u++)
        {
            if(u<=stop1)
            {
                suma.wiel[u]=wiel[u]+w.wiel[u];
                cout << "Dodaje '" << wiel[u] << "' do '" << w.wiel[u] << "'" << endl;
            }
            else
                suma.wiel[u]=w.wiel[u];
        }
    }

    return suma;
}

Po pierwsze, czy tablicę wiel[] powinienem inicjować w konstruktorze przyjmującym za argument stopień wielomianu, czy może lepiej napisać konstruktor domyślny który wszystkim wartościom przypisuje 0, a tablicę zainicjować dopiero w funkcji obsługującej dodawanie?

Po drugie, dodawanie wyglądałoby dużo prościej gdybym mógł je przeprowadzić w następujący sposób:
Mam dwa wielomiany: w1 (stopnia 4) i w2 (stopnia 6)
Pobieram który stopień jest większy, tworzę pętlę for z licznikiem od 0 do 6 i dodaje poszczególne elementy:
w1.wiel[1]+w2.wiel[1]
w1.wiel[2]+w2.wiel[2]

Jednak jaką wartość przyjmie w1.wiel[5] (współczynnik stojący przy x^5 w wielomianie stopnia 4)? Próbowałem tak zrobić wcześniej i wydawało mi się, że przyjmuje losowe wartości - w każdym razie rzadko jest to 0. Jak sprawić by element który nie istnieje przyjmował jednak wartość 0? Czy muszę pozostać przy swojej wersji, ewentualnie ją optymalizując (jest pisana na szybko).

Będę wdzięczny za rady

za dużo tych if-ów i coś pokręciłeś (przekobinowałeś), nie chce mi się tego analizować, bo za dużo if-ów, więc tak wygląda moja wersja:

Wielomian Wielomian::operator+(const Wielomian & w) const
{
      if(stopien>=w.stopien) {
           Wielomian suma(stopien);
           int i;
           for(i=0;i<=w.stopien;++i) {
               suma.wiel[i]= wiel[i] + w.wiel[i];
           }

           for(;i<=stopien;++i) {
               suma.wiel[i]= wiel[i];
           }

           return suma;
      } else {
           return w+*this; // mały trick by nie pisać za dużo :)
      }
}

Dzięki! Tricku nie znałem, dlatego robiłem na około.

A co z inicjowaniem tablicy współczynników? Lepiej zostawić je w konstruktorze, czy przenieść do funkcji przeładowania operatora?