Question

我有一些看起来像这样的代码

class Split
{
public:
    Split(Hand *pcHand = NULL)
        : phand(pcHand), phandsplit(pcHand)
     {
     }

    int CardOne;
    int CardTwo;
    int CardThree;

    void getCardOne(Hand & phand)
    {
        CardOne = phand.SendCOneToSplit();
        std::cout << "Card One: " << CardOne << std::endl;
    }

    void getCardTwo(Hand & phandsplit)
    {
        CardTwo = phandsplit.SendCOneToSplit();
        std::cout << "Card Two: " << CardTwo << std::endl;
    }

    void getCardThree(Hand & phandsplitTwo)
    {
        CardThree = phandsplitTwo.SendCOneToSplit();
        std::cout << "Card Two: " << CardTwo << std::endl;
    }

private:
    Hand * phand;
    Hand * phandsplit;
};

我想让它成为一个函数，而不是需要添加另一个函数，它只使用同一个类的不同对象完成同样的事情。有没有办法做到这一点？如果是这样，有人能指出我正确的方向吗？

Answer 1

只需将另一个参数传递给函数，该函数告诉您要处理哪个类成员。

enum
{
    CardOne, CardTwo, CardThree, //so on....
}CardNumber;

void getCard(Hand & phandsplitTwo, CardNumber card)   
{
    if(card == CardOne)
       CardOne = phand.SendCOneToSplit();
    else if(card == CardTwo)
       CardTwo = phandsplit.SendCOneToSplit();
    else if(card == CardThree)
       CardThree = phandsplitTwo.SendCOneToSplit();
    //....
}

注意：
我不知道为什么你将你的方法命名为 getXXXXX ，它们实际上并没有返回任何内容。也许，名称应为 setXXXXXX ??

Answer 2

好吧，既然你的变量是公开的，你总是可以传入你想要操作的变量：

void getCard(Hand& hand, int& card)
{
    card = hand.SendCOneToSplit();
    std::cout << "Card: " << card << std::endl;
}

然后这样打电话：

split.getCard(hand, split.CardOne);

当然，使用公共变量可能不是一个长期的解决方案，所以另一种选择是替换：

int CardOne;
int CardTwo;
int CardThree;

有一个数组：

int cards[3];

然后只传入你想要的索引：

void getCard(Hand& hand, int ndx)
{
    cards[ndx] = hand.SendCOneToSplit();
    std::cout << "Card: " << cards[ndx] << std::endl;
}

Answer 3

如果表现令人担忧，并且有很多“卡片类型”;我会使用函数指针（即方法指针）。

void (Split::*pfGetTheCard)(Hand & phand);

// Dynamically assign it to one of those:
pfGetTheCard =  &Split::getCardTwo;

// And call it:
(cardobj.*pfGetTheCard)(); 
(pCardPtr->*pfGetTheCard)();

请注意，这可能不是合适的解决方案，因为这一切都取决于您的设计，性能和维护问题。这只是我的想法！

如何将对象的多个实例发送到一个函数中

3 个答案: