cout << static_cast <int> (sizeof (koenigins) / sizeof (int)) << endl;

Das Ergebniss muesste aber durch 5 dividiert werden damit es stimmt. Koennte ich zwar machen, aber gibt es nicht einen professionelleren Weg?

cout << static_cast <int> (sizeof (koenigins) / sizeof (int)) << endl;

Klappt eher nur dort, wo das Array erzeugt wurde. Nicht in mit dem Array aufgerufenen Funktionen, denn dort sind Array-Parameter in Wirklichkeit nur Zeiger aufs erste Element.

/ sizeof (int)

/ sizeof *koenigins

schreiben.
Besser gehts allerdings mit dieser Funktion hier, denn sie hat nicht den Nachteil, dass du falscherweise 1 raus bekommst, wenn das Array zu einem Pointer zerfällt, und ist außerdem kürzer beim Benutzen:

template <class T, size_t s>
size_t size(const T (&)[s]){
    return s;
}
...
cout << size(koenigins) << endl;

Bei sizeof bauerns kommt 160 statt 8

Was ist bauerns? Wieso 160? Woher kommen auf einmal die Zahlen?

Pferds / *Pferds

Was ist pferds und was ist *pferds?

Byte? Anzahl?

kamelkacke schrieb:

Bei sizeof bauerns kommt 160 statt 8

Was ist bauerns? Wieso 160? Woher kommen auf einmal die Zahlen?

Aus dem arabischen

prfessionelleren weg

Ja, gibt es. Er beginnt bei einer ordentlichen Fragestellung. Diese beinhaltet neben grundlegenden Informationen zum Problem auch eine halbewgs ordentliche Rechtschreibung und Grammatik.

Aus dem arabischen

Du bestaetigst meine Vorurteile dir gegenueber.

Zu der Rechtschreibung möchte ich folgendes anmerken: ich saß im bus mit dem Handy und mein Sitznachbar hat staendig auf mein Display geschielt also hab ich Beleuchtung auf minimal und Energiesparmodus an. Hab kaum was gesehen. Dass so ein Kauderwelsch rauskommt, wusste ich echt nicht ^^.

Dennoch ist der Informationsgehalt der Fragestellung wohl ausreichend, wie nwp3s Antwort beweist. Und ich wüsste auch nicht was man dem Sachverhalt noch hinzufügen sollte, da er komplett zusammenhangslos ist.

Und wenn jemand trollt, dann wird ja wohl zurückgetrollt werden dürfen, klare Sache.

Abschliessend möchte ich mich wieder für alle Antworten bedanken!

Also unabhaengig von dem template, dass ich noch nicht verstehe,
Kannst du mir bitte den Ablauf deiner ersten Moeglichkeit erklaeren? Also zuerst einmal es klappt. Aber ich verstehe nicht wie..

Pferds / *Pferds

Was ist pferds und was ist *pferds?

Byte? Anzahl?

Beispiel:
int arr[123];
arr ist ein Array. Der sizeof-Operator gibt dir die Größe in Bytes eines Typs oder einer Variablen. sizeof arr gibt die Größe von arr, also 123*sizeof (int). Wenn du die Anzahl der Elemente im Array haben willst nimmst du die Größe des Arrays und teilst durch die Größe eines einzelnen Elements. Raus kommt die Anzahl der Elemente.
Typische Schreibweise: *sizeof arr / sizeof arr.
arr ist immernoch das Array. *arr hat bei Arrays keinen Sinn, aber Arrays können in Pointer zerfallen. Aus dem int arr[123] wird ein *int arr. Diesen kann man dereferenzieren und bekommt ein int. Und der Compiler weiß wie groß ein int ist.

Jetzt warum es schlecht ist:

size_t failsize(int arr[]){
   return sizeof arr / sizeof *arr;
}

int arr[123];
cout << size(arr);

Als Ergebnis sollte eigentlich 123 rauskommen. Es kommt aber 1 oder 2 raus. Arrays kann man nicht direkt als Parameter übergeben, sie zerfallen zu Zeigern. Wie du oben gesehen hast ist die 123 beim Zerfallen verschwunden. Der Parameter in der failsize-Funktion sieht aus wie ein Array, ist aber ein Pointer und äquivalent zu *int arr. Dann wird gerechnet: *sizeof arr / sizeof arr. sizeof arr ist die Größe eines Pointers, *sizeof arr die Größe eines ints. Je nachdem wie groß bei dir Pointer sind kommt 4 / 4 = 1 oder 8 / 4 = 2 raus, jedenfalls nicht 123.

Damit das funktioniert muss man das Array anders übergeben, entweder als Pointer auf ein Array oder Referenz auf ein Array. Pointer machen es anstrengend weil man dann *(arr)[index] oder arr[0][index] schreiben muss (einmal den Pointer aufs Array dereferenzieren und dann erst funktioniert [index] richtig).

Also kommt man zu dieser Funktion:

size_t mehsize(int (&arr)[123]){
    return sizeof arr / sizeof *arr;
}

Jetzt kommt das Richtige raus, denn arr wird als Referenz übergeben und damit zerfällt arr nicht zum Zeiger. Du kannst aber nur int Arrays der Größe 123 übergeben. Dann kann man sich den sizeof-Kram auch sparen und gleich 123 zurückgeben. Wir möchten jetzt also, dass diese 123 eine Variable ist, die vom Compiler ausgefüllt und zurückgegeben wird.

size_t syntaxerrorsize(int (&arr)[size_t groesse]){
    return groesse;
    return sizeof arr / sizeof *arr; //Geht auch
}

So nimmt das dein Compiler nicht, aber so ähnlich:

template<size_t groesse>
size_t intsize(int (&arr)[groesse]){
    return groesse;
    return sizeof arr / sizeof *arr; //Geht auch
}

Jetzt tut die Funktion was sie soll. Sie funktioniert aber nur mit ints. Wir wollen jetzt int durch einen beliebigen Typen T ersetzen damit das mit allen Arrays funktioniert:

template<class T, size_t groesse>
size_t size(T (&arr)[groesse]){
    return groesse;
    return sizeof arr / sizeof *arr; //Geht auch
}

Ich hatte noch ein const spendiert, damit es auch mit konstanten Arrays funktioniert, ist aber eigentlich nicht nötig, da das const Teil von T sein kann. Wenn man die return groesse;-Variante benutzt, dann stellt man fest, dass die Variable arr gar nicht mehr benutzt wird, daher kann man sie weglassen. Der (&)-Teil ist hingegen weiterhin wichtig.
Vielleicht wunderst du dich, dass ich immer size_t statt int schreibe. size_t ist so definiert, dass es jede Anzahl von Arrayelementen darstellen kann, ist also genau das was wir wollen. int kann das nicht unbedingt. Für Arrays kleiner als 2 Milliarden ist es egal, deshalb würde die int-Variante ziemlich lange gleich gut funtkionieren. Man könnte sogar argumentieren, dass int besser ist, weil dann size(T[12])-size(T[23]) den korrekten Wert 11 und nicht eine blödsinnig gigantische Zahl zurückgibt (size_t ist unsigned).

Denn als nächstes kommt

void do_somethin_with_array(int arr[])
{
   size_t size = size(arr); // geht nicht
   // ...
}

also doch gleich

template <typename T, std::size_t N>
void do_something_with_array(T (&arr)[N])
{
  std::size_t size = size(arr); // is nun überflüssig
  //...
}

die Funktion size ist also sinnlos.

Dennoch ist der Informationsgehalt der Fragestellung wohl ausreichend, wie nwp3s Antwort beweist.

Gut geraten ...