Производный класс. Перегрузка << (cout).

#include <iostream>
 
class Port
{
private:
    char * brand;   // название
    char * style;   // тип
    int bottles;    // бутылки
protected:
    const char * Brand() const {return brand;}
    const int Bottles() const {return bottles;} 
public:
    Port();
    Port(const char * br, const char * st, int b);
    Port(const Port & p);
    virtual~Port();
    Port & operator = (const Port & p);
    Port & operator += (int b);
    Port & operator -= (int b);
    int BottleCont()const {return bottles;}
    virtual void Show() const;
    friend std::ostream & operator<<(std::ostream & os, const Port & p);
};
 
class VintagePort : public Port
{
private:
    char * nickname;    // старый или новый
    int year;           // год
public:
    VintagePort();
    VintagePort(const char *br, int b, const char *nn, int y);
    VintagePort(const VintagePort & vp);
    ~VintagePort();
    VintagePort & operator= (const VintagePort & vp);
    void Show() const;
    friend std::ostream & operator<<(std::ostream & os, const VintagePort & vp);
};

#include "bor.h"
 
// методы Port
Port::Port()
{
    char *br = "none";
    brand = new char[strlen(br)+1];
    strcpy(brand,br);
    style = new char[strlen(br)+1];
    strcpy(style,br);
    bottles = 0;    
}
Port::Port(const char * br, const char * st, int b)
{
    brand = new char[strlen(br)+1];
    strcpy(brand,br);
    style = new char[strlen(st)+1];
    strcpy(style,st);
    bottles = b;    
}
Port::Port(const Port & p)
{
    brand = new char[strlen(p.brand)+1];
    strcpy(brand,p.brand);
    style = new char[strlen(p.style)+1];
    strcpy(style,p.style);
    bottles = p.bottles;
}
Port & Port::operator = (const Port & p)
{
    if(this == &p)
        return *this;
    delete [] brand;
    delete [] style;
    brand = new char[strlen(p.brand)+1];
    strcpy(brand,p.brand);
    style = new char[strlen(p.style)+1];
    strcpy(style,p.style);
    bottles = p.bottles;
 
    return *this;
}
Port & Port::operator += (int b)
{
    bottles+=b;
    return *this;
}
Port & Port::operator -= (int b)
{
    bottles-=b;
    return *this;
}
void Port::Show() const
{
    std::cout << "Brand: " << brand << std::endl;
    std::cout << "Kind: " << style << std::endl;
    std::cout << "Bottles: " << bottles;
}
std::ostream & operator<<(std::ostream & os, const Port & p)
{
    os << p.brand << ", " << p.style << ", " << p.bottles;
 
    return os;
}
 
Port::~Port() 
{
    delete [] brand; 
    delete [] style; 
}
 
// методы VintagePort
VintagePort::VintagePort():Port()
{
    nickname = new char [5];
    strcpy(nickname,"none");
    year = 0;
}
 
VintagePort::VintagePort(const char *br, int b, const char *nn, int y):Port(br,"none",b)
{
    nickname = new char[strlen(nn)+1];
    strcpy(nickname,nn);
    year = y;
}
VintagePort::VintagePort(const VintagePort & vp) : Port(vp)
{
    nickname = new char[strlen(vp.nickname)+1];
    strcpy(nickname,vp.nickname);
    year = vp.year;
}
VintagePort & VintagePort::operator= (const VintagePort & vp)
{
    if(this == &vp)
        return *this;
    Port::operator=(vp);
    delete [] nickname;
    nickname = new char[strlen(vp.nickname)+1];
    strcpy(nickname,vp.nickname);
    year = vp.year;
 
}
void VintagePort::Show() const
{
    std::cout << "Название: " << Brand() << std::endl;
    std::cout << "Kоличество бутылок: " << Bottles() << std::endl;
    std::cout << "Старое или новое: " << nickname << std::endl;
    std::cout << "Год: " << year;
}
std::ostream & operator<<(std::ostream & os, const VintagePort & vp)
{
    os << (const Port &)vp;
    os << ", " << vp.nickname << ", " << vp.year;
    return os;
}
 
VintagePort::~VintagePort() 
{
    delete [] nickname;
}

#include <iostream>
#include "bor.h"
 
const int SIZE = 2;
 
