Question

我有类似的东西

class Foo {
    Bar a, b, c;

    void doStuffWithA();
    void doStuffWithB();
    void doStuffWithC();
}

而不是为每个我希望像模板之类的方法编写实现。怎么做？

干杯，德克

编辑：

我明确需要知道我用哪个变量（递归）：

class Foo {
    Bar a, b, c;
    Foo* parent;

    static void doRecursiveStuffWithA(Foo *_node) {
        if(_node->parent==NULL) {

            return;
        } else {
            doRecursiveStuffWithA(_node->parent)
        }

    }
    static void doRecursiveStuffWithB(Foo *_node) {
        if(_node->parent==NULL) {
            return;
        } else {
            doRecursiveStuffWithB(_node->parent)
        }

    }
    static void doRecursiveStuffWithC(Foo *_node) {
        if(_node->parent==NULL) {
            return;
        } else {
            doRecursiveStuffWithC(_node->parent)
        }

    }

}

EDIT2：

也许这确实可以更好地解释我的问题：

class Foo {
public:
    int a, b, c;

}

class Bar {
public:
    void doStuffWithAOfFoo(Foo *_foo);
    void doStuffWithBOfFoo(Foo *_foo);
    void doStuffWithCOfFoo(Foo *_foo);

}

我只想保持我的代码简单，而不是必须三次实现doStuffWithX ......

Answer 1

我想你想要参数......

class Foo {
    Bar a, b, c;

    void doStuffWithBar(Bar x);
}

模板用于处理各种数据类型，函数参数用于处理各种变量。

Answer 2

@Andrew White有最简单的答案。如果你想要一个可以做同样事情但有各种不同值的函数，它应该采取一个参数。

在某些情况下，我们合法地希望看起来几乎相同的不同方法，例如getFirstName()，setFirstName()，getLastName()，setLastName()。在那里，使用论据宁愿打败目的。

那里的建筑完美无缺（并且确实被广泛接受）;唯一的问题是单调输入它的单调乏味。如果您只是想避免所有额外输入，请考虑使用提供“代码模板”的集成开发环境。 Eclipse和Visual Studio（当然还有许多其他版本）都可以让你选择一个变量并单击一个按钮来为该变量生成一个getter和setter。所有的代码都没有麻烦。

Answer 3

您可以使用参考：

class Foo {
    Bar a, b, c;

    void doStuffWithBar(Bar& what)
    {
        print(what);
        bool flag = check(what);
        if (!flag)
            doStuffWithBar(what);
    }
}

您可以使用指向成员的指针：

class Foo {
    Bar a, b, c;
    typedef Bar (Foo::*PointerToBar);

    void doStuffWithBar(PointerToBar selector)
    {
        print(this->*selector);
        bool flag = check(this->*selector);
        if (!flag)
            doStuffWithBar(selector);
    }
}

后一种解决方案更灵活：您可以选择另一个对象和/或另一个继续递归的成员（指向成员的指针是模糊的，很少使用;除非您需要这种灵活性，否则不要使用它们）：

class Foo {
    Bar a, b, c;
    Foo* next;
    typedef Bar (Foo::*PointerToBar);

    void doStuffWithBar(PointerToBar selector)
    {
        print(this->*selector);
        if (next)
            next->doStuffWithBar(selector);
    }
}

Answer 4

为了扩展安德鲁的解决方案，您可能也在寻找：

void doStuffWithBar(Bar x, Bar y, Bar z);

如果你真的有BarX x，BarY y和BarZ z，那么你可能想要在你的班级重载你的成员函数

class Foo {
BarX x;
BarY y;
BarZ z;

void doStuffWithBar(BarX x);
void doStuffWithBar(BarY y);
void doStuffWithBar(BarZ z);
};

您可能也在寻找类似的东西（这是最丑陋的解决方案，我不会真的推荐它）：

void doStuffWithBar(int n)
{
    if(n==0)
          doSomethingWithX();
    else if(n==1)
          doSomethingWithY();
    else if(n==2)
          doSomethingWithZ();
}

编辑：

ReturnType Bar::doStuffWithBar(ParamA a, ParamB b);

Answer 5

代码味道 - 设计问题？这里的重复让人觉得Bar需要一种新的方法：

void Bar::doStuff(Foo &foo);

然后你需要弄清楚什么是public，private和const。

修改：您的修改会稍微改变一下。我现在真的觉得有一些方法可以改进你的设计，例如： STL容器和算法。

一种用不同变量做同样的方法

5 个答案: