C++ 继承与重载无法编译？

Question

我正在用 C++ 制作扑克游戏，我只是想开始。 我需要能够比较“手”，看看哪一只更大、相等或更小。 所以，我现在有一个 Hand 类，并且创建了另外两个子类，分别称为 Straight 和 ThreeOfKind(稍后我将添加其余的子类)。 Hand 类有一个名为 compareTo(Hand* otherHand) 的方法，它会检查手牌排名，看看哪一个更好。此外，对于顺子和三同，当它们处于相同等级时，您可以将它们放在一起进行比较。就像顺子与顺子以及三同与三同。

我今天写了一些初始代码，我的问题是，当我尝试调用“Hand”的 compareTo(Hand* otherHand) 方法并传入 Hand、Straight 或 Three of a Kind 时，编译器会提示，因为它试图强制我使用 Straight 的 compareTo(Straight* otherStraight) 方法。所以，我应该重载，但它不起作用。

所以在继承完成后的Straight类中，我们应该有这两个方法:

int Hand::compareTo(Hand* otherHand);
int Straight::compareTo(Straight* otherStraight);

// But, if you do this, it works:
Straight myStraight1 = new Straight(7);
Straight myStraight2 = new Straight(5);
myStraight1.compareTo(myStraight2);
// This is valid...

// If you do this, then the compiler complains!
Straight myStraight3 = new Straight(10);
ThreeOfKind myTrips4 = new ThreeOfKind(3);
myStraight3.compareTo(myTrips4);
// This above line complains that you cannot convert a ThreeOfKind to a Straight
// Even though I am trying to use Hand's compareTo(Hand* otherHand) method and
// cast a Three of a Kind to a Hand object,
// it fails with the overloading!

这是所有源代码...

//////////////////////////
// C++ main header file //
//////////////////////////


#pragma once


class Hand {

private:
    int ranking;

public:
    Hand(int aRanking);
    Hand();

    int getRanking();

    int compareTo(Hand* otherHand);
};

class Straight : public Hand {

private:
    int highCard;

public:

    Straight(int aHighCard);
    Straight();

    int getHighCard();

    int compareTo(Straight* otherStraight);
};

class ThreeOfKind : public Hand {

private:
    int tripsValue;

public:

    ThreeOfKind(int aTripsValue);
    ThreeOfKind();

    int getTripsValue();

    int compareTo(ThreeOfKind* otherThreeOfKind);
};


///////////////////////////
// C++ main .cpp file... //
///////////////////////////
#include <iostream>
#include "PokerTest1.h"
using namespace std;

Hand::Hand(int aRanking) {

    this->ranking = aRanking;
}

Hand::Hand() {

    this->ranking = 0;
}

int Hand::getRanking() {
    return this->ranking;
}

int Hand::compareTo(Hand* otherHand) {

    cout << "COMPARING HANDS..." << endl;

    if (this->getRanking() < otherHand->getRanking()) {

        cout << "HANDS RETURNING -1..." << endl;

        return -1;
    }
    else if (this->getRanking() > otherHand->getRanking()) {

        cout << "HANDS RETURNING 1..." << endl;

        return 1;
    }

    cout << "HAND RANKINGS ARE EQUAL..." << endl;

    if (this->getRanking() == 4 && otherHand->getRanking() == 4) {

        cout << "HANDS ARE BOTH STRAIGHTS..." << endl;

        Straight* myStraight1 = (Straight*)this;
        Straight* myStraight2 = (Straight*)otherHand;

        cout << "COMPARING BOTH STRAIGHTS..." << endl;

        return myStraight1->compareTo(myStraight2);
    }
    else if (this->getRanking() == 3 && otherHand->getRanking() == 3) {

        cout << "HANDS ARE BOTH THREE OF A KINDS..." << endl;

        ThreeOfKind* myTrips1 = (ThreeOfKind*)this;
        ThreeOfKind* myTrips2 = (ThreeOfKind*)otherHand;

        cout << "COMPARING BOTH TRIPS..." << endl;

        return myTrips1->compareTo(myTrips2);
    }

    return 0;
}

Straight::Straight(int aHighCard) : Hand(4) {
    this->highCard = aHighCard;
}

Straight::Straight() : Hand(4) {
    this->highCard = 0;
}

