abstrakte Basisklasse und Vererbung
-
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; }
-
@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.
-
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_];
-
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.
-
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.
-
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.
-
Das kommt immer wenn man "unsafe" Iteratoren verwendet. Wie z.B. Zeiger.
=>
#define _SCL_SECURE_NO_WARNINGS
-
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.
