wie bestimme ich die Größe eines Arrays, welches
ich als Eingabeparameter erhalten habe?

Der Funktionskopf:

Object::Object(float newX, float newY, float newZ, CUSTOMVERTEX vertexArray[], int vCount)

Ich würde gerne die Länge von vertexArray hier selber bestimmen und ungern vorher zählen müssen (also vCount als Parameter mitschleppen)

sizeof(vertexArray) liefert die Größe vom Pointer
sizeof(*vertexArray) liegert die Größe vom ersten Element

Ich brauche aber die Größe vom gesamten Array um daraus die Länge zu errechnen!

Die Form der Übergabe des Array ist frei wählbar.

Mit freundlichem Gruß
Schifty

Object::Object(float newX, float newY, float newZ, std::vector<CUSTOMVERTEX> &vertexArray) 
{ std::for_each(vertexArray.begin(), vertexArray.end(), boost::bind(CopyCoordsToVec(_1, x, y, z))); } // Was auch immer du vor hast!?

EDIT:
std::vector::size() returnt einen std::size_type mit der Größe des Vektors.

Ich brauche aber die Größe vom gesamten Array

Dann merk sie Dir irgendwo oder benutz etwas anderes als Zeiger!

EDIT:

Dort wo ich das Array erstelle, kann ich ja ohne Probleme auf die Gesamtgröße zugreifen - worin besteht denn der genaue Unterschied zwischen der Variable am Anfang und der im Funktionskopf - sind ja beides nur Pointer aufs erste Element, aber das eine liefert mir die Gesamtgröße, das andere nicht?

wenn du native arrays brauchst, ist das mit vector auch kein problem:

std::vector<KOMISCHER_TYP> vec;
//füllen oder resize oder was auch immer
c_api_fkt(&vec[0], vec.size());

bb

Weil ich keine Ahnung ob und wie memcpy mit vector funktioniert.
Vertices ist im folgenden mein CUSTOMVERTEX Array.
pVoidist mit einem meiner VertexBuffer verknüpft

memcpy(pVoid, currentObject->vertices, vertexCount*sizeof((*currentObject->vertices)));

Wenn der Befehl gehen würde, wäre vector eine sinnvolle Alternative.

Gerade diese Vertex Geschichte ist sehr wichtig für die Performance - ich würde ungern das Vertex-Array in vector überführen, nur um die Größe zu bestimmen und dann anschließend wieder mit dem Array arbeiten ... denn dieses brauche ich um über Memcopy einen VertexBuffer zu bauen.

Klingt so, als würdest Du nicht die Garantie kennen, die std::vector macht. Die Elemente stehen alle hintereinander im Speicher. Du kannst Dir also ein Zeiger-Paar so geben lassen und auch benutzen:

void foo(double const* beg, double const* end);

void bar(std::vector<double> const& vec)
{
  double const* beg = vec.empty() ? 0 : &vec.front();
  double const* end = beg + vec.size();
  foo(beg,end);
}

Schifty schrieb:

EDIT:

Dort wo ich das Array erstelle, kann ich ja ohne Probleme auf die Gesamtgröße zugreifen - worin besteht denn der genaue Unterschied zwischen der Variable am Anfang und der im Funktionskopf - sind ja beides nur Pointer aufs erste Element, aber das eine liefert mir die Gesamtgröße, das andere nicht?

Wie bitte? Formuliere das mal um, dass ich das auch verstehe, was Du meinst. Was meinst Du mit "Variable am Anfang" und "Variable im Funktionskopf"? Was für einen Unterschied soll es da geben?

Gruß,
SP

bb

Wenn ich das Array in der Main erstelle

CUSTOMVERTEX cube[] = {...};

und direkt dahinter sizeof(cube) schreibe
erhalte ich die Größe des gesamten Arrays.

Übergebe ich an eine Funktion:
new Object(cube);

Object::Object(CUSTOMVERTEX vertexArray[]) {...}

Und schreibe hier sizeof(vertexArray) erhalte ich die
größe des Pointers, bzw mit * die Größe des ersten Elements.

Ich dachte es handelt sich in beiden Fällen um Pointer auf das erste Element?
Wo liegt der unterschied, und gibt es eine Möglichkeit im letzteren Fall, ersteres sizeof-Ergebnis zu erlangen?

gibt es eine Möglichkeit im letzteren Fall, ersteres sizeof-Ergebnis zu erlangen?

nein

Aber in beiden Fällen handelt es sich wie du schon sagtest intern um einen Zeiger. Doch erkennt der Compiler natürlich wann du so ein Ding auch wirklich als array deklariert hast.
Aber wie gesagt, dass funktioniert nur weil die Informationen aus dem Stackframe ermittelt werden können so ein Array fürht keinerleich Verwaltungsinformationen mit sich, am Ende hast du mit so einem array halt "nur" aufeinander folgenden Speicher für Mehrere Objekte eines Typs und nicht mehr.

--------------------------

Und wenn du wirklich ein eigenes Array anlegen möchtest ohne auf die Größeninformationen zu verzichten, könntest du dir im ersten Element oder je nachdem wie du das handhabst vor dem Ersten Element die Anzahl der Elemente als int speichern.

Wenn ich das Array in der Main erstelle

CUSTOMVERTEX cube[] = {...};

und direkt dahinter sizeof(cube) schreibe erhalte ich die Größe des gesamten Arrays.

Korrekt. Größe in Bytes.

Schifty schrieb:

Übergebe ich an eine Funktion:
new Object(cube);

Object::Object(CUSTOMVERTEX vertexArray[]) {...}

Und schreibe hier sizeof(vertexArray) erhalte ich die
größe des Pointers, bzw mit * die Größe des ersten Elements.

Korrekt.

Schifty schrieb:

Ich dachte es handelt sich in beiden Fällen um Pointer auf das erste Element? Wo liegt der unterschied,

Nein. Das erste ist ein Array vom Typ CUSTOMVERTEX[N] (nicht CUSTOMVERTEX[] !) mit N=Anzahl der Elemente. Das zweite ist ein Zeiger. Großer Unterschied!

C++ erlaubt Dir einfach bei der Definition von cube das N wegzulassen. Der Compiler ist so schlau, dass er das selbst einsetzen kann, nachdem er die Elemente gezählt hat.

Der Typ CUSTOMVERTEX[] hingegen wird in der Parameterliste einer Funktion zu CUSTOMVERTEX übersetzt*. Auch eine Größe, falls angegeben, wird ignoriert. Diese Ersetzung des Typs findet statt, weil es in C auch so ist, weil man dachte es wäre praktisch, und weil Arrays keine Kopier-Semantik haben. Diese Ersetzung gibt es nur, falls das [] sich auf der "obersten Ebene" befindet. Ein Zeiger ( int(*)[3] ) oder eine Referenz ( int(&)[3] ) auf ein Array gibt es also als möglichen Parameter.

CUSTOMVERTEX[] ist aber auch als "unvollständiger Typ" in einer Deklaration auf globaler bzw Namensraum Ebene und innerhalb von Klassen für statische Elemente zulässig (Array mit Größe, die nicht verraten wird). Da es sich in dieser Situation um einen unvollständigen Typ handelt, ist die Anwendung von sizeof gar nicht zulässig.

Schifty schrieb:

und gibt es eine Möglichkeit im letzteren Fall, ersteres sizeof-Ergebnis zu erlangen?

Nur, wenn Du den Konstruktor von Object änderst. Hier mal eine Inspiration:

template<typename T>
class referenz_auf_bloedes_array
{
  T* base_;
  std::size_t size_;
public:
  referenz_auf_bloedes_array(T* base, std::size_t N)
  : base_(base), size_(N) {}

  template<std::size_t N>
  referenz_auf_bloedes_array(T (&ref)[N])
  : base_(ref), size_(N) {}

  std::size_t size() const {size_;}

  T& operator[](std::ptrdiff_t idx) const {return base_[idx];}
};

void foo(referenz_auf_bloedes_array<int> r) {
  if (3u <= r.size()) {
    r[0] = 1;
    r[1] = 2;
    r[2] = 3;
  }
}

int main() {
  int xx[] = {9,9,9,9,9};
  foo(xx);
}

Gruß,
SP