Operator przypisania klasy pochodnej nie rusza

Witam mam problem z ta linijką

  w3=w5;

nie wiem co mam zrobić, by ruszyła. Jedyne co przychodzi mi na myśl to może zaprzyjażnić operator przypisania z klasy bazowej.

 
#include <iostream>
#include <vector>
using namespace std;
class B{

public:
   virtual ostream& Wypisz(ostream& out)const = 0;
   virtual ~B(){}
};

class P1:public B{
public:
    string* tab;     // jezeli na zwyklych tablicach to "string tab[2]" i nie trzeba przydzielac zadnych pamieci w konstruktorach.
    P1():tab(new string[2])  // jezeli zwykla tablica to tu bez new .
    {
        tab[0]= "Brak";
        tab[1]="Brak";
    }
    P1(const string& imie_,const string nazwisko_):tab(new string[2])
    {
        tab[0]=imie_;
        tab[1]=nazwisko_;
    }
    P1(const P1& ob):tab(new string[2])
    {
        tab[0]=ob.tab[0];
        tab[1]=ob.tab[1];
    }
    P1& operator=(const P1& ob)
    {
        if(this!=&ob)
        {
            delete []tab;  // tak naprawde to jest tu zbêdne, bo jest typu string
            tab = new string[2];
            tab[0]=ob.tab[0];
            tab[1]=ob.tab[1];
        }
        return *this;
    }
    friend ostream& operator << (ostream& out,const P1& ob)
    {
        return ob.Wypisz(out);
    }
    ostream& Wypisz(ostream& out)const
    {
        return out << tab[0] << " " << tab[1];
    }
    //string operator[](unsigned i)
    ~P1(){delete[]tab;}
};
class P2:public P1{
    P1* obiekt ;
public:
    P2():P1(),obiekt(new P1){}
    P2(const string& imie_,const string& nazwisko_):P1(imie_,nazwisko_),obiekt(new P1(imie_,nazwisko_))
    {
    }
    P2(const P2& ob):P1(ob),obiekt(new P1(ob))
    {
    }
    P2& operator=(const P2& ob)
    {
        if(this!=&ob)
        {
            delete obiekt;
            P1::operator=(ob);
            obiekt = new P1(*ob.obiekt);
        }
        return *this;
    }
    ostream& Wypisz(ostream& out)const
    {
        P1::Wypisz(out);
        return out <<"Wypisanie tego waszego obiektu dynamicznego(bezsensu)" << obiekt->tab[0] << obiekt->tab[1];
    }
    friend ostream& operator << (ostream& out,const P2& ob)
    {
        return  ob.Wypisz(out);
    }
    ~P2(){delete obiekt;}

};
/*S¹ 3 klasy. klasa B czysto virtualna, klasa P1 podklas¹ B i klasa P2 podklas¹ p1.
Klasa P1 posiada zmienn¹ tablicow¹ o rozmiarze 2. Klasa P2 posiada 1 zmienn¹ typu P1*/
int main()
{
    P1 w1;
    const P1 w2("Ala", "Koala");
    P2 w3;
    const P2 w4("Warszawa", "Krakow");
    const P1 w5("******", "+++++++");
    w1=w5;
    w3=w5;

    return 0;
}

"Nie rusza" bo nie zdefiniowałeś operatora= przypisującego P1 do P2.

Cały kod wywal i napisz od nowa:

1. nie kłam w komentarzach
2. nie używaj nagiego new i delete - to antyidiom w C++ (masz kontenery, smart pointery)
3. Jaki sens ma dziedziczenie po P1 i posiadanie obiektu typu P1 wewnątrz klasy?

Ale co to ma robić? Jest jakaś treść zadania?

Bo większość tego kodu jest właściwie niepotrzebna. Na przykład męczysz się z wypisywaniem do strumienia ale nigdzie nie wypisujesz.

Dostałem tylko tyle klasa B czysto virtualna, klasa P1 podklasa B i klasa P2 podklasa p1. Klasa P1 posiada zmienna tablicowa o rozmiarze 2. Klasa P2 posiada 1 zmienna typu P1 . Zakładam, że po prostu pomylili mi się podając taka treść w kazdym bądz razie dzięki za odpowiedzi :)