4

我正在设计一个枚举系统中所有正在运行的进程的输入迭代器类型。

这类似于我为枚举进程中的模块而设计的迭代器。模块迭代器在构造函数中采用“进程”对象，并且默认构造的迭代器被认为是结束迭代器。

例子：

hadesmem::ModuleIterator beg(process);
hadesmem::ModuleIterator end;
assert(beg != end);

我不知道如何处理进程枚举，因为没有“状态”或需要提供给迭代器的信息（一切都由迭代器使用 Windows API 在内部处理）。

例子：

// This is obviously a broken design, what is the best way to distinguish between the two?
hadesmem::ProcessIterator beg;
hadesmem::ProcessIterator end;

处理这种情况的惯用方法是什么？即，当不需要向迭代器构造函数提供任何内容时，您需要区分“新”迭代器和非终端迭代器的创建。

如果相关，我可以在这个库中使用 C++11，只要它受 VC11、GCC 4.7 和 ICC 12.1 支持。

谢谢。

编辑：

澄清一下，我知道无法以我上面发布的形式区分两者，所以我要问的是一个“设计”问题而不是其他任何问题......也许我只是忽略了一些东西虽然很明显（不会是第一次）。

4

3 回答 3

2

您真正想要做的是创建一种 ProcessList 对象，并以此为基础创建迭代器。我不想在每次增加迭代器时枚举所有进程或其他东西。

于 2012-06-18T18:01:28.283 回答
1

如果您创建一个类来保存CreateToolhelp32Snapshot()代表您正在迭代的快照的参数，那么您将拥有一个自然的迭代器工厂。像这样的东西应该可以工作（我不在 Windows 上，所以没有经过测试）：

class Process;
class Processes {
    DWORD what, who;
public:
    Processes(DWORD what, DWORD who) : what(what), who(who) {}

    class const_iterator {
        HANDLE snapshot;
        LPPROCESSENTRY32 it;
        explicit const_iterator(HANDLE snapshot, LPPROCESSENTRY32 it)
            : snapshot(snapshot), it(it) {}
    public:
        const_iterator() : snapshot(0), it(0) {}

        // the two basic functions, implement iterator requirements with these:
        const_iterator &advance() {
            assert(snapshot);
            if ( it && !Process32Next(snapshot, &it))
                it = 0;
            return *this;
        }
        const Process dereference() const {
            assert(snapshot); assert(it);
            return Process(it);
        }
        bool equals(const const_iterator & other) const {
            return handle == other.handle && it == other.it;
        }
    };

    const_iterator begin() const {
        const HANDLE snapshot = CreateToolhelp32Snapshot(what, who);
        if (snapshot) {
            LPPROCESSENTRY32 it;
            if (Process32First(snapshot, &it))
                return const_iterator(snapshot, it);
        }
        return end();
    }
    const_iterator end() const {
        return const_iterator(snapshot, 0);
    }
};

inline bool operator==(Processes::const_iterator lhs, Processes::const_iterator rhs) {
    return lhs.equals(rhs);
}
inline bool operator!=(Processes::const_iterator lhs, Processes::const_iterator rhs) {
    return !operator==(lhs, rhs);
}

用法：

int main() {
    const Processes processes( TH32CS_SNAPALL, 0 );
    for ( const Process & p : processes )
        // ...
    return 0;
}
于 2012-06-18T18:34:57.313 回答
1

您可以使用命名构造函数 idiom。

class ProcessIterator
private:
    ProcessIterator(int) //begin iterator
    ProcessIterator(char) //end iterator
    //no default constructor, to prevent mistakes
public:
    friend ProcessIterator begin() {return ProcessIterator(0);}
    friend ProcessIterator end() {return ProcessIterator('\0');}
}

int main() {
    for(auto it=ProcessIterator::begin(); it!=ProcessIterator::end(); ++it)
        //stuff
}
于 2012-06-18T19:50:01.110 回答