标签: boost-optional

我有这样的代码:

boost::optional<double> result = _ind1.Value() / _ind2.Value();

每个arg boost::optional<double>也是:

boost::optional<double> Value() {
    return value;
}

错误是:

Error 1 error C2676: binary '/' : 'boost::optional<T>' does not define this operator or a conversion to a type acceptable to the predefined operator 2 IntelliSense: no operator "/" matches these operands operand types are: boost::optional<double> / boost::optional<double>

我明白分裂似乎没有定义.我希望结果是boost::none两个参数中的任何一个none- 否则我希望它是正常的双重除法.我应该自己写吗？

对于for-range循环语法,如何使原始指针的行为类似于范围.

double five = 5;
double* dptr = &five;
for(int& d : dptr) std::cout << d << std::endl;// will not execute if the pointer is null

动机:

现在,vox populi可以将boost::optional(未来std::optional)值视为范围,因此可用于范围循环http://faithandbrave.hateblo.jp/entry/2015/01/29/173613.

当我重写我自己的简化版本时:

namespace boost {
    template <class Optional>
    decltype(auto) begin(Optional& opt) noexcept{
        return opt?&*opt:nullptr;
    }

    template <class Optional>
    decltype(auto) end(Optional& opt) noexcept{
        return opt?std::next(&*opt):nullptr;
    }
}

用作

boost::optional<int> opt = 3;
for (int& x : opt) std::cout << x << std::endl;

在查看代码时,我想象它也可以推广到原始(可空)指针.

double five = 5; …

我遇到了一个我无法理解的编译时错误。我尝试在我的代码中使用boost::optional，一旦包含，boost/optional.hpp我就无法再构建我的项目。如果我注释掉这个 include 语句，它就会起作用。我什至在我的代码中还没有任何实际用法boost::optional，只是类标头中的 include 语句（请参阅下面的完整标头）。编译器错误C2143 syntax error: missing ',' before '<'发生在另一个 Boost 标头中boost/utility/compare_pointees.hpp（请参阅下面的 GitHub 链接）。我还成功地使用了 Boost 中的其他东西，就像boost::filesystem::path在同一个项目中一样，所以我的 Boost 发行版应该没有问题。

这是我的环境：Microsoft Visual Studio Professional 2015 Version 14.0.25431.01 Update 3和boost 1.62.0。我还使用第三方库C++ REST SDK，其他都是 C++ 标准库的东西。

我的标题看起来像这样。我想添加一个新方法作为boost::optional<size_t>返回类型。

#pragma once

#include <boost/optional.hpp>   // <==== ERROR

// C++ REST SDK
#define _TURN_OFF_PLATFORM_STRING
#include <cpprest/http_listener.h>
#include <cpprest/http_msg.h>

namespace SANDBOX::REST
{
   class HttpGetHandler
   {
   public:
       virtual void …

说我有:

#include <iostream>
#include "boost/optional.hpp"
struct cat
{
    int paw = 4;
};

int main()
{
    boost::optional<cat&> z;
    {
        cat realCat = cat();
        z = realCat;
    }
    std::cout << z->paw << std::endl;
    return 0;
}

在上面,没有理由期望打印出一致的结果,就像realCat发布的那样}？还是optional保留了生命realCat？

我看到一个错误,我没有看到解决方案.一,相关代码:

namespace C {

    struct RangeEntry {
        size_t byte;
        boost::optional<size_t> bit;
    };

    struct Range {
        RangeEntry firstPart;
        boost::optional<RangeEntry> secondPart;
        boost::optional<size_t> shift;
    };
}

BOOST_FUSION_ADAPT_STRUCT(
    C::RangeEntry,
    (size_t, byte)
    (boost::optional<size_t>, bit)
)

BOOST_FUSION_ADAPT_STRUCT(
    C::Range,
    (C::RangeEntry , firstPart)
    (boost::optional<C::RangeEntry> , secondPart)
    (boost::optional<size_t> , shift)
)

... Declare the rules ...

karma::rule<Iterator, C::Range()> range;
karma::rule<Iterator, C::RangeEntry()> range_part;

... Define rules ...

range_part %= no_delimit[ulong_ << -(lit(":") << ulong_)];
range %= no_delimit[range_part << -(lit("-") << range_part)] << -(lit("<<") << ulong_);

在该range %=部分,我得到编译错误

/usr/include/boost/spirit/home/karma/numeric/detail/numeric_utils.hpp:504:30: …

我有以下简单的结构：

struct X
{
    X(std::string name, int value): name_(name), value_(value){}

    std::string name_;
    int value_;
};

我想将其与boost可选一起使用而不进行复制。这是一个选择：

boost::optional<X> op;
op.emplace("abc", 5);

是否可以不使用emplace函数？（我的意思是一行表达式）

我想写这样的代码:

template <typename K, typename T, template <typename, typename> class C>
boost::optional<T> search(const C<K, T>& dict,
                          const K& key)
{
  auto it = dict.find(key);

  if (it != dict.end()) {
    return it->second;
  } else {
    return boost::none;
  }
}

希望能够(std::[unordered_][multi]map)使用字典界面在各种容器上调用上述函数,如:

std::map<std::string, Foo> strToFoo;
auto val = search(strToFoo);

我知道功能模板不允许使用模板模板参数.但还有另一种方法可以达到同样的效果吗？

如果一个类T具有对齐要求,例如由alignas关键字指定的对齐要求,std::optional<T>并且boost::optional<T>保证尊重所述对齐？

如果它们只是T对象和a的包装类bool initialized,那么它们会T根据需要自动对齐它们的成员,但标准和boost文档声明它们不能容纳任何对象并且很好地处理昂贵的构造对象.据我所知,他们不仅仅包含一个T.相反,它们似乎分配了一个缓冲区,T手动构造或销毁它.因此,C++语言不会自动对齐缓冲区,因为它不是类型T.

那么,做std::optional<T>并boost::optional<T>正确对齐他们的托管T对象？他们是否也提供optional<T>::operator new并optional<T>::operator new[]尊重对齐要求？

分配可选结构成员的最佳方式是什么？例如,我有一个结构:

struct B{
public:
    int x;
}


struct A{
public:
    boost::optional<B> b;
};


void foo(){
   A a;
   a.b.x = 10; //Runtime exception because a.b is not initialized. 
}

一种选择是定义临时B结构并将其分配给A:

void foo(){
    A a;
    B tmp;
    a.b = tmp;
    a.b.x = 10; //OK. 
}

要么:

void foo(){
    A a;
    a.b = B();
    a.b.x = 10; //OK. 
}

有更明确的方法吗？