12

我有以下简单的课程：

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&&)' 在 ..\src\main.cpp:10:0 包含的文件中: source.hpp:28:5: 注意: 'cy::Source::Source(cy::Source&&)' 被隐式删除，因为默认定义格式不正确：source.hpp:28:5: 错误：使用删除函数'std::basic_ifstream::basic_ifstream(const std::basic_ifstream&)' c:\mingw\bin../lib/gcc/mingw32/4.7.2/include/c++/fstream:420:11: 注意： 'std::basic_ifstream::basic_ifstream(const std::basic_ifstream&)' 被隐式删除，因为默认定义格式错误：c:\mingw\bin../lib/gcc/mingw32/4.7.2/include/ c++/fstream:420:11: 错误：使用已删除的函数 'std::basic_istream::basic_istream(const std::basic_istream&)'

难道我做错了什么？还是 cppreference 的文档不准确？还是 GCC 4.7.2 有错误？

4

2 回答 2

12

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

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

于 2013-02-01T06:05:50.520 回答
1

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

#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); }

然后可以从函数返回这个包装器，作为右值参数传递，等等。

于 2013-09-29T21:49:34.373 回答