一种对不同变量做相同的方法

One method for doing the same with different variables

本文关键字：变量 方法 一种      更新时间：2023-10-16

我也有类似的东西

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三次…

我想你需要参数…

class Foo {
    Bar a, b, c;
    void doStuffWithBar(Bar x);
}

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

@Andrew White给出了最简单的答案。如果你想要一个函数可以做同样的事情，但有不同的值，它应该接受一个参数。

在某些情况下，我们合理地希望不同的方法看起来几乎相同，如getFirstName(), setFirstName(), getLastName(), setLastName()。在这种情况下，使用实参反而会破坏目的。

那里的架构非常健全(并且确实被广泛接受);唯一的问题是把它们全部打出来很乏味。如果您只是想避免所有额外的输入，请考虑使用提供"代码模板"的集成开发环境。Eclipse和Visual Studio(当然还有许多其他工具)都允许您选择一个变量并单击按钮来生成该变量的getter和setter。所有的代码，没有麻烦。

您可以使用引用:

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);
    }
}

代码气味 -设计问题?这里的重复让人觉得Bar需要一个新方法:

void Bar::doStuff(Foo &foo);

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

编辑:你的编辑改变了一点。我现在真的觉得你的设计有很多可以改进的地方，比如STL容器和算法。

要进一步了解Andrew的解决方案，您可能还需要查找:

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

如果你实际上有BarX x, BarY和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);
相关文章：