Question

我想知道是否有任何方法可以将自定义方法编写为“for”循环。由于对象的非常不寻常的迭代（好吧，不像通常的迭代那样平常）我每次想要使用它时都被迫重写它。

对不起我的英语和非常不清楚的解释，我不是一个很善于交际的人，但我认为下面的示例将正确解释我的问题。下面的代码不是真正的代码，只是一个方案。指针和引用可能使用错误，但我的意思是显示我的概念。

 class Element{
          Element *next;       // Pointer to the next object
          Element *previous;   // Pointer to the previous object
          // There are also some primitives (int, double etc.) there.

          void actionA(int a){ /* sth happpens to the primitives and may affect *next and *previous */ } 
          void actionB(int b,int c){ /* just like above */ }
          // ............. and even more methods 

    }




void makeActionA(int i){
       Element pointer=start.next;
       while(pointer!=end){
            Element tmp=pointer.next;
            pointer.actionA(i);          //X
            pointer=tmp;
        }
    }

void makeActionBC(int i,int j){
       Element pointer=start.next;
       while(pointer!=end){
            Element tmp=pointer.next;
            pointer.actionB(i,j);            //X
            pointer.actionC(i,j,i*j);        //X
            pointer=tmp;
        }
    }
    // AND SO ON

除了标有“X”的行外，我们可以看到makeAction方法的结构几乎相同。我希望缩短它，而不是愚蠢的重复，就像在“for”循环中一样。

   void custom_loop(Element pointer,Element start, Element end){ 
            pointer=start.next;
            while(pointer!=end){
                Element tmp=pointer.next;
                {
                        // Magical function that read the code between the brackets in code.
                }
                pointer=tmp;

            }
    }

使用custom_loop

将makeAction方法替换为更简单的方法

    void makeActionA(int i){
          Element t,s,e;
          custom_loop(t;s;e){
               t.actionA(i); 
          }
    }

    void makeActionBC(int i,int j){
          Element t,s,e;
          custom_loop(t;s;e){
               t.actionB(i,j);
               t.actionC(i,j,i*j); 
          }
    }

我想到的唯一解决方案是使用元编程和宏的一些神奇技巧。我不是真的进入他们，但他们不会吓到我。我期待着解决方案。非常感谢。对我的英语再次感到抱歉。

Answer 1

在c ++中，你可以做到

template <typename F>
void makeElementAction(Element& element, F f){
   for (auto* pointer = &element; pointer != nullptr; pointer = pointer->next) {
       f(*pointer);
   }
}

拨打电话

makeElementAction(root, [&](Element& element) { element.actionA(i); });

Answer 2

在Java中，您可以实现接口Iterable，它允许您迭代＆＃34;可迭代＆＃34;结构使用for循环：

Element start = ...;
for (Element current : start) {
   // do something with current element
}

class Element implements Iterable<Element> {
    ...

    public Iterator<Element> iterator() {
        return new ElementIterator(this);
    }
}

class ElementIterator implements Iterator<Element> {
    private Element current;

    ElementIterator(Element start) {
        this.current = start;
    }

    public boolean hasNext() {
        return current != null;
    }

    public Element next() {
        Element result = current;
        current = current.next;
        return result;
    }
}

Answer 3

我找到了一个有趣的结构。它也解决了这个问题。

循环看起来：

operator[]

新方法看起来像那样

records[order].push_back( item );

链接：https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html ：http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/Lambda-QuickStart/index.html

是否有可能使函数像for循环一样工作？

3 个答案: