C++ I'；我写了C++；将boost:：optional作为一个范围处理的代码，但它没有'；不编译

我希望将boost:：optional视为一个可以包含零个或一个元素的容器。从逻辑上讲，我应该能够为容器创建一个迭代器，并在容器上使用boost:：for_。我的尝试如下，但未能编译。我已经试过了

以下代码供参考

#include <boost/optional.hpp>
#include <boost/range.hpp>
#include <boost/range/algorithm/for_each.hpp>
#include <iostream>

namespace boost {

    template <typename OT>
        class optional_iterator
        : public boost::iterator_facade<optional_iterator<OT>,
        typename OT::value_type,
        boost::forward_traversal_tag> {
            private:
                OT m_o;

            public:
                optional_iterator() : m_o(boost::none) {}
                explicit optional_iterator(OT& o) : m_o(o) {}

            private:
                friend class boost::iterator_core_access;

                void increment() { m_o = boost::none; }

                bool equal(OT& other) const { return this->m_o == other.m_o; }

                typename OT::value_type& dereference() { return *m_o; }
        };

    template <typename T>
        struct optional_iterators {
            typedef optional_iterator<boost::optional<T>> iterator;
            typedef optional_iterator<boost::optional<T> const> const_iterator;
        };

    template <class T>
        struct range_mutable_iterator<boost::optional<T>> {
            typedef typename optional_iterators<T>::iterator type;
        };

    template <class T>
        struct range_const_iterator<boost::optional<T> const> {
            typedef typename optional_iterators<T const>::const_iterator type;
        };

    template <class T>
        inline typename optional_iterators<T>::iterator range_begin(
                boost::optional<T>& x) {
            return typename optional_iterators<T>::iterator(x);
        }

    template <class T>
        inline typename optional_iterators<T>::const_iterator range_begin(
                boost::optional<T> const& x) {
            return typename optional_iterators<T>::const_iterator(x);
        }

    template <class T>
        inline typename optional_iterators<T>::iterator range_end(boost::optional<T>&x) {
            return typename optional_iterators<T>::iterator();
        }

    template <class T>
        inline typename optional_iterators<T>::const_iterator range_end(boost::optional<T> const & x) {
            return typename optional_iterators<T>::const_iterator();
        }
}  // namespace boost

int main() {
    auto a = boost::optional<int>(10);
    auto rb = range_begin(a);
    auto re = range_end(a);

   boost::for_each(a, [](int const& i) { std::cout << i; });
}

