abstrakte Basisklasse und Vererbung

Marthog

hustbaer schrieb:

Sonst ist das ganze nämlich nicht Exception-safe.

An der exceptionsafety aendert das wenig. Es gibt nur keine strong guarantee.

hustbaer

Marthog schrieb:

hustbaer schrieb:

Sonst ist das ganze nämlich nicht Exception-safe.

An der exceptionsafety aendert das wenig. Es gibt nur keine strong guarantee.

Wenn man nur stur die einzelnen Punkte runtertippt, dann ist es gar nicht exception-safe.
Wenn man es "richtig" macht, und auch der Destruktor passend implementiert ist (wovon man in diesem Fall vermutlich ausgehen kann), dann bekommt man die basic guarantee.

Sogesehen hast du Recht.

Allerdings halte ich die basic guarantee für zu schwach um nützlich zu sein. Wobei es lustigerweise keinen (mir bekannten) Namen für das mMn. nützlichere Mittelding zwischen strong und basic gibt. Nämlich die Garantie dass das Objekt in einem gültigen, aber undefinierten Zustand zurückbleibt. D.h. zusätzlich zur basic guarantee (=nur garantiert dass man das Objekt ohne Probleme löschen kann) noch die Garantie dass man sämtliche Memberfunktionen (und friends bzw. was sonst noch zum Interface der Klasse gehört) aufrufen kann ohne dass es UB gibt.

Und ganz allgemein halte ich es für angebracht bei der Beschreibung von solchen Dingen darauf zu achten nichts wichtiges auszulassen -- auch wenn ein erfahrener Programmierer (der dann allerdings gar keinen Teil der Erklärung braucht, weil er es schon weiss) es sich denken kann.
Also:
* alten Speicher freigeben
*** pc_ auf NULL setzen**
* neuen Speicher allozieren
* n_ kopieren
* Daten kopieren

bina

händisch geschrieben müsste der assignment operator also dann so aussehen:

Polynomial& Polynomial::operator=(const Polynomial& polyn) {
	if (&polyn != this) {
		delete[] pc_;
		pc_ = new double[polyn.n_];
		n_ = polyn.n_;
		for (size_t i = 0; i < polyn.n_; ++i) {
			pc_[i] = polyn.pc_[i];
		}
	}
	return *this;
}

und wenn ich nun das copy/swap ideom benutze, könnte ich das so schreiben?

Polynomial& Polynomial::operator=(const Polynomial& poly) {
	if (&poly != this) {
		Polynomial(poly.pc_, poly.n_).swap(*this);
	}
	return *this;
}

hustbaer

@Marthog
Siehst du jetzt was ich meine?

bina schrieb:

händisch geschrieben müsste der assignment operator also dann so aussehen:

Polynomial& Polynomial::operator=(const Polynomial& polyn) {
	if (&polyn != this) {
		delete[] pc_;
		pc_ = new double[polyn.n_];
		n_ = polyn.n_;
		for (size_t i = 0; i < polyn.n_; ++i) {
			pc_[i] = polyn.pc_[i];
		}
	}
	return *this;
}

Ja.
Du kannst noch an der Reihenfolge drehen z.B. erst wenn eine neue Allozierung erfolgreich war, das alte Array freigeben. (Das wurde von Hustbaer und Marthog angerissen. Exkurs: Stichwort: Exception safety.)
Du kannst auch darauf verzichten neu zu allozieren, wenn Du gleichviel oder weniger Speicher brauchst. Und, und, und...
Aber prinzipiell: ja.

bina schrieb:

und wenn ich nun das copy/swap ideom benutze, könnte ich das so schreiben?
Polynomial& Polynomial::operator=(const Polynomial& poly) {
	if (&poly != this) {
		Polynomial(poly.pc_, poly.n_).swap(*this);
	}
	return *this;
}

Ja.

Da fällt die Wahl doch leicht.

hustbaer

Für copy & swap reicht

Polynomial& Polynomial::operator=(Polynomial other) { 
     swap(other); 
     return *this; 
}

Und für die basic exception-guarantee reicht

delete[] pc_;
        pc_ = 0; // <----------------------
        pc_ = new double[polyn.n_];

volkard

bina schrieb:

und wenn ich nun das copy/swap ideom benutze, könnte ich das so schreiben?
Polynomial& Polynomial::operator=(const Polynomial& poly) {
	if (&poly != this) {
		Polynomial(poly.pc_, poly.n_).swap(*this);
	}
	return *this;
}

Der Test auf Selbstzuweisung ist nicht mehr notwendig.

bina

Vielen vielen Dank euch allen!!!

Eine abschließende Frage hab ich noch. Ich bekomm eine Compilerwarnung und zwar: error C4996: 'std::_Copy_impl': Function call with parameters that may be unsafe...
Ignoriere ich das gekonnt, oder muss ich da was ändern?

bina schrieb:

Ich bekomm eine Compilerwarnung und zwar: error C4996: 'std::_Copy_impl': Function call with parameters that may be unsafe...
Ignoriere ich das gekonnt, oder muss ich da was ändern?

Das ignorierst Du natürlich nicht, sondern behebst es.
Wenn der Fehler nicht offensichtlich ist, kommst Du nicht darum herum uns die fragliche Stelle in Deinem Code zu zeigen.

bina

die fragliche stelle ist in zeile 2132 einer datei namens xutility:

template<class _InIt,
	class _OutIt> inline
	_OutIt copy(_InIt _First, _InIt _Last,
		_OutIt _Dest)
	{	// copy [_First, _Last) to [_Dest, ...)
	if (_First == _Last)
		return (_Dest);
	else
		{	// worth copying, check then copy
		_DEBUG_RANGE(_First, _Last);
		_DEBUG_POINTER(_Dest);
		return (_Copy_impl(_Unchecked(_First), _Unchecked(_Last),
==>			_Dest, _Is_checked(_Dest)));
		}
	}

bina schrieb:

die fragliche stelle ist in zeile 2132 einer datei namens xutility

Wichtig ist die Stelle, wo Du std::copy() aufrufst.

hustbaer

Das kommt immer wenn man "unsafe" Iteratoren verwendet. Wie z.B. Zeiger.
=>
#define _SCL_SECURE_NO_WARNINGS

http://msdn.microsoft.com/en-us/library/aa985974.aspx

bina

Furble Wurble schrieb:

bina schrieb:

die fragliche stelle ist in zeile 2132 einer datei namens xutility

Wichtig ist die Stelle, wo Du std::copy() aufrufst.

Da hab ich deinen Teil übernommen:

Polynomial::Polynomial(const double* const pc, size_t n)
: pc_(new double[n]), n_(n)
{
	std::copy(pc, pc + n, pc_);
}

bina schrieb:

Polynomial::Polynomial(const double* const pc, size_t n)
: pc_(new double[n]), n_(n)
{
	std::copy(pc, pc + n, pc_);
}

Der Code ist richtig.

Wenn Dich das wie und warum der Warnung interessiert, steht sicherlich viel zur Erklärung in hustbaers Link zum MSDN...
Oder Du übernimmst einfach das Makro, das er gepostet hat und gut ist.