С++. Перегрузка оператора.

class Vegetable
{  
protected:
    float Mass;
    int  Ripeness;
    static unsigned int count;
public:
    Vegetable(): Mass(0), Ripeness(0)
    {
        count++;
    }
    Vegetable(float m, int r): Mass(m), Ripeness(r)
    {
        count++;
    }

    ~Vegetable(void)
    {
        count--;
    }
    unsigned int GetCount();
    float GetMass();
    int SetMass(float m);
    int GetRipeness();
    int SetRipeness(int r);
    void Fertilize();
    void Print();
    Vegetable operator ++();
    Vegetable operator --();

};

unsigned int Vegetable::count=0;

unsigned int Vegetable::GetCount(){
    return count;
}


Vegetable Vegetable::operator++(){
    return Vegetable(Mass,++Ripeness);
}

Vegetable Vegetable::operator--(){
    return Vegetable(Mass,--Ripeness);
}

float Vegetable::GetMass(){
    return Mass;
}

int Vegetable::SetMass(float m){
    if(m>0){
        Mass=m;
        return 1;
    }
    else
        return 0;
}


int Vegetable::GetRipeness(){
    return Ripeness;
}

int Vegetable::SetRipeness(int r){
    if(r>0){
        Ripeness=r;
        return 1;
    }
    else
        return 0;
}

void Vegetable::Fertilize(){
    Mass+=0.1;
}

void Print(){

}

#include "vegetable.h"
#include <string.h>
class Tomato :
    public Vegetable
{
private:
    char *Type;
    char *Size;
    char *Color;
    static unsigned int tomato_count;
public:

    Tomato(){
        Mass=0;
        Ripeness=0;
        Type=new char [strlen("unknown")+1];
        Type=new char [11];
        strcpy(Type,"unknown");
        Size=new char [strlen("unknown")+1];
        Size=new char [11];
        strcpy(Size,"unknown");
        Color=new char [strlen("unknown")+1];
        Color=new char [11];
        strcpy(Color,"unknown");
        tomato_count++;
        count--;
    }
    Tomato(float m, int r, char *t, char *s, char *c)
    {
        Type=new char [strlen(t)+1];
        strcpy(Type,t);
        Size=new char [strlen(s)+1];
        strcpy(Size,s);
        Color=new char [strlen(c)+1];
        strcpy(Color,c);
        Mass=m;
        Ripeness=r;
        count--;
        tomato_count++;
    }

    ~Tomato(void)
    {
        delete Type;
        delete Size;
        delete Color;
        tomato_count--;
    }
    int SetType(char* type);
    char *GetType();
    int SetSize(char* size);
    char *GetSize();
    int SetColor(char* color);
    char *GetColor();
    unsigned int GetTomato_count();
    Tomato operator -(Tomato object);
    //void operator =(Tomato object);
};

Tomato Tomato::operator-(Tomato object){
    if(Mass>object.Mass){
        return Tomato(Mass,Ripeness,Type,Size,Color);
    }
    else {
        return object;
    }
}

/*void Tomato::operator=(Tomato object){
    Type=new char [strlen(object.Type)+1];
    strcpy(Type,object.Type);
    Color=new char [strlen(object.Color)+1];
    strcpy(Color,object.Color);
    Size=new char [strlen(object.Size)+1];
    strcpy(Size,object.Size);
    Mass=object.Mass;
    Ripeness=object.Ripeness;
}*/

unsigned int Tomato::tomato_count=0;

unsigned int Tomato::GetTomato_count(){
    return tomato_count;
}

int Tomato::SetType(char *type){
    Type=new char [strlen(type)+1];
    strcpy(Type,type);
    return 1;
}

int Tomato::SetColor(char *color){
    Color=new char [strlen(color)+1];
    strcpy(Color,color);
    return 1;
}

int Tomato::SetSize(char *size){
    Size=new char [strlen(size)+1];
    strcpy(Size,size);
    return 1;
}

char * Tomato::GetColor(){
    return Color;
}

char * Tomato::GetSize(){
    return Size;
}

char * Tomato::GetType(){
    return Type;
}