string getShipType ()

aship a;
// code
 
cout<<" It is a "<< a.getShipType ();

------------------ classes.cpp --------------------
#include <iostream>
#include <math.h>
#include "classes.h"
#include "ships.h"
 
 
   //bool func() {    // Function returns a bool type
   //return NULL;  // NULL is converted to Boolean false
// return false;  // This statement is Boolean equivalent to the one above.
   //}
 
 
int main()
{
  bool val = false;  // Boolean variable
  bool a, b, c;
  cout<<"Sea Battle\n\n";
  cout<<"Exit program - enter x\n";
  cout<<"Please enter numbers 1 or 0 for x, y, z values to indentify ship\n";
  cout<<"\n";
  cout<<"Object can move:    ";
  cin>>a;
  cout<<"Object needs wind:  ";
  cin>>b;
  cout<<"Object may explode: ";
  cin>>c;
  cout<<"\n";
 
  if ((bool(a)==TRUE) && (bool(b)==TRUE) && (bool(c)==FALSE))
  cout<<"It's a yacht"<< endl;
  if ((bool(a)==TRUE) && (bool(b)==FALSE) && (bool(c)==FALSE))
  cout<<"It's a ship"<< endl;
  if ((bool(a)==FALSE) && (bool(b)==FALSE) && (bool(c)==TRUE))
  cout<<"It's a mine"<< endl;
  if ((bool(a)==TRUE) && (bool(b)==FALSE) && (bool(c)==TRUE))
  cout<<"It's a torpedo"<< endl;
  cout<<"\n";
 
  torpedo tt;
  char aa;
 
  tt.x(3);tt.y(5); // set start coordinates
 
  cout<<"Object can move:    "<<tt.canmove()<<"\n";
  cout<<"Object needs wind:  "<<tt.needswind()<<"\n";
  cout<<"Object may explode: "<<tt.canexplode()<<"\n";
  cout<<"x="<<tt.x()<<" y="<<tt.y()<<"\n";
 
  // test movement
 
  if (tt.canmove()) {
     tt.setspeed(2,45); // do not use yacht a while!
     }
    while (aa!='x') {
      tt.goahead(1);
      cout<<"x="<<tt.x()<<" y="<<tt.y()<<"\n";
      cin>>aa;
    };
 
}
-----------------------------------------------------
 
------------------   classes.h   --------------------
#define TRUE 1
#define FALSE 0
#define pi 3.1415
------------------------------------------------------
 
-------------------  ships.h  ------------------------ 
class aship { // class to keep common ship data
    //char[32] id;        // object id
    float fx;           // x
    float fy;           // y
    bool bcanmove;       // moveable or fixed
    bool bcanexplode;    // can explode
    bool bneedswind;     // wind-dependant ship
 
public:
    aship() {bcanmove=FALSE;bcanexplode=FALSE;bneedswind=FALSE;}
    void setparams (bool canmove,
                    bool canexplode,
                    bool needswind) {
         bcanmove = bcanmove | canmove;
         bcanexplode = bcanexplode | canexplode;
         bneedswind = bneedswind | needswind; }
    void x(float ax) { fx = ax; }
    void y(float ay) { fy = ay; }
    float x() { return fx; }
    float y() { return fy; }
    bool canmove() {return bcanmove; }
    bool canexplode() {return bcanexplode; }
    bool needswind() {return bneedswind; }
};
 
class ship : public virtual aship { // a ship class
    float fspeed; // speed by engine
    float fangle; // ship direction
public:
    void goahead(float time); // update coordinates after "time"
    void setspeed(float speed, float angle) // set speed & angle
        { fspeed = speed; fangle = angle; }
    float speed() {return fspeed; } // get speed
    float angle() {return fangle; } // get angle
    void speed(float speed) {fspeed = speed; } // set speed only
    void angle(float angle) {fangle = angle; } // set angle
    ship() ;
};
 
ship::ship() { // ship constructor
    fspeed=0; fangle=0;
    setparams(TRUE,   // can move
              FALSE,  // can explode
              FALSE); // needs wind
}
 
void ship::goahead(float time) {
    x(x()+fspeed*time*cos(fangle*pi/180));
    y(y()+fspeed*time*sin(fangle*pi/180));
}
 
class mine : public virtual aship { // static sea-mine
public:
    float explosive; // explosive on-board
    mine() { // mine constructor
    setparams(FALSE,   // can move
              TRUE,    // can explode
              FALSE);} // needs wind
};
 
 
class yacht : public virtual aship { // wind-powered ship
    bool sail;      // are sail up or down
    float dewind;   // wind speed / ship speed ratio
    float wind;     // wind speed
    float angle;    // wind angle
public:
    void sail_up()    { sail = TRUE;  } // set up sail
    void sail_down()  { sail = FALSE; } // remove sail
    bool get_sail() { return sail;  }   // is sail up?
    void goahead(float time); // update coordinates after "time"
    void setwind(float wind, float angle); // update wind params
    yacht();
};
 
yacht::yacht() { // yacht constructor
    dewind=0.5; // ratio - two times slower then wind speed
    sail=FALSE; wind=0; angle=0;
    setparams(TRUE,   // can move
              FALSE,  // can explode
              FALSE); // needs wind
}
 
void yacht::goahead(float time) {
    if (sail) {
        x(x()+wind*dewind*time*cos(angle*pi/180));
        y(y()+wind*dewind*time*sin(angle*pi/180));
    }
}
 
class torpedo : public ship, public mine { // moveable mine
 
 
};
-------------------------------------------

class Ship
{
std::String GetType() {return "Ship";}
}
 
Ship aShip;
std::cout << "This is a " <<  aShip.GetType();