3. Blackout beim Array

Blackout beim Array

  • A

    Hallo,

    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

    0
  • T

    Entweder so:

    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)
   {
      //...
   }
}
    0
  • B

    sizeof(_werte)/sizeof(int)

    0
  • A

    Babbage schrieb:

    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).

    0
  • B

    Ups, bist Du sicher?
    Bei mir hat sowas schon geklappt. Ich weis, ist nicht besonders schön aber gelaufen ist das.

    0
  • A

    Ihr seid ja Spitze! War grad mal unterwegs und schon 4 Antworten! 😃
    Vielen Dank erst mal an Alle!!!

    @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 😕

    0
  • N

    Die Grössenbestimmung funktioniert bei statischen Arrays, so lange du sie nicht an eine Funktion übergibtst. Trotzdem oder gerade aus letzterem Grund solltest du entweder die Grösse separat speichern oder mit Containern arbeiten.

    #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();
}
    0
  • A

    @Nexus:
    Sorry für die Frage. Aber was ist da der Unterschied?
    Im Prinzip macht die Funktion

    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?

    0
  • N

    Beim Aufruf der Funktion wird das Array als Zeiger übergeben, und dabei geht die Grösseninformation des Arrays verloren.

    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; 
}
    0
Anmelden zum Antworten