0

我的代码中有一个非常奇怪的错误，并设法将其简化为以下单个函数。

#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 语句将导致堆栈分配变量的破坏。

我对这些功能的使用是否存在问题，是由于我不知道的原因导致的未定义行为，还是仅仅是编译器错误？

这是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.
4

1 回答 1

2

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

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

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

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

于 2013-11-09T20:38:37.630 回答