主页 / 问题 / 1306040
Accepted
ArtemiiSelyankin
Asked:2022-07-17 08:53:04 +0000 UTC2022-07-17 08:53:04 +0000 UTC

组织功能的最佳方式是什么

  • 772

有这个代码：

template<class __T>
class IdContainer
{
    std::vector<__T> unorderedIds_;

public:
    __T getNext() {
        auto _it = unorderedIds_.begin();

        if (_it != unorderedIds_.end()) {
            __T _id = *_it;
            unorderedIds_.erase(_it);
            return _id;
        }

        throw std::runtime_error("---");
    };
}

也就是说，如果向量是空的，我会抛出一个异常，如果那里有东西，我会返回第一个元素。这样做可能会更好：

bool getNext(__T& id) {
    auto _it = unorderedIds_.begin();

    if (_it != unorderedIds_.end()) {
        id = *_it;
        unorderedIds_.erase(_it);
        return true;
    }

    return false;
};

我还看到一个返回指针的选项：

__T* getNext() {
    return _id;
    or
    return nullptr;
}

但是在堆上分配一些 int 有点过头了。

我可能还缺少其他选项。请告诉我编写此函数的最佳方法。她的想法是，她应该给我们第一个id，否则明确id结束。

c++

2 个回答

  1. Best Answer

    您有多达 4 个（连同optional）选项来解决这个问题，并且所有 4 个选项都很好。

    特定选项的选择取决于许多因素：

    1. 根据项目通过的协议

    2. 从正在执行的操作的意义来看——通常情况下，发生异常情况时会抛出异常，程序员尽量不让普通逻辑通过异常。但这更多的是项目通过的协议问题。

    3. 为项目选择的最佳协议是什么？

    • 如果您是学生，则必须了解并理解所有选项。

    • 如果您作为团队的一部分开始一个新项目，您将做出共同决定。

    • 如果必须由您亲自做出决定，请以您的经验为指导。如果没有经验，你有一个学习项目，见上面的一点（你应该探索所有的选项）。

    • 0

  2. 如果您没有机会切换到新的编译器和 C++ 17 标准，那么很有可能编写 std:: optional 的类似物，这很容易，例如，我尝试编写类似的类：

    在线尝试！

    #include <utility>
#include <stdexcept>

template <typename T>
class Optional {
public:
    Optional() {}
    ~Optional() { Destruct(); }
    template <typename Q>
    Optional(Q && v) { Construct(std::forward<Q>(v)); }
    template <typename Q>
    Optional & operator = (Q && v) { return Construct(std::forward<Q>(v)); }
    Optional(Optional const & other) { Replace(other.has_val, other.val); }
    Optional & operator = (Optional const & other) {
        return Replace(other.has_val, other.val);
    }
    Optional(Optional && other) { Replace(other.has_val, std::move(other.val)); }
    Optional & operator = (Optional && other) {
        return Replace(other.has_val, std::move(other.val));
    }
    bool has_value() const { return has_val; }
    operator bool() const { return has_val; }
    T & value() {
        if (!has_val)
            throw std::runtime_error("Optional doesn't contain value!");
        return val;
    }
    T const & value() const { return const_cast<Optional&>(*this).value(); }
    T & operator * () { return val; }
    T const & operator * () const { return val; }
    T * operator -> () { return &val; }
    T const * operator -> () const { return &val; }
    void reset() { Destruct(); }
    template <typename ... Args>
    T & emplace(Args && ... args) {
        Construct(std::forward<Args>(args)...);
        return val;
    }
private:
    template <typename ... Args>
    Optional & Replace(bool has, Args && ... args) {
        return has ? Construct(std::forward<Args>(args)...) : Destruct();
    }
    template <typename ... Args>
    Optional & Construct(Args && ... args) {
        Destruct();
        new (&val) T(std::forward<Args>(args)...);
        has_val = true;
        return *this;
    }
    Optional & Destruct() {
        if (has_val) {
            val.~T();
            has_val = false;
        }
        return *this;
    }
    
    bool has_val = false;
    struct Dummy {};
    union {
        Dummy dummy;
        T val;
    };
};

    总的来说，我认为bool getNext(__T& id)按照您的建议从视图函数中简单地返回 bool 是一个非常合适且简单的选项。

    返回指针或异常的选项也可以，但如果这是一段高性能的代码，那么最好不要使用它们，它们会大大减慢代码的速度。bool此选项不会影响性能。

    • -2

相关问题