-
Thread
AVR Studio Bug beim Laden von PROGMEM Tabelle
sizeof(x_pos_table)}, {(uint8_t*) &eep_x_pos_20m, (uint8_t*)&x_pos_table, NULL, sizeof(x_pos_table)}, // {(uint8_t*) &eep_x_pos_20m, (uint8_t*)&x_pos_table, NULL
sizeof(x_pos_table)}, // {(uint8_t*) &eep_x_pos_20m, (uint8_t*)&x_pos_table, NULL, sizeof(x_pos_table)}, // {(uint8_t*) &eep_x_pos_20m, (uint8_t*)&x_pos_table, NULL
-
Thread
Das alte Problem: Datentypen
16 Bit Maschinen, d.h. es > gibt kein Byte mit 8 Bit. Der Speicher ist immer 16 Bit breit. > sizeof(short int ) = 1 , also 16 Bit > sizeof(char) = 1 , also 16 Bit > sizeof(long) = 2 , also 32 Bit. Beim TMS320C40 (32-Bit-FP-DSP) war [pre] sizeof(char) == sizeof(short) == sizeof(int) == sizeof(long) == sizeof(float) == sizeof(double) == 1 [/pre] :)
-
Thread
Hilfe die Zeiger kommen !
ist mit der Länge sizeof(struct eeprom_giess). Hast du das gemeint?
ergäbe p1+1 dann 9. Bei uint32_t *p2 mit der Annahme p2==8 ergäbe p2+1 dann 12. Das mit dem sizeof brauchste bei malloc, etwa um auf einen uint32-t-Pointer 5 uint32_t zu allozieren: uint32_t *p3; p3 = malloc(5 * sizeof(uint32_t));
-
Thread
C String einlesen, wieso geht das?!
Eingabe ist, braucht es eine Begrenzung auf den benutzten Puffer. Man kann es zB mit fgets(buf, sizeof(buf),stdin);
beispielsweise erst zur Laufzeit dynamisch Speicher zugewiesen werden: [c] char name[ 123 ]; // sizeof( name ) = 123 - Der Compiler kennt die Größe char* p = NULL; // sizeof( p ) = 4 p = name; // sizeof( p ) = 4 p = new char[64]; // sizeof( p ) = 4 [/c] Ein "sizeof( pointer )" ergibt
-
Thread
canbus / SN65HVD230 / lib?
ja auch einfach folgendes schreiben unsigned int a = 1234; msg.id = 0x100; msg.len = sizeof(a); memcpy(msg.buf, &a, sizeof(a)); CANbus.write(msg); signed int b = -62662; msg.id = 0x101; msg.len = sizeof(b); memcpy(msg.buf, &b, sizeof(b)); CANbus.write(msg); usw
(msg); msg.id = 0x102; msg.len = sizeof(sysData.c); memcpy(msg.buf, &sysData.c, sizeof(sysData.c)); CANbus.write(msg); msg.id = 0x103; msg.len = sizeof(sysData.d); memcpy(msg.buf, &sysData.d, sizeof(sysData.d)); CANbus.write
-
Thread
sizeof bei Array von Pointern auf Arrays
sowohl für das pArray als auch für die Zielarrays) nicht überschritten werden. Mit pIndex < (sizeof(pArray)/sizeof(Type_pArray)) kann ich das schonmal für das Zeiger-Array realisieren. Wie aber kann ich dies für den Zielarray-Index machen? Habe Index < (sizeof(pArray[pIndex])/sizeof(Type_Array
[c] typedef struct { size_t size; int *data; } SizeArray; SizeArray a = malloc(sizeof(SizeArray)); a.size = ANZAHL_ELEMENTE; a.data = malloc(ANZAHL_ELEMENTE * sizeof(int)); [/c] Lösung Nr. 3: [c] int data[ANZAHL_ELEMENTE+1]; data[0] = ANZAHL_ELEMENTE; [/c] Lösung Nr. 4:
-
Thread
sizeof() bei char[11] ?
Was ist wenn lon nur zu haelfte gefuellt ist? darf ich da ueberhaupt sizeof() nehmen? oder gibt es eine funktion die nur die anzahl der zeichen vor der \0 zaehlt? volatile char lon[11]; sd_raw_write(myoffset,&lon,sizeof(lon)); myoffset++; sd_raw_sync();
hat nix mit dem zu tun was hinter diesem Pointer steckt. Nein. lon ist kein Zeiger auf char. sizeof(lon) ist 11. Übrigens ist sizeof keine Funktion sondern ein Operator, der auf Typen angewandt wird, etwa [c] size_t s = sizeof (int); [/c] Johann
-
Thread
Arduino Mega2560 mit externem RAM: linker flag für .data section geht nicht
*/ Serial.println(); Serial.print("Dynamic buffer 1 of "); Serial.print(arraysize * sizeof(uint32_t)); Serial.print(" bytes created, address: 0x"); Serial.println((uintptr_t)dataBuffer1, HEX); Serial.print("Dynamic buffer 2 of "); Serial.print(arraysize * sizeof(uint32_t));
uintptr_t)dataBuffer2, HEX); Serial.print("Dynamic buffer 3 of "); Serial.print(arraysize * sizeof(uint32_t)); Serial.print(" bytes created, address: 0x"); Serial.println((uintptr_t)dataBuffer3, HEX); Serial.print("Dynamic buffer 4 of "); Serial.print(arraysize * sizeof(uint32_t));
-
Thread
Größe eines #define String mit sizeof ermitteln
Länge bis zur ersten 0 liefert, sizeof beim string literal dagegen die bis zur letzten. Beispiele: [c] strlen("test"); // 4 sizeof("test"); // 5 strlen("test\0test"); // 4 sizeof("test\0test"); // 10 char *test = "test"; strlen(test); // 4 sizeof(test); // sizeof(char +) [/c]
-
Thread
Daten in Struct zuordnen und ins EEPROM speichern
eeprom_load(uint32_t addr, void *data, size_t len); aufrufen z.B. mit: eeprom_store(0, &my_struct, sizeof(my_struct)); eeprom_load(0, &my_struct, sizeof(my_struct)); VG Basti P.S. sizeof beachtet das padding des Kompilates!
Sorry: eeprom_write_block(&eep_datensatz.resetCounter,&counter,sizeof(counter));// schreiben Muss so: eeprom_write_block(&counter,&eep_datensatz.resetCounter,sizeof(counter));// schreiben
-
Thread
C Frage zu Subtraktion
puts("8 Bit"); uint8_t c=1; uint8_t d=0xFF; printf("%X + %X = %X (%d bytes)\n",c,d,c+d,sizeof(c+d)); printf("%X - %X = %X (%d bytes)\n\n",c,d,c+d,sizeof(c-d)); puts("16 Bit"); uint16_t e=1; uint16_t f=0xFFFF; printf("%X + %X = %X (%d bytes)\n",e,f,e+f,sizeof(e+f)); printf("%X - %X = %X (%d bytes)\n\n",e,f,e+f,sizeof(e-f)); puts("32 Bit"); uint32_t g=1; uint32_t h=0xFFFFFFFF; printf("%lX + %lX = %lX (%d bytes)\n",g,h,g+h,sizeof(g+h)); printf("%lX - %lX = %lX (%d bytes)\n\n",g,h,g+h,sizeof(g-h
-
Thread
C++ array aus structs kopieren
Das hier: [c] sizeof(myKeys) [/c] gibt dir die Länge des kompletten Arrays zurück. ALso ist das *3 höchstwahrscheinlich fehl am Platz. [c] memcpy( &keys, &myKeys, sizeof(myKeys) ); [/c] Kopiert das Array myKeys
kann es sein, dass mein memcpy nicht funktioniert weil ich sizeof verwende?
-
Thread
Tipps zur Speicheranalyse gesucht
am Ende malloc hinter. [c] kiss_fft_alloc (nfft, inverse_fft, NULL, &subsize); memneeded = sizeof(struct kiss_fftr_state) + subsize + sizeof(kiss_fft_cpx) * ( nfft * 3 / 2); if (lenmem == NULL) { st = (kiss_fftr_cfg) KISS_FFT_MALLOC (memneeded); } else { if (*lenmem >= memneeded
Portpin oder irgendwas ... Anmerkung: Es ist immer blöd, wenn der Speicherbedarf der Struktur a von sizeof(Struktur b) + komische Rechnungen ("sizeof(Struktur c) * n * 3 / 2") abhängig ist.
-
Thread
Probleme mit C Code und hilfe bei änderung
hingeschrieben hast, ist es *kein* Zeiger, sondern tatsächlich ein Array. Den Unterschied zeigt Dir der /sizeof/ -Operator: [c] void test(char[] p) { printf("sizeof = %d\n", sizeof p); } void main(void) { char array[10]; printf("sizeof = %d\n", sizeof array); test(array); } [/c]
Rufus Τ. F. schrieb im Beitrag #5782991: > Den Unterschied zeigt Dir der /sizeof/ -Operator: > > [c] > void test(char[] p) > { > printf("sizeof = %d\n", sizeof p); > } > > void main(void) > { > char array[10]; > > printf("sizeof = %d\n", sizeof array); >
-
Thread
Pointer und C
Mal ne andere Lösung. void array_loeschen(unsigned char *buffer ) { memset(&buffer,0,sizeof(buffer)); }
Mal ne andere Lösung. > void array_loeschen(unsigned char *buffer ) > { > memset(&buffer,0,sizeof(buffer)); > } Kann nicht funktionieren. Würde nur zwei Bytes in buffer löschen, da sizeof(buffer) == 2 ist. Innerhalb einer Funktion geht das mit sizeof() so gar nicht, da der generierte
-
Thread
init typedef , structure , bitfield c code
mask3.c); printf("Mask8: %d a:%d b:%d c:%d\n", mask8, mask8.a, mask8.b, mask8.c); // test sizeof struct: printf ("Groesse struct (3) : %d\n", sizeof(struct bitfields3) ); printf ("Groesse struct (8) : %d\n", sizeof(struct bitfields8) ); // test sizeof type printf ("Groesse typedef (3) : %d\n", sizeof(bitfields3_t) ); printf ("Groesse typedef (8) : %d\n", sizeof(bitfields8_t) ); } [/c] sizeof stimmt bei struct und type (1) Wo liegt aber mein Denkfehler für die vorgesehene Wert Ausgabe
-
Thread
struct einer Funktion übergeben
[c] st_data1 data1; st_data2 data2; st_data3 data3; WriteToMemory((uint8_t *)&data1, sizeof(data1)); WriteToMemory((uint8_t *)&data2, sizeof(data2)); WriteToMemory((uint8_t *)&data3, sizeof(data3)); [/c]
st_data1 data1; st_data2 data2; st_data3 data3; ... write_ee_block(0x00, &data1, sizeof data1); write_ee_block(0x20, &data2, sizeof data2); write_ee_block(0x40, &data3, sizeof data3); [/c]
-
Thread
Switch/Case auf Array anwenden
Dann merk dir. Das kleinste was es in C gibt, ist ein char. Definitionsgemäss hat ein char eine sizeof von 1. Kleiner als 1 geht nicht.
allerdings an dieser Adresse wirklich nur ein Bit Speicherplatz zur Verfügung steht! Somit könnte man bei sizeof 1 zurückgeben und die weiteren Bedingungen an sizeof wären erfüllt. Vor allem sizeof(array) / sizeof(array[0]). Meine andere Aussage, daß der Compiler Bitoperatoren verwenden darf, um einen _Bool
-
Thread
Adresse von char-array Zeiger?
komplet alles enthält. [c] #include <iostream> using namespace std; #define SIZE(arr) sizeof(arr)/sizeof(arr[0]) #define SIZE1(arr) sizeof(arr)/sizeof(arr[0]) #define SIZE2(arr) sizeof(arr[0])/sizeof(arr[0][0]) #define SIZE3(arr) sizeof(arr[0][0])/sizeof(arr[0][0][0]) int main() {
> beides kann man mit sizeof(char *) und sizeof(char **) > nachprüfen. Auch sizeof(char(*p)[10]) wird wahrscheinlich so gross > wie sizeof(char *) sein. Denn alloziert muss da nichts. Das einzige > was Compiler sich aber merken
-
Thread
"char" is incompatible with parameter of type char *restrict
Was ist "sizeof(20)" ? 1? oder 2? oder 4==sizeof(int)? Mit -1 wird dann 3 draus. snprintf reserviert noch ein Null-Byte zum String-Terminieren, also: "te" ist korrekt.
blöd geschrieben gebe ich zu. dahinter steckt ein define > > also > #define LINE_LENGTH 20 > sizeof(LINE_LENGTH) aber sizeof(20) ist nicht dasselbe wie 20. "sizeof" gibt an, wieviel bytes der Datentyp im Speicher belegt. "20" ist ein integer, der braucht auf deiner Hardware 4 Bytes. also sizeof
-
Thread
Samplefrequenz, welchen Denkfehler mache ich?
bleibt Audiopuffer[(i*4)-4] = (sinus[ ( (k + (sizeof(sinus)/8)) % (sizeof(sinus)/2) ) ] - 32768); Audiopuffer[(i*4)-3] = 0; Audiopuffer[(i*4)-2] = (sinus[k] - 32768); Audiopuffer[(i*4)-1] = 0; k++; k %= (sizeof(sinus
(Siehe 2tes Bild, hier 20ms pro Diverse, beim ersten waren es 10ms/Div). Wenn ich das k modulo (sizeof(sinus)/4) nehme, kommt nur der halbe Sinus raus, und wenn ich modulo (sizeof(sinus) nehme, kommt eine Hälfte der Ausgabe eine ganze Schwingung und nochmal solange "Rauschen", naja hinter dem Sinus
-
Thread
ReadFile WriteFile an serielle Schnittstelle
%d instead of %d\n", res, sizeof (single_with_read)); exit(1); } memset(recbuf, 0, sizeof (recbuf)); if (!ReadFile(flasher_port, recbuf, sizeof (unsigned char), (DWORD *) & res, NULL)) res = -1; if
%i instead of %i charachters!\n", txcnt, sizeof (unsigned char)); } recbuf = 0; if (!ReadFile(flasher_port, &recbuf, sizeof (unsigned char), &rxcnt, NULL)) { retValue = 1; break; } else if (rxcnt != sizeof
-
Thread
Arbeit mit 16 bit in 32 bit system in C
Wie groß ist auf Deinem 32-Bit-System sizeof (short)? In C ist sizeof (char) <= sizeof (short) <= sizeof (int) <= sizeof (long) nur die genaue Verteilung kann von Zielsystem zu Zielsystem differieren.
sizeof(int) = 4 byte
-
Thread
Seltsames Arduino Serial Read verhalten
" ->zu kurz, min. 17 Zeichen\"setdate2014/10/05\"")); memset(&serial_in_command[0], 0, sizeof(serial_in_command)); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); } memset(&serial_in_command[0], 0, sizeof(serial_in_command)); memset(&serial_in_buff[0], 0
[0], 0, sizeof(serial_in_command)); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); } } // if(strlen(serial_in_command)) [/c]
-
Thread
Problem mit Funktion: Pointer falsche Arraygröße
kommando[3] = 0x28; //( kommando[4] = objectnumber; kommando[5] = 0x29; for( i = 6; i < sizeof( kommando ) / sizeof( *kommando ); i++ ) { kommando[i] = value[j]; j++; } for( i = 0; i < sizeof( kommando ) / sizeof( *kommando ); i++ ) { SIMKNX_Transmit
, dessen Grösse sizeof korrekt als Grösse des Zeigers angibt, nicht des Vektors. Die Information, ob und wieviele chars denn auf den ersten folgen, ist verlorengegangen. sizeof, angewendet auf Vektoren, wertet zur Compile-Zeit
-
Thread
Strukturen mit memset initialisieren (C/C++)
struct myStruct { ... ... ... }; myStruct einsDavon; memset( &einsDavon, (int)'\0', sizeof(myStruct) ); Dazu 2 Fragen: 1) Was soll der (int) Cast? warum nicht einfach: memset( &einsDavon, 0, sizeof(myStruct) ) 2) Es gibt Kollegen, die die ganze memset Initialisierung für Quatsch
pointer dereferenzieren (schließlich ist es keine echte Dereffernzierung, da der Compiler das Sizeof zur Compilezeit berechnet). zb: [c] myStruct* einPointerDavon; einPointerDavon = (myStruct*) malloc(sizeof(*einPointerDavon)); memset( einsDavon, (int)'\0', sizeof(*einPointerDavon) ); //
-
Thread
Menüstruktur für Grafikdisplay
struct Button buttons[] = { { ... }, { ... }, ... }; #define NrAllButtons ( sizeof( buttons ) / sizeof( buttons[0] ) ) struct Button* Main[] = { // zum Main Menü gehören diese Buttons &buttons[0], &buttons[1] }; #define NrMainButtons ( sizeof( Main ) / sizeof
&button[9], > &button[12], > &button[14]}; > #define BUT_ANZ_MAIN (sizeof(*main[]) / sizeof(sButton *)) > [/c] Das letzte sollte heissen #define BUT_ANZ_MAIN (sizeof(butMain)/ sizeof(*butMain)) Immer: Die Größe über alles ( sizeof(butMain) ) dividiert durch
-
Thread
Typumwandelung: float <---> char*
// convert float to char array unsigned char buf[4]; float f1=(float)12.3456; memcpy(buf,&f1,sizeof(f1)); // convert char array to float float f2; memcpy(&f2,buf,sizeof(buf)); printf("f2: %lf\n",f2); [/c]
memcpy (&f, buf, sizeof(buf));
-
Thread
Vergleich von signed und unsigned
klaus schrieb: > (1) Wenn sizeof(T) >= sizeof(int): Keine Änderung von T Bedenke, dass Operatoren auch mal 2 Operanden haben. > (2) Wenn sizeof(T) < sizeof(int): > (a) unsigned(T): T wird zu "unsigned int" promoted > (b) signed(T): T wird zu "int" promoted (2) Wenn sizeof(T) < sizeof(int): T wird zu "int" promoted
-
Thread
Arduino als WOL server
Das sizeof mac in der Funktion WOL liefert nicht den gewünschten Wert. Da kommt sizeof (byte*) raus Entweder du machst einen extra Paramter oder schreibst fest 6 rein.
{ Serial.println(sizeof mac); } [/c]
-
Thread
linked list - verkettete Liste
(sizeof(item)); list->first = p; } [/c]
an dieser Stelle sogar keine gute Idee. Lass ihn weg struct List *liste = malloc(sizeof(List)); > Gibt es einen unterschied zwischen > List *liste = (List*)malloc(sizeof(List)); und > struct List *liste = (List*)malloc(sizeof(List)); ? ohne den typedef wäre das erste ein
-
Thread
Rückgabe von sizeof() bei einer Struktur
__u8 can_dlc; __u8 data[8] __attribute__((aligned(8))); };[/c] Wenn ich nun sizeof(frame) aufrufe, erhalte ich als Ergebnis den Wert 16. Meiner Meinung nach hätte ich aber den Wert 13 ("4 Byte für _u32" + "1 Byte für _u8" + "8*1 Byte für _u8[8]") erhalten müssen. Kann mir jemand
-
Thread
sizeof() bei GCC und Mingw
long longitude; char latitude_ns; char longitude_ew; } tPositionSet; sizeof(tPositionSet) gibt beim GCC die erwarteten 18 Bytes, der Mingw sagt mir jedoch 20. Obwohl die einzelnen Datentypen unsigned long da auch 4 und char 1 Byte benötigt. Wie kommt das, ist meine Struktur
nur dann, wenn die Länge der Struktur auf das nächstgrößere Vielfache von 4 verlängert wird. > sizeof(tPositionSet) gibt beim GCC die erwarteten 18 Bytes Ich weiß nicht, was du mit "beim GCC" meinst. Auf 32bit-Plattformen wäre das jedenfalls eher unüblich, da manche 32bit-Architekturen (z.B. x86
-
Thread
C: Variable aus einer Schleife | Call by Value sehr langsam?!
wie er das hatte. Hier ist *leds kein Pointer sondern evaluiert zum ersten Array-Element und der sizeof nimmt sich dann von dem den Datentyp. Man hätte es auch als int len=(sizeof(leds)/sizeof(leds[0])); schreiben können, da sieht man dann besser was passiert. > Ich würde Dir raten, mal ein
er das hatte. >Hier ist *leds kein Pointer sondern evaluiert zum ersten Array-Element >und der sizeof nimmt sich dann von dem den Datentyp Stimmt, da habe ich Unsinn erzählt. sizeof(*leds) entspricht sizeof(int), sizeof(&leds) würde sizeof(int*), also der Pointergröße, entsprechen.
-
Thread
Array einer Variable übergeben in C
Hans schrieb im Beitrag #5775707: > val = sizeof(sumArray)/sizeof(sumArray[0]); Warum so umständlich? Da du das Array vorher explizit auf diese Größe festgelegt hast, genügt doch: [c] val = (limitIndexRight - limitIndexLeft) * sizeof(uint16
limitIndexLeft; Jörg W. schrieb im Beitrag #5775714: > val = (limitIndexRight - limitIndexLeft) * sizeof(uint16_t); Was will der TO? Die Anzahl der Array-Member oder die Größe des dynamischen Arrays in Bytes? Nach den verzweifelten Versuchen mit "sizeof(sumArray)/sizeof(sumArray[0])" zu urteilen
-
Thread
GCC ARM Embedded -> Compiler bug! Dereferenzierung von Pointern.
= %lp\r",&b); my_printf("&array_a = %lp\r",&array_a); my_printf("sizeof(t_a) = 0x%02X\r",sizeof(t_a)); my_printf("sizeof(arr_t_a) = 0x%02X\r",sizeof(arr_t_a)); my_printf("sizeof(t_b) = 0x%02X\r",sizeof(t_b)); CR; my_prints("Addresses dereferencing
TEST ptr_b = 0x1fff8038 &b = 0x1fff8038 &array_a = 0xba5c sizeof(t_a) = 0x11 sizeof(arr_t_a) = 0x55 sizeof(t_b) = 0x08 Addresses dereferencing ptr_b ptr_b->number_b = 0x1fff8038 ptr_b->arr_a[0] = 0xba5c ptr_b->arr_a[1]
-
Thread
dma schreibt nicht ins Datenregister
angeschaut zu haben, sieht deine Grössenberechnung: Sebastian Kaulitz schrieb im Beitrag #5487991: > sizeof(flameBits)/sizeof(flameBits[U8FLAMELED1ST.position]) auch ziemlich "strange" aus.
Beides kannst du testen, indem du in den RAM schreiben lässt. Sebastian Kaulitz schrieb: > sizeof(flameBits)/sizeof(flameBits[U8FLAMELED1ST.position]) > > Wo ist das Problem? Üblicherweise nimmt man sizeof(array)/sizeof(array[0]), wenn man die Größe eines Arrays in Bytes möchte. Per Definition
-
Thread
USART Fleruy lib auf ATMEGA88 - Problem bei hohen Datenraten
erstes Zeichen speichern next= 1; while( ( c = uart1_getc() ) != 55 && next< sizeof(Message) ) { Message[ next++ ] = c; } Message[next] = '\0'; } _delay_ms(400); } [/c]
kein Fehler und es liegt auch ein Zeichen vor. Message[next++]=c; if ( c != 55 && next< sizeof(Message) ) { TLED_ON(); Message[next] = '\0'; } else { TLED_OFF(); } } [/c]
-
Thread
ARM GCC Problem Größe übergeordneten struct bestimmen
pragma pack(1) const struct SENSOR_PARA_DESCR Sensor_Para_Descr = { .SensorZelle = { sizeof(Sensor_Para_Descr.SensorZelle)+sizeof("Zelle minV") ,PARDSC_MEASURE ,"Zelle minV" } ,.UminZelle = { sizeof(Sensor_Para_Descr.UminZelle)+sizeof("") ,PARDSC_MSBDATA
Was berechnert er denn? sizeof(UminZelle) sollte 4 sein.
-
Thread
Macro: compiler warning sizeof(any data type)
dann geht's so: [pre](gdb) print swid $1 = "[ver:1.2.10]-[08:16:33 Jun 11 2022]" (gdb) print sizeof swid $2 = 36[/pre] im Gegensatz zu [pre](gdb) print sizeof SWID No symbol "SWID" in current context.[/pre] Damit es garnicht erst soweit kommt, benutze ich gerne [c]_Static_assert (sizeof(
{ uint8_t unused[E2END+1-(XXX+sizeof(SWID)-1)] oscCal[12], TimerOperation, TimeMode, ... swID[sizeof(SWID)-1]; } ee = {...}; [/c] Ideen/Vorschläge? sind willkommen!
-
Thread
Linux C Read von ttys0
die Speicherlecks entfernen. Ja dann funzt es xD -->siehe malloc ->res = read(fd,(char *)buf,sizeof(buf)); ^^ wohle eher res = read(fd, buf, sizeof(buf) / sizeof(buf[0]); -->memcpy(spei, buf, res); // anzahl der gelesenen Zeichen umschaufeln spei += rc // pointer hochzählen SoSo ^^ --> Speicher
Frage) Dem Compiler ist die Laenge des Strings bereits bekannt, weshalb ich anstelle von strlen() sizeof() benutzen würde.
-
Thread
Pointer auf Struct - Unterschiede
mit_ptr = &ohne_ptr; test_t *new_ptr = new test_t; // C++ test_t *malloc_ptr1 = (test_t *)malloc(sizeof(test_t)); // C/C++ test_t *malloc_ptr2 = malloc(sizeof(test_t)); // C [/c]
einen char an? [c] char *ptr = NULL; int main(void){ printf("Size of Pointer %d\n\r",sizeof(*ptr)); } [/c]
-
Thread
malloc nur innerhalb einer main ?
Peter B. schrieb im Beitrag #6146130: > unsigned char *p = malloc(64000 * sizeof(char)); > unsigned char *z = malloc(64000 * sizeof(char)); > > int main(void) { nee, sowas ist auch nicht erlaubt, Funktionsaufrufe im Niemandsland. [c] unsigned char *p; unsigned char *z; int main(void) { p = malloc(64000 * sizeof(char)); z = malloc(64000 * sizeof(char)); [/c]
-
Thread
bringt einfache Zeigerei einen Performance-Vorteil?
wieder zum Basiszeiger etwas addieren. Warum? Das ist der Unterschied: array + i -> array + sizeof(*array) * i {2 Ops} array++ -> array + sizeof(*array) {1 Op} Ob und wie der konkrete Compiler da noch wilde Optimierungen macht oder sogar die Hardware (Intel z.B. für sizeof(*array) == 2, 4
bei jedem i!=0 ergibt das true (solange (i * sizeof(element_type) implizit mit der Größe der Feldelemente multipliziert wird)
-
Thread
uShell - ein universeller Parser für uCs
, sizeof("\x0d") -1, (UCHAR *) "\x0d" }, { TC_STD , sizeof("=") -1, (UCHAR *) "=" }, { TC_STD , sizeof(".") -1, (UCHAR *) "." }, { TC_STD , sizeof(",") -1, (UCHAR *) "," }, { TC_FOLLOW, sizeof(" ") -1, (UCHAR *) " " }, { TC_STD , sizeof("?") -1, (UCHAR *) "?" }, { TC_VALUE , sizeof("0x") -1, (UCHAR *) "0x" }, { TC_STRING, sizeof("\x34") -1, (UCHAR *) "\x34" },
-
Thread
[AVR, C] Arrayzugriff aus Interrupt
das man array und index vertauschen kann) Daher &array[SIZE] oder array+SIZE oder array+sizeof(array)/sizeof(*array) was aber nur im Scope funktioniert, in dem auch array definiert ist.
Dirk B. schrieb im Beitrag #6331337: >> ... oder array+sizeof(array) > > Nein, weil sizeof Bytes liefert, die Arrayarithmetik aber die Größe > eines Elements berücksichtigt. Uuups, stimmt ;-) Na dann so array+ (sizeof(array)/sizeof(Datentyp))
-
Thread
Array mit vorzeichen im eeprom Speichern
Wert[1] = -20; Wert[8] = -18; eeprom_write_word(Wert, b, sizeof(Wert)); Wert[i]=eeprom_read_word(Wert, b, sizeof(Wert)); [/c]
man das genauso machen int indxex; int wert; eeprom_read_block ( &wert, &(g_eepromWert[index]), sizeof (wert)); eeprom_write_block ( &wert, &(g_eepromWert[index]), sizeof (wert)); [/c]
-
Thread
ARM-GCC: 64 Bit breites enum
default: printf("Pech gehabt\n"); } printf("s1=%d, s2=%d, s3=%d\n", sizeof(e_test1), sizeof(e_test2), sizeof(e_test3)); } [/c] Ausgabe unter Windows: [code] Enum: 8000000080000000 Gl³ck gehabt s1=8, s2=4, s3=4 [/code] Ausgabe auf dem LCD des STM32: [code]
e_test2 = 0x1, } test_t; enum { e_test3 = 0x1, }; printf("s1=%d, s2=%d, s3=%d\n", sizeof(e_test1), sizeof(e_test2), sizeof(e_test3)); printf("enumsize = %d\n", sizeof( (test_t) e_test2) ); [/c] kommt beim ersten printf noch das gewohnte Ergebnis mit unterschiedlichen Größen heraus
-
Thread
GCC Preprozessor Berechnungen und Forced Errors
dem Compiler voran läuft und keine intime Kenntnis vom dem hat, was erst der Compiler weiss. Und sizeof kennt erst der Compiler.
Vollständigkeit halber, mit diesem Makro funktioniert es auch: [c]#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)])) char some_array[10]; BUILD_BUG_ON(sizeof(some_array) != 10);[/c]
-
Thread
GSM-Modul sendet SMS ohne Inhalt
_1.io, text, sizeof(text)); delay_ms(500); io_write(&USART_1.io, ctrlz, sizeof(ctrlz));
Versuche mal an Stelle von sizeof(text) direkt 6 einzusetzen.