int main()
{
    setlocale (LC_ALL, "rus");
    using std::cout;
    using std::endl;
    using std::cin;
 
            char ch[40];
            char ch2[40];
            int reiting;
            int reiting2;
            int i;
 
    Port *mass [SIZE];
 
    for(i=0; i<SIZE; i++)
    {
        char letter;
        if(i!=0)
            cout << endl;
        cout << "Введите что пишем:\nPort - A, VintagePort - B, Выход - С: ";
        cin >> letter;
        if((letter<65||letter>67)&&(letter<97||letter>99))
        {i--; cin.getline(ch,40); continue;}
        cin.get();
        if(letter == 'C' || letter == 'c')
            break;
 
        switch(letter)
        {
        case 'A':
        case 'a':
            cout << "\nPort:\n";
            cout << "Введите название: ";
            cin.getline(ch,40);
            cout << "Введите тип: ";
            cin.getline(ch2,40);
            cout << "Введите количества бутылок: ";
            cin>>reiting;
 
            mass[i] = new Port(ch,ch2,reiting);
            break;
        case 'B':
        case 'b':
            cout << "\nVintagePort:\n";
            cout << "Введите название: ";
            cin.getline(ch2,40);
            cout << "Введите количество бутылок: ";
            cin >> reiting2;
            cin.get();
            cout << "Введите старый или новый: ";
            cin.getline(ch,40);
            cout << "Введите год: ";
            cin>>reiting;
 
            mass[i] = new VintagePort(ch2,reiting2,ch,reiting);
            break;
        }
    }
    
    if(i!=0)
    {
    cout << endl << endl;
    for(int i=0; i<SIZE; i++){
        mass[i]->Show();
    cout << endl << endl;
    }
 
    //cout << *(mass[0]) << endl;   // отображает Port в любом случае
 
    for(int j=0; j<SIZE; j++)
    {
        delete mass[j];
    }
    }
 
    cout << "By :)\n\n";
 
    system("pause");
    return 0;
}

Введите что пишем:
Port - A, VintagePort - B, Выход - С: A
 
Port:
Введите название: qw
Введите тип: as
Введите количества бутылок: 2
 
Введите что пишем:
Port - A, VintagePort - B, Выход - С: B
 
VintagePort:
Введите название: rt
Введите количество бутылок: 6
Введите старый или новый: n
Введите год: 1234
 
 
Brand: qw
Kind: as
Bottles: 2
 
Название: rt
Kоличество бутылок: 6
Старое или новое: n
Год: 1234
 
By :)
 
Для продолжения нажмите любую клавишу . . .

Введите что пишем:
Port - A, VintagePort - B, Выход - С: A
 
Port:
Введите название: Q
Введите тип: W
Введите количества бутылок: 11
 
Введите что пишем:
Port - A, VintagePort - B, Выход - С: B
 
VintagePort:
Введите название: A
Введите количество бутылок: 12
Введите старый или новый: n
Введите год: 34
 
 
Brand: Q
Kind: W
Bottles: 11
 
Название: A
Kоличество бутылок: 12
Старое или новое: n
Год: 34
 
Q, W, 11
By :)
 
Для продолжения нажмите любую клавишу . . .

class Base
{
public:
   virtual void Print(std::ostream& out) const
   {
      // тут имплемент печати базового класса
   }
};
 
class Derivated : public Base
{
public:
   virtual void Print(std::ostream& out) const
   {
      // тут имплемент печати производного класса
   }
};
 
std::ostream& operator << (std::ostream& out, const Base& base)
{
   // вот в таком случае если base ссылается на производный класс, то будет вызвана
   // ф-ия печати производного класса если она в нем переопределена.
   base.Print(out);
   return out;
}

cout << *(mass[1]) << endl;

...
    cout << "Ввывод Port:\n";
    cout << *(mass[0]);
    cout << "\n\nВывод VintagePort:\n";
    cout << *(mass[1]) << endl;
...

       cout << *(mass[0]) << endl; 
        mass[0]= mass[1];
        cout << *(mass[0]) << endl;  
 
 
        for(int j=0; j<SIZE_- 1; j++)
        {
                delete mass[j];
        }

std::ostream & operator<<(std::ostream & os, const Port & p)
{
        os << p.brand << ", " << p.style << ", " << p.bottles;
 
        return os;
}

         cout << *(mass[1]) << endl;

  mass[i] = new VintagePort(ch2,reiting2,ch,reiting);

#include <iostream>
 
namespace Bad
{
  class Base
  {
  };
 
  std::ostream& operator << (std::ostream& out, const Base& base)
  {
    out << "Base";
    return out;
  }
 
  class Der : public Base
  {
  };
 
  std::ostream& operator << (std::ostream& out, const Der& der)
  {
    out << "Der";
    return out;
  }
}
 
namespace Good
{
  class Base
  {
  public:
    virtual void Print(std::ostream& out) const
    {
      out << "Base";
    }
  };
 
  std::ostream& operator << (std::ostream& out, const Base& base)
  {
    base.Print(out);
    return out;
  }
 
  class Der : public Base
  {
    virtual void Print(std::ostream& out) const
    {
      out << "Der";
    }
  };
}
 
int main()
{
  {
    // Base ссылается на производный класс (считай винтажный порт.)
    // Но вызывается оператор, который определен для базового класса (считай обычный порт)
    std::cout << "Bad:" << std::endl;
    Bad::Der der;
    Bad::Base* base = &der;
    std::cout << "print: " << *base << std::endl;
  }
 
  {
    // А вот по прежнему вызывается оператор, который определен для базового класса
    // (другого даже нет), но работает все так, как и задумывалось.
    std::cout << "Good:" << std::endl;
    Good::Der der;
    Good::Base* base = &der;
    std::cout << "print: " << *base << std::endl;
  }
 
  return 0;
}

std::ostream & operator<<(std::ostream & os, const Port & p)