Arrays von Objekten

Sebi84

Hallo,

Ich habe folgenden Code:

...
Punkt* a;
a=new Punkt[anzahlecken];
...
a[i].setpositionX=x;

Leider kann ich so nicht auf die Objekte im Array zugreifen. Wie funktioniert das richtig?

Dann würde ich noch gerne wissen, wie man beim erzeugen der Objekte in einem Array einen Parameter angibt, der für jedes Objekt anders ist. Oder ist sowas nicht möglich, da alle Objekte im Array gleichzeitig erzeugt werden müssen?

Danke!

Swordfish

Ich versteh' Dich zwar nicht, aber ich sag's Dir trotzdem

class foo_t { // Dein "Objekt"

    public:

        int bar;
};

int main( ) {

    foo_t array[ 100 ]; // 100 Instanzen des Typs foo_t

    array[ 0 ].bar = 10;
}

So, what's the problem, man!?

BTW: Warum quälst Du dich mit dynamischer Speicherverwaltung ( new[] )?

Wenn Du's wirklich brauchst, dann nimm einen std::vector :

#include <vector>

class foo_t {

    public:

        int bar;
};

int main( ) {

    std::vector< bar_t > array; // Ein Container für bar_t-Elemente

    array.push_back( foo_t( ) ); // Hängt ein neues foo_t an deinen Vector an.
                                 // Dein Objekt muss kopierbar sein.
}

greetz, Swordfish

//edit: apropos: std::

Sebi84

Jagut, aber was mache ich, wenn ich ein pointer auf ein Array von Objekten habe und nun auf einzelne Elemente des Arrays zugreifen möchte?

Z.B. Klasse Punkt

Punkt* a;
a = new Punkt[10];
a[1].eineMethodeVonPunkt(); //hier Fehler

Wie greife ich auf die Objekte in der Liste zu?

std::vector<Punkt> vec;
vec.push_back(Punkt());
vec[0].setX(20);

So kannst du direkt auf ein Element zugreifen bei std::vector. Ist viel angenehmer zu verwenden.

Ansonsten kann ich bei dir so keinen Fehler entdecken.

BOSS

ich kann auch keinen fehler bei deinem code erkennen...mir ist nur aufgefallen das du beim array-index 1 anfängst. also falls das beabsichtigt ist dann ist ja ok aber ich bin mir nicht sicher ob du vll doch auf das 1. objekt des arrays zugreifen willst...also mit dem klammerindex 0...vll liegt dein "fehler" ja daran...ansonsten stimmt der code

mfg namreb

Swordfish

Sebi84 schrieb:

Jagut, aber was mache ich, wenn ich ein pointer auf ein Array von Objekten habe und nun auf einzelne Elemente des Arrays zugreifen möchte?

Z.B. Klasse Punkt
Punkt *a;
a = new Punkt[10];
a[1].eineMethodeVonPunkt(); //hier Fehler
Wie greife ich auf die Objekte in der Liste zu?

Genauso wie du's tust
Nicht vergessen das dynamisch alloziierte Array zu löschen ( delete[] )!

greetz, Swordfish

BTW: Bist du sicher, dass du den Speicher dynamisch verwallten willst/musst!? Und wenn ja - auf die Gefahr hin, mich zu wiederholen - nimm einen std::vector .

*D*Evil

template <typename T=unsigned long>
class point
{
    typedef std::pair<T, T> point_t;
    point_t m_data;

public:
    point(T const& x, T const& y) 
        : m_data(std::make_pair(x, y))
    {}

public:
    point_t const& get() const { return m_data; }
    void set(point_t const& data) { m_data = data; }

    point& operator+=(point const& rhs)
    { m_data.first += rhs.m_data.first; m_data.second += rhs.m_data.second; return *this; }
};

// Beispiele:
{
    // Zeiger (new[]/delete[]
    const std::size_t size(2);
    point* ptr_array[size](10UL, 10UL);
    ptr_array[0] += ptr_array[1];
    // ptr_array[0] => '(20, 20)'
    delete [] ptr_array;
} // Scope schließen
{
    // STL Container Class (std::vector)
    std::vector<point> data(10, point(10UL, 10UL));
    data[0] += data.at(1); // at mit range check, operator[] ohne!
    // ptr_array[0] => '(20, 20)'
}// Scope schließen (Desturktor von data wird aufgerufen)

asc

Swordfish schrieb:

Sebi84 schrieb:
...auf einzelne Elemente des Arrays zugreifen möchte?

Z.B. Klasse Punkt
Punkt *a;
a = new Punkt[10];
a[1].eineMethodeVonPunkt(); //hier Fehler
Wie greife ich auf die Objekte in der Liste zu?
Genauso wie du's tust
Nicht vergessen das dynamisch alloziierte Array zu löschen ( delete[] )!

Vielleicht ein Mißverständnis meinerseits da ich eigentlich kaum noch mit Arrays (und grade nicht mit Arryas von Zeigern) arbeite. Aber ich bin der Meinung wenn man auf einen Zeiger zugreift sollte man statt den . -> schreiben...

Punkt *a;
a = new Punkt[10];
a[1]->eineMethodeVonPunkt();
delete[] a;

cu André

CStoll

asc schrieb:

Vielleicht ein Mißverständnis meinerseits da ich eigentlich kaum noch mit Arrays (und grade nicht mit Arryas von Zeigern) arbeite. Aber ich bin der Meinung wenn man auf einen Zeiger zugreift sollte man statt den . -> schreiben...
Punkt *a;
a = new Punkt[10];
a[1]->eineMethodeVonPunkt();
delete[] a;
cu André

Mußt du (in diesem Fall) nicht - du brauchst einen Zeiger nur einmal dereferenzieren - und sowohl der Index-Zugriff [] als auch der Pfeil-Operator -> beinhalten eine Dereferenzierung (davon ist also eine überflüssig).

*D*Evil

Punkt* ptr_array = new Punkt[10];
ptr_array->foo(); 
ptr_array[0].foo();

Die beiden Aufrufe sind gleich

ptr_array[1]->

geht nur bei Punkt**