void Universum::AddStar(String &s,double x, double y, double z)
{
    Stern **h = new Stern*[anzahl_sterne+1];
    for(int i = 0; i < anzahl_sterne; i++)
    {
//        h[i] = new Stern(stars[i].GetName(),stars[i].GetX(),stars[i].GetY(),stars[i].GetZ());
        delete this->stars[i];
    }
    h[anzahl_sterne] = new Stern(s,x,y,z);
    delete [] stars;
    stars = h;
    anzahl_sterne++;
}

Die Zeile die kommentiert ist wird immer als fehler erkannt.

die Variable stars ist vom Datentyp: Stars **

Der Konstruktor von Stern sieht folgendermasen aus:

Stern::Stern(String &name,double x,double y,double z)
{
    this->name = name;
    this->x = x;
    this->y = y;
    this->z = z;
}

Danke für die hilfe im Voraus

Was auf jeden Fall falsch ist, ist stars[i].XXX , weil stars[i] nicht ein Star-Objekt selbst, sondern nur ein Zeiger darauf ist. Es muss also stars[i]->XXX heißen.

Was sonst noch schlecht ist:
- Du willst ein Star-Objekt kopieren. Für so etwas gibt es es Kopierkonstruktor, die Du nutzen solltest
- Du machst es Dir mit Star** unnötig kompliziert und fehleranfällig.

Probier mal diesen Ansatz:

struct Star
{
  std::string name;
  double x, y, z;
  // normales "Aggregat" (keine benutzerdefinierten Konstruktoren)
};

class Universum
{
public:
  void addStar(Star const& x) {stars_.push_back(x);}
  int numStars() const {return stars_.size();}
private:
  std::vector<Star> stars_;
};

int main()
{
  Universum u;
  Star s = {"Dings", 1.0, 3.0, 2.0}; // Aggregat-Initialisierung
  u.addStar(s);
}

Beachte: Hier wurden keine Zeiger verwendet und kein new/delete. Die dynamische Speicherverwaltung wird in std::vector gekapselt. Kapselung ist etwas feines!

Mach Dir auch klar, was das const jeweils im Quellcode zu suchen hat, wenn Du es noch nicht weißt.

Du kannst Star natürlich auch so schreiben:

struct Star
{
  std::string name;
  double x, y, z;

  Star() : x(0), y(0), z(0) {}
  explicit Star(std::string const& n,
    double x, double y, double z)
  : name(n), x(x), y(y), z(z) {}
  // kein Aggregat mehr. Die Klasse bekommt vom
  // Compiler dennoch einen impliziten Kopierkonstruktor
  // und Zuweisungsoperator =
};

und dann so benutzen

int main()
{
  std::vector<Star> sterne;
  sterne.push_back( Star("Dings",1.0,3.0,2.0) );
  Star dings = sterne[0]; // "Kopier-Initialisierung" (copy-ctor)
  Star bums  = dings;     // "Kopier-Initialisierung" (copy-ctor)
  dings = bums;           // "Kopier-Zuweisung" (operator=)
}

Gruß,
SP

explicit ist doch hier gar nicht nötig!?

bb

explicit Star(std::string const& n, 
    double x, double y, double z) 
  : name(n), x(x), y(y), z(z) {}

explicit ist doch hier gar nicht nötig!?

bb

Korrket, denn das ist nur bei Konstruktoren mit einem Argument nötig.
(Od. die Anzahl Argumente könnnen durch Default Werte zu einem Argument reduziert werden.)
Simon

explicit Star(std::string const& n, 
    double x, double y, double z) 
  : name(n), x(x), y(y), z(z) {}

explicit ist doch hier gar nicht nötig!?

Hast recht. Das kommt davon, wenn man erst x,y,z, "mit 0 defaulten" will und sich dann umentschließt.

Gruß,
SP