Wie schreibe ich die Bewegungszuweisungsfunktion für diese abgeleitete Klasse?

Question

Due to this bug in Visual Studio 2013, ich muss meinen eigenen Move-Konstruktor bereitstellen und die Zuordnung für eine abgeleitete Klasse verschieben. Ich weiß jedoch nicht, wie die entsprechenden Verschiebungsfunktionen für die Basisklasse aufgerufen werden.

Hier ist der Code:

#include <utility> 

// Base class; movable, non-copyable 
class shader 
{ 
    public: 
     virtual ~shader() 
     { 
      if (id_ != INVALID_SHADER_ID) 
      { 
       // Clean up 
      } 
     } 

     // Move assignment 
     shader& operator=(shader&& other) 
     { 
      // Brett Hale's comment below pointed out a resource leak here. 
      // Original: 
      // id_ = other.id_; 
      // other.id_ = INVALID_SHADER_ID; 
      // Fixed: 
      std::swap(id_, other.id_); 
      return *this; 
     } 

     // Move constructor 
     shader(shader&& other) 
     { 
      *this = std::move(other); 
     } 

    protected: 
     // Construct an invalid shader. 
     shader() 
      : id_{INVALID_SHADER_ID} 
     {} 

     // Construct a valid shader 
     shader(const char* path) 
     { 
      id_ = 1; 
     } 

    private: 
     // shader is non-copyable 
     shader(const shader&) = delete; 
     shader& operator=(const shader&) = delete; 

     static const int INVALID_SHADER_ID = 0; 

     int id_; 
     // ...other member variables. 
}; 

// Derived class 
class vertex_shader final : public shader 
{ 
    public: 
     // Construct an invalid vertex shader. 
     vertex_shader() 
      : shader{} 
     {} 

     vertex_shader(const char* path) 
      : shader{path} 
     {} 

     // The following line works in g++, but not Visual Studio 2013 (see link at top)... 
     //vertex_shader& operator=(vertex_shader&&) = default; 

     // ... so I have to write my own. 
     vertex_shader& operator=(vertex_shader&&) 
     { 
      // What goes here? 
      return *this; 
     } 

     vertex_shader(vertex_shader&& other) 
     { 
      *this = std::move(other); 
     } 

    private: 
     // vertex_shader is non-copyable 
     vertex_shader(const vertex_shader&) = delete; 
     vertex_shader& operator=(const vertex_shader&) = delete; 
}; 

int main(int argc, char* argv[]) 
{ 
    vertex_shader v; 

    // later on 
    v = vertex_shader{ "vertex_shader.glsl" }; 

    return 0; 
} 

Was wie der Umzug Zuordnungsfunktion in der abgeleiteten Klasse aussehen sollte?

Answer 1

Sie müssen nur den Umzug Zuweisungsoperator Basisklasse aufrufe:

vertex_shader& operator=(vertex_shader&& rhs) 
    { 
     shader::operator=(std::move(rhs)); 
     return *this; 
    }