Move CTOR?

Guten Morgen Gemeinde,

ich habe mal wieder eine Frage. Wenn ich eine Vectorklasse von vector ableite, wie muß dann der Move Konstruktor aussehen?
Ist das folgende korrekt?

template<class T>
class MyVector : public vector<T>
{
  MyVector(MyVector&& other)
  {
    this = std::move(other);
  }
};

Wenn ich in MyVector mit T* ptr; und new/delete arbeiten würde wäre es einfach, was ist aber mit dem Container als Basisklasse?

Gruß Andreas Georg

1. std::vector<T> ist nicht als Basisklasse geeignet.
2.

MyVector(MyVector&& other)
 : std::vector<T>{std::forward<MyVector>(other)} {}

Danke Dir.

Zu ist nicht geeignet, da hast Du sicherlich recht.

Aber mir ist nichts besseres eingefallen um meinen Vektor Addition, Multiplikation usw. beizubringen.

Gruß Andreas Georg

Fytch

fwbp34 schrieb:

Aber mir ist nichts besseres eingefallen um meinen Vektor Addition, Multiplikation usw. beizubringen.

dazu gibt es bessere möglichkeiten:

// Iterator-Pattern
template<typename InputIteratorType>
void Add(InputIteratorType LhsBegin, InputIteratorType LhsEnd, InputIteratorType RhsBegin)
{
	while(LhsBegin != LhsEnd)
	{
		*LhsBegin++ += *RhsBegin++;
	}
}

// Operator-Überladung
template<typename T, typename LhsAllocator, typename RhsAllocator>
std::vector<T, LhsAllocator>& operator+= (std::vector<T, LhsAllocator>& Lhs, std::vector<T, RhsAllocator> const& Rhs)
{
	// Range prüfen, evtl. throwen
	for(typename std::vector<T, LhsAllocator>::size_type i = 0; i < Lhs.size(); ++i)
	{
		Lhs[i] += Rhs[i];
	}
	// Edit: Hier natürlich noch ein return-Statement, das hab ich Schussel natürlich vergessen:
	return Lhs;
}

cooky451

Wenn du kleinere vectoren für Spiele willst bau das lieber auf std::array auf (als Member, nicht erben! Oo Oder vielleicht noch besser, überlade einfach die Operatoren für std::array<float, N>.) und nimm die Größe als Template-Parameter. Dafür jedes mal neu Speicher anzufordern macht weder Sinn noch ist es (cache) effizient. Zudem ist std::forward hier nicht angebracht, nimm std::move. std::forward ist nur für einen Spezialfall in der Sprache gedacht bei dem du noch nicht weist ob du eine rvalue-reference oder eine lvalue-reference vorliegen hast.

MyVector(MyVector&& other)
    : std::vector<T>{std::move(other)}
{}