标签: boost-optional

我一直在尝试使用boost可选的函数来返回一个对象或null,我无法弄明白.这是我到目前为止所拥有的.任何有关如何解决此问题的建议将不胜感激.

class Myclass
{
public:
    int a;
};

boost::optional<Myclass> func(int a)  //This could either return MyClass or a null
{
    boost::optional<Myclass> value;
    if(a==0)
    {
        //return an object
            boost::optional<Myclass> value;
        value->a = 200;

    }
    else
    {
        return NULL;
    }

    return value;
}

int main(int argc, char **argv)
{
    boost::optional<Myclass> v = func(0);
    //How do I check if its a NULL or an object

    return 0;
}

更新:

这是我的新代码,我收到了编译错误 value = {200};

class Myclass
{
public:
    int a;
};

boost::optional<Myclass> func(int a) …

我有以下内容:

class Obj;
typedef std::map<string, string> StrMap;
std::map<std::string, std::pair<Obj, StrMap> > complexMap;

问题是对于complexMap中的一些条目,StrMap将是空的,我根本不会使用它,所以为了提高效率,我正在考虑使用boost :: optional.我的问题是什么是提升效率::可选,我担心通过支付它的价格,我最终将无法获得任何收益.

我正在审查一些生产代码,其中一个函数说它将返回一个boost::optional,但它只返回一个double:例如

boost::optional<double> Foo(){
   double a = 1.0;
   double b = 2.0;
   return a + b;
}

这种可接受的风格/是否有任何不安全的情况？

我在想,如果有蒙上了一种优雅的方式boost::optional<A>到boost::optional<B>时B可以从构造A,虽然明确地.这有效:

# include <boost/optional.hpp>

class Foo
{
  int i_;
public:
  explicit Foo(int i) : i_(i) {}
};

int main()
{
  boost::optional<int> i;
  ... // i gets initialized or not
  boost::optional<Foo> foo;
  foo = boost::optional<Foo>(bool(i), Foo(i.value_or(0 /*unused value*/)));
  return 0;
}

但需要放入一些永远不会被使用的价值似乎很尴尬.还有更好的建议吗？

有没有办法包装boost::optional<T>类型对象以通过公开它boost::python::class_（用于BOOST_PYTHON_MODULE）

struct Foo 
{
    boost::optional<int> bar;
};

BOOST_PYTHON_MODULE(module_name)
{
    class_<Foo>("Foo")
    .def_readwrite("bar", &Foo::bar);
}

在这种情况下，我在Python中期望的是AttributeError

import module_name
f = module_name.Foo()
print f.bar

因为bar尚未设置的值。而TypeError当

import module_name
f = module_name.Foo()
f.bar = "string"

bar是int类型。

另一个相关的问题是以相同的方式导出boost::python::indexing_suite容器类型的类的对象。

使用boost::pythonapi 是否可以解决问题？

是否可以实现std :: optional,以便sizeof(std::optional<double>) == 8通过某种方式使用它可以将字符存储在NAN中,请参阅http://en.cppreference.com/w/cpp/numeric/math/nan？是否有实现这样做？它可以在标准中提供的功能方面完成吗？

我怀疑boost :: optional's get_value_or已被弃用,因为如果将rvalue作为default参数传递则不安全.但是,有时可以引用可选值或默认备选方案.

以下是安全的吗？

template<typename T>
T const& get_reference_or(boost::optional<T> const& opt, T const& alt)
{
    if (opt) return opt.get();
    else return alt;
}

template<typename T>
T const& get_reference_or(boost::optional<T> const&, T&&) = delete;

gcc 时不时地通过 may-uninitialized 发出有关 boost::optional 工作的警告，但我认为这是误报（如此处描述的https://github.com/boostorg/optional/issues/72）。

但是现在valgrind在运行时报告了同样的问题，所以出了点问题，不知道是什么问题：

//Foo.hpp
#include <boost/optional.hpp>
#include <boost/variant.hpp>
#include <cstdio>
#include <string>

extern "C" {
typedef struct FooOpaque FooOpaque;

FooOpaque *Foo_new();

void Foo_delete(const FooOpaque *self);
}

class Foo {
public:
  explicit Foo(FooOpaque *o) noexcept : self_(o) {}
  Foo(const Foo &) = delete;
  Foo &operator=(const Foo &) = delete;

  Foo(Foo &&o) noexcept : self_(o.self_) { o.self_ = nullptr; }
  Foo &operator=(Foo &&o) noexcept {

    assert(this != &o);
    free_mem(this->self_);
    self_ = o.self_;
    o.self_ = nullptr;
    return …

我正在读一些代码而且我遇到了一些我不理解的东西.它是关于测试是否初始化Boost :: optional值.它使用提供ASSERT_TRUE()宏的gtest框架.

#include "gtest\gtest.h"

void test() {
    boost::optional<someClass> opt = someFunc();
    ASSERT_TRUE(!!opt);
}

为什么我需要!!之前的opt？是boost::optional不是隐式转换为bool,这是宏所需要的？我认为用它ASSERT_TRUE(opt)来检查opt是否保持正确值是足够的吗？

我有

auto result = std::is_convertible
    < boost::optional<int>
    , bool
    >::value;

static_assert( result , "task should return bool" );

它无法编译.std :: is_convertible的定义是

template< class From, class To > struct is_convertible;

并且可选显然可以转换为布尔值,因为我们总是使用它

void(boost::optional<int> const & value){
    if(value){
        std::cerr << *value << endl; 
    }
}

我在这里想念的是什么？