Zahl der Elemente eines Arrays bestimmen

m.g.

Hallo zusammen,

Ich übergebe ein Array von Zeigern, bzw. den Zeiger darauf, an eine Funktion. Wie kann ich nun innerhalb der Funktion herausfinden, wieviele Elemente das Array hat?

wchar_t **templates_compare= new wchar_t*[10];
	templates_compare[0] = (wchar_t*) malloc(1024);
	//usw...
	templates_compare[0] = L"template_comp1.txt"; 
	//usw...

	identify_files(L"template.txt",templates_compare);

Dabei möchte ich weder std::vector nutzen noch die Zahl der Elemente als Argument an die Funktion übergeben. Danke für die Hilfe.

Schöne Grüsse,
m.g.

Nexus

m.g. schrieb:

Ich übergebe ein Array von Zeigern, bzw. den Zeiger darauf, an eine Funktion. Wie kann ich nun innerhalb der Funktion herausfinden, wieviele Elemente das Array hat?
[...]
Dabei möchte ich weder std::vector nutzen noch die Zahl der Elemente als Argument an die Funktion übergeben. Danke für die Hilfe.

Das ist im Allgemeinen nicht möglich. Du kannst z.B. bei Zeigern das Ende als Nullzeiger markieren (wie bei C-Strings), oder sonst etwas basteln. Aber es ist mühsam.

Gibt es einen Grund, wieso du std::vector nicht verwenden willst?

Janjan

m.g. schrieb:

templates_compare[0] = (wchar_t*) malloc(1024);
	templates_compare[0] = L"template_comp1.txt";

Das produziert ein schönes Speicherleck. Gibt es einen Grund warum du nicht wstring benutzt?

[quote="m.g."]

wchar_t **templates_compare= new wchar_t*[10];
templates_compare[0] = (wchar_t*) malloc(1024);
templates_compare[0] = L"template_comp1.txt";

{/quote]
Bist Du Dir darüber im Klaren, dass das ein Speicherleck ist? Die 1024 wchar_t Dinger hängen nämlich unerreichbar im Heap.

Viel zu viel *
Viel zu viel new
Viel zu viel malloc

Wenn Du einen vector<wstring> willst, dann nimm ihn doch auch. :p

m.g.

Ich wollte ja eigentlich keinen Vektor verwenden. Aber ihr habt mich überzeugt, ich werde mein Programm etwas anders aufbauen und Vektoren verwenden.
Ich war mir im übrigen auch nicht im klaren, dass es ein Speicherleck ist. Danke für den Hinweis.

Nexus

m.g. schrieb:

Ich wollte ja eigentlich keinen Vektor verwenden.

Hattest du einen bestimmten Grund? Bei mir ist es genau umgekehrt: Es braucht eine besondere Rechtfertigung, damit ich mit rohen Arrays oder besitzenden Zeigern hantiere und auf moderne Mittel wie std::vector verzichte.

m.g.

Weil das ganze Teil einer DLL wird und unter anderem von einem Programm in Smalltalk angesprochen wird. Und das klappt wohl nur, bzw. am einfachsten, mit Pointern auf Char Arrys.

vector<T> für T!=bool garantiert ein lineares Speicherlayout

vector<int> foo (99);
  int* ptr = &foo[0];
  ptr[3] = 23;
  cout << foo[3] << '\n';

zeusosc

Hi,.

Du musst dir die allocierte größe in bytes durch typengröße speichern. Dann hast Du auch die anzahl der Elemente.

grüüße

Nexus

zeusosc schrieb:

Du musst dir die allocierte größe in bytes durch typengröße speichern. Dann hast Du auch die anzahl der Elemente.

Du meinst wohl divideren?

zeusosc

Jo,..
deswegen auch das wort "durch"...

m.g.

Und wie soll das bitte mit Pointern funktionieren?

zeusosc

#define MAX_SIZE 1024

size_t index=0;

size_t size_in_bytes = MAX_SIZE*sizeof(double);

double* ptr=(double*)malloc(size_in_bytes);

//der compiler convertiert automatisch den index als vielfaches der typengröße

index=511;

double Wert_An_stelle_512 = *(ptr+index);

gruß

Nexus

zeusosc, ich denke eher, m.g. meinte, wie du bei einem Zeiger auf ein dynamisches Array die Anzahl Elemente bestimmen kannst. Dafür gibt es nämlich keine portable Möglichkeit.

zeusosc

Hi,.

ja ist richtig,.. ich dachte es bezog sich auf die äußerung die größe einfach zu sichern,..

grüße