[с++] Множественное наследование

[huichos]

У меня есть ромбовидное наследование. От Ship наследуются виртуально GuardShip и TransShip, а TransGuardShip наследуется от них.
Компилятор сообщает о такой ошибке: error C2250: TransGuardShip: неоднозначное наследование "TransShip *Ship::copy(void) const"
Причем если поменять строчку

class TransGuardShip : public TransShip, public GuardShip

на

class TransGuardShip : public GuardShip, public TransShip

то компилятор будет писать: error C2250: TransGuardShip: неоднозначное наследование "GuradShip *Ship::copy(void) const"

Но при этом

 virtual std::ostream& show(std::ostream &) const;
virtual std::istream& get(std::istream &);

наследуются нормально. Кто-нибудь может предложить решение этой проблемы?
PS: Понимаю, что ромбовидное наследование вещь гадкая, но по условию оно должно быть

Базовый класс Судна:

#ifndef _SHIP_H_
#define _SHIP_H_

#include "stdafx.h"
#include <iostream>
#pragma once
#include "Captain.h"

//базовый класс Судно


class Ship {	
	char *name;
	Captain cap;
	int draft;		// водоизмещение
	int maxSpeed;
	int numberOfCrew;	// кол-во экипажа
protected:
	virtual std::ostream& show(std::ostream &) const;
	virtual std::istream& get(std::istream &);
	virtual Ship* copy() const = 0;
public:
	Ship() {
		name = 0;
		draft = 0;
		maxSpeed = 0;
		numberOfCrew = 0;
	}
	friend std::ostream &operator << (std::ostream &, const Ship &);
	friend std::istream &operator >> (std::istream &, Ship &);
	Ship(char *_Name, Captain _cap, int _draft, int _maxSpeed, int _numberOfCrew);
	Captain getCap() const {return cap;}
	Captain setCap();
	char *getName() const {return name;}
	char *setName();
	int getDraft() const {return draft;}
	int setDraft();
	int getMaxSpeed() const {return maxSpeed;}
	int setMaxSpeed();
	int setMaxSpeed(int);
	int getNumberOfCrew() const {return numberOfCrew;}
	int setNumberOfCrew();
};

#endif // _SHIP_H_

Транспортный корабль:

#ifndef _TRANS_SHIP_H_
#define _TRANS_SHIP_H_

#include "stdafx.h"
#include <iostream>
#pragma once
#include "Ship.h"
#include "LawOfMotion.h"
#include "BiLineLawOfMotion.h"
#include "BiSqrLawOfMotion.h"
#include "LineLawOfMotion.h"
#include "SqrLawOfMotion.h"

class TransShip : virtual public Ship {
	LawOfMotion *pLaw;
	int weight;
protected:
	//LawOfMotion *pLaw;
	//int weight;
	virtual std::ostream& show(std::ostream &) const;
	virtual std::istream& get(std::istream &);
	virtual TransShip* copy() const;
public:
	
	TransShip():Ship() {
		weight = 0;
		pLaw = 0;
	}
	TransShip(char *_Name, Captain _cap, int _draft, int _maxSpeed, int _numberOfCrew, int _weight, LawOfMotion *law):Ship(_Name, _cap, _draft, _maxSpeed, _numberOfCrew) {
		weight = _weight;
		pLaw = law;
	}
	LawOfMotion * getLaw() const {return pLaw;}
	int getWeight() const {return weight;}
	int setWeight();
	int getCurrentSpeed(); // изменение скорости по закону
	void setLaw(LawOfMotion *);
};



#endif // _TRANS_SHIP_H_

Военный корабль:

#ifndef _GUARD_SHIP_H_
#define _GUARD_SHIP_H_
#include <iostream>
#include <vector>
#pragma once
#include "stdafx.h"
#include "Ship.h"
#include "Armament.h"

using namespace std;

class GuardShip : virtual public Ship {
	//vector<Armament>::iterator p;
	vector<Armament> arma;
protected:
	virtual std::ostream& show(std::ostream &) const;
	virtual std::istream& get(std::istream &);
	virtual GuardShip* copy() const;
public:
	GuardShip():Ship() {
		vector<Armament> arma;
	}
	GuardShip(char *_Name, Captain _cap, int _draft, int _maxSpeed, int _numberOfCrew, vector<Armament> arma_):Ship(_Name, _cap, _draft, _maxSpeed, _numberOfCrew) {
		arma = arma_;
	}
	
	void addArm(const Armament& arma);
	void removeArm(Armament &arms);
	Armament &findArm(Armament &arms);
	Armament &findArm(char*);
	void getFullInfoArm(Armament &arms);
	void setFullArm(Armament &arms);
	char* setNameArm(Armament &arms) {return findArm(arms).setName();}
	char* getNameArm(Armament &arms) {return findArm(arms).getName();}
	double getCalArm(Armament &arms) {return findArm(arms).getCal();}
	double setCalArm(Armament &arms) {return findArm(arms).setCal();}
	size_t getRangeArm(Armament &arms) {return findArm(arms).getRange();}
	size_t setRangeArm(Armament &arms) {return findArm(arms).setRange();}
	location getLocArm(Armament &arms) {return findArm(arms).getLoc();}
	location setLocArm(Armament &arms) {return findArm(arms).setLoc();}
	size_t getAmmoArm(Armament &arms) {return findArm(arms).getAmmo();}
	size_t setAmmoArm(Armament &arms) {return findArm(arms).setAmmo();}
	void shootArm(Armament &arms) {findArm(arms).shoot();}
};

#endif // _GUARD_SHIP_H_

[huichos]

Военно-транспортный кораблик:

#ifndef _TRANS_GUARD_SHIP_H_
#define _TRANS_GUARD_SHIP_H_
#pragma once

#include "stdafx.h"
#include <iostream>

#include "TransShip.h"
#include "GuardShip.h"

class TransGuardShip : public TransShip, public GuardShip {
	std::istream& get(std::istream &);								// show почему-то было 
	TransGuardShip* copy() const;
	std::ostream& show(std::ostream &) const;
public:
	TransGuardShip() : TransShip(), GuardShip(), Ship() {;}
	TransGuardShip(char *_Name, Captain _cap, int _draft, int _maxSpeed, int _numberOfCrew, int _weight, LawOfMotion *law, vector<Armament> arma_); //:  
	//GuardShip(_Name,  _cap, _draft, _maxSpeed,  _numberOfCrew,  arma_), 
	//TransShip(_Name,  _cap, _draft, _maxSpeed, _numberOfCrew,  _weight, law) {;}
	friend std::istream &operator >> (std::istream &is, TransGuardShip &ship);
	friend std::ostream &operator << (std::ostream &os, const TransGuardShip &ship);
};

#endif // _TRANS_GUARD_SHIP_H_

Проблема кроется в том, что функция copy() является чисто виртуальной?

Вот текст самой функции copy()

TransShip* TransShip::copy() const {
	return new TransShip(*this);
}

[htonasral]

Я думаю что проблема заключается в том что у вас функция copy() возвращает разные значения в классах:
в классе Ship - это указатель на Ship, в классе TransShip - это указатель на TransShip, а в классе GuardShip - указатель на GuardShip.
Поэтому компилятор думает что это разные функции и не знает какую нада перегружать.
На счет функций get и show, то они во всех классах возвращают одинаковые данные(то есть поток) и они перегружаются правильно.
Для проверки, сделайте функцию copy() например void, то есть во всех классах она должна перегружаться как void copy() и он ругаться не будет.

[huichos]

htonasral, спасибо.
Проблема была решена, путем изменения значения возвращаемых функций. Везде оставил Ship*