int Straight::getHighCard() {
    return this->highCard;
}


int Straight::compareTo(Straight* otherStraight) {

    cout << "INSIDE STRAIGHT COMPARE TO..." << endl;

    if (this->highCard < otherStraight->highCard) {

        cout << "STRAIGHT COMPARE RETURNING -1..." << endl;

        return -1;
}
    else if (this->highCard > otherStraight->highCard) {

        cout << "STRAIGHT COMPARE RETURNING 1..." << endl;

        return 1;
    }

    cout << "STRAIGHT COMPARE RETURNING 0..." << endl;

    return 0;
}


ThreeOfKind::ThreeOfKind(int aTripsValue) : Hand(3) {
    this->tripsValue = aTripsValue;
}

ThreeOfKind::ThreeOfKind() : Hand(3) {
    this->tripsValue = 0;
}

int ThreeOfKind::getTripsValue() {
    return this->tripsValue;
}

int ThreeOfKind::compareTo(ThreeOfKind* otherThreeOfKind) {

    cout << "INSIDE STRAIGHT COMPARE TO..." << endl;

    if (this->tripsValue < otherThreeOfKind->tripsValue) {

        cout << "TRIPS COMPARE RETURNING -1..." << endl;

        return -1;
    }
    else if (this->tripsValue > otherThreeOfKind->tripsValue) {

        cout << "TRIPS COMPARE RETURNING 1..." << endl;

        return 1;
    }

    cout << "TRIPS COMPARE RETURNIN 0..." << endl;

    return 0;
}

int main()
{

    // Test the classes...
    // with Straight compared to a Three of a Kind.
    // Should try to invoke Hand::compareTo(Hand* otherHand) { ... };
    // But, instead, it try to invoke Straight::compareTo(Straight* otherStraight) { ... };

    // If you put both these methods in the Straight class (rather than using inheritence, it works)
    // If  you delete Straight::compareTo(Straight* otherStraight) { ... }, the line below compiles

    // It is just strange why it won't compile...
    Straight* myStraightA = new Straight(9); // Straight of 5, 6, 7, 8, 9
    ThreeOfKind* myTripsB = new ThreeOfKind(2); // Three of a Kind of 2, 2, 2

    cout << "Compare results..." << endl;
    cout << myStraightA->compareTo(myTripsB) << endl; // Compiler error...

    return 0;
}

此外，这里是手牌排名列表:

0 → high card
1 → pair
2 → two pair
3 → three of a kind
4 → straight
5 → flush
6 → full house
7 → quads
8 → straight flush
9 → royal flush

基本上，我在 Hand 类中有一个字段将这些排名存储为整数。只是想让你知道。

最后，这是编译器错误消息:

error C2664: 'int Straight::compareTo(Straight )': cannot convert argument 1 from 'ThreeOfKind' to 'Straight*'

Answer 1

You are trying to overload across classes.

编译器会查找 compareTo 方法，在 Straight 中找到它，而不查找 Hand。如果添加适当的 using 语句，您可以告诉它查看 Hand 的compareTo 来完成重载。

class Straight : public Hand {
private:
    int highCard;

public:
    using Hand::compareTo; // <<< HERE

    Straight(int aHighCard);
    Straight();

    int getHighCard();

    int compareTo(Straight* otherStraight);
};

我建议您使用 getRanking() 来比较不同牌型的牌，而不是这样做，并定义由子类覆盖的 getTieBreaker() 来处理同类型手型的情况。

class Hand {
public:
    int getRanking();
    // virtual causes subclass' version to be called if done from reference or pointer.
    virtual int getTieBreaker();  
};

这简化了 Hand 的比较:

int Hand::compareTo(Hand* otherHand) {
    if (this->getRanking() < otherHand->getRanking()) {
        return -1;
    }
    else if (this->getRanking() > otherHand->getRanking()) {
        return 1;
    }

    if (this->getTieBreaker() < otherHand->getTieBreaker()) {
        return -1;
    }
    else if (this->getTieBreaker() > otherHand->getTieBreaker()) {
        return 1;
    }
    return 0;
}

并且让您可以直接定义它:

class Straight : public Hand {
//...
public:
    int getHighCard();
    int getTieBreaker();
};

int Straight::getTieBreaker() {
    return this->highCard;
}