Question

我用矢量创建了一种显示树。树中的对象可能有孩子，而那些孩子也可能有孩子，唯一的是，我不知道有多少...

我在一个循环内，一个循环内，一个循环内，一个循环内创建了一个循环...是否有一种优雅的方法来避免写下过多的循环？

for (unsigned int i =0; i< vectorTree.size(); i++){
    if (vectorTree[i].hasChildren){
        for (unsigned int j = 0; j < vectorTree[i].children.size(); j++){
            if (vectorTree[i].children[j].hasChildren){
                for (unsigned int k = 0; k< 
                    vectorTree[i].children[j].children.size(); k++){
                        if (...
                }
            }
        }
    }

我想找到一种优雅的方式来做到这一点，我敢肯定，这是经过实验的编码人员已经知道的，我只是那个新的：D

Answer 1

您可以使用递归来避免编写过多的循环。

这里是一个例子：

#include <iostream>
#include <vector>

void print_multidimensional_vector(std::vector<int> const& vec) {
    for (auto item : vec) {
        std::cout << item << " ";
    }
}

template <typename T>
void print_multidimensional_vector(T const& vec) {
    for (auto item : vec) {
        print_multidimensional_vector(item);
    }
}

int main() {
    std::vector<std::vector<std::vector<int>>> vec = {
        {
            {
                1, 2, 3
            },
            {
                4, 5, 6
            }
        },
        {
            {
                7, 8, 9
            },
            {
                10, 11, 12
            }
        }
    };

    print_multidimensional_vector(vec);

    return 0;
}

输出为：1 2 3 4 5 6 7 8 9 10 11 12

Answer 2

再次感谢您的宝贵帮助！这是我经过一番游戏后想到的：

Sprite stage;

int main(){

    recursiveFinder(stage);
    return 0;
}

void  Stage::recursiveFinder(Sprite * _sprite)
{
    for (unsigned int i=0; i<_sprite->_children.size(); i++)
    {
        renderWindow.draw(_sprite->_children[i]->sprite);
        if (_sprite->_children[i]->hasChildren){
            recursiveFinder(_sprite->_children[i]);
        }
    }
}

我正在寻找一种优雅的方法来遍历具有多个深度的向量

2 个答案: