Eigentlich nichts schwieriges, würde ich sagen. Ich komme bloß im Moment nicht drauf und finde auch in den Foren und Tutorials keine Lösung.

Ich erstelle in Integer-Array

int _werte[]={3,5};

und weise ihm zwei Felder zu.

Nun brauche ich die Werte für eine Funktion innerhalb einer Schleife.
Also muß die Schleife die Anzahl der Felder des Arrays kennen.

Ich weiß aber nicht mehr wie?
Mit

sizeof(_werte)

kriege ich 8 (also eine Addition der Felder)!

Hat jemand da evtl. mal schnell ne Anregung?
Kleine Anmerkung noch: Die Anzahl der Felder kann variieren! Kann also nicht einfach sagen, daß es zwei Felder sind...
Danke im Voraus
Arne

void myFunction(int* data, size_t size)
{
   for(size_t n = 0; n != size; ++n)
   {
      //...
   }
}

oder so:

void myFunction(int data[N]) //N hat feste, konstante Groesse...
{
   for(size_t n = 0; n != (sizeof(data)/sizeof(*data)); ++n)
   {
      //...
   }
}

oder so (mein Favorit):

void myFunction(std::vector<int>& data)
{

   for(std::vector<int>::iterator iter = data.begin(); iter != data.end(); ++iter)
   {
      //...
   }
}

sizeof(_werte)/sizeof(int)

sizeof(_werte)/sizeof(int)

Da wird mit Sicherheit nicht das herauskommen was du denkst. Die Größe eines Arrays kannst du unter C++ nicht bestimmen. Entweder gibst du sie mit, oder du weichst auf Alternativen aus (z.B. vector).

@Babbage:
Hast' recht! So funktioniert es tatsächlich!
Vielen Dank! Bin ehrlich, auf diese Variante wäre ich nicht gekommen.

@asc:
Könnte mir höchstens vorstellen, daß es systemabhängig ist?
Wenn ich mich recht an die Anfänge erinnere, gabs doch Unterschiede bei
Integer-Größen zwischen 16- und 32bit

#include <iostream>

void func(int Array[])
{
	std::cout << sizeof(Array)/sizeof(Array[0]) << std::endl;
}

int main()
{
	int Array[35];
	std::cout << sizeof(Array)/sizeof(Array[0]) << std::endl;  // Ausgabe: 35
	func(Array);									           // Ausgabe: 1 (=sizeof(int*)/sizeof(int))
	std::cin.get();
}

void func(int Array[]) {
  std::cout << sizeof(Array)/sizeof(Array[0]) << std::endl;
}

doch nichts anderes als

sizeof(Array)/sizeof(int)

Außer das Ergebnis auszugeben natürlich

Oder hab' ich da was falsch verstanden?

Du könntest die Funktion auch so schreiben:

void func(int* Array) // statt int Array[] oder int Array[35]
{
    // "Array" ist hier kein Array mehr, sondern ein Zeiger auf int
    // sizeof(Array) ist deshalb sizeof(int*) und das ist 4 (Grösse eines Zeigers)
	std::cout << sizeof(Array)/sizeof(Array[0]) << std::endl; 
}