-
Thread
Daten ins Flash speichern mit dem STM32
Diese Berechnung: > int x = (sizeof(tSetup2) / sizeof(int)); und diese Schleife > for(i=0;i<x;i++) > { > FLASH_ProgramWord(FLSHBSEADRPG192, pData[i]); > } können funktionieren. Zwischen dem BOOL und dem ersten
du schreibst alle deine Daten an die selbe Adresse. [c]FLASH_ProgramWord(FLSHBSEADRPG192 + i*sizeof(uint32_t), pData[i]);[/c]
-
Thread
[C] Böse Falle: Datentyp korrekt angegeben, falscher verwendet
im Beitrag #5764572: > "Standard": > 30000 * 2 --> int16_t * int16_6 => int16_t Nur wenn sizeof(int16_t) == sizeof(int). Präziser: int * int => int, egal wie gross.
Yalu X. schrieb im Beitrag #5768551: > In > > a * b + c * d > > müssen für sizeof(int)=sizeof(x)=2 (x∈{a,b,c,d}) und a*b ≥ 65536 ≤ c*d Kannst du die Regeln zitieren, aus denen das folgt?
-
Thread
(Multi)Touch Treiber / Simulation, Raspberry Pi
memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_ABS; ev.code = ABS_MT_SLOT; ev.value = 0; if(write(fd, &ev, sizeof(struct input_event)) < 0)
die("error: write"); memset(&ev, 0, sizeof(struct input_event)); ev.type = EV_SYN; ev.code = SYN_REPORT; ev.value = 0; if(write(fd, &ev, sizeof(struct input_event)) < 0) die
-
Thread
Genauigkeit von float in AVR-GCC
und long double _könnten_ für eine, zwei oder drei verschiedene Größen stehen." Also: sizeof (float) <= sizeof (double) <= sizeof (long double) (Ja. Ich bin mir im Klaren darüber, daß bei präziser Lesart des bewussten Satzes sogar folgendes legal ist: sizeof
annehme.) Das wiederum besagt, daß die vom avr-gcc vorgenommene Annahme sizeof (float) == sizeof (double) vollkommen korrekt ist. *) Kernighan & Ritchie Programmieren in C Deutsche Ausgabe besorgt (sic!) von Prof. Dr. A. T. Schreiner und Dr.
-
Thread
Telnet-Client basteln
cout << "connecting remote telnet server..." << endl; connect (sConnect, (SOCKADDR*)&addr, sizeof(addr)); Sleep(10); answer = recv(sConnect, message, sizeof(message), NULL); strmessage = message; cout << strmessage << endl; getchar(); } [/c]
cout << "connecting remote telnet server..." << endl; connect (sConnect, (SOCKADDR*)&addr, sizeof(addr)); Sleep(10); //notwendig? int i; for (i = 0; i<sizeof(message); i++) message[i] = 0; answer = recv(sConnect, message, sizeof(message), NULL); // Welcome... strmessage =
-
Thread
Hilfe zu C-Programm
bei sowas würd ich sagen access violation... hzgr ->text1 = (char*)malloc(sizeof(struct telement)); hzgr ->text2 = (char*)malloc(sizeof(struct telement)); das schaut mir nicht richtig aus.. du kopierst 100bytes drüber aber telement hat sicher keine 100bytes.. probier hier
| | +---+---+---+---+---+---+---+--- ... ---+---+---+ hzgr ->text1 = (char*)malloc(sizeof(struct telement)); hzgr ->text2 = (char*)malloc(sizeof(struct telement)); Die mallocs erzeugen wieder neue Rechtecke. Es muessen Pfeile von hzgr->text1 nzw. hzgr->text2 zu diesen Rechtecken
-
Thread
malloc struct in c
das Allokieren der Struktur, quasi von innen nach aussen, so korrekt? m->y1->x1 = (x) malloc(sizeof(x*x_size)); m->y1 = (y) malloc(sizeof(y*y_size)); m = (matrix) malloc(sizeof(matrix)); typedef struct { int a; }x; typedef struct { x * x1; }y;
test schrieb im Beitrag #2847106: > m->y1 = malloc(sizeof(y)*y_size); ach kacke: m->y1 = malloc(sizeof(y*) * y_size);
-
Thread
Pointer-Array auf mehrere unterArrays (PROGMEM) wie zugriff?
Architektur wäre. &lightshow[x][y] wird vom Compiler so umgesetzt (*(lightshow + x * sizeof(const char*))) + y Das Problem ist das dereferenzieren an dieser Stelle (*(lightshow + x * sizeof(const char*))) Der Compiler weiss ganz einfach nicht, dass er mit der erhaltenen Adresse
Daher muss diese bytegröße noch durch die Bytegröße eines Array Elements dividiert werden. sizeof(a) / sizeof(a[0]) ergibt dann tatsächlich 5 > for(x=0; x<sizeof(lightshow); x++) for( x=0; x < sizeof(lightshow)/sizeof(lightshow[0]); x++ ) Abgesehen davon, sollte das aber
-
Thread
Grösse von enums immer 8bit bei wenigen Einträgen?
dereferenzieren, da den compiler hier nur der Typ interessiert. Point* p; sendDebugData(p, sizeof(*p));
für die zahlreichen Antworten. Ich werde in Zukunft bei enums immer die eeprom_write_block mit sizeof (enum_t) oder sizeof(enum_var) nehmen, je nach dem, da es ja egal ist. Gruß Bernhard Nöst
-
Thread
Geht so? uint64_t Array in EEPROM
Mich hat das sizeof(eellArray[index]) verwirrt. NIE würde ich auf die Idee kommen das so zu kompliziert schreiben. Würde hier sizeof(buffer) bzw. sizeof(data) schreiben. Sorry 8-) P.S. Muss das nicht eeprom_read_block(&buffer, &eellArray[index], sizeof(... und eeprom_write_block(data, &eellArray[index], sizeof(... sein?
-
Thread
Wie Array-Size bekannt machen
können. *Lösung 1* Wenn das Objekt nur 1x referenziert wird, dann geht ein [c] // #Einträge: sizeof (array) / sizeof (array[0]) static const type_t array[] = { ... }; [/c] im Header. Wenn das Objekt in einem Modul nicht referenziert wird (sizeof referenziert nicht), dann legt gcc auch kein
const size_t array_size; ... static const type_t array[] = { ... }; const size_t array_size = sizeof (array) / sizeof (array[0]); [/c] *Lösung 3* Vorsicht, Hack (tm): 1: Man schreibt die Größe ins Assembler-File, zB via [c] asm volatile ("/*\n#define array_size %0\n*/" :: "n" (sizeof (array
-
Thread
TCP/IP Socket Prgrammierung-Probleme beim Senden/empfangen
hton in die Netzwerkdarstellung um b) sende genügend Bytes z.B. mit send(IDclient,&ADCbuffer[n],1*sizeof(uint32_t),0) c) verwende den richtigen Datentyp uint32_t* Car = malloc(sizeof(uint32_t)); d) Lese auch genügend Bytes mit recv(IDMySocket, ctr, 1*sizeof(uint32_t),0) e) wandle das gelesene wieder
Martin K. schrieb im Beitrag #4241665: > d) Lese auch genügend Bytes mit recv(IDMySocket, ctr, > 1*sizeof(uint32_t),0) Und überprüfe ob auch tatsächlich 1*sizeof(uint32_t) Bytes gelesen wurden!
-
Thread
C++ alle Daten mit recv() empfangen?
> > /* Empfangende Daten auslesen */ > rc = recv(this->_s, &recvBuf[readSize], sizeof(recvBuf), 0); sizeof(recvBuf)? > /* Wurde etwas ausgelesen? */ > if(rc > 0) { > > /* Anzahl der ausgelsenen Daten hochzählen */ > readSize += rc; >
Kilian K. schrieb im Beitrag #4660643: > Mikro 7. schrieb im Beitrag #4660622: >> sizeof(recvBuf)? > > Lese halt nicht jedes Byte einzelnd aus sondern immer 4... Warum "tarnen" mit sizeof(recvBuf)? Bug: Was passiert wenn bereits BUFFER_LENGTH Daten gelesen wurden? > Mikro
-
Thread
SIM800 GSM: Welche Library für Arduino?
serialSIM800.print(atc); delay(500); while (serialSIM800.available() && (cnt < sizeof(response))) { *(p++) = serialSIM800.read(); cnt++; } if (cnt >= sizeof(response)-1) /*Buffer Überlauf? */ return 0; *p = '\0'; /* String Null terminieren
/* Hole die Zeichen langsam ab */ delay(50); while (serialSIM800.available() && (cnt < sizeof(response))) { *(p++) = serialSIM800.read(); cnt++; delay(5); yield(); } if (cnt >= sizeof(response)-1) /*Buffer Überlauf? */ return 0; *p = '\0';
-
Thread
Arduino: Größe eines Pointers
; testPtr(); testPtr = [](){Serial.println("Lambda");}; testPtr(); Serial.print("sizeof(testPtr) : "); Serial.println(sizeof(testPtr)); } void loop() { } [/c]
avr schrieb im Beitrag #5604706: > Mit sizeof findest du die Größe heraus. [c] return sizeof(void*); c0: 82 e0 ldi r24, 0x02 ; 2 c2: 08 95 ret [/c]
-
Thread
Überprüfen ob String ein Zahl ist
[C] while(i < sizeof(string) ){ [/C] du kannst hier nicht sizeof benutzen. sizeof gibt dir an dieser Stelle die Größe des Pointers, also 2
>uint8_t is_number( char* string){ > while(i < sizeof(string) ){ Woher soll sizeof hier wissen wie groß der String ist? sizeof vom Pointer wird 2 oder sowas sein. strlen ist da wohl die bessere Wahl.
-
Thread
Display Position bestimmen
Ausserdem kommt hierbei .... > zeichen = sizeof(*data); ... 1 raus. data ist ein Zeiger auf einen char also ist *data der char selber. Und ein char hat definitionsgemäss eine sizeof von 1
Das kannte ich auch aber dachte es muss auch mit sizeof gehen. Danke
-
Thread
Strings schreiben und entleeren
'sizeof' schon übersichtlicher. Entweder: [c] #define number_of_elements(a) (sizeof (a)/sizeof (a[0])) unsigned char uart0_command_buffer[6]; // egal, wie groß ... int i; for (i = 0; i
? [c] const size_t mySize = 13; // mal ungerade probieren? unsigned short ausArray[mySize / sizeof (unsigned short)]; [/c]
-
Thread
Ringpuffer vs Linkedlist
>size(uint8_t)=8=size(ll_type), oder seh ich's grad net? sizeof(uint8_t)=8 das ist korrekt >typedef struct ll_type { > uint8_t *dat; //allocatable int array, hold the data > struct ll_type *next; >}ll_type; sizeof(uint8_t *) ist was anderes als
>Hast du das ausprobiert? Nö ;) >uint8_t sieht mir eher wie 8 Bit aus, also müßte sizeof (uint8_t) == 1 >sein. Du hast recht. sizeof gibt die Anzahl Bytes zurück. Ich geh lieber schlafen.
-
Thread
Delphi / c code string/byte packetweise verarbeiten
unsigned int i,x, pack=0, packetsz=3; unsigned char packet[8] = "abcdefgh"; for (i=0; i<(sizeof(packet));i++) { for (x=pack; x<packetsz+pack;x++){ printf("%c",packet[x]); //rumpf zweite for schleife } if (pack < (sizeof(packet))){ pack += packetsz; printf
TODO } // int main(void) { uint8_t einzeln[] = {1,2, 3}; size_t laenge_einzeln = sizeof(einzeln) / sizeof(einzeln[0]); print_subpacket(einzeln, laenge_einzeln); return 0; } [/c] Compiliert, tut aber noch nichts sinnvolles. Das gilt es zu beheben. ###################
-
Thread
stdint.h, string.h Datentyp "Char"?
schrieb im Beitrag #1781366: > Wenn du wirklich portabel programmieren willst, musst du über sizeof() > die tatsächliche Größe von char ermitteln, und in einen Code entsprechen > darauf reagieren. Das geht auf jeden Fall schief. Den sizeof(char) ist definitionsgemäs eine glatte 1 > Oder
automatisch byteweise Zugriffe. > Wenn du wirklich portabel programmieren willst, musst du über sizeof() > die tatsächliche Größe von char ermitteln, sizeof(char) ist _immer_ 1. > Oder du schränkst die Portabilität auf Systeme ein, bei denen char ein > Byte groß ist. Viel verlierst du damit
-
Thread
Leidiges Thema: Pointer/Array/Struct
Falls Padding am Ende der Struktur ist, dann gehört dieses zur Struktur und ist auch im Array und in sizeof berücksichtigt.
gibt es von vielen Bibliotheken, etwa Qt, auch eigene Kompilate für MSVC und GCC. > Auch dass sizeof(char) == 1 steht da drin. Diese Aussage ist in dieser Form eindeutig falsch. Das steht nicht im ABI, sondern das ist im C-Standard definiert. Mehr oder weniger Wortwörtlich, sizeof(char) = 1. Das
-
Thread
Struct alias
] #include "temp.h" .align 4 .bss .global Temp1 .global Temp2 Temp1: Temp2: .space sizeof(Temp_t) [/asm]
verwendenten Dateien: [c] /* mrtm.c */ #include "mrtm.h" #include "temp.h" static_assert( sizeof(MrtmTemp_t) <= sizeof(GlTemp), "Temp-Variable zu klein"); extern MrtmTemp_t MrtmTemp; [/c] Insgesamt spart die Aktion nicht ganz 400 Bytes gegenüber dem vorherigen Stand. Ob ich die jetzt als
-
Thread
doppelt verkettete List mit AVR?
SwitchList* newList( uint8_t Schalter){ struct SwitchList *addr = ( struct SwitchList* ) malloc(sizeof( SwitchList )); addr->back=NULL; addr->next=NULL; ldHandlerSchalter(Schalter, & (addr->switchData)); return addr; } [/c]
davon ausgehen, dass malloc einen int retourniert (als Standardannahme). Wenn nun auf deinem System sizeof(void*) != sizeof(int), dann geht das böse in die Hose.
-
Thread
Einheitliche Regel für in C erstellte Variablen, Typen etc
b = (int16_t)a; c = (int_fast16_t)a; printf("%d %d\n%d %d %d\n", sizeof(b), sizeof(c), (int)a, (int)b, (int)c); } [/c] Ausgabe: [code] 2 8 65535 -1 65535 [/code] Wenn jetzt eine Plattform sich entscheiden würde int_fast16_t tatsächlich als int16_t zu implementieren
> b = (int16_t)a; > c = (int_fast16_t)a; > printf("%d %d\n%d %d %d\n", sizeof(b), sizeof(c), (int)a, > (int)b, (int)c); > } > > Ausgabe:2 8 > 65535 -1 65535 > > Wenn jetzt eine Plattform sich entscheiden würde int_fast16_t > tatsächlich als int16_t zu implementieren
-
Thread
Merkwürdiges Verhalten des GCC
@Rolf Magnus Habe beide Vergleiche durch Makros ersetzt. if (LCDstate == 255) {LCDstate = (sizeof(mainMenu)/sizeof(*mainMenu)), mainMenu-1;} liefert den falschen Vergleich mit 14 if (LCDstate >= (sizeof(mainMenu)/sizeof(*mainMenu)), mainMenu) {LCDstate = 0 ;} liefert LCDstate 0 @Alle Was
funktioniert: > > if (LCDstate == 255) {LCDstate = -1+size;} richtig und [C] LCDstate = -1+(sizeof(mainMenu)/sizeof(*mainMenu)), mainMenu; [C] hier ist die -1 links vom Komma. > if (LCDstate == 255) {LCDstate = size-1;} nicht richtig? [C] LCDstate = (sizeof(mainMenu)/sizeof(*mainMenu)),
-
Thread
Schnelle Suche in großer Datei (1GB)?
if (memcmp(data + i, pattern, sizeof(pattern)) == 0) {
; } ssize_t nread = read(fd, buf, sizeof(buf)); if (nread == -1) { fprintf(stderr, "read() failed: %s\n", strerror(errno)); close(fd); } else if (nread < sizeof(buf)) { fprintf
-
Thread
c-array werte zuweisen
Also nehme ich um sicher zu sein strncpy(a, "any length",sizeof(a)-1); a[sizeof(a)-1]='\0'; Damit sollte dann ein Overflow ausgeschlossen sein oder nicht? Danke nochmal für die Tips!
..., wenn man das in einer Funktion macht. So wie der TO das eigentlich auch vor hat. Dann ist sizeof(a) == sizeof(char*) und das ist nicht das gewünschte.
-
Thread
C-Lehrbuch aus dem Rheinwerk-Verlag schlecht? Alternative?
Und für diesen Zweck reicht es aus (da reicht auch ein char, ist ja das Mikrocontrollerforum) (sizeof(anArray)/sizeof(short)) geht auch eleganter: (sizeof(anArray)/sizeof(*anArray))
: comparison between signed and unsigned integer expressions [-Wsign-compare] for (ix=0; ix< (sizeof(anArray)/sizeof(short)); ++ix)[/code] In der konkreten Anwendung kann man sich dann immer noch überlegen ob man's anders macht - immer noch besser, als das original falsch gelernte zu un-lernen.
-
Thread
C String in uint32 und zurück?
os_printf("spi_flash_erase_sector: %d\n", i); int o = spi_flash_write(0x8c000, (uint32*)ssid, sizeof(ssid)); os_printf("spi_flash_write: %d\n", o); int p = spi_flash_read(0x8c000, &toread, sizeof(toread)); os_memcpy(ssid2, &toread,sizeof(&toread)); os_printf("Read from flash: %s\
dafür sorgen, das die länge durch 4 Teilbar ist. [c] spi_flash_write(0x8c000, (uint32*)ssid, sizeof(ssid)); spi_flash_read(0x8c000, (uint32*)ssid, sizeof(ssid)); [/c]
-
Thread
Binäre Konstanten in C
Ergebnisse die folgenden, für klassische C-Arrays wohldefinierten Ausdrücke liefern sollten: [c] sizeof Tout[0] Tout + 1 [/c]
auch machbar sein. Man wird aber eben auf bestimmte Funktionalitäten verzichten müssen, wie eben sizeof oder z.B. Zeiger auf die Elemente.
-
Thread
internes EEProm als Einstellungs-speicher - wo liegt der Fehler?
i; uint16_t start_addr = 200; for(i=0; i<17; i++) { Addr_prop_sg[i] = start_addr + ((i) * (sizeof(uint16_t) + sizeof(int16_t) + sizeof(int16_t))); } } [/c] Da das aber natürlich blödsinn ist, will ich die Werte lieber von vornherein einmal vorgeben...
a im RAM void speicher_struct_a (uint8_t ind) { eeprom_write_block(&cur_a,&EE_A[ind],sizeof(struct a)); } void lade_struct_a (uint8_t ind) { eeprom_read_block(&cur_a,&EE_A[ind],sizeof(struct a)); } [/c]
-
Thread
Problem: Rechnen mit Werten aus EEPROM
Hallo Sven, nach meiner Kenntnis liefert sizeof(array) die Größe des gesamten Arrays in Bytes. Hier also Double*12. Du brauchst aber an der Stelle eigentlich sizeof(double) oder wie man manchmal nutzt sizeof(array[0]). Alternativ geht auch [
edit: muss ich dann in eeprom_read_block auch sizeof(double) schreiben?
-
Thread
ESP8266 Webradio Stream
); receivezaehler=0; memset(&empfangsbuffer[0], 0, sizeof(empfangsbuffer)); HAL_Delay(1000); HAL_UART_Transmit(&huart6,connect,44,1000); HAL_Delay(1000); printf("An ESP gesendet: %s",connect); printf("ESP Antwort: %s \n\n", empfangsbuffer); receivezaehler=0; memset(&empfangsbuffer[0], 0, sizeof(empfangsbuffer)); /* HAL_Delay(1000); HAL_UART_Transmit(&huart6,sendebuffer13,10,1000); HAL_Delay(1000); printf("An ESP gesendet: %s",sendebuffer13); printf("ESP Antwort: %s \n
-
Thread
Strings verbinden Gesperrt
Zeichen hinein passen. [c] char a[201]; char b[100]; ... (Eingabe) ... strlcat(a, "&", sizeof(a)); strlcat(a, b, sizeof(a)); [/c]
pointer auf den gleichen String zeigen? Stefan ⛄ F. schrieb im Beitrag #6524734: > strlcat(a, "&", sizeof(a)); > strlcat(a, b, sizeof(a)); Erfüllt nicht die Forderung nach einem dritten String, sondern ist destruktiv auf a. Blöd wenn das eine Konstante ist. Jobst Q. schrieb im Beitrag #6524971
-
Thread
i2C uint8_t *data
ACCESS_CONFIG; HAL_I2C_Master_Transmit(&hi2c1, TEMP_SENSOR_ADRESS_7_BIT << SHIFT, &txData, sizeof(txData), 10); // Shift is necessary because of i2C function description HAL_I2C_Master_Receive(&hi2c1, TEMP_SENSOR_ADRESS_7_BIT << SHIFT, &rxData, sizeof(rxData), 10); // Shift is necessary
ByteArray; HAL_I2C_Master_Transmit(&hi2c1, TEMP_SENSOR_ADRESS_7_BIT << SHIFT, &txData, sizeof(txData), 10); // Shift is necessary because of i2C function description HAL_I2C_Master_Receive(&hi2c1, TEMP_SENSOR_ADRESS_7_BIT << SHIFT, rxData, sizeof(rxData), 10); // Shift is necessary
-
Thread
Lauflicht mit 2 Atmega8
uint8_t i; DDRB = 0xFF; DDRC = 0xFF; DDRD = 0xFF; while( 1 ) { for( i = 0; i < sizeof( Values ) / sizeof( *Values ); ++i ) { PORTB = Values[i].valueB; PORTC = Values[i].valueC; PORTD = Values[i].valueD; _delay_ms( 20 ); } } } [/C] jetzt musst
Also sieht die Hauptschleife auf dem Master so aus: [c] while( 1 ) { for( i = 0; i < sizeof( Values ) / sizeof( *Values ); ++i ) { PORTB = Values[i].valueB | (1<<7); // Daten fuer B und Sync-Port setzen PORTC = Values[i].valueC; PORTD = Values[i].valueD; _delay_ms
-
Thread
Takte pro Befehl
; > } > [/c] Aha, eine pessimierte Reimplementierung von [c]memmove(data, data + 1, 16 * sizeof data[0]);[/c]
[i+1]; >> } >> > Aha, eine pessimierte Reimplementierung von > memmove(data, data + 1, 16 * sizeof data[0]); kleine Korrektur: memmove(data, data + 1, 17 * sizeof data[0]);
-
Thread
Arduino und struct gefallen sich nicht !
Nick schrieb im Beitrag #8022601: > stattdessen sizeof verwenden > zu müssen und dann Zeichen für Zeichen in die UART zu schubsen. sizeof ist auch oft ein Ort für vertippsler. Seit C++11 kann man den "range based for loop" verwenden. Oder per
type, the result is the size of the referenced type. https://en.cppreference.com/w/cpp/language/sizeof.html
-
Thread
umwandlung von intger Arry zu unsigned char Arry
bitrange=8; // wird von tastatur eingelesen entweder 8 oder 16 bit sein werte1=(int*)malloc(n*sizeof(int)); for(int i=0;i<n;i++){ werte1[i]=pow(2,bitrang)-1; } unsigned char *werte2; werte2=(unsigned char*)malloc( (n*bitrange/8)*sizeof(unsigned char) ); memcpy(werte2,werte1,n*sizeof(int
Speicherinhalt, der am Pointer wert1 hängt. Schau dir genau wie gross die beiden Speicherbereiche sind! sizeof(int)>=sizeof(char) in den allermeisten Fällen gilt >
-
Thread
geschicktes Suchen von Elementen im Array Gesperrt
85, 0, 0, 0, 0, 0}; int magic_number=arr2[0]; int offset=7; int arr_len=sizeof(arr1)/sizeof(arr1[0]); int m_wert1=mittelwert(arr1, arr_len, magic_number, offset); int m_wert2=mittelwert(arr3, arr_len, magic_number, offset); printf("Mittelwert: %d\n", m_wert1
[]={13,14}; int arr3[]={7,8,9,10,11,12,13,14,15,16,17,18,19}; const int arr1_len=sizeof(arr1)/sizeof(arr1[0]); const int arr2_len=sizeof(arr2)/sizeof(arr2[0]); const int arr3_len=sizeof(arr3)/sizeof(arr3[0]); double temp; int magic_number=0; int offset=7;
-
Thread
Struct per Uart Senden
> 0) { uart_putc(cData); // shift out data cData++; } } Transmit(Proto,sizeof(Proto));
um ein Byte erhöht werden soll. fridrich schrieb im Beitrag #2601084: > Transmit(Proto.start,sizeof(Proto)); So: [c] Transmit(&Proto.start,sizeof(Proto)); [/c] oder besser: [c] Transmit(&Proto,sizeof(Proto)); [/c] weil die Adresse der Struktur gemeint ist. Bedenklich ist: fridrich schrieb
-
Thread
gcc linkercommandfile
für die Info. Das ist tatsächlich etwas schwach vom Linker... Ich habe gerade gesehen, dass es "sizeof" auch für den Linker gibt. Daher erlaube ich mir noch die Frage, kann man eventuell etwas in der Form schreiben? [code] .stack (ORIGIN(ram)+LENGTH(ram)-SIZEOF(.bss)-SIZEOF(.relocate)-4) { ... } .relocate (ORIGIN(ram)+LENGTH(ram)-SIZEOF(.bss)-SIZEOF(.relocate)) { ... } .bss (ORIGIN(ram)+LENGTH(ram)-SIZEOF(.bss)) { ... } [/code] Die Variante mit konstanter Stack Größe habe ich natürlich in der Hinterhand. @Nop Es ist nicht
-
Thread
short != int16_t
ist es Compiler-spezifisch, ob es ohne weitere Angabe mit oder ohne Vorzeichen ist. Es gilt sizeof(char) = 1 sizeof(short) >= sizeof(char) sizeof(int) >= sizeof(short) sizeof(long) >= sizeof(int) sizezof(long long) >= sizeof(long) Außerdem muß char mindestens 8 Bit breit sein, short und int
-
Thread
Arduino: if(String == "ein") funktioniert nicht
else { Serial.println(F("serBUF ov-> DEL")); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); memset(&serial_in_command[0], 0, sizeof(serial_in_command)); chr_cnt=0; } // if !(chr_cnt<(MAXBUFFER-2)) } // if(isprint(incomingByte))
else { Serial.println(F("serBUF ov-> DEL")); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); memset(&serial_in_command[0], 0, sizeof(serial_in_command)); chr_cnt=0; } // if !(chr_cnt<(MAXBUFFER-2)) } // if(isprint(incomingByte))
-
Thread
[C] Namensgebung von 'strchr' oder 'memchr'
hat. Geht nicht. Ein char ist ein Byte gross. Ein Byte darf aber mehr als 8 Bits haben. "The sizeof operator yields the size (in bytes) of its operand," "When sizeof is applied to an operand that has type char, unsigned char, or signed char, (or a qualified version thereof) the result is 1."
sm320f2812-ep?keyMatch=2812&tisearch=Search-EN-Everything Dort hat eine Speicherzelle 16 Bit. sizeof(char) == sizeof(short) == sizeof(int) == 1, alles 16 Bit. Speichert man wirklich nur 8 Bit Zeichen, dann sind die obersten 8 Bit verschwendet. Man kann auch im Speicher kein Byte alleine ansprechen
-
Thread
C Anfängerfrage zu Pointern in Funktionen
Pointer definiert wurde. In Ausdrücken Unterschiedlich behandelt werden Arrays und Pointer m.W. nur in sizeof. Weshalb C in Parameter-Deklarationen sowas wie f(int a[]) überhaupt zugelassen hat, habe ich nie verstanden.
Man braucht dafür keine Philosophie, nur Abstraktion. > Diese Struct ist jedenfalls > gemäss sizeof 8 Bytes gross (x64): > struct S { > int& y; > }; Und wie groß ist die Referenz gemäß sizeof? Welches Alginment hat eine Referenz? Auf diese Fragen gibt es auf der abstrakten Ebene von
-
Thread
[c] dynamische Speicherverwaltung mit malloc
freigeben?? D.h. [c] size+=more; free(value); value = malloc(size * sizeof(int)); [/c] Temp muss auch noch freigeben werden, aber da ist die Sachlage klar. Vielen Dank.
du willst ein Speicherleck. Am2302 schrieb im Beitrag #4397649: > value = (int *)malloc(size*sizeof(int)); Den Cast nach int * sollte man auch weglassen, der ist unnötig. Ausserdem bevorzuge ich folgende Schreibweise: [c]int * Var = malloc(Size * sizeof(*Var));[/c] So kann sich der Datentyp
-
Thread
STM32 FRAM Modul WREN Bit wird nicht gesetzt
spi_buf[1] = (uint8_t)(adress >> 8); spi_buf[2] = (uint8_t)(adress); for(int i = 0; i < sizeof(pdata) / sizeof(pdata[0]); i++){ spi_buf[i+3] = pdata[i]; } HAL_GPIO_WritePin(FRAM_CS_GPIO_Port, FRAM_CS_Pin, RESET); //Enable FRAM SPI HAL_SPI_Transmit_DMA(FRAM_hspi, spi_buf, (sizeof
#6541006: > void SPI_FRAM_WRITE(uint16_t adress, uint8_t* pdata){ > ... > for(int i = 0; i < sizeof(pdata) / sizeof(pdata[0]); i++){ Du gibst einen Pointer auf einen Buffer runter und berechnest dann die zu übertragende Länge als sizeof(pdata) / sizeof(pdata[0]). Das ist hier aber nicht zielführend
-
Thread
Compiler bläht Code nach entfernter Anweisung auf.
char getFifo(){ static char pReadOffset = 0; char nextChar = *(fifoBuffer + pReadOffset * sizeof(char*)); *(fifoBuffer + pReadOffset * sizeof(char*)) = 0x00; if((fifoBuffer + pReadOffset * sizeof(char*)) - fifoBuffer == (FIFO_LENGTH - 1) ){ pReadOffset = 0; }else{ pReadOffset
x sizeof(char*) enthalten. Grüße Andreas