ich habe in meiner Anwendung viele Stellen, an denen z.B. ein std::vector erstellt und befüllt wird. Danach wird dieser Vector an eine andere Klasse zur weiterverarbeitung überreicht.

Die aufrufende Klasse macht mit dem std::vector danach nichts mehr. Das hört sich für mich nach einem Fall an, wo ich die Move-Semantik verwenden könnte um ohne SmartPtr/Heap-Objekte billig Objekte weiterreichen könnte.

Nur so richtig klar ist mir nicht, wie der Code aussehen sollte.

Macht man das wie folgt dargestellt?

class Datensenke {
  public:
  Datensenke(std::vector<size_t> &&vec)
    : myVec_(vec) {
  }

  void machWas();

  private:
  std::vector<size_t> myVec_;
};

class Datenquelle {
  public:
  void verarbeite() {
      for (size_t i = 0; i < 100; ++i) {
          myVec_.push_back(i);
      }

      Datensenke senke(std::move(myVec_));
      senke.machWas();
  }

  private:
  std::vector<size_t> myVec_;
};

Falls ja, eine Folgefrage: wie kann ich eine RValue-Referenz weitergeben? Beispiel:

class Datensenke {
  public:
  Datensenke(std::vector<size_t> &&vec)
    : myVec_(vec) {
  }

  void machWas();

  private:
  std::vector<size_t> myVec_;
};

void verarbeite(std::vector<size_t> &&vec)  // <<---- Ist das so richtig, oder sollte hier std::vector<size_t> stehen?
{
      Datensenke senke(std::move(myVec_));  // <<---- Wie gebe ich hier vec weiter?
      senke.machWas();
}

int main()
{
    std::vector<size_t> myVec;
    for(size_t i = 0; i < 1000; ++i) {
       myVec.push_back(i);
    }

   verarbeite(std::move(myVec));

   return 0;
}

Danke.

Grüße Wadim

vec ist ein lvalue. Daher wird eine Kopie durchgeführt. std::move(vec) ist hingegen ein rvalue (xvalue).

Datensenke(std::vector<size_t> &&vec) 
    : myVec_(vec) { 
  }

vec ist ein lvalue. Daher wird eine Kopie durchgeführt. std::move(vec) ist hingegen ein rvalue (xvalue).

Interessant, ich bekomme bei meinem g++ keine Warnung an dieser Stelle.

Was für ein Konstruktor ruft der g++ dann auf (ohne das move)?