您现在的位置: 主页 > 华夏黑客联盟 > QQ黑客软件 > 文章内容

黑基网c++11实现c++14的optional

作者: QQ黑客 来源:未知 时间: 2014-03-03 阅读:
c++14中将包含一个std::optional类,它的功能和用法和boost的optional类似。optional<T>内部存储空间可能存储了T类型的值也可能没有存储T类型的值,只有当optional被T初始化之后,这个optional才是有效的,否则是无效的,它实现了未初始化的概念。
 
optional的应用场景
函数返回无效对象 破解QQ密码
  有时根据某个条件去查找对象时,如果查找不到对象时就会返回一个无效值,这不表明函数执行失败,而是表明函数正确执行了,但是结果却不是有用的值,这时就可以返回一个未初始化的optional对象出去,在外面判断这个optional对象是否有效对象是否被初始化,如果没有被初始化就表明这个值是无效的。 
boost中的optional就实现了这种未初始化的概念,boost.optional的基本用法很简单:
 
复制代码
optional<int> op;
if(op)
    cout<<*op<<endl;
 
optional<int> op1 = 1;
if(op1)
    cout<<*op1<<endl;
复制代码
  第一个op由于没有被初始化,所以它是一个无效值,将不会输出打印信息,第二个op被初始化为1,所以它是一个有效值,将会输出1。optional经常用于函数返回值,像boost.property_tree中就有很多optional接口(关于boost.property_tree可以参考我前面博文的介绍:),比如get_child_optional接口,返回一个optional<ptree>对象,外面需要判断它是否是一个有效值来确定是否取到了对应的子节点。
 
c++11实现optional
  c++11中目前还没有optional,在c++14中将会增加std::optional功能和用法和boost.optional类似。在c++14中的std::optional出来之前,如果不想依赖boost库的话,就用c++11实现一个optional,也不是难事。
 
c++11实现optional需要注意的问题
 
1.内部存储空间
  由于optional<T>需要容纳T的值,所以需要一个缓冲区保存这个T,这个缓冲区不能用普通的char数组,需要用内存对齐的缓冲区,这里还是采用std::aligned_storage,关于这个可以参考我前面的博文中对std::aligned_storage的讨论。
 
2.拷贝构造函数和赋值构造函数
 
  需要注意拷贝和赋值时,内部状态和缓冲区销毁的问题。内部状态用来标示该optional是否被初始化,当已经初始化时需要先将缓冲区清理一下。需要增加右值版本优化效率。
  来看看具体的实现吧:
 
复制代码
#include <type_traits>
 
template<typename T>
class Optional
{
    using data_t = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
public:
    Optional() : m_hasInit(false) {}
    Optional(const T& v)
    {
        Create(v);
    }
 
    Optional(T&& v) : m_hasInit(false)
    {
        Create(std::move(v));
    }
 
    ~Optional()
    {
        Destroy();
    }
 
    Optional(const Optional& other) : m_hasInit(false)
    {
        if (other.IsInit())
            Assign(other);
    }
 
    Optional(Optional&& other) : m_hasInit(false)
    {
        if (other.IsInit())
        {
            Assign(std::move(other));
            other.Destroy();
        }
    }
 
    Optional& operator=(Optional &&other)
    {
        Assign(std::move(other));
        return *this;
    }
 
    Optional& operator=(const Optional &other)
    {
        Assign(other);
        return *this;
    }
 
    template<class... Args>
    void emplace(Args&&... args)
    {
        Destroy();
        Create(std::forward<Args>(args)...);
    }
 
    bool IsInit() const { return m_hasInit; }
 
    explicit operator bool() const { return IsInit(); 
 
}
 
    T& operator*()
    {
        return *((T*) (&m_data));
    }
 
    T const& operator*() const
    {
        if (IsInit())
        {
            return *((T*) (&m_data));
        }
 
        throw std::exception("");
    }
 
    bool operator == (const Optional<T>& rhs) const
    {
        return (!bool(*this)) != (!rhs) ? false : (!bool(*this) ? true : (*(*this)) == (*rhs));
    }
 
    bool operator < (const Optional<T>& rhs) const
    {
        return !rhs ? false : (!bool(*this) ? true : (*(*this) < (*rhs)));
    }
 
    bool operator != (const Optional<T>& rhs)
    {
        return !(*this == (rhs));
    }
private:
    template<class... Args>
    void Create(Args&&... args)
    {
        new (&m_data) T(std::forward<Args>
 
(args)...);
        m_hasInit = true;
    }
 
    void Destroy()
    {
        if (m_hasInit)
        {
            m_hasInit = false;
            ((T*) (&m_data))->~T();
        }
    }
 
    void Assign(const Optional& other)
    {
        if (other.IsInit())
        {
            Copy(other.m_data);
            m_hasInit = true;
        }
        else
        {
            Destroy();
        }
    }
 
    void Assign(Optional&& other)
    {
        if (other.IsInit())
        {
            Move(std::move(other.m_data));
            m_hasInit = true;
            other.Destroy();
        }
        else
        {
            Destroy();
        }
    }
 
    void Move(data_t&& val)
    {
        Destroy();
        new (&m_data) T(std::move(*((T*) 
 
(&val))));
    }
 
    void Copy(const data_t& val)
    {
        Destroy();
        new (&m_data) T(*((T*) (&val)));
    }
 
private:
    bool m_hasInit;
    data_t m_data;
};
复制代码
测试代码:
 
复制代码
void TestOptional()
{
    Optional<string> a("ok");
    Optional<string> b("ok");
    Optional<string> c("aa");
    c = a;
    if (c<a)
        cout << "<" << endl;
 
    if (a == b)
        cout << "=" << endl;
 
        map<Optional<string>, int> mymap;
    mymap.insert(std::make_pair(a, 1));
    mymap.insert(std::make_pair(c, 2));
 
    auto it = mymap.find(a);
    cout << it->second << endl;
}    
复制代码
可以看到用法和boost.optional的用法保持一致,实现起来也比较简单。