c++ - 为什么使用 union、class 和 lambda 会产生段错误？

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 类正在使用具有两个成员的 union ，lambda 的返回语句将导致栈分配变量的破坏。

我对这些功能的使用是否存在问题，是否出于某种我不知道的原因出现了未定义的行为，或者仅仅是一个编译器错误？

这是 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 union ，但我认为你需要使用

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

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

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