virtual methods, operator=(), operator<<(); - c++

Question

class Port
{
private:
char * brand;
char style[20]; // i.e., tawny, ruby, vintage
int bottles;
public:
Port(const char * br = "none", const char * st = "none", int b = 0);
Port(const Port & p); // copy constructor
virtual ~Port() {delete[] brand; }
Port & operator=(const Port & p);
Port & operator+=(int b); // adds b to bottles
Port & operator-=(int b); // subtracts b from bottles, if
int BottleCount() const { return bottles; }
virtual void Show() const;
friend ostream & operator<<(ostream & os, const Port & p);
};
class VintagePort : public Port // style necessarily = "vintage"
{
private:
char * nickname; // i.e., "The Noble" or "Old Velvet", etc.
int year; // vintage year
public:
VintagePort();
VintagePort(const char * br, const char *st, int b, const char * nn, int y);
VintagePort(const VintagePort & vp);
~VintagePort() { delete[]nickname;}
VintagePort & operator=(const VintagePort & vp);
virtual void Show() const;
friend ostream & operator<<(ostream & os, const VintagePort & vp);
};
I have to explain why operator=() and operator<<() are not
virtual. I think that operator<<() can't be virtual because only class methods could be, but I have no idea about operator=(). How does the pointer at basic class know which one of operator=() it has to use?
Second question is about how I can make operator<<() behave like a virtual method for example:
basicClass B;
inheritClass I;
basicClass *ptr;
ptr=&I;
std::cout << ptr // Here I'd like to use operator<<(std::ostream, inheritClass)

Answer 1

operator = is not virtual because it is not marked virtual. The declaration of operator = looks like this
//No virtual here
Port& operator =(const Port&);
If, however, operator = was virtual it would be declared like this
virtual Port& operator =(const Port&);
^^^^^^^ Virtual here!
Since operator = is not virtual the compiler uses static linkage when compiling. This means the function called is dependent on the type of the variable it is being referred to by. Consider this code:
VintagePort vp;
//Calls VintagePort::operator =(const VintagePort&)
vp = VintagePort();
Port* p = &vp;
//Calls Port::operator =(const Port&)
*p = Port();
VintagePort::operator = is called when it is being accessed as a VintagePort, however, Port::operator = is called when it is accessed as a Port. (Live example here.)
To make operator << behave as if it were virtual you would have to declare a virtual member function within your class that does the printing. Something like this
//Inside Port
virtual void Print(std::ostream& os) const
{
os << brand << ' ' << style << ' ' << bottles;
}
Then in every class that derives from Port (like VintagePort) you would override the method to also print the values for that derived class. So for VintagePort you could do this
//Inside VintagePort
void Print(std::ostream& os) const
{
//Make Port print first
Port::Print(os);
os << ' ' << nickname << ' ' << year;
}
Then in operator << all you would have to do is to call the Print method on the argument. Which would look like this:
std::ostream& operator <<(std::ostream& os, const Port& p)
{
P.Print();
return os;
}
As a plus you don't have to overload operator << for every derived the class as the overload only needs the virtual function in the Port class.

Answer 2

This has the feeling of a codereview which is not what SO is for -- but anyways:
Don't use character arrays. Use std::string:
class Port
{
private:
std::string brand;
std::string style; // i.e., tawny, ruby, vintage
//...
};
Moreover, and in general, don't use pointers where objects are appropriate. And if you need pointers, use smart pointers to clearly express the purpose.
This is the RAII principle which underpins most of C++.
If you follow the previous suggestion, there is no need to define: destructors, copy/move constructors, and -- that touches your question -- also not assignment operators. (And particularly, there is no need to overload the latter).
operator<< can't should not declared virtual, as it is not a class member. It's a stand-alone function which, due to being a friend, may have access to private members of your port wine classes.
But you can overload it outside of the class. This is what one straightforwardly does by setting up different overloads as operator<<(ostream & os, const Port & p); and operator<<(ostream & os, const VintagePort & p);.