Ich habe vor mir eine Aufgabe liegen, die ich alleine leider nicht lösen kann.
Wäre super, wenn ihr mir unter die Arme greifen könntet

Aufgabe lautet wie folgt:

Schreibe eine Klasse Vektor, die einen Vektor von Gleitkommazahlen (Typ double) der Länge n darstellt. Der Wert n soll variabel sein.
Die Klasse soll folgende Eigenschaften haben:
- Als gekapselte Attribute werden unsigned int dim (Länge n des Vektors) und double *elemente (Pointer auf die eigentlichen Vektorelemente) definiert. Dabei sollen die Vektorelemente auf dem Heap abgelegt werden.
- Alle Methoden sollen öffentlich sein
- Es soll einen Konstruktor mit dem int Parameter i geben, der einen Vektor mit i Elementen erzeugt und Elemente mit 0 initialisiert. Das Anlagen der Vektorelemente auf dem Heap kann im Konstruktor beispielsweise durch die Anweisung elemente = new double[dim] erreicht werden. Auf die Vektorelemente kann dann mittels elemte[k] indiziert zugegriffen werden.
- Es soll eine Methode geben, die ein Element des Vektors auf einen Wert setzt. Der Index des Vektorelements und der Wert sollen per Parameter an die Methode übergeben werden. Das element soll nur gesetzt werden, wenn der Parameterwert von Index korrekt ist. Weitere Fehlerbehandlungen sind nicht nötig.
- Ein Destruktor soll die Vektorelemente auf dem Heap wieder löschen. Achten Sie auf das richtige Freigeben des Heapbereiches.

Leider habe ich nicht wirklich viel Ahnung, wie ich anfangen soll, da ich nicht weiß wie ich die Klasse auf dem Heapspeicher anlege.
Hoffe ihr könnt mir bei der Aufgabe weiterhelfen...

Danke im Voraus!

Leider habe ich nicht wirklich viel Ahnung, wie ich anfangen soll, da ich nicht weiß wie ich die Klasse auf dem Heapspeicher anlege.

Das sollst du ja auch gar nicht machen. Nicht die Klasse soll auf dem Heapspeicher angelegt werden (das hat auch streng genommen keinen Sinn), sondern die Elemente. Und wie das geht steht in der Aufgabenstellung.

class Vektor{
protected:
unsigned int dim[n];
double *elemente;
};
public:

Vektor()
{ elemente = new double[dim]
};

Vektor(int i)
{
*dim[i];
elemente[k] = 0;
};

Soweit komme ich...keine Ahnung ob das richtig ist, der Satz mit elemente[k] indiziert zugreifen, verwirrt mich ziemlich

Die Methode zum Wertesetzen kann ich leider auch nicht aus dem Stegreif..
Der Destruktor müsste irgendwas mit
~Vektor()
{delete};

sein oder?
Wär nett, wenn ihr mir den Quellcode fertigstellt...ich versteh es meistens erst wenn ich es dann durchgehe.

Danke im Voraus

class Vektor{
protected:
unsigned int dim[n]; // ein int, nicht ein int[], oder? Wo kommt das n her?
double *elemente;
};
public:

Vektor()
{ elemente = new double[dim] // dim ist nicht initialisiert!
};

Vektor(int i)
{
*dim[i]; // hä?
elemente[k] = 0; // hier sollte das new hin.
};

Schreibe eine Klasse Vektor, die einen Vektor von Gleitkommazahlen (Typ double) der Länge n darstellt.

const unsigned n = 5431;
class Vektor
{
double werte[n];
};

Der Wert n soll variabel sein.

class Vektor
{
  unsigned n;
  double* werte;
};

Die Klasse soll folgende Eigenschaften haben:
- Als gekapselte Attribute werden unsigned int dim (Länge n des Vektors) und double *elemente (Pointer auf die eigentlichen Vektorelemente) definiert. Dabei sollen die Vektorelemente auf dem Heap abgelegt werden.

ok...

class Vektor
{
  unsigned dim;
  double* elemente;
};

- Alle Methoden sollen öffentlich sein

ok; merken wir uns.

- Es soll einen Konstruktor mit dem int Parameter i geben, der einen Vektor mit i Elementen erzeugt und Elemente mit 0 initialisiert. Das Anlagen der Vektorelemente auf dem Heap kann im Konstruktor beispielsweise durch die Anweisung elemente = new double[dim] erreicht werden. Auf die Vektorelemente kann dann mittels elemte[k] indiziert zugegriffen werden.

so nen quatsch mit int Parameter i machen wir nicht. bei der länge hat er ja auch noch gewusst, dass nen unsigned für längen sinnvoll ist. i nehm ich auch nicht als parameter-name.

Sie auf das richtige Freigeben des Heapbereiches.

gehört hier auch dazu.

class Vektor
{
public:
  Vektor(unsigned laenge)
  : dim(laenge)
  {
    elemente = new double[dim];

    for(unsigned i(0); i != laenge; ++i)
      elemente[i] = 0;
  }

  ~Vektor()
  {
    delete[] elemente;
  }
private:
  unsigned dim;
  double* elemente;
};

- Es soll eine Methode geben, die ein Element des Vektors auf einen Wert setzt. Der Index des Vektorelements und der Wert sollen per Parameter an die Methode übergeben werden. Das element soll nur gesetzt werden, wenn der Parameterwert von Index korrekt ist. Weitere Fehlerbehandlungen sind nicht nötig.

das fehlt dann noch.

Die Methode würde bei mir folgendermaßen aussehen:

void setze (unsigned int laenge, double elemente)
{
if (laenge<0)cout << "Falscheingabe" << endl;
else elemente[laenge]=element;
};

Stimmt das so?

mfG

void setze (unsigned int laenge, double elemente)
{
if (laenge<0)cout << "Falscheingabe" << endl;
else elemente[laenge]=element;
};

das meinte dein lehrer definitiv nicht, als er _bereichs_prüfung schrieb.
und der vorteil am unsigned für solche dinge ist, dass man sich den test auf < 0 sparen kann. er kann ja nur positive werte darstellen.

außerdem compiliert das so auch ganz sicher nicht.

Ums kompilieren mache ich mir aktuell keine Gedanken, da ich morgen die Prüfung auch auf dem Blatt schreiben werde, und es mehr um den Inhalt geht, als dass es sich kompilieren lässt

Stimmt die Methode denn jetzt so?

Hätte noch eine Frage: Wenn ich einen Unterklassen-Konstruktor schreibe, der einen vorhandenen Oberklassen Konstruktor aufruft, um ererbte Attribute setzen zu können, wie mache ich das am geschicktesten?

mfG

Wenn ich einen Unterklassen-Konstruktor schreibe, der einen vorhandenen Oberklassen Konstruktor aufruft, um ererbte Attribute setzen zu können, wie mache ich das am geschicktesten?

initialisierungsliste

Wird schon klappen morgen, darf ja Gott sei Dank meine Unterlagen mitnehmen

Also nochmal danke euch alle, und gute Nacht.