#包括
#包括
#包括
#包括
名称空间提升{
模板
类可选迭代器
：public boost:：迭代器{
私人：
奥特穆奥；
公众：
可选的迭代器（）：m_o（boost:：none）{
显式可选_迭代器（OT&o）：m_o（o）{}
私人：
朋友类boost：：迭代器\u核心\u访问；
void increment（）{m_o=boost:：none；}
bool equal（OT&other）const{返回this->m_o==other.m_o；}
typename OT:：value_type&dereference（）{return*m_o；}
};
模板
结构可选迭代器{
typedef可选_迭代器迭代器；
typedef可选迭代器const迭代器；
};
模板
结构范围可变迭代器{
typedef typename可选_迭代器：：迭代器类型；
};
模板
结构范围常量迭代器{
typedef typename可选的迭代器：：常量迭代器类型；
};
模板
内联typename可选\u迭代器：：迭代器范围\u开始(
boost：：可选&x）{
返回typename可选的迭代器：：迭代器（x）；
}
模板
内联类型名可选迭代器：：常量迭代器范围\u开始(
boost：：可选常量和x）{
返回typename可选迭代器：：常量迭代器（x）；
}
模板
内联typename可选迭代器：：迭代器范围\u结束（boost：：可选&x）{
返回typename可选的迭代器：：迭代器（）；
}
模板
内联typename可选迭代器：：常量迭代器范围\u结束（boost：：可选常量&x）{
返回typename可选的迭代器：：常量迭代器（）；
}
}//名称空间提升
int main（）{
自动a=增压：：可选（10）；
自动rb=范围_开始（a）；
自动重新=范围结束（a）；
boost:：for_each（a，[]（int const&i）{std:：cout:：type const_迭代器；
^~~~~~~~~~~~~~
在/opt/compiler explorer/libs/boost_1_64_0/boost/concept/assert.hpp:35中包含的文件中，
从/opt/compiler explorer/libs/boost_1_64_0/boost/concept_check.hpp:20，
从/opt/compiler explorer/libs/boost_1_64_0/boost/range/concepts.hpp:19，
从/opt/compiler explorer/libs/boost_1_64_0/boost/range/size_type.hpp:20，
从/opt/compiler explorer/libs/boost_1_64_0/boost/range/size.hpp:21，
从/opt/compiler explorer/libs/boost_1_64_0/boost/range/functions.hpp:20，
从/opt/compiler explorer/libs/boost_1_64_0/boost/range.hpp:18，
发件人：3:
/opt/compiler explorer/libs/boost\u 1\u 64\u 0/boost/range/concepts.hpp:279:9:错误：“struct boost:：range\u迭代器”中没有名为“type”的类型
增强\u范围\u概念\u断言((
^~~~~~~~~~~~~~~~~~~~~~~~~~
在/opt/compiler explorer/gcc-8.1.0/include/c++/8.1.0/algorithm:62中包含的文件中，
从/opt/compiler explorer/libs/boost_1_64_0/boost/core/swap.hpp:25，
从/opt/compiler explorer/libs/boost_1_64_0/boost/optional/optional.hpp:27，
从/opt/compiler explorer/libs/boost_1_64_0/boost/optional.hpp:15，
发件人：2:
/opt/compiler explorer/gcc-8.1.0/include/c++/8.1.0/bits/stl_-algo.h:3876:5:错误：“_-Funct std:：for_each（_-IIter，_-IIter，_-Funct），[with _-IIter=boost:：optional_迭代器；_-Funct=main（）：]”，使用局部类型“main（）：”声明，但从未定义[-fpermissive]
对于每个（\u输入迭代器\uuuu优先，\u输入迭代器\uuuu最后，\u函数\uuf）
^~~~~~~~
/opt/compiler explorer/gcc-8.1.0/include/c++/8.1.0/bits/stl_-algo.h:3876:5：警告：“_-Funct std:：for_-each（_-IIter，_-IIter，_-Funct）[with _-IIter=boost:：optional_-iterator；_-Funct=main（）：]”已使用但从未定义
返回的编译器：1

我会保持简单：

template <typename T> auto make_range(optional<T>& opt) {
    T* addr = opt? std::addressof(*opt) : nullptr;
    return make_iterator_range(addr, opt? addr+1 : addr);
}

模板自动生成范围（可选和可选）{
T*addr=opt？std:：addressof（*opt）：nullptr；
返回make_迭代器_范围（addr，opt？addr+1:addr）；
}

---

我还没有对此进行测试，但它似乎足够简单，可以正常工作。

定义迭代器不足以生成可选的模型a。代码中的任何内容都不能使有效的表达式列表保持不变。请尝试将可选表达式包装在轻量级代理中，以对所需概念进行建模。根据我提供的免费函数，但你告诉我的链接似乎定义了一种不同的方式来做它。或者也许我需要这两个部分。你忽略了这个部分。它不考虑所有的自由函数。只有那些以特定的样式添加的函数。你添加它的命名空间很重要。我把自由函数放在Boost命名空间中，因为<代码> Boo:：可选的< /Cord>是在Boost名称中的。这是错误的吗？如果是，你建议使用什么名称空间？抱歉。我错过了重新打开的boost名称空间。这不是问题。我仔细查看了你的链接文章和错误消息。“相关概念”列是问题所在。错误消息以非常详细的方式说明了这一点：

boost:：concepts:：requirement实际上我可以将这两个操作结合起来。我不喜欢使用make_range。
optional
应该只是作为一个范围来工作。但是，我在的实现可能可以很容易地更改为使用与您的答案类似的指针不是自定义迭代器。是的。我的想法是，你可以有一个很小的包装器类型，它只在
begin（）
和
end（）
中执行所需的操作，并且所有内容都仍然是内联的。我没有看到大的
template <typename T> auto make_range(optional<T>& opt) {
    T* addr = opt? std::addressof(*opt) : nullptr;
    return make_iterator_range(addr, opt? addr+1 : addr);
}