Ich habe folgende Methode geschrieben:

// ----------------------------------------------------------------------------
bool ResourceHandler::AddBitmap(const unsigned char *data, int length, const std::string& name)
// ----------------------------------------------------------------------------
{	
	MAP_WXBITMAP_T::iterator it = mapBitmaps.find(name);

	if(it == mapBitmaps.end())
	{
		wxMemoryInputStream is(data, length);
        mapBitmaps[name] = wxBitmap(wxImage(is, wxBITMAP_TYPE_ANY, -1), -1);
		return(true);
	}

	return(false);
}

Dummerweise muss der benutzer immer die Länge von char *data per sizeof übergeben, wenn ich in der Methode sizeof(data) aufrufe meldet mir der Stream, dass das Bild korrupt ist.
Wo ist da jetzt genau der unterschied?

Hab's grad mal ausprobiert. Wenn du data an die Funktion übergibst, dann gibt sizeof nicht mehr die Länge des Arrays zurück, sondern die Länge des Pointers! Ich vermute mal, dass er in der Funktion erstmal nicht sehen kann, ob da denn auch ein Pointer auf ein Array übergeben wird. es ist sowieso nicht verkehrt und absolut üblich, die Länge eines Arrays an eine Funktion mitzuliefern.

könnte ich denn trotzdem irgendwie casten um den aufrufer jedes mal das sizeof zu ersparen?

_matze schrieb:

Hab's grad mal ausprobiert. Wenn du data an die Funktion übergibst, dann gibt sizeof nicht mehr die Länge des Arrays zurück, sondern die Länge des Pointers! Ich vermute mal, dass er in der Funktion erstmal nicht sehen kann, ob da denn auch ein Pointer auf ein Array übergeben wird. es ist sowieso nicht verkehrt und absolut üblich, die Länge eines Arrays an eine Funktion mitzuliefern.

könnte ich denn trotzdem irgendwie casten um den aufrufer jedes mal das sizeof zu ersparen?

Du konntest einen Vektor übergeben, und dann die Funktion so aufrufen:

wxMemoryInputStream is(&data[0], data.size());

Das ist für einen Vektor von POD-Typen zwar zulässig, aber eigentlich nicht schön.

Es ist aber auch üblich, dass man Funktionen die mit rohen Arrays arbeiten die Größe mitgibt.

könnte ich denn trotzdem irgendwie casten um den aufrufer jedes mal das sizeof zu ersparen?

Nein. Wenn der Benutzer ein Array übergibt (nur dann würde sizeof auf seiner Seite überhaupt funktionieren), dann ist im Aufruf die Größeninformation nicht mehr da.

Wäre der erste Parameter was anderes, zB (DerGuteAlteUwe *param), dann könnte man mit sizeof(*param) die Größe ermitteln. Aber bei einem Array hast du halt das Problem das nur auf das erste Element gezeigt wird. Bei einem C-Char-Array kann man sich unter Umständen auf die terminierende Null verlassen, sollte aber nicht.

Wäre der erste Parameter was anderes, zB (DerGuteAlteUwe *param), dann könnte man mit sizeof(*param) die Größe ermitteln.

Genau, dann würde man die Länge des Typs bekommen, die eben auch der Länge der Variable entspricht.

Fellhuhn schrieb:

Aber bei einem Array hast du halt das Problem das nur auf das erste Element gezeigt wird. Bei einem C-Char-Array kann man sich unter Umständen auf die terminierende Null verlassen, sollte aber nicht.

Wenn man ein Array mit []-Operator deklariert, dann kann sizeof ja ohne Probleme die Länge des Arrays liefern, auch wenn der Name des Arrays ohne Index nur auf das erste Element zeigt. Da braucht's auch keine terminierende Null. Das Problem entsteht ja erst, wenn ein Pointer auf das Array z.B. an eine andere Funktion übergeben wird, die das dann nicht mehr erkennen kann. Ich vermute mal, bei dynamisch mit malloc erzeugten Arrays (die man ja erstmal nur als Pointer deklariert), wird es das gleiche Problem geben. Die abschließende Null brauchst du aber natürlich bei strlen. Aber da hier Bilddaten verarbeitet werden, bringt ihm diese Info natürlich wenig.

Nur noch mal als Zusatz:

Wäre der erste Parameter was anderes, zB (DerGuteAlteUwe *param), dann könnte man mit sizeof(*param) die Größe ermitteln. Aber bei einem Array hast du halt das Problem das nur auf das erste Element gezeigt wird. Bei einem C-Char-Array kann man sich unter Umständen auf die terminierende Null verlassen, sollte aber nicht.

Das geht aber auch nur so lange gut, wie DerGuteAlteUwe nichts auf den Heap packt.