Ich soll eine von der abstrakten Basisklasse Function abgeleitete Klasse Polynomial schreiben und bräuchte dabei dringend Hilfe.
Die Anforderungen an Konstruktoren und Memberfunctions sind in der Polynomial.hpp nochmal beschrieben.

Ich hoffe ihr könnt mir helfen und dankeschön schonmal!

//  Function.hpp

#pragma once
#include <cstdlib>

class Function {
public:

    virtual double operator() (double x) const = 0;
    virtual ~Function() {};
};

//  Polynomial.hpp

#pragma once
#include <cstdlib>
#include "Function.hpp"

///@@ NOTE: Polynomial must be derived from Function!
class Polynomial : public Function {
public:
    //! Default constructor
    //! Creates 0th-order polynomial p(x) = 0
    Polynomial();
    //
    //! Constructor: Construct polynomial with given coefficients
    //! The coefficients are copied and stored by the class, the
    //! pointer pc to the original array is *not* used again.
    //! \param pc pointer to coefficient array
    //! \param number of coefficients (=order of polynomial)
    Polynomial(const double* const pc, size_t n);

	~Polynomial();

    //
    //! Set polynomial coefficients. Coefficients are copied, the
    //! pointer pc is never used again.
    //! \param pc pointer to coefficient array
    //! \param number of coefficients (=order of polynomial)
    void setCoefficients(const double* const pc, size_t n);

Wozu brauche ich denn setCoefficient?? Macht die nicht dasselbe wie der Konstructor??

virtual double operator() (double x) const;

private:
    ///@@ you *must* use a plain-C double array to store
    ///@@ the coefficients of the polynomial, std::vector is NOT allowed
    double * pc_;
    size_t n_;
};

//  Polynomial.cpp

#include "Polynomial.hpp"
#include <iostream>
#include <math.h>

using namespace std;

Polynomial::Polynomial(const double* const pc, size_t n) : n_(n) {
	pc_ = new double[n];
	for (size_t i = 0; i < n; ++i) {
		pc_[i] = pc[n-i-1];
		cout << pc_[i] << endl;
	}
	setCoefficients(pc_, n_);
}

Polynomial::~Polynomial() {
	delete[] pc_;
}
void Polynomial::setCoefficients(const double* const pc, size_t n) {
	cout << "p(x) = ";
		for (size_t i = 0; i < n; ++i) {
			cout << pc[i] << " * x^" << i << " + ";
		}
		cout << endl;
}

double Polynomial::operator() (double x) const {
	double y = 0;
	for (size_t i = 0; i < n_; ++i) {
		y += pc_[i] * std::pow(x,i);
	}
	return y;
}

kommt mit bekannt vor: http://www.c-plusplus.net/forum/324188-full

snip, nicht richtig gelesen.

darf ich fragen von wo der code ist? ist das irgendeine aufgabe oder sowas?

ja, setCoefficients sollte das selbe machen wie der konstruktor. quasi eine assign-methode. setCoefficients kann einfach den konstruktor aufrufen, ganz ohne code-redundanz.

Ich versteh die edits nicht ganz. Wofür wäre denn diese swap methode und wie kann man einen std::vector nachimplementieren??

Wofür wäre denn diese swap methode und wie kann man einen std::vector nachimplementieren??

Das mit dem Vektor vergiss einfach wieder.

Die swap Funktion vereinfacht die Implementierung einiger Funktionen, die noch fehlen. Könnte so aussehen:

#include <algorithm>

void Polynomial::swap(Polynomial& x){
  using std::swap;
  swap(x.pc_, pc_);
  swap(x.n_, n_);
}

Und ja setCoefficient() macht ungefähr das gleiche wie der Konstruktor. Das machen wir uns zu nutze.
Und dann nehmen wir auch noch swap dazu et voilá:

void Polynomial::setCoefficients(const double* const pc, size_t n){
  // bau ein Polynomial und tausch Plaetze mit diesem:
  Polynomial(pc, n).swap(*this);
}

Das war ja einfach! Und alle Widrigkeiten (n!=this->n_) elegant umschifft.

Trotzdem hat Polynomial so wie es jetzt da steht noch ein Riesenproblem:

void f(){
  Polynomial p1;
  Polynomial p2(p1);
} // crash!

Warum macht das Programm hier einen uneleganten Abgang?
Lies mal, über die "Rule of three" in C++.

Könnte das nach der deklaration im header dann so aussehen?

Polynomial::Polynomial(const Polynomial& polyn) : pc_(polyn.pc_), n_(polyn.n_)
{
}

Polynomial& Polynomial::operator=(const Polynomial& polyn) {
	pc_ = polyn.pc_;
	n_ = polyn.n_;
	return *this;
}

Das heißt mir fehlen noch copy constructor und copy assignment.

Ja. stimmt!

bina schrieb:

Könnte das nach der deklaration im header dann so aussehen?

Polynomial::Polynomial(const Polynomial& polyn) : pc_(polyn.pc_), n_(polyn.n_)
{
}

Polynomial& Polynomial::operator=(const Polynomial& polyn) {
	pc_ = polyn.pc_;
	n_ = polyn.n_;
	return *this;
}

Nein - jetzt hast Du genau die implizit definierten Versionen nachgebaut, die auch der Compiler generiert.
Hast Du denn verstanden, warum die Rule of three wichtig ist, und warum f() oben crasht?

das heißt, ich muss ein neues array erzeugen...

Polynomial::Polynomial(const Polynomial& polyn) {
	n_ = polyn.n_;
	pc_ = new double[polyn.n_];
	for (size_t i = 0; i < polyn.n_; ++i) {
		pc_[i] = polyn.pc_[i];
	}
}

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

so in etwa?

f() crasht, weil der destructor zweimal aufgerufen wird, die selbe adresse zu löschen, oder?

das heißt, ich muss ein neues array erzeugen...

Genau. Offensichtlich war das dann ein Flüchtigkeitsfehler mit Deinem ersten Schuß von Copy C'tor und -Assignment.

Versuch die einzelnen Konstruktoren und Operatoren aufeinander aufzubauen. Du kannst u.U. auch C++11 features nutzen, z.B. Konstruktoren bequem aus Konstruktoren aufrufen (Delegating Constructors):

#include <algorithm> // copy

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

// diser C'tor delegiert an den C'tor oben - der macht dann die Arbeit
Polynomial::Polynomial(const Polynomial& poly)
  : Polynomial(poly.pc_, poly.n_)
{
}

Vergiss auch nicht, dass Du unter anderem auch schon ein swap() im Baukasten hast. Und das von Braunstein erwähnte Copy/Swap Idiom benutzt Du u.U. schon, wenn Du setCoefficients() so übernommen hast, wie sie oben steht.
Du wirst sehen, dass die Zeilenanzahl angenehm übersichtlich bleibt und Du nirgendwo über Sonderfälle stolperst oder manuell Speicher freigeben musst (Ausser natürlich im Destruktor.)

Ich klebe es hier nochmal rein:

void Polynomial::setCoefficients(const double* const pc, size_t n){
  // bau ein Polynomial und tausch Plaetze mit diesem:
  Polynomial(pc, n).swap(*this);
}

Händisch würde man das evtl. so programmieren müssen:

• alten Speicher freigeben
• neuen Speicher allozieren
• n_ kopieren
• Daten kopieren

Das alles in nur einer Zeile.

Händisch würde man das evtl. so programmieren müssen:

• alten Speicher freigeben
• neuen Speicher allozieren
• n_ kopieren
• Daten kopieren

Das alles in nur einer Zeile.

Eher
* Neuen Speicher anfordern
* Neuen Speicher initialisieren
* Zeiger- und Grösse-Member auf neuen Speicher verbiegen
* Alten Speicher freigeben

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

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

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

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

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;
}

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.

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_];

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.

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?

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.

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)));
		}
	}

die fragliche stelle ist in zeile 2132 einer datei namens xutility

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

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

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_);
}

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.