3. variable Länge eines arrays in einer Klasse

variable Länge eines arrays in einer Klasse

  • A

    ich benötige eine Klasse, in der ein Element ein array ist. Dieses Array soll eine offene Länge haben, die ich mittels einer Übergabe festlege.
    Also so etwa soll die Klasse aussehen:

    class Punkt
{
public:
 Punkt(){}
 Punkt(int len)
 {
  int verbindungen[len];
 }
};
int main(void)
{
Punkt A(20);
}
    0
  • 1

    meinst du sowas ?

    class Punkt
{
public:
 int *verbindungen;
 Punkt(){}
 Punkt(int len)
 {
  verbindungen = new int[len];
 }
};
int main(void)
{
Punkt A(20);
}
    0
  • T

    oder sowas?

    template<int size>
class Punkt
{
    int  verbindungen[size];
};

Punkt<10> P;
    0
  • A

    An 1ntrud0r

    lol, hab gerade den absolut gleichen code geschrieben. Hab mir das mit dem heap überlegt. war mir nur nicht sicher ob ich das im Konstruktor machen kann.
    naja, vielen Dank für die Bestätigung.

    und noch ne Frage. Wie kann ich jetzt feststellen wie groß mein Objekt ist, also der Speicherplatz?
    Bei sizeof(A); ist er nicht begeistert

    class Punkt
{
public:
	int *ptr;
	Punkt()
	{
		ptr=new int[100];
	}
	Punkt(int len)
	{
		ptr=new int[len];
	}
	~Punkt()
	{
		delete[] ptr;
		ptr=NULL;
	}
};
    0
  • J

    @1ntrud0r:

    Wo ist das delete?

    Mein Vorschlag wäre:

    #include <vector>

class A
{
public:
  A(int size) : verbindungen(size, -1) {}
private:
  std::vector<int> verbindungen;
}

    Damit sparen wir uns auch gleich die Verantwortung für das delete

    MfG Jester

    0
  • T

    Täten wir mit der Templateklasse auch, außerdem hat ers im Destruktor stehen (zumindest rookie).

    Btw sizeof(*A), sonst kriegst du die Größe des Pointers...

    0
  • 1

    er hat nur eine klasse gewollt mit nem array er hat nicht gesagt das er das wieder freigeben will oder hab ich mich geirrt ... ?

    außerdem ist es ein delete[] und soweit ich weiss ist das ein anderer operator wie delete 🙂 zumindest partitiell

    0
  • A

    Thx Theston

    immer dieses derefferenzieren 😉

    funzt aber mit dem auch nicht, oder eher noch weniger.#

    Punkt A(10),B;
cout<< sizeof(A);
cout<< sizeof(B);

    nix gehen!!!

    0
  • T

    Inwiefern funktioniert es denn nicht?
    Bedenke, dass dein Objekt, so wie es ist, 4 Byte Speicher belegt, da es nur einen Zeiger hat.

    0
  • 1
     

    class Punkt 
{ 
public: 
    int size;
    int *ptr; 
    Punkt() 
    { 
        ptr=new int[100]; 
        size = 100;
    } 
    Punkt(int len) 
    { 
        ptr=new int[len]; 
        size = len;
    } 
    ~Punkt() 
    { 
        delete[] ptr; 
        ptr=NULL; 
    } 
};

    macht doch kein stress 🙂

    0
  • O

    Die Größe eines mit new[] allokierten Arrays kann man später nicht mehr herausfinden.
    Davon abgesehen reicht delete im Destruktor auch nicht, weil das automatisch generierte Kopieren und Zuweisen auch noch falsch ist. Man kann sich die ganze Tipp- und Denkarbeit ersparen, indem man einfach Objekte nimmt, die sich so verhalten, wie C++ es erwartet - std::vector zum Beispiel. IMHO sollte man delete/delete[]/sonstige Freigabefunktionen nur und wirklich nur benutzen, um Wrapperklassen zu schreiben.

    0
  • A

    So jetzt habe ich aber ein dickes Problem:

    ich hab das allokieren ja nur gemacht um speicher zu sparen.
    nun brauche ich ein array vom Typ Punkt.
    die Verbindungsanzahl eines Punktes zu anderen Punkten kann ich aber erst nach der deklaration des Punkt arrays angeben. Damit sind aber alle arrays in den Objekten 100 Felder lang. Wie bekomme ich die auf eine Länge, die ich angeben kann?
    btw. Ich möchte ein Programm schreiben, dass mir z.B. die Anzahl der Vierecke in einer Figur angibt.
    Ich gebe also für jeden Punkt an mit welchen Punkten er verbunden ist.
    Das ändert sich eben für jeden Punkt und deshalb möchte ich als Element des Punktes ein array der Laenge len.
    Vielleicht habt ihr ne Idee 😉

    0
  • O
     

    class Punkt
{
private:
    std::vector<int> verbindungen;

public:
    Punkt(std::size_t anzahl = 0)
    : verbindungen(anzahl, -1)
    {
    }

    std::size_t anzahl() const
    {
        return verbindungen.size();
    }

    void setze_anzahl(std::size_t neue_anzahl)
    {
        verbindungen.resize(neue_anzahl, -1);
    }

    int verbindung(std::size_t index) const
    {
        return verbindungen.at(index);
    }

    void setze_verbindung(std::size_t index, int wert)
    {
        verbindungen.at(index) = wert;
    }
};

    Damit kannst du die Größe beliebig ändern.

    0
  • H

    ist garantiert, dass vector<...>::size_type std::size_t entspricht? Ich meine, das hängt vom Allokator ab und ist vorgeschreiben, dass der Standard-Allokator std::size_t verwendet?

    0
  • O

    Ich denke schon. Immerhin zeigt die MSDN std::allocator::size_type nicht als impl-def an 🙂 Ich habe ehrlich gesagt nicht lange drüber nachgedacht, ich wollte nur nicht die ints übernehmen 😉

    0
Anmelden zum Antworten