Question

我有以下简单类：

class Source
{
public:
    Source() = default;
    Source(Source const&) = delete;
    Source(Source&&) = default;

    explicit Source(std::string const& fileName)
     : inputStream(fileName), path_(fileName)
    {}

    ~Source() = default;

    auto path() const -> std::string
    {
        return this->path_;
    }

    std::ifstream inputStream;
private:
    std::string path_;
};

auto main(int argc, char* argv[]) -> int
{
    Source source(Source("test.txt"));
    cout << source.path() << "\n";

    return 0;
}

根据cppreference ifstream有一个move构造函数，但是当我尝试使用MinGW 4.7.2编译时，我收到以下错误：

.. \ src \ main.cpp：32：46：错误：使用已删除的功能 'cy :: Source :: Source（cy :: Source＆amp;＆amp;）'包含在文件中 .. \ src \ main.cpp：10：0：source.hpp：28：5：注意： 'cy :: Source :: Source（cy :: Source＆amp;＆amp;）'被隐式删除，因为默认定义将是格式错误：source.hpp：28：5：错误：使用删除函数'std :: basic_ifstream :: basic_ifstream（const 的std :: basic_ifstream＆安培）” C：\ MinGW的\ BIN ../ LIB / GCC /的mingw32 / 4.7.2 /包括/ C ++ / fstream的：420：11：注意：'std :: basic_ifstream :: basic_ifstream（const std :: basic_ifstream＆amp;）'被隐式删除，因为默认值定义将是不正确的： C：\ MinGW的\ BIN ../ LIB / GCC /的mingw32 / 4.7.2 /包括/ C ++ / fstream的：420：11：错误：使用已删除的功能 “的std :: basic_istream :: basic_istream（常量的std :: basic_istream＆安培）'

我做错了吗？或者cppreference的文档是不准确的？或者GCC 4.7.2有错误吗？

Answer 1

事实证明，GCC的标准库实现尚未实现流类的移动和交换操作。有关gcc标准库中C ++ 11功能的当前状态的详细信息，请参阅here。

感谢Jesse Good提供信息和链接。

Answer 2

我意识到这个答案有点晚了但是为了给出一个不可移动的类移动语义，你可以编写一个非常简单的包装类。例如：

#include <memory>



template <typename T>
class swap_wrapper
{
    //! internal buffer to hold object (on heap)
    std::unique_ptr<T> p_obj;
public:
    //! allows any of objects constructors to be called directly
    template <typename... Args>
    explicit swap_wrapper(Args&&... args)
        :   p_obj(
                     new T( std::forward<Args>(args)... )
                     ) {    }

    //! swaps pointer value of T object is unchanged therefore this 
    //! function puts no requirement on base class.

    //! note p_obj is left as a nullptr so dereferencing will cause
    //! undefined behaviour.
    swap_wrapper (swap_wrapper &&other) noexcept
        : p_obj(nullptr)
    {
        swap(other);
    }

    //! swaps pointer like above,
    //! T object is not touched; just the pointer.
    swap_wrapper &operator = (swap_wrapper &&other) noexcept
    {
        swap(other);
        return *this;
    }

    //! uses swap member function of std:unique_ptr
    void swap(swap_wrapper &other) noexcept
    {
        std::swap(p_obj, other.p_obj);
    }

    //! operators to allow access to stream
    T& operator *() { return *p_obj; }
    T const& operator *() const { return *p_obj; }

    T * operator ->() { return p_obj.get(); }
    T const * operator ->() const { return p_obj.get(); }

};


//! overload of default swap (calls member function swap)
template <typename S>
inline void swap(swap_wrapper<S> &one, swap_wrapper<S> &two) noexcept
{ one.swap(two); }

然后可以从函数返回此包装器，作为rvalue参数传递，等等。

ifsteam的move构造函数是否被隐式删除？

2 个答案: