Folgender Quelltext gibt nämilch 80 als erstes aus:

#include <iostream>
#include <vector>
using std::vector;
using std::cout;
using std::cin;
using std::string;
using std::endl;
int main() 
{ 
   const int g = 20;
   int arr[g]={0};
   cout << "\n" << endl;
   cout << sizeof(arr)<< endl;

   cout << "BITTE DRÜCKEN SIE EINE TASTE UM DAS PROGRAMM ZU BEENDEN" << endl;
   cin >> hallo[1
   ];
}

Woran kann das liegen?

cya
David

20 *4 byte

4 Byte = 32 Bit = Integer

überall, außer bei char-arrays nötig.

sizeof(int) ==> 4

Ein

std::cin.get();

am Ende des Programms tuts auch (hallo* ist nirgens definiert, sollte also erst gar nicht übersetzen).

@Boris "veto":
Ein Byte kann - muss aber nicht - 8bit haben

(warum eigentlich "pseudo"?)

sizeof ist ein Operator, keine Funktion. Die Benutzung sieht aus wie ein Funktionsaufruf, vielleicht verwenden deshalb manche den Begriff Pseudo-Funktion. Hab ich aber noch nicht gehört, sehr verbreitet scheint das nicht zu sein.

Eigentlich würde ein /4 ja jetzt reichen.

Aber nicht gerade Fehlerfrei... -.-

wann hat 1 Byte keine 8 bit?

Wie groß ein Byte ist, kann der compiler frei definieren (der Standard gibt nur eine Minimalgröße von 8 Bit vor.

@777: Besser ist es, du rechnest "sizeof(arr)/sizeof(arr[0])" (das klappt für beliebige Arrays, solange du sie direkt in der Hand hast (nicht für dynamische Arrays (new[]) oder als Parameter übergebene) - oder gleich std::vector<>.

Gibts doch überall Unterschiede...-.-
Zudem muss es doch eine einfache Funktion geben, welche einfach die Objektanzahl eines Arrays zurückliefert.
x.x.

cya
David

Zudem muss es doch eine einfache Funktion geben, welche einfach die Objektanzahl eines Arrays zurückliefert.

Keine Funktion, aber eine triviale Berechnung, die schon zweimal genannt wurde. Gefällt Dir die nicht gut genug?

sizeof(array)/sizeof(*array)

oder

sizeof(array)/sizeof(array[0])

Oder bau Dir n Template

template< class T, size_t N > inline size_t array_length( T ( &ary )[ N ] ) { return N; }

kann der compiler frei definieren

Glaub nicht das das der compiler entscheiden kann
Sondern eher das das vom prozessor kommt ... und ja, es gab prozessoren wo 1 byte = 7 bit.

waer doof wenn der Prozessor meint, eine Speicherzelle hat 8 Bit, und der compiler mag nur 7 davon benutzen

dann duerfte der compiler keinerlei erweiterte prozessorbefehle wie multiplikation / division / addition / subtraktion auf registerbasis benutzen wenn ein register mehrere bytes gross ist, weil die operationen ja auf auf ner anderen basis beruhen

Prinzipiell waer sowas vielleicht moeglich, aber praktisch eher unmöglich, rein schon von der performance her ....

<klugscheissmode off>

Ciao ...

Zudem muss es doch eine einfache Funktion geben, welche einfach die Objektanzahl eines Arrays zurückliefert.
x.x.

cya
David

Gibts aber nicht. Darum sollst du ja std::vector<> benutzen.

Falls wirklich einer an nem Rechner sitzt, wo das nicht so ist, dann weiß er das.

Toll, und darf etliche Zeit damit verbringen, das Programm anzupassen. Anstatt es einfach durch den entsprechenden Compiler zu jagen und fertig. Was du erzählst, ist Unsinn. Der Standard legt halt einfach nicht fest, dass ein Byte aus exakt 8 Bits besteht. Ende der Geschichte. Wenn du mal ernsthaft programmierst, wirst du lernen, dass dies nur auf zuverlässiger Basis Sinn macht.

kopfschüttel schrieb:

Falls wirklich einer an nem Rechner sitzt, wo das nicht so ist, dann weiß er das.

Toll, und darf etliche Zeit damit verbringen, das Programm anzupassen. Anstatt es einfach durch den entsprechenden Compiler zu jagen und fertig. Was du erzählst, ist Unsinn.

Na toll, es ist ja nicht genug Arbeit, alle Programme plattformunabhängig zu schreiben, jetzt muss man auch noch mit variabler Bitzahl pro Byte rechnen. Tschuldige, aber das ist auch Unsinn. Meist programmiert man eh nur für ein System (z.B. Standard-Desktop-Windows oder -Linux), wenn's hart auf hart kommt, auch mal für Win, Linux und Mac gleichzeitig. Aber dann noch mit einer variablen Bitzahl zu rechnen, sprengt doch schlicht und ergreifend den Rahmen!

Gut, es ist irgendwie doch kein Problem.. Ich bin aber nach wie vor der Meinung, dass man soetwas einem Anfänger nicht zumuten sollte. Ich persönlich lege mir übrigens in naher Zukunft ein System zu, dessen Byte genau 2 Bits groß ist; tja und damit bist du wohl gezwungen, deine Programme auch kompatibel zu meinem System zu schreiben :p

aber fals mal wer ein betriebsystem proggen will kann einfach

#define MAX_INT ~0

machen dann weis man wieviel platz man hat

mfg spjoe

kopfschüttel schrieb:

Falls wirklich einer an nem Rechner sitzt, wo das nicht so ist, dann weiß er das.

Toll, und darf etliche Zeit damit verbringen, das Programm anzupassen. Anstatt es einfach durch den entsprechenden Compiler zu jagen und fertig. Was du erzählst, ist Unsinn. Der Standard legt halt einfach nicht fest, dass ein Byte aus exakt 8 Bits besteht. Ende der Geschichte. Wenn du mal ernsthaft programmierst, wirst du lernen, dass dies nur auf zuverlässiger Basis Sinn macht.

Ja genau Es programmiert ja jeder täglich auf irgendwelchen exotischen Systemen, dass da jeder Anfänger darauf achten muss.