Array größe von einem Struct-Zeiger

Ich hab ein Array-Zeiger auf ein Struct und möchte wissen wie viele Elemente ich hab *kompleziert zu erklären*

Folgenes:

struct sMeinStruct
{
  int    nInt;
  float  ffloat;
  double double;
  ...
} *pMeinStruct;

pMeinStruct = new sMeinStruct[nAnzahl];

Nun will ich wissen wie groß nAnzahl ist. Hab mir schon folgenes ausprobiert:

nItemCount = sizeof(pMeinStruct)/sizeof(sMeinStruct); // bekomme ich immer 4 / 0 = 	CXX0032: Fehler: Division durch Null
 nItemCount = sizeof(pMeinStruct)/sizeof(pMeinStruct[0]); // bekommme ich das gleich

Logisch find ich das im augenblich nicht - kann mir das jemand mal erleutern. Hab auch nix im FAQ darüber gefunden.

BTW: Noch eine kleine Frage am Rande. Wo ist der Unterschied beim Array freigeben zwischen:

free(pMeinStruct);
 delete [] pMeinStruct;

Bashar

pMeinStruct = new sMeinStruct[nAnzahl];

Nun will ich wissen wie groß nAnzahl ist.

Du wirst nicht umhin kommen, die nAnzahl zu merken. Es gibt keine (portable) Möglichkeit, nachträglich zu erfahren, wie groß ein dynamisches Array ist.

Der Unterschied zwischen free und delete[] ist zweierlei:

free darf nur auf Pointer, die von malloc kommen, angewendet werden; delete[] nur auf Pointer von new[]
free gibt einfach den Speicher frei, delete[] ruft vorher die Destruktoren der Array-Elemente auf

Artchi

Benutz einfach std::vector welches den gewünschten Zweck erfüllt. Dynamisches Array und du weißt immer wie groß es ist.

C14

Dass du nen Divisionsfehler bekommst kann eigentlich nicht sein...
sizeof(sMeinStruct) sollte gehen.

Um nochmal den Fehler bei deinem Ansatz zu erklären:
sizeof(pMeinStruct) liefert die Größe von pMeinStruct, also die Größe eines Zeigers (auf MeinStruct) der idr. 4 bytes groß ist, nicht aber die Größe des Bereichs auf den er zeigt.
Das ist anders bei Arrays:

sMeinStruct array[10];
int groesse = sizeof(array)/sizeof(sMeinStruct); // funktioniert

Benutz einfach std::vector welches den gewünschten Zweck erfüllt. Dynamisches Array und du weißt immer wie groß es ist.

Wie funktioniert das? Hab schon rumgesucht aber nix gefunden. Möchte nur die Arraygröße wissen.

entelechie

der vector ist eine container-klasse.
du kannst also dinge in den vector reintun, nach
der groesse fragen, etc.

#include <vector>
...
std::vector<sMeinStruct> v( 10 );

// elemente hinzufuegen
v.push_back( meinstructX );
// oder analog zum array
v[5] = meinstructY;

//groesse
v.size();

Cool, funktioniert soweit. Hätte da nur noch mal paar Fragen zum händlich, da ich leider die hilfe dazu nicht so ganz verstehe. *voll verwirrend*

Wie bekomme ich einen Zeiger auf mein Vector (nicht aus Struct). Und wie deklariere ich mir ein vector pointer:
std::vector<sMeinStruct> * MeinVectorStruct; // geht nicht?!

struct sMeinStruct 
{ 
  int    nInt; 
  float  ffloat; 
  double double; 
  ... 
} *pMeinStruct; 

...

std::vector<sMeinStruct> MeinVectorStruct;  // mein Vector
MeinVectorStruct.push_back(MeinTempStruct); // einmal ein struct einfügen
ASSERT(MeinTempStruct.size() == 1); // nun größe checken
MeinTempStruct.pop_back(); // struct wider löschen
ASSERT(MeinTempStruct.size() == 0); // nun ist es wider weg

entelechie

X-Ray schrieb:

std::vector<sMeinStruct> * MeinVectorStruct; // geht nicht?!

doch. du hast jetzt einen zeiger auf einen vector<sMeinStruct>.
allerdings hast du noch keine instanz vom vector.
der unterschied zwischen
std::vector<sMeinStruct> * MeinVectorStruct;
und
std::vector<sMeinStruct> MeinVectorStruct;
ist, dass bei der zweiten anweisung bereits ein objekt erzeugt wird.
die erste anweisung deklariert nur einen zeiger, der die adresse
fuer einen vector aufnehmen kann.

du koenntest:

std::vector<sMeinStruct> v1;
std::vector<sMeinStruct> * v2 = &v1; // v2 zeigt auf v1

// vector dynamisch anlegen
std::vector<sMeinStruct> * v3 = new std::vector<sMeinStruct>();
...
// dann musst du ihn auch wieder explizit loeschen
delete v3;

junix

Wobei es hier langsam zeit wird für eine Zeile ala

typedef std::vector<sMeinStruct> MyStructVector;

-junix

Descartes

X-Ray schrieb:

Cool, funktioniert soweit. Hätte da nur noch mal paar Fragen zum händlich, da ich leider die hilfe dazu nicht so ganz verstehe. *voll verwirrend*

Wie bekomme ich einen Zeiger auf mein Vector (nicht aus Struct). Und wie deklariere ich mir ein vector pointer:
std::vector<sMeinStruct> * MeinVectorStruct; // geht nicht?!

Der Einfachheit halber nehme ich jetzt mal nur "int" statt dein struct...

#include <vector>
#include <iostream>

int main()
{
  std::vector<int> vec;   /* vector<int> anlegen */

  vec.push_back(10);      /* den Vector mit etwas leben fuellen... */
  vec.push_back(20);
  vec.push_back(30);
  vec.push_back(40);
  vec.push_back(50);

  std::vector<int>::iterator iter; /* einen Iterator auf vector<int> anlegen */
  iter = vec.begin();              /* ... und auf den Anfang unseres vector<int> zeigen lassen */

  while( iter != vec.end() )       /* jetzt iterieren wir ueber unseren vector<int> */
    {
      std::cout << *iter << std::endl;
      ++iter;                      /* ... und schieben unseren Iterator eine Position weiter */
    }

  return 0;
}