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しかし、2 番目のステートメントを削除すると、完全に機能します。

現在、data::eitherクラスは 2 つのメンバーを持つ共用体を使用しており、ラムダの 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コピー コンストラクターでは、 orが aまたはm_rightを割り当てるのに適した方法で初期化されていると想定しているようです。ただし、メンバーは、クラスに適したように初期化されていない可能性が高く、私の知る限り、ゼロで初期化されています。私は C++11 の共用体を十分に使用していませんが、使用する必要があると思いますstd::vector<int>std::string

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

についても同様ですm_right。move-constructor では、明らかに も挿入する必要がありstd::move()ます。

コピー割り当てにも深刻な欠陥がある可能性があることに注意してください。割り当ての左側が右側と同じタイプであると想定しています。格納されているタイプが異なると、割り当てが機能しません! 格納されている型が異なる場合は、左側のコンテンツを破棄し、右側のコピーを構築する必要があります。手に負えない場合は、既存のコピー コンストラクターとデストラクタを活用して強力な例外セーフ割り当てを作成するコピー & スワップ アプローチを使用すると思います (それぞれの現在の要素のスワップが非スローの場合)。

于 2013-11-09T20:38:37.630 に答える