-
Thread
sizeof
sizeof geht nur bei statischen strukturen (z.B. sizeof(int), sizeof(struct str)) Man kann damit nicht die Größe von dynamischen Datenstrukturen erkennen!!!
Hi, <bisschenofftpopic> Sizeof ist übrigens ein Operator und keine Funktion. Es heißt also nicht "sizeof(variable)" sonder "sizeof variable". (wenn man die größe eines datentyps wissen will muss man natürlich sizeof (int) o.ä
-
Thread
sizeof auf strukturmember
habe eingentlich eine total billige Frage, aber ich krieg es grad nicht hin: wie mache ich ein sizeof auf ein Strukturelement, ohne eine Instanz zu haben? Beispiel: [c] typedef struct A { int b; int c; }A; uint32_t gesamtgroesse = sizeof( A ); uint32_t teilgroesseC1 = sizeof
sizeof ja mitlerweile nicht mehr notwendigerweise eine Compiletime Angelegenheit ist)
-
Thread
Schon wieder sizeof
) { uint8_t i; for (i = 0; i < count; i++) ...werte[i]... } ... machwas(werte, sizeof werte); [/c]
ich vermute (bzw. bin mir eigentlich ziemlich sicher) dass sizeof() gleich bei der Compilezeit berechnet wird. Das einzige was mir dazu einfällt wäre: machwas (uint8_t *pWerte, unint8_t size) { ... } und dann der Aufruf: machwas (werte, sizeof(werte)
-
Thread
Problem mit sizeof
Hallo, bei folgendem Code-Fragment #if sizeof(char)>1 #warning "Size zu gross!" #endif bringt der GCC 3.4.6 die Fehlermeldung ../main.c:240:11: missing binary operator before token "(" (Zeile 240 ist die "#if sizeof(char)>1") Der
<assert.h> void assert(scalar expression); ... [/pre] Darin kannst Du problemlos sizeof verwenden. Aufruf: assert (sizeof(char)==1); ==1 deshalb, weil assert bei false abbricht.
-
Thread
strlen(.) oder sizeof(.)-1
Jochen schrieb im Beitrag #4727186: > Was ist denn besser? ordentlicher ist strlen, schneller ist sizeof
Jochen schrieb im Beitrag #4727199: > Peter II schrieb: >> ordentlicher ist strlen, schneller ist sizeof > > Habe ich vermutet, da der Compiler vermutlich schon das sizeof()-1 > ausrechnet und als festen Wert in den Code einträgt. Ja, natürlich wird sizeof() _immer_ zur Compilezeit ermittelt. Aber
-
Thread
sizeof von Stringarray
C-Grundlagen! Wort ist ein Zeiger. Und mit sizeof bekommst du die Größe vom Zeiger und *nicht* von dem, worauf er zeigt. Du *musst* die Größe mit einem weiteren Parameter übergeben.
Strings werden in C IMMER als Pointer übergeben. [c] char meinstring[] = "Hallo Welt"; int l = sizeof(meinstring); [/c]
-
Thread
kleines problem mit sizeof
Hallo, ich habe ein kleines Problem mit dem sizeof. Ich möchte eine c und h Datei anlegen für Ausgabenstrings. [c] c: const char msg [] = " Hallo"; h: extern const char msg []; main.c: size = sizeof(msg); // ---> Geht nicht [/c] [
problemoSizeof schrieb: > also gibt die header datei mit > > extern const char msg []; > > die info für sizeof nicht her. Nein. sizeof wird zur Compiletime ausgewertet. Und genausowenig wie du bei [
-
Thread
frage zu sizeof() in c
Hallo, ich habe ein verständnisproblem zu dem Befehl sizeof() in c. z.B. const uint8_t x[] = {0x00, 0x01, 0x02}; sizeof(x) ergibt 24. Um die Anzahl der elemente im array zu ermittlen, mache ich sizeof(x)/(sizeof(uint8_t)); Jetzt habe ich zwei arrays
Das sizeof(x) sollte 3 ergeben. Die Anzahl der Elemente bekommst du besser mit sizeof(x)/sizeof(x[0]) Dann spielt der Typ keine Rolle mehr. Mach das nicht bei Funktionsparametern. Die Länge eines Strings
-
Thread
sizeof geht nicht
in Projekt.c (die auch auf Main.h verweist) steht: void Test(void) { uint8_t a; a = sizeof(TestArray); } und dann das: invalid application of 'sizeof' to incomplete type 'uint8_t[]' kann man mir helfen??? wenn alle in der Main.c steht geht es, aber eben nicht ausgelagert
nur innerhalb von main.c. Zusammenfügen tuts ja erst der Linker. Aber der interssiert sich für ein sizeof nicht mehr.
-
Thread
[c] sizeof(enum) bestimmen?
Peterle Anonym schrieb im Beitrag #2266124: > sizeof liefert nicht die gesamtgröße wieder, sondern die größe eines > elements, sprich eines INTs! sizeof wovon? Du meinst offenbar von einem enum-Element (ja, das ist dasselbe wie ein sizeof(int) ),
{ fIdle, fStartConversion, fWaitConversion, fCheckResults }; #define NO_STATES (sizeof(func_array) / sizeof(PWMstateControl)) [/c] Peter
-
Thread
sizeof() eines Arrays
Wie gross sind die "rtcc*" Dinger? sizeof(digital) => gesamte Grösse, nicht Anzahl Elemente sizeof(digital[0]) => Grösse von IO_DIGITAL Wenn man bei Arrays die Anzahl Elemente wissen will, dann nimmt man üblicherweise sowas wie (sizeof(a) / sizeof(a[0]))
-
Thread
IAR sizeof???
hi, des geht leider nicht. es funktioniert aber noch nicht einmal ein einfaches int x = sizeof(int). breakpoint dahinter, wert von x ist unavaiable. gruß
> wert von x ist unavaiable. Du hast ein Problem mit deinem Debugger, nicht mit sizeof.
-
Thread
sizeof nicht konstant?
GPIOA, .GPIO_Pin = GPIO_Pin_1, //[...] } //[...] }, const uint32_t nConf = sizeof(Conf)/sizeof(Conf[0]); [/c] Die Größe der Konstanten "nConf" ist zur Compilezeit bekannt. Erzeuge ich innerhalb einer Funktion allerdings ein Array mit dieser Größe: [c] void fcn(void) { static
Ausdruck sei? Die "Lösung" für die Implementierung kenne ich natürlich: Mit [c] #define NCONF (sizeof(Conf)/sizeof(Conf[0])) void fcn(void) { static uint_fast8_t helpbuf[NCONF]; } [/c] bekommt der Compiler seinen konstanten Ausdruck und ist zufrieden. Mich interessiert also nur: Warum ist
-
Thread
sizeof Frage
Warum liefert sizeof(sendstring) den Wert 2? sowohl bei: void can_send_mg (char sendstring[8], long msid, int m_box) { AnzZeichen=sizeof(sendstring); ... als auch bei: void can_send_mg (char *sendstring, long
%d bytes\n" "baz and bay have %d and %d bytes and no content\n", sizeof(bar), strlen(bar), sizeof(baz), sizeof(bay)); printf("btw: bar points to %p and src to %p\n", bar, src); } Kompilieren mit: $ gcc -O -ggdb -o foo.exe foo.c Ausgabe
-
Thread
ISR Code schneller machen?
void send_Nachricht () { uint8_t data = 0; sendDaten.crc = calc_CRC16(sendDaten.asArray, (sizeof(Nachricht)-sizeof(sendDaten.crc)) ) ; MAX487_Sendemodus(); uart0_putc(STX); for (uint8_t i=0; i < sizeof(Nachricht); i++) { data = sendDaten.asArray[i]; if (data == ESC || data
void send_Nachricht () { uint8_t data = 0; sendDaten.crc = calc_CRC16(sendDaten.asArray, (sizeof(Nachricht)-sizeof(sendDaten.crc)) ) ; MAX487_Sendemodus(); uart0_putc(STX); for (uint8_t i=0; i < sizeof(Nachricht); i++) { data = sendDaten.asArray[i]; if (data == ESC || data
-
Thread
sizeof Konfusion
struct vom Typ elementType) while (element != NULL) { machwas_mit(element); element+=sizeof(struct elemtType); } Ich wunder mich schon die ganze Zeit warum er Einträge zu "überspringen" scheint bis ich folgendes versucht habe: PORTC=sizeof(struct rePARTSTransition); currentList=currentList+sizeof(struct rePARTSTransition); Die Zeilen stehen so direkt hintereinander im Source. Der Assembler dazu sagt: ---- d:\atmel\reparts\fsm.c ---------------------------------------------------------
-
Thread
C: sizeof (zeigerinhalt)
ich sowohl bei sizeof(data) oder sizeof(*data) = 4. Wie komm ich an die 12 ran? Gruß Jan
} } int somedata[3]; int main (void) { function ( somedata , sizeof (somedata) / sizeof (*somedata) // das hier liefert 3 ); } [/c]
-
Thread
C - Function / Define / Macro / Obfuscated C ?
Zeilen im bzip2 Code gefunden: > > [c] > static > int bz_config_ok ( void ) > { > if (sizeof(int) != 4) return 0; > if (sizeof(short) != 2) return 0; > if (sizeof(char) != 1) return 0; > return; > } > [/c] > > Bei Optimierung auf Codegröße(/O1) oder Schnelligkeit (/O2)
sizeof(int) ergibt 0 statt 4!
-
Thread
canbus mit SN65HVD230D und FlexCan
can-messages verpacken und wegschicken, also in einer dauer-scheife msg.id = 0x100; msg.len = sizeof(a); memcpy(msg.buf, &a, sizeof(a)); CANbus.write(msg); msg.id = 0x101; msg.len = sizeof(b); memcpy(msg.buf, &b, sizeof(b)); CANbus.write(msg); ... usw ... leider funktioniert
CANbus.write(msg); delay(3); msg.id = 0x102; msg.len = sizeof(sysData.c); memcpy(msg.buf, &sysData.c, sizeof(sysData.c)); CANbus.write(msg); delay(3); msg.id = 0x103; msg.len = sizeof(sysData.d); memcpy(msg.buf, &sysData.d, sizeof(sysData.d));
-
Thread
Größe einer beliebigen Reihe, auch unterschiedlich viele Elemente, berechnen.
= {1}; int x2[] = {2, 7, 56, 12, 1, 78}; int x3[] = {2, 3, 4}; struct krempel y[] = { {sizeof (x0) / sizeof (x0[0]), x0}, {sizeof (x1) / sizeof (x1[0]), x1}, {sizeof (x2) / sizeof (x2[0]), x2}, {sizeof (x3) / sizeof (x3[0]), x3}, }; [/c] Das entspricht dem Beispiel von yalu, mit
Harald K. schrieb im Beitrag #7489950: > {sizeof (x0) / sizeof (x0[0]), x0} Was spricht, in diesem Fall, gegen meine Variante? > #define SIZEOF(arr) sizeof(arr) / sizeof(*arr) > > {OutputArray(Array, SIZEOF(Array));} Ist das nicht
-
Thread
Wie bekomme ich Daten richtig in eine Datei?
); fwrite(&BMPFileHeader.bfReserved, sizeof(BMPFileHeader.bfReserved), 1,MandelbrotBild1); fwrite(&BMPFileHeader.bfOffBits,sizeof(BMPFileHeader.bfOffBits), 1,MandelbrotBild1);*/ fwrite(&BMPInfoHeader.biSize,sizeof(BMPInfoHeader.biSize
); fwrite(&BMPInfoHeader.biSize,sizeof(BMPInfoHeader.biSize), 1, MandelbrotBild1); fwrite(&BMPInfoHeader.biWidth, sizeof(BMPInfoHeader.biWidth), 1, MandelbrotBild1); fwrite(&BMPInfoHeader.biHeight, sizeof(BMPInfoHeader.biHeight
-
Thread
typedef struct an funktion übergeben
Karl Heinz Buchegger schrieb im Beitrag #2749341: > wenn schon dann > > sizeof(tSetup)/sizeof(int) > > und nicht /4 sollte es nicht besser sizeof(tSetup)/sizeof(Word) sein, denn die funktion heist FLASH_ProgramWord
[c] x = (sizeof(tSetup) / sizeof(int)); [/c] x = 2119
-
Thread
C Array copy by reference
uint8_t(*)[2])grosses_array); puts(""); uint8_t test[][2] = {{1,2},{3,4},{5,6}}; example2d(sizeof(test)/sizeof(*test),sizeof(*test)/sizeof(**test),test); } [/c] https://repl.it/repls/MeanLumberingWorker
kleines_array = (kleines_array_p_t)&grosses_array[8]; void example(kleines_array_p_t e) { printf("sizeof(*e) = %I64u\n", sizeof(*e)); for(int i=0; i<sizeof(*e); i++) printf("e[%d] = %d\n",i,(int)(*e)[i]); } int main() { printf("sizeof(*kleines_array) = %I64u\n", sizeof(*kleines_array))
-
Thread
uip Datten zum Webserver
+) { static char *pname,*pval; pname=http_get_parameter_name(s->filename,i,sizeof(s->filename)); pval =http_get_parameter_value(s->filename,i,sizeof(s->filename)); if(!strcmp(pname,("mac")) ) { result = decode_mac(pval,_eth_addr); }
++) { static char *pname,*pval; pname=http_get_parameter_name(s->filename,i,sizeof(s->filename)); pval =http_get_parameter_value(s->filename,i,sizeof(s->filename)); if(!strcmp(pname,("woh")) ) { result = decode_ip(pval,ablage); for(j=
-
Thread
sizeof mit strukt und padding.
finde deine Einstellung etwas komisch. Legst Du auch erst einen int-Pointer an, und wendest darauf sizeof an, oder wendest du sizeof direkt auf int an? [c] int *ptr; ptr = malloc(sizeof(*ptr)); ptr = malloc(sizeof(int)); [/c] Mag geschmackssache sein. Soll also jeder machen, wie er mag. :)
deine Einstellung etwas komisch. Legst Du auch erst einen > int-Pointer an, und wendest darauf sizeof an, oder wendest du sizeof > direkt auf int an? > int *ptr; > ptr = malloc(sizeof(*ptr)); > > ptr = malloc(sizeof(int)); > > Mag geschmackssache sein. Soll also jeder machen, wie er mag. :
-
Thread
C - Char array löschen
String (char Array) braucht immer 1 Zeichen mehr für die abschließende \0 [c] fgets(nutzername, sizeof(nutzername) / sizeof(char), stdin); [c] sizeof(char) ist immer 1 - kannst du dir also sparen. teste mal mit: [c] fgets(nutzername, sizeof(nutzername)-1, stdin); [/c]
es geht weiter: [c] if(sizeof(string1) <= 1 || sizeof(string2) <= 1) return 0; [/c] ein Zeiger ist immer gleich groß, die abfrage macht überhaupt keinen sinn. viel zu kompliziert und falsch (length-1 warum nicht das
-
Thread
static global
Kindergärtner schrieb im Beitrag #3295874: > void foo (int n) { > char x [n]; > std::cout << sizeof (x); // ja was ist sizeof hier... Das ist kein Problem: sizeof x == n * sizeof (char) > static std::array<decltype(x), 7> blub; // und wie groß ist blub? Hier stört zunächst das /static
... for (size_t i = 0; i < sizeof x / sizeof x[0]; i++) { ... } [/c] /Ohne/ irgendwelche Klammern nach dem „sizeof“. Die Klammern sind nur gefordert, wenn nach dem „sizeof“ ein Typname steht, bei einem Objekt gehören
-
Thread
array copy in c?
Leute! sizeof(a)/sizeof(a[0]) kann man verkürzen zu sizeof(a)/sizeof(*a) Spart wertvolle Bildschirmtinte! LG, Sebastian
nicht explizit in meinen Code schreiben. Sebastian schrieb im Beitrag #6940358: > Leute! > > sizeof(a)/sizeof(a[0]) kann man verkürzen zu sizeof(a)/sizeof(*a) > > Spart wertvolle Bildschirmtinte! Man kann es sogar verkürzen zu sizeof a/sizeof*a
-
Thread
Fragen zu sizeof() in Kombination mit structs
= malloc(10 * sizeof(struct_def_Benutzer)); [/c] funktioniert das?
int lastline = ((sizeof(obj_dir_std)+sizeof(can_object_directory_sd_struct)+1) / sizeof(can_object_directory_sd_struct))-1; obj_dir_app[lastline].tagnummer = 0; obj_dir_app[lastline
-
Thread
Größe eines externen Arrays in C
element_t; extern const element_t element[100]; // Test int main() { printf("%d\n", sizeof(element)/sizeof(element_t)); } [/c] Gruss, Udo
include "header.h" > const element_t element[] = { {1,2}, {3,4}, {5,6} }; > size_t nElemente = sizeof(element)/sizeof(element[0]);
-
Thread
Arrays, Pointer und Schleifen (avr-gcc)
sizeof(short) = 16 sizeof(int) = 32 sizeof(long) = 32 sizeof(long long) = 64 wenn jetzt dein Array aus 5 Elementen besteht, dann char x[5]; // 5 * sizeof(char) = 5 genau das gibt dir auch sizeof(x
teilen sizeof(x)/sizeof(x[0]) x[0] ist das erste Element des Arrays oder in Makroform #define SIZE(x) sizeof(x)/sizeof(x[0]) grüsse, daniel
-
Thread
sizeof ergibt 2 für array mit 9 16bit werten
n = sizeof (&SortierArray)/2
n = sizeof (&SortierArray)/2 damit wird n = 1....
-
Thread
DMX empfang in C funktioniert nicht richtig.
> Die einzige Stelle im Programmtext die ich nicht verstehe ist > > #define ARRAY_SIZE(x) (sizeof(x)/sizeof(*x)) sizeof liefert die Größe eines 'Objektes' in Bytes. [c] int data[5]; [/c] sizeof(data) würde also die Größe des Arrays in Bytes liefern. da ein int aus 2 Bytes besteht, wären
einzelnes element davon zb x[0]. Oder kürzer geschrieben *x (wegen der Pointer/Array Dualität) [c] sizeof(data) / sizeof(data[0]) [/c] liefert daher, die Anzahl an Array Elementen, wenn data als Array vorliegt. denn sizeof(data[0]) würde ja 2 ergeben, weil data[0] ja ein einzelner int aus dem Array ist
-
Thread
RS232 lcc-win32 WinXp
irgendein Prüfbyte; wenn ja, wie berechnet?) In Deinen Code ist "laenge=3" ?!?!? Dann "... malloc(sizeof(int)*laenge)", warum multiplizierst Du hier mit sizeof(int) und nicht mit sizeof(char) bzw. sizeof(unsigned char) ? Anschließend schreibts Du da 4 Bytes rein! Sollten das nicht 6 sein? Und zum Schluß
erwähnt habe, mit einbauen. Das tat ich nicht. Klar, dass es dann auch schon mal nicht geht... - sizeof(int): OK. Da sollte sizeof(unsigned char) stehen... Schon geändert. - sizeof(output): Hier hatte ich mich auf den Code von Blackbird bezogen.... Für mich klang es logisch, dass ich die Anzahl
-
Thread
Pointer in Struct-Arrays Werd Wahnsinnig!
8 sizeof (a1_arg) = 8 sizeof (a1_arg_100) = 8 sizeof (*a1_arg_ptr) = 1 sizeof (a2_arg_ptr) = 8 sizeof (a2_arg_7) =
sizeof (a3) = 8 sizeof (a3[0]) = 800 sizeof (a3[0][0]) = 8 sizeof (a3[0][0][0]) = 1 sizeof (s1) =
-
Thread
Umstieg auf C
auch stapeln düfen. Eine direkte Beschränkung habe ich auf die Schnelle nicht gefunden, aber: - sizeof(bool) kann nicht kleiner als 1 sein. - sizeof(char), sizeof(signed char) und sizeof(unsigned char) ist 1. - Der address-of-Operator muss funktionieren (bool * muss existieren). - sizeof(bool[8])
düfen. > > Eine direkte Beschränkung habe ich auf die Schnelle nicht gefunden, > aber: > - sizeof(bool) kann nicht kleiner als 1 sein. > - sizeof(char), sizeof(signed char) und sizeof(unsigned char) ist 1. > - Der address-of-Operator muss funktionieren (bool * muss existieren). > - sizeof(bool
-
Thread
AT90USB162 Endpoint Interrupts funktionieren nicht
UTF-16 codieren. [c] { .bLength = sizeof(struct string_descriptor) + sizeof(USB_VENDOR_NAME) - sizeof(wchar_t), .bDescriptorType = STRING_DESC, .bString = USB_VENDOR_NAME }; [/c] mit USB_VENDOR_NAME [c] #define
auch völlig logisch. Diese Berechnung: [c] #define WCHAR_TO_STRING_DESCRIPTOR(wchar) { \ sizeof(USB_String_Descriptor) + sizeof(wchar) - 2, \ DESCRIPTOR_TYPE_STRING, \ wchar \ } [/c] setzt ja voraus, dass sizeof(USB_String_Descriptor) eben *nicht* bereits den tatsächlichen
-
Thread
Überlauf bei 255 + 1?
Dafür gibt es sizeof(). Wobei sizeof(char) per C-Definition 1 ist.
int afaik mindestens 16 Bit haben muss, und zwar plattformunabhängig... Mein Wissensstand ist: sizeof(char) == 1 sizeof(int) >= 2 ("natürliche Breite" der Maschine, aber mind. 16 Bit) sizeof(short) <= sizeof(int) sizeof(long) > sizeof(int) (Da bin ich mir grad nicht 100%ig sicher, ob da auch ein
-
Thread
C sizeof Funktion in main vs in Funktion
min); printf("Maximum: %d ", max); return (float)summe/(float)sizeof(zahlen); return 0; } int main() { int zahlen[] = {3,7,5,10,122}; int bla = sizeof(zahlen)/sizeof(int); MinMaxDurch(zahlen); return 0; }
Array ermittel willst, dann schreib beim Divisor die ein Element aus dem Array hin size_t bla = sizeof(zahlen)/sizeof(zahlen]0]); oder size_t bla = sizeof(zahlen)/sizeof(*zahlen); Dann ist da auch noch korrekt, wenn sich der Typ von zahlen ändert. Bei Übergabe von Arrays an Funktionen solltest
-
Thread
Reichweite von Pointern
ahnung wo man das suchen müsste. Aber ein Pointer ist immer gleich gross egal wohin er zeigt. sizeof(int*)==sizeof(void*)==sizeof(char*)==sizeof(struct xyz*)
Peter II schrieb im Beitrag #2626026: > sizeof(int*)==sizeof(void*)==sizeof(char*)==sizeof(struct xyz*) = 2 [Byte] (ATmega8)
-
Thread
C String in Hexstring umwandeln
[C] ... * sizeof(FORMAT) ... [/C] Hmm. Jetzt bist du übers Ziel hinausgeschossen. Das was du da vorhast, ist gar nicht so einfach wasserdicht zu machen. sizeof(Format) ergibt in diesem speziellen Fall 8
12 }, { 21, 22 }, { 31, 32 }, }; int *pp[3]; pp[0] = (int*)malloc( 2*sizeof(int) ); pp[0][0] = 111; pp[0][1] = 112; pp[1] = (int*)malloc( 2*sizeof(int) ); pp[1][0] = 121; pp[1][1] = 122; pp[2] = (int*)malloc( 2*sizeof(int) ); pp[2][0] = 131; pp[2][1
-
Thread
for Schleife (C)
nach gibt es auch Umgebungen, bei > denen selbst char ein 32-bit-Typ ist. Bei denen gilt dann > sizeof(char) == sizeof(int) == sizeof(short) == sizeof(long) = 1. Huh? Du meinst doch sicher sizeof(char) == sizeof(int) == sizeof(short) == sizeof(long) = 4
> Huh? Du meinst doch sicher > > sizeof(char) == sizeof(int) == sizeof(short) == sizeof(long) = 4 Nein, Jörg hat Recht, sizeof(char) ist per Definition immer 1. Nur was das System unter "1 Byte" versteht, variiert. Es gibt wohl Systeme
-
Thread
Anfängerproblem mit C
int main(void) { int array_of_ints[] = {3,5,7,11}; for (unsigned long idx = 0; idx < sizeof(array_of_ints)/sizeof(int); idx++) { printf("%d\n", arr(array_of_ints, idx)); } return 0; } [/c]
Norbert schrieb im Beitrag #8070199: > for (unsigned long idx = 0; idx < sizeof(array_of_ints)/sizeof(int); > idx++) { "unsigned long". <tiefes Durchschnaufen> der Rückgabewert von sizeof ist size_t
-
Thread
problem mit malloc und arrays
, ob dich der Compiler vor Fehlern schützen kann oder nicht. > int* pI = (int*)malloc( 100 * sizeof(int) ); * du hast den Header für malloc vergessen Tja. Dann gibt das nur eine Warnung, wenn überhaupt bei sizeof(int) != sizeof(void*) gibt es allerdings massenhaft Ärger > int* pI =
Syntaktisch ist sogar 'int * pi = pi;' korret, produziert aber natürlich Unsinn. Der Vorteil von 'sizeof *pi' gegenüber 'sizeof(int)' liegt darin, daß man bei einer Änderung des Typs von pi nicht vergessen kann, das sizeof mit anzupassen. Karl heinz Buchegger schrieb im Beitrag #1970844: >> ich mach
-
Thread
Attiny Speicher zu knapp
wie oben beschrieben auch größer geben (pattern1-pattern8) struct Pattern pattern_pointer[]={ {sizeof(pattern0), pattern0}, {sizeof(pattern1), pattern1}, {sizeof(pattern2), pattern2}, {sizeof(pattern3), pattern3}, {sizeof(pattern4), pattern4}, {sizeof(pattern5), pattern5}, {sizeof(pattern6),
0b00100000,0b00100000,0b00100000 }; //... const struct Pattern pattern_pointer[] PROGMEM={ {sizeof(pattern0), pattern0}, {sizeof(pattern1), pattern1}, {sizeof(pattern2), pattern2}, {sizeof(pattern3), pattern3}, {sizeof(pattern4), pattern4}, {sizeof(pattern5), pattern5}, {sizeof(pattern6),
-
Thread
Darf man die Adresse einer Structure nicht erfragen? "&struct->dword"
tmp_cnt = 0x1122AAEE; // Geht bestens: SSTFlash_Write(bf->addr_tmp,(uint8_t *)&tmp_cnt,sizeof(tmp_cnt)); chksum_add((uint8_t *)&tmp_cnt, sizeof(tmp_cnt)); bf->addr_tmp += sizeof(tmp_cnt); // geht nicht: SSTFlash_Write(bf->addr_tmp,(uint8_t *)&bf->cnt,sizeof(bf->cnt));
und du so ausließt [c] A a1; A a2; uint8_t* p = (uint8_t*)a1; lese(p, (uint8_t*)&a2->a, sizeof(a2->a)); p +=sizeof(a2->a); lese(p, (uint8_t*)&a2->b, sizeof(a2->b)); p +=sizeof(a2->b); lese(p, (uint8_t*)&a2->c, sizeof(a2->c)); p +=sizeof(a2->c); ... [/c] dann hast du am Ende
-
Thread
Size von Vektor mit Zeigern auf char-arrays ermitteln
Lutz S. schrieb im Beitrag #6096055: > (sizeof commands)/(sizeof &commands[0]) > > Das sieht nicht elegant aus, ... und ist auch flasch. [c] (sizeof commands)/(sizeof commands[0]) [/c] Wenn sich die Anzahl der commands aendert, wuerde
Bernd B. schrieb im Beitrag #6096100: > Genausogut könnte man auch sizeof(char*) wenn man (sizeof arrayname)/(sizeof arrayname[0]) oder (sizeof arrayname)/(sizeof *arrayname) nimmt, braucht man sich keine Gedanken um den Typ machen. Egal ob int, char, char* oder struct
-
Thread
Fehlermeldungen beim compilieren von SPI Code
} SPIDataBlock; // Schreiben des Messdatenblocks mit SPI_WriteBuffer ((void*) &(data.values), sizeof (data.values)); // Schreiben der counter SPI_WriteBuffer ((void*) &(data.counters), sizeof (data.counters)); [/c]
funktionsaufrufe mit: [c] // Schreiben des Messdatenblocks SPI_WriteBuffer((void*) &(data.values), sizeof (data.values)); // Schreiben der counter SPI_WriteBuffer((void*) &(data.counters), sizeof (data.counters)); // Schreiben der adressfelder SPI_WriteBuffer((void*) &adressfeld, sizeof (adressfeld
-
Thread
C typecast array nach struct
hinaus, falls es versehentlich kleiner ist. Das ist auch nicht so viel besser. > memcpy(&ds, da, sizeof (struct dat_struct)); Warum nicht gleich [c] memcpy(&ds, da, sizeof ds); [/c]
aber vielleicht ein wenig, weil Lesen normalerweise zerstörungsfrei ist. >> memcpy(&ds, da, sizeof (struct dat_struct)); > > Warum nicht gleich memcpy(&ds, da, sizeof ds); Ja, natürlich. Ich habe mich durch das [c] 3 * sizeof(int)" [/c] im zitierten Programmcode blenden lassen.
-
Thread
for(i=0;i<256;i++) funktioniert nicht!
Dann sollte sizeof(irgendein_int32_typ) aber auch 1 zurückgeben....
Bleifuss schrieb: > Dann sollte sizeof(irgendein_int32_typ) aber auch 1 zurückgeben.... Tut es auch. Noch besser: Auf dem TMS320C3x und -C4x ist auch sizeof(double) == 1