-
Thread
3-D Zahlenfelder und Probleme
unsigned int ***Platine_l; int i, j; // allocate memory Platine_l = (unsigned int***)malloc(250*sizeof(unsigned int**)); for(i=0; i<250; i++) { Platine_l[i] = (unsigned int**)malloc(250*sizeof(unsigned int*)); for(j=0; j<250; j++) Platine_l[i][j] = (unsigned int*)malloc(5*sizeof(unsigned
folgendes Szenario: Auf deinem System sei sizeof(int) != sizeof(void*) und weiters vergisst du das korrekte Header-File für malloc zu inkludieren. Damit ist das Szenario aufgesetzt. Wenn du jetzt machst int* pi = (int*)malloc( sizeof
-
Thread
Compiler Bug oder 1001 C-Integer Promotion Rule?
. encoder = read_encoder(); ... letter += encoder; if (letter > (sizeof(file_letters)-1) ) { letter =0; } else if (letter < 0 ) { letter = sizeof(file_letters)-1; } menu_dir[menu_letter_pos] = pgm_read_byte
warning: comparison between signed and unsigned integer expressions [-Wsign-compare] if (a > sizeof (b) -1) ^ [/pre] sizeof liefert ein size_t, gemäß ABI ein "unsigned int".
-
Thread
spannung einlesen auf led-reihe ausgeben
dividieren muss. Also hab ich das so umformuliert, dass der Compiler die Berechnung macht. Hinweis: sizeof liefert die Größe in Bytes des angegebenen Ausdrucks. Fuer ein Array Datentyp Array[ irgendwas ]; liefert der Ausdruck sizeof( Array ) / sizeof( Array[0] ) daher die Anzahl Elemente
alles reinpasst. Nur weiss ich halt nicht wieviele Eintraege das sind. Macht aber nichts, denn sizeof( Leds ) / sizeof( Leds[0] ) (Also: Gesammtgröße des Arrays in Bytes durch Größe des ersten Eintrags in Bytes) liefert mir diese Anzahl wieder. Sinn der Sache: Ich kann die Mustertabelle beliebig
-
Thread
Anfängerfrage zu Unions
Besser: int16_t WortArray[sizeof(struct SondenTel) / sizeof(int16_t)]
Damit reservierst du doppelt soviel Speicher wie nötig. > Besser: > > int16_t WortArray[sizeof(struct SondenTel) / sizeof(int16_t)] Und was geschieht, wenn sizeof (struct SondenTel) ungerade ist? Besser wäre es, das Array dann noch ein Element größer anzulegen ...
-
Thread
Alias-Funktionen abhängig vom Datentyp
Funktionen noch für Datentypen mit plattformabhängigen Bitbreiten nutzen. Folgendes geht nicht: [c] #if sizeof(uint_fast8_t) == sizeof(uint8_t) uint_fast8_t complkft_uint_fast8(uint_fast8_t val1, int_fast8_t val2) { return complfkt_uint8(val1,val2); } #elif sizeof(uint_fast8_t) ==
wird: [c] uint_fast8_t complkft_uint_fast8(uint_fast8_t val1, int_fast8_t val2) { switch(sizeof(uint_fast8_t)) { case sizeof(uint16_t) return complfkt_uint16(val1,val2); case sizeof(uint8_t) return complfkt_uint8(val1,val2); ... default: error("function is
-
Thread
Problem beim senden mit printf
sortieren der Befehlsliste (Voraussetzung für bsearch) char *tmp; qsort(&sms_cmd_list, (sizeof(sms_cmd_list)/sizeof(SMS_CMD_LIST_T)), sizeof(SMS_CMD_LIST_T), (int(*)(const void*,const void*))strcmp); ptr_nachricht = strtok_r(nachricht,SMS_DELIMITER,&tmp); // ersten Befehl extrahieren
übergeben SMS_CMD_LIST_T* spItem = (SMS_CMD_LIST_T*)bsearch (&keyItem, sms_cmd_list, (sizeof(sms_cmd_list)/sizeof(SMS_CMD_LIST_T)), sizeof(SMS_CMD_LIST_T), (int(*)(const void*,const void*)) strcmp); if (spItem != NULL) { spItem->fp(0); } ptr_nachricht = strtok_r(NULL,
-
Thread
Floatwerte in EEPROM abspeichern
Kleines Beispiel in C: unsigned char i,j; float wert; unsigned int adresse; //lesen for(i=0;i<sizeof(wert);i++) { eeprom_lesen(adresse,k); adresse ++; if (i<sizeof(wert)-1) { wert = k; wert = wert << 1; } wert = k; } //schreiben for(i=0;i<sizeof(wert);i++)
float my_float, my_erg; my_float = -12.4; eeprom_write_block(&my_float, (void*) 20, sizeof(my_float)); my_float = 0; eeprom_read_block (&my_float, (void*) 20, sizeof(my_float)); my_erg = my_float; Den EEPROM-Ptr habe ich kurz quick&dirty gecastet, sorry dafür. Stefan
-
Thread
Schieberegister mit PIN abfrage
PORTB &= ~(1<<PB0); itoa(Datain, Dataout, 10); usbMsgPtr = Dataout; return sizeof(Dataout); [/code] Das Shiften muss außerdem vor dem Ver-Odern geschehen. Ob das 'sizeof(Dataout)' stimmt, ist auch fraglich...
> >Ob das 'sizeof(Dataout)' stimmt, ist auch fraglich... > Es funktioniert habe es noch in anderen Cases. Da hat er sich falsch ausgedrückt. Das du den sizeof zurückgeben kannst steht natürlich ausser Frage. Die
-
Thread
C -> AVR -> Strukturen -> Padding Bytes
t y; * }pos_t; * pos_t Position = [x][Padding][Padding][Padding][Padding][Padding][y][y] * sizeof(pos_t) = 8 Bytes bei einem "AVR", mit Padding Bytes * * * typedef struct __PACKED__ * { * uint8_t x; * uint16_t y; * }pos_t; * pos_t Position = [x][y][y] * sizeof(pos_t) = 3 Bytes
sizeof() würde es dir zeigen. Wieso stellst du solche Fragen?
-
Thread
C++ template Funktion doppelt definiert in header und cpp
peripheral->spi)) { return queue_transfer(tx_buffer, tx_length, rx_buffer, rx_length, sizeof(Type) * 8, callback, event); } start_transfer(tx_buffer, tx_length, rx_buffer, rx_length, sizeof(Type) * 8, callback, event); return 0; } [/code] und in SPI.cpp
range" error uint16_t rx_data[8] = {0}; spi.transfer(tx_data, tx_word_len * sizeof(*tx_data), rx_data, rx_word_len * sizeof(*rx_data), nullptr); [/code] das ist Teil von einem Testcode, deshalb die 'komische' Größenangabe.
-
Thread
Feld mit Strucktur an Funktion übergeben und dann zurückge
Größenberechnung (das kann schon mal passieren, wenn Code größer wird) [C] double a[20]; ... int j = sizeof(a) / sizeof(int); [/C] Kein Compiler kann diesen Fehler entdecken und glaub mir: An solchen Sachen sucht man lange. Hingegen [C] int a[20]; ... int j = sizeof(a) / sizeof(*a); [/C] ist richtig [C] double a[20]; ... int j = sizeof(a) / sizeof(*a); [/C] ist auch richtig. Durch die Schreibweise kann ich den vorhergehenden Fehler einfach nicht mehr machen -> ein vermeidbarer Fehler ist kein Problem mehr.
-
Thread
True =1 false =0 kann man damit rechnen?
mit 32/64-Bit Daten besser zurecht kommen als mit 8-Bit Daten. So beispielsweise bei IBM Power: sizeof(_Bool)==4.
einen Pointer umcastest, ist die Sprachdefinition am Ende mit ihren Zusagen. > memcpy( &b, "x", sizeof( b ) ); memcpy nimmt als erstes Argument keinen bool* Du akzeptierst ja auch, dass [C] int a[sizeof(double)/sizeof(int)]; double b = 5.0; memcpy( &a, &b, sizeof(double) ); [/C]
-
Thread
Warnung / Fehler nach casten von char a[] zu uint_32*
zu lösen (alle ungetestet): 1. nimm eine union: [c] union { uint32_t data[3]; char msg[sizeof(data)]; }; [/c] 2. caste in die umgekehrte Richtung: [c] uint32_t data[3]; char *msg = (char*) data; [/c] 3. nimm memcpy (wie schon erwähnt): [c] uint32_t data[3]; char msg[sizeof(data)]; memcpy(msg, data, sizeof(msg)); [/c] 4. mach es von Hand: [c] uint32_t data[3]; char msg[sizeof(data)]; for ( int i=0; i<sizeof(data)/sizeof(*data); ++i ) for ( int j = 0; j < sizeof(*data); ++j ) msg[i*sizeof
-
Thread
Temperaturanzeige /7 Segment LED mit KYT 81-110, Atmega 8
verwendet wird, bleibt sie da 4. [code] uint8_t i,seg,dig; int temp; void setup() { for(i=0;i<sizeof(segmentPins)/sizeof(segmentPins[0]);i++) pinMode(segmentPin[i],OUTPUT); for(i=0;i<sizeof(digitPins)/sizeof(digitPins[0]);i++) pinMode(digitPins[i],OUTPUT); dig=0; } void loop() { digitalWrite
dig 1 2 3 4 const int digitPins[nbrDigits] = {8,9,10,11}; void setup() { for(i=0;i<sizeof(segmentPins)/sizeof(segmentPins[0]);i++) pinMode(segmentPins[i],OUTPUT); for(i=0;i<sizeof(digitPins)/sizeof(digitPins[0]);i++) pinMode(digitPins[i],OUTPUT); dig=0; } // Funktion zum auslesen
-
Thread
Uart Daten-Empfang
// if( Message[0] == '?' ) { uint8_t sensorNr = atoi( &Message[1] ); if( sensorNr < sizeof( TWert ) / sizeof( *TWert ) ) { char Answer[10]; uart_putc( '#' ); uart_puts( itoa( (int)sensorNr, Answer, 10 ) ); uart_putc( ',' ); uart_puts( itoa( (int)TWert[sensorNr
nextChar == ',' ) { nextChar++; newValue = atoi( nextChar ); if( sensorNr < sizeof( TWert ) / sizeof( *TWert ) ) TWert[sensorNr] = newValue; } } else return 254; return 0; } int main() { .... while( 1 ) { error = processMessages()
-
Thread
Pointer incrementieren schlägt fehl?!
printf(str); } int main(int argc, char *argv[]) { char *buff = (char*)calloc(11,sizeof(char)); ausgabe(buff); return 0; } [/c]
Jan H. schrieb im Beitrag #5112745: > char *buff = (char*)calloc(11,sizeof(char)); sizeof(char) ist per Definition /immer/ 1. Du kannst also einfach calloc(11,1) oder noch einfacher malloc(11) schreiben. Der Grund ist, dass sizeof die Größe des Typs als Vielfache von der
-
Thread
Grösse Array im Struct
printf("text %s \n",mainMenu.menuItems[3].text); //size of mainmenu.menuItems printf("sizeof(mainMenu %lu \n", sizeof(mainMenu.menuItems) / sizeof(mainMenu.menuItems[0]) ) ; //<-- Error 'sizeof' to an incomplete type MANUMEMBER_t [] } [/c] Kann mir einer auf die Sprünge
{"zurueck", NULL, 0}, }; MENU_t mainMenu = { "Main Menu", //Menu Name sizeof( mainMenuItems ) / sizeof( *mainMenuItems ), mainMenuItems; }; [/c] da kann dir jetzt wieder der Compiler unter die Arm greifen und per sizeof die Länge des Arrays ermitteln und in die Struktur
-
Thread
Esp32 usb host
may be in PROGMEM, so copy them to RAM for printf char s1[32], s2[64]; strncpy_P(s1, type, sizeof(s1)); s1[sizeof(s1)-1]=0; strncpy_P(s2, string, sizeof(s2)); s2[sizeof(s2)-1]=0; Serial.printf("METADATA(%s) '%s' = '%s'\n", ptr, s1, s2); Serial.flush(); } // Called when there's
string may be in PROGMEM, so copy it to RAM for printf char s1[64]; strncpy_P(s1, string, sizeof(s1)); s1[sizeof(s1)-1]=0; Serial.printf("STATUS(%s) '%d' = '%s'\n", ptr, code, s1); Serial.flush(); } void setup() { Serial.begin(115200); delay(1000); Serial.println("Connecting
-
Thread
Daten aus bestimmten EEProm-Addressen lesen
eeprom_read_block( *eeprom_text_buffer, (uint8_t*) 0x01ff, sizeof(eeprom_text_buffer)); Damit Zerstörst Du Dir den Zeiger auf Dein Array! Das: eeprom_read_block( eeprom_text_buffer, (uint8_t*) 0x01ff, sizeof(eeprom_text_buffer
aktuell getesteten Alternativen sind: eeprom_read_block(eeprom_text_buffer, (uint8_t*) 0x01ff, sizeof(eeprom_text_buffer)); eeprom_read_block(eeprom_text_buffer, (uint8_t*) 0x01, sizeof(eeprom_text_buffer)); eeprom_read_block(eeprom_data_buffer, (uint8_t*) 0x01ff, sizeof(eeprom_text_buffer
-
Thread
int/float => buffer?
memcpy > > float b = 1234.56; > memcpy(msg.buf, &b); ich hab jetzt memcpy(msg.buf, &data, sizeof(data)); das scheint zu passen ?
es wieder raus ? einfach die Parameter von memcpy tauschen [c] //rein memcpy(msg.buf, &b, sizeof(float) ); //raus memcpy(&b, msg.buf, sizeof(float) ); [/c]
-
Thread
sizeof(struct_name) in union
unsigned char check_sum; unsigned char stop_flag; } fields; unsigned char bytes[sizeof(fields)]; }Frame; ../datalink.c:48: error: 'fields' undeclared here (not in a function) [/c]
unsigned char stop_flag; }; typedef union{ struct xyz fields; unsigned char bytes[sizeof(struct xyz)]; }Frame; [/c]
-
Thread
Pixeldaten aus bitmap auslesen
. aber Anscheinend passt es doch nicht überall. [c] fread(&bmpData_s.fileHeader_s.file_type, sizeof(bmpData_s.fileHeader_s.file_type), 1, imageFile); fread(&bmpData_s.fileHeader_s.file_size, sizeof(bmpData_s.fileHeader_s.file_size), 1, imageFile); fread(&bmpData_s.fileHeader_s.reserved1, sizeof(bmpData_s.fileHeader_s.reserved1), 1, imageFile); fread(&bmpData_s.fileHeader_s.reserved2, sizeof(bmpData_s.fileHeader_s.reserved2), 1, imageFile); fread(&bmpData_s.fileHeader_s.offset_data, sizeof(bmpData_s.fileHeader_s.offset_data), 1, imageFile);[/c] damit bekomme ich die Ausgabe [code]
-
Thread
Terminal-Befehle aus mehreren Zeichen im Controller erkennen, wie am besten?
{ int iOut; caCmdBuffer[0] = 'a'; caCmdBuffer[1] = 'b'; Init(); qsort(sCmdList, (sizeof(sCmdList)/sizeof(struct sCmd)), sizeof(struct sCmd), (int(*)(const void*,const void*))strcmp); vSendText(caCmdBuffer); sscanf(caCmdBuffer, "%x", &iOut); while(1){ if(cEnterFlag == 1
cpCmdBuffer = caCmdBuffer; spItem = (struct sCmd*)bsearch (cpCmdBuffer, sCmdList, (sizeof(sCmdList)/sizeof(struct sCmd)), sizeof(struct sCmd), (int(*)(const void*,const void*)) strcmp); if (spItem != NULL) spItem->Function(); else vSendText("Ungueltige Eingabe
-
Thread
IRQ hängt ab und zu - Warum?
writeuartrxbuffer++; // Aendere Position im Empfangsringspeicher writeuartrxbuffer %= sizeof(uartrxbuffer);; readuartrxbuffer++; // Aendere Position im Empfangsringspeicher. Leseposition muss ebenfalls geaendert werden readuartrxbuffer %= sizeof(uartrxbuffer);; } }
writeuartrxbuffer++; // Aendere Position im Empfangsringspeicher writeuartrxbuffer %= sizeof(uartrxbuffer);; readuartrxbuffer++; // Aendere Position im Empfangsringspeicher. Leseposition muss ebenfalls geaendert werden readuartrxbuffer %= sizeof(uartrxbuffer);; } }
-
Thread
C und "call by reference"
Dann ist es formaljuristisch auf allen Plattformen korrekt. Solange aber sizeof (int) == sizeof (int *) ist, funktioniert die --unsaubere-- Variante auch. Den Irrtum hat der Hobbyprogrammierer ja auch schon selbst bemerkt.
Beitrag #3316967: > Dann ist es formaljuristisch auf allen Plattformen korrekt. > > Solange aber sizeof (int) == sizeof (int *) ist, funktioniert die > --unsaubere-- Variante auch. Allerdings haben Pointer auf manchen Plattformen etwas spezielle Schreibweisen, die %p berücksichtigen kann, %i aber
-
Thread
Konvertierungsproblem in C
Wie könnte ich das anders lösen? double**XX; XX = (double**)malloc(2 * N * sizeof(double)); Wie kann ich da nun auf das zweite Feld zugreifen? Ich benötige das zweite Feld für eine Funktion.
nicht ganz sicher, aber es könnte so irgendwie funktionieren: [c] double (*XX)[2] = {malloc(N * sizeof(double)) , malloc(N * sizeof(double)}; [/c] Bin mir auch nicht sicher was Du überhaupt machen möchtest...
-
Thread
code umwandeln
pointer to width table inline PGM_P font_widthtable(FONT_P charset) { PGM_P tmp; if (sizeof(tmp) == 2) tmp = (PGM_P)pgm_read_word(&(charset.widthtable)); else memcpy_P((char*)&tmp,&(charset.widthtable),sizeof(tmp)); return tmp; } [/c]
c] //load pointer to width table inline font_widthtable(FONT_P charset) { tmp; if (sizeof(tmp) == 2) tmp = ()pgm_read_word(&(charset.widthtable)); else memcpy_P((char*)&tmp,&(charset.widthtable),sizeof(tmp)); return tmp; } [/c]
-
Thread
Bitte um Verständnishilfe bei Pointer in Funktion
0; i < sizeof(floatwert); i++) buffer[i] = *floatBytes++; } [/C] oder so [C] void float_to_uint8 (float floatwert, uint8_t *buffer) { memcpy( buffer, (uint8_t*)&floatwert, sizeof(floatwert) ); }
Dietmar Hersch schrieb im Beitrag #1791078: > Der "sizeof" liefert mir ja die Anzahl in Bytes zurück, richtig? Also > ergibt sizeof "4" - Die Schleife wird also 4-mal durchlaufen. richtig. Da aber niemand garantiert dass ein float immer 4 Bytes hat,
-
Thread
Struct abspeichern
mittels zeiger+sizeof(unsigned char) genauso adressieren. Geht sowas? Kann mir jemand da mal mit nem C Codefragment helfen? Danke Danni
struct irgendwas* What ) { union { struct irgendwas Original; unsigned char Bytes[ sizeof( struct irgendwas ) ] } *Wandler; Wandler = &What; for( i = 0; i < sizeof( irgendwas ); ++i ) WriteByteToEEprom( Wandler->Bytes[i] ); } Hmm. Wenn ich mir das so anschaue, ist
-
Thread
strlen bei mehrdimensionalen Strings
definierst ein zweidimensionales Feld von Pointern. Du kannst die Anzahl der Pointer insgesamt über sizeof des Feldes geteilt durch sizeof eines Elementes herausfinden. Die Grösse der zweiten Dimension kennst du doch (6) - warum willst du die berechnen? Ich würde erwarten, dass du die Grösse der ersten
Beenden", "Exit" } }; DisplayScreen Display1 = { { "Hauptseite", "Main Screen" }, { sizeof( Display1Text ) / sizeof( *Display1Text ), Display1Text } }; int Language = 0; char* GetCurrentText( Text* pText ) { if( Language == 0 ) return pText->m_Deutsch;
-
Thread
Anfängre string zerlgen
} // sortieren der Befehlsliste (Voraussetzung für bsearch) char *tmp; qsort(&sms_cmd_list, (sizeof(sms_cmd_list)/sizeof(SMS_CMD_LIST_T)), sizeof(SMS_CMD_LIST_T), (int(*)(const void*,const void*))strcmp); ptr_nachricht = strtok_r(nachricht,SMS_DELIMITER,&tmp); // ersten Befehl extrahieren while
Kommando übergeben SMS_CMD_LIST_T* spItem = (SMS_CMD_LIST_T*)bsearch (&keyItem, sms_cmd_list, (sizeof(sms_cmd_list)/sizeof(SMS_CMD_LIST_T)), sizeof(SMS_CMD_LIST_T), (int(*)(const void*,const void*)) strcmp); if (spItem != NULL) { spItem->fp(0); } ptr_nachricht = strtok_r(NULL,SMS_DELIMITER,&tmp
-
Thread
packed bei verschachtelten Strukturen
>Zum unpacked Element kann es auch nicht gehören, da >sich dann sizeof(member) ändern würde. Wieso "ändern"? Gegenüber welcher Referenzgröße? sizeof(MEMBER_STRUCT) ist 4 wenn man es im normalen Kontext verwendet, also gehört das pad-byte zu MEMBER_STRUCT, wo ist das
schrieb im Beitrag #1932263: >>Zum unpacked Element kann es auch nicht gehören, da >>sich dann sizeof(member) ändern würde. > Wieso "ändern"? Gegenüber welcher Referenzgröße? Dem alleinstehenden MEMBER_STRUCT. sizeof(MEMBER_STRUCT) wäre dann nicht mehr gleich sizeof(MYSTRUCT.member3). > sizeof
-
Thread
Variable in Flash-ROM?
die beiden unsigned shorts (als struct organisiert) übereinander liegen (wenn auf deinem Target sizeof(float)= 2*sizeof(unsigned short)). Vom Programm aus dann das float beschreiben und die beiden unsigned shorts dann ins Flash wegschreiben bzw. umgekehrt beim Lesen.
Zeile funktionierts. Aber eben die letzte Zeile funktioniert nicht, denn pFlash zeigt ja jetzt um sizeof (unsigned int) daneben. Du musst also pFlash wieder dekrementieren.
-
Thread
'return' with no value, in function returning int
Rück Kehrer schrieb im Beitrag #4993320: > if (index >= sizeof SHM_DATA_TYPES) { Das ist übrigens falsch, du meinst vermutlich: [c]if (index >= sizeof(SHM_DATA_TYPES) / sizeof(SHM_DATA_TYPES[0]))[/c]
ausgeborgt; danke, Giovanni Di Sirio). Dr. Sommer schrieb: > Rück Kehrer schrieb: >> if (index >= sizeof SHM_DATA_TYPES) { > Das ist übrigens falsch, du meinst vermutlich:if (index >= > sizeof(SHM_DATA_TYPES) / sizeof(SHM_DATA_TYPES[0])) Ja, das ist ein heikles Thema. Eigentlich hast du Recht. Aber
-
Thread
Zeiger Array
Lückengrösse übergeben, also wieviele elemente zu überspringen. ( "some_function(&somearray[0].b, sizeof(somearray[0])/sizeof(somearray[0].b))" ). Geht halt dann nur mit arrays, aber nicht mit linked lists oder so. 3) Ein Iterator. Das ist ja normalerweise auch der C++ Ansatz. Ich versuch mich mal
count = (N), \ .current = (X) }) #define ARRAY_ITERATOR(T, N, X) SPARSE_ARRAY_ITERATOR(sizeof(T), N, (T*){(X)}) #define SPARSE_ARRAY_ITERATOR(T, S, N, X) SPARSE_ARRAY_ITERATOR(sizeof(T) * S, N, (T*){(X)}) #define ARRAY_MEMBER_ITERATOR(T, N, X, M) GENERIC_ARRAY_ITERATOR(T, sizeof(*X), N, (
-
Thread
Pointer in C
Walter S. schrieb im Beitrag #2697601: > Oliver Lehmann schrieb: >> sizeof(cmd_buffer) > > das ist nicht das was du willst, das gibt dir die Größe eines Pointers, > dein array besteht aber nicht aus pointern! besser sizeof(uint8_t)?
im Beitrag #2697607: > Walter S. schrieb im Beitrag #2697601: >> Oliver Lehmann schrieb: >>> sizeof(cmd_buffer) >> >> das ist nicht das was du willst, das gibt dir die Größe eines Pointers, >> dein array besteht aber nicht aus pointern! > > besser sizeof(uint8_t)? sizeof(*cmd_buffer)
-
Thread
Sprache C - > long oder besser immer long long
ist automatisch und plattform-unabhängig so breit wie nötig. Wenn man sich dann noch mit dem sizeof-Operator anfreunden kann, klappt's auch mit dem sprintf.
Frank M. schrieb im Beitrag #5426441: > ptr = malloc(strlen(string) + 1); Warum nicht sizeof()
-
Thread
UDP Packete AVR NET IO
http_header[]={"Test aaa bbb ccc"}; memcpy_P((char*)ð_buffer[UDP_DATA_START],http_header,(sizeof(http_header)-1)); create_new_udp_packet((sizeof(eth_buffer)), 905, 904, IP(192,168,000,158)); [/Code] Nun bekomme ich den String so wie er sein soll, allerdings mit 4 absätzen! Des weiteren
http_header[]={"Test aaa bbb ccc"}; > > memcpy_P((char*)ð_buffer[UDP_DATA_START],http_header,(sizeof(http_header)-1)); > create_new_udp_packet((sizeof(eth_buffer)), 905, 904, > IP(192,168,000,158)); > [/Code] > > Nun bekomme ich den String so wie er sein soll, allerdings mit 4 > absätzen
-
Thread
Programm auf PC und AVR: unterschiedliche Ergebnisse
auf: [C] printf ("char %d short %d int %d long %d longlong %d bit\n", 8 * sizeof (char), 8 * sizeof (short), 8 * sizeof (int), 8 * sizeof (long), 8 * sizeof (long long)); [/C]
Besser noch: [C] printf("char %d short %d int %d long %d longlong %d bit\n", CHAR_BIT * sizeof (char), CHAR_BIT * sizeof (short), CHAR_BIT * sizeof (int), CHAR_BIT * sizeof (long), CHAR_BIT * sizeof (long long)); [/C] Es soll ja auch Plattformen geben, auf
-
Thread
warning: from incompatible pointer type
Zeiger auf ein Array muß eine Angabe für die Arraygröße enthalten. Du mußt nur daran denken, daß sizeof *a ja die Größe des Arrays zurückgeben muß und diese dafür bekannt sein muß.
das Array zugreifen willst. Ein (*a)[3] = 5; meldet zumindest bei gcc auch keinen Fehler. Aber ein sizeof(*a) tut das.
-
Thread
Alignment des ARM7
// 0x0C USInt usiOffset2 = offsetof ( FlexString8, charData ); // 0x02 USInt usiOffset3 = sizeof(FlexString8); // 0x0C USInt usiOffset4 = sizeof(UInt); // 0x02 USInt usiOffset5 = sizeof(Char); // 0x01 USInt usiOffset6 = sizeof(Char[8]); // 0x08 Nur weiss ich jetzt zb.B. leider nicht, wie
__attribute__((packed)) stype; obj.a = 1; obj.b = 2; obj.c = 3; obj.size = sizeof(stype); rprintf("a=%u, b=%u, c=%u, size=%u\n", obj.a, obj.b, obj.c, obj.size); [/c] - Michael
-
Thread
Call by Referenz - Unter unter Funktion
Danke habe sizeof() also falsch verstanden. Habe es weggelassen und nun funktioniert das Programm.
sizeof(uint8_t*) statt sizeof(uint8_t[30]) zurück.
-
Thread
"Driverless" HID, bidirektional, je 64 Byte - möglich?
DSC_RPT, // Report descriptor type HID_RPT01_SIZE,0x00, //sizeof(hid_rpt01) report descriptor /* Endpoint Descriptor */ 0x07,/*sizeof(USB_EP_DSC)*/ USB_DESCRIPTOR_ENDPOINT, //Endpoint Descriptor HID_EP | _EP_IN, //EndpointAddress
code string descriptor const struct{uint8_t bLength;uint8_t bDscType;uint16_t string[1];}sd000={ sizeof(sd000),USB_DESCRIPTOR_STRING,{0x0409 }}; //Manufacturer string descriptor const struct{uint8_t bLength;uint8_t bDscType;uint16_t string[27];}sd001={ sizeof(sd001),USB_DESCRIPTOR_STRING, {'A'
-
Thread
Lookup Tablegenerator für NTC-Widerstände (Linux)
constexpr(sizeof(value_type) == 1) { return value_type{pgm_read_byte(&data[i])}; } if constexpr(sizeof(value_type) == 2) { return value_type
assert(i < size()); if constexpr(sizeof(value_type) == 1) { return value_type{pgm_read_byte(&data[i + 1])}; } if constexpr(sizeof(value_type) == 2) { return value_type
-
Thread
Struct aus EEPROM lesen als Funktionsparameter
soll der Funktion übergeben werden? Ist Dir bewusst, daß Du so nur genau /ein/ Byte liest? sizeof(Lv->Level[3].default.allowed) ist nämlich sizeof uint8_t ...
. F. schrieb im Beitrag #4908448: > Ist Dir bewusst, daß Du so nur genau ein Byte liest? > > sizeof(Lv->Level[3].default.allowed) ist nämlich sizeof uint8_t ... Ja ist mir bewusst, aber die Struktur enthält auch andere Datentypen die größer uint8_t sind z.B. könnte allowed auch uint32_t sein..
-
Thread
C++ forward declaraion
sind?! std::optional<> enthält aber schon ein Bool, ist also mindestens 1 Byte groß. Dann wäre: sizeof(Node1)=sizeof(Node2)+1 und sizeof(Node2)=sizeof(Node1)+1 Das ist somit rekursiv und unendlich.
sind?! std::optional enthält aber schon ein Bool, ist also mindestens 1 Byte groß. Dann wäre: sizeof(Node1)=sizeof(Node2)+1 und sizeof(Node2)=sizeof(Node1)+1 Das ist somit rekursiv und unendlich.
-
Thread
Float to Raw Bytes
Type-casting oder per memcpy für ARM mit gcc? z.B. char buf[4]; float f = 10; memcpy(buf,f,sizeof(f); Beste Grüsse Geri
(char*)buffer; Jetzt hast du ein char Array bei dem du mittels (float*)&(buffer[NrFloat*sizeof(float)]) reinindizieren kannst, und wo das Alignment für float passen müsste.
-
Thread
STM32: gcc 5.4.1 vs. 6.3.1 und memset
diese Zeile ist noch gefährlich: [c] for (int i=0; i<sizeof(data_xxx); i++) { data_xxx[i] = 0; [/c] weil du mit sizeof(data_xxx) nicht die Anzahl der Elemente bekommst. In diesem Fall müsste es richtig sein, aber etwas besser ist dafür ein Makro in der Art [c] #define countof(arr) (sizeof(arr) / sizeof(arr[0])) [/c] zu benutzen.
-
Thread
port brav nach c Standard setzen
", LAMP_TYPE, ErrorLamp }, { "Ready", LAMP_TYPE, ReadyLamp } }; #define NR_OUT_DEVICES ( sizeof( OutDevices ) / sizeof( *OutDevices ) ) struct InDevices[] = { { "Throttle", POTI_TYPE, Throttle } }; #define NR_IN_DEVICES ( sizeof( OutDevices ) / sizeof( *OutDevices ) ) // // als
", LAMP_TYPE, ErrorLamp }, { "Ready", LAMP_TYPE, ReadyLamp } }; #define NR_OUT_DEVICES ( sizeof( OutDevices ) / sizeof( *OutDevices ) ) struct Device InDevices[] = { { "Throttle", POTI_TYPE, Throttle } }; #define NR_IN_DEVICES ( sizeof( OutDevices ) / sizeof( *OutDevices ) ) [/
-
Thread
LED-Blinker von AtMega8(328) auf AtTiny2313
0,0,0,0,0,0,0,0,0,1,1,0}; char LED_10[]={1,0,0,0,0,0,1}; char LED_11[]={0,0,0,0,0,1,1}; char LED_SIZE[]={ sizeof(LED_00), sizeof(LED_01), sizeof(LED_02), sizeof(LED_03), sizeof(LED_04), sizeof(LED_05), sizeof(LED_06), sizeof(LED_07), sizeof(LED_08), sizeof(LED_09), sizeof(LED_10), sizeof(LED_11), }; const int ledCount = 12; // Anzahl der LEDs im Array char LED_NOW_OUT[] ={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // aktueller Zählstand der einzelnen LEDs