Question

我的代码中出现了一个非常奇怪的错误，并设法将其减少为以下单个函数。

#include "either.hpp"

#include <string>
#include <iostream>
#include <vector>
#include <functional>

int main()
{
    using std::string;
    using std::vector;

    auto callback = []()
    {
        auto either = data::either<string,vector<int>>(string("test"));
        return either;
        return data::either<string,vector<int>>(string("test"));
    };
    callback();
}

运行时，此程序会在std::string的析构函数上生成分段错误。但是，如果我们删除第二个return语句，它就能完美运行。

现在，data::either类正在使用一个带有两个成员的联合，而lambda的return语句将导致对stack-allcated变量的破坏。

我使用这些功能是否有问题，是因为我不知道的原因是未定义的行为，还是仅仅是编译器错误？

以下是either类：

#ifndef EITHER_HPP
#define EITHER_HPP

#include <cassert>
#include <functional>
#include <type_traits>
#include <utility>

// Model the haskel Data.Either data type.
// http://hackage.haskell.org/package/base-4.6.0.1/docs/Data-Either.html

namespace data
{
    template<class Left, class Right>
    class either
    {
        static_assert(
            !std::is_same<
                typename std::remove_cv<Left>::type,
                typename std::remove_cv<Right>::type
            >::value,
            "data::either<A,B>: type A and B must be different.");

        bool m_is_right;
        union
        {
            Left m_left;
            Right m_right;
        };


    public:
        explicit either(Left l)
            : m_is_right(false)
            , m_left(std::move(l))
        {
        }

        explicit either(Right r)
            : m_is_right(true)
            , m_right(std::move(r))
        {
        }

        either(either const& other)
            : m_is_right(other.is_right())
        {
            if (other.is_left())
            {
                m_left = other.left();
            }
            else
            {
                m_right = other.right();
            }
        }

        either(either&& other)
            : m_is_right(other.is_right())
        {
            if (other.is_left())
            {
                m_left = std::move(other.left());
            }
            else
            {
                m_right = std::move(other.right());
            }
        }

        ~either()
        {
            if (is_right())
            {
                right().~Right();
            }
            else
            {
                left().~Left();
            }
        }

        either& operator=(either const& other)
        {
            m_is_right = other.is_right();

            if (other.is_left())
            {
                m_left = other.left();
            }
            else
            {
                m_right = other.right();
            }

            return *this;
        }

        either& operator=(either&& other)
        {
            m_is_right = other.is_right();

            if (other.is_left())
            {
                m_left = std::move(other.left());
            }
            else
            {
                m_right = std::move(other.right());
            }

            return *this;
        }

        bool is_left() const
        {
            return !is_right();
        }

        bool is_right() const
        {
            return m_is_right;
        }

        Left& left()
        {
            assert(is_left());
            return m_left;
        }

        Left const& left() const
        {
            assert(is_left());
            return m_left;
        }

        Right& right()
        {
            assert(is_right());
            return m_right;
        }

        Right const& right() const
        {
            assert(is_right());
            return m_right;
        }
    };
}

#endif

我使用以下编译器对其进行了测试：

$ clang++ -std=c++11 test.cpp && ./a.out 
Segmentation fault
$ clang++ --version
Debian clang version 3.2-11 (tags/RELEASE_32/final) (based on LLVM 3.2)
Target: x86_64-pc-linux-gnu
Thread model: posix

$ g++ -std=c++11 test.cpp && ./a.out 
Segmentation fault
$ g++ --version
g++ (Debian 4.7.3-4) 4.7.3
Copyright (C) 2012 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Answer 1

在您的复制构造函数中，您认为m_left或m_right的初始化方式适合分配std::vector<int>或std::string。但是，该成员很可能根本没有被初始化以适合该类：据我所知，它是零初始化的。我没有充分使用C ++ 11联合，但我认为你需要使用

new(&this->m_left) Left(other.m_left);

同样适用于m_right。在移动构造函数中，您显然还需要插入std::move()。

请注意，您的副本分配也可能存在严重缺陷：它假定分配的左侧与右侧的类型相同。如果存储的类型不同，则分配不工作！如果存储的类型不同，则需要销毁左侧的内容并在其中构建右侧的副本。副手，我想我会使用复制和交换方法利用现有的复制构造函数和析构函数来创建一个强大的异常安全分配（如果交换相应的当前元素是非抛出的）。

为什么使用union，class和lambda产生分段错误？

1 个答案: