移动资源出一个通用类

Question

的在上下文下面的一个：

template <class T> 
struct MyStruct 
{ 
    T resource; 
    decltype(auto) getResource() 
    { 
     return std::move(resource); 
    }  
}; 

是我getResource方法做什么，我希望它做的，即resource成员迁出之类的？我想在MyStruct将不使用任何更多的情况下使用它，这是确定从中“窃取”内存。

Answer 1

随着

template <class T> 
struct MyStruct 
{ 
    T resource; 
    decltype(auto) getResource() 
    { 
     return std::move(resource); 
    } 
}; 

decltype(auto)是T&&。但T&&本身并不会窃取资源，（但允许它被隐含地窃取）。

另一种方法是

template <class T> 
struct MyStruct 
{ 
    T resource; 
    T takeResource() 
    { 
     return std::move(resource); 
    } 
}; 

这里，一旦takeResource被调用时，资源已经转移。

因此，例如

MyStruct<std::unique_ptr<int>> foo; foo.resource = std::make_unique<int>(42); 
*foo.get_resource() = 51; // No transfer ownership, just get a reference 
*foo.get_resource() = 69; // still works. 

但

*foo.get_resource() = 51; // Transfer ownership, and resource will be released here 
*foo.get_resource() = 69; // dereferencing nullptr -> UB. 

Answer 2

这一切都取决于什么是T和移动构造函数是怎么写的。例如，如果它是一个int，它只是复制它。如果它是std::unique_ptr，它将完全符合你的期望。

为了更好地理解看到这个例子请：

#include <iostream> 
#include <string> 
class copyable{ 
public: 
    copyable():x(0){}; 
    ~copyable()=default; 
    copyable(copyable const&)=default; 
    copyable(copyable&&)=default; 

    int x; 
}; 

class moveable{ 
public: 
    moveable():x(new int{0}){}; 
    ~moveable(){ 
     delete[] x; 
    }; 
    moveable(moveable const&)=delete; 
    moveable(moveable&& other){ 
     this->x=other.x; 
     other.x=nullptr; 
    }; 

    int* x; 
}; 

template <class T> 
struct MyStruct 
{ 
    T resource; 
    decltype(auto) getResource() 
    { 
     return std::move(resource); 
    }  
}; 

int main() 
{ 
    MyStruct<copyable> a; 
    std::cout << a.resource.x <<"\n"; 

    MyStruct<moveable> b; 
    std::cout << "address: "<< b.resource.x << "\tval: " << *b.resource.x <<"\n\n"; 

    auto temp_a=a.getResource(); 
    std::cout << temp_a.x <<"\n"; 

    auto temp_b=b.getResource(); 
    std::cout << "address: "<< temp_b.x << "\tval: " << *temp_b.x <<"\n\n"; 


    std::cout << a.resource.x <<"\n"; 
    std::cout << "address: "<< b.resource.x << "\tval: " << /* *b.resource.x << THIS IS UB */ "\n\n"; 

} 

输出：

0 
address: 0x2d366f0 val: 0 

0 
address: 0x2d366f0 val: 0 

0 
address: 0 val: 

Live Demo

Answer 3

std::move自身不动，这是一个轻微的misnoma 。 std::move这里只确保一个右值。你的类型T还需要有一个构造函数来允许实际移动它。

总而言之，你不能保证你的资源是不可复制的。

，如果你想明确谁拥有在特定的时间了得天独厚的资源传递一个unique pointer左右。独特的指针是通用的，如果你将设计细化到足够长的时间，可能会成为你最终实现的东西。