-
Thread
Struct per Pointerzugriff befüllen
Ben Banane schrieb im Beitrag #4368221: > Geht's "noch" schöner? memset( &Data, 255, sizeof( sizeof(Data) );
Peter II schrieb im Beitrag #4368223: > memset( &Data, 255, sizeof( sizeof(Data) ); Ein /sizeof/ weniger. [c] struct irgendwas { uint8_t etwas; uint8_t nochwas; uint16_t wasanderes; uint16_t nochwasanderes; } Data; memset(&Data, 255, sizeof
-
Thread
Beschnittene Zeichenabfolge in string gesucht
nicht. Dort sollte der größe des Ringpuffers eingetragen weden. Entweder mit einem DEFINE oder mit sizeof()
'e')) { Serial.println("Libelle gefunden"); i = 0; memset(commandbuffer,0,sizeof(commandbuffer)); }
-
Thread
Lichtschranke NRF24L01 ATMega 328p
radio.stopListening(); char text[]="Lichtschranke unterbrochen"; if (radio.write( &text,sizeof(text))){ }else{ } radio.startListening(); delay(1000); }else{ } delay(5); } [/c]
Und bis du da sicher? Was soll hier passieren? [c]if (radio.write( &text,sizeof(text))){ }else{ }[/c]
-
Thread
gcc switch for alignement / sizeof
signed short int x; // sizefo(signed short int)=2 - habe überprüft } warum ist sizeof(test)=4? Ich erwarte eine Größe von 2, da die Klasse "test" nur einen member hat (signed short int x). Ich benutze GCC ARM mit Ubuntu. Mit Microsoft Compiler ist sizeof(test)=2 (wie erwartet
GCC x86 (4.1): sizeof(test)==2
-
Thread
Größe eines Strukturfeldes über Pointer ermitteln
struct Menus { UART_MEN* UART_menu; size_t UART_menu_size; } #define ARRAY_SIZE(x) ( sizeof(x) / sizeof(*x) ) struct Menus UART_menu[] = { { UART_menu_C, ARRAY_SIZE( UART_menu_C ) }, { UART_menu_D, ARRAY_SIZE( UART_menu_D ) } }; [/C]
>Da ich im Programm aber nur mit Pointern arbeite kann ich nuri=sizeof>(*pUART_menu_sub); >verwenden. Und wer hindert dich daran, trotzdem [c]i=sizeof(UART_menu_C);[/c] zu benutzen? Oliver
-
Thread
NRF24L01 Sensornetzwerk?
Mirf.channel = 2; Mirf.setRADDR((byte *)"serv0"); //Mirf.setTADDR((byte *)"sens1"); Mirf.payload = sizeof(data); //Mirf.payload = sizeof(Sens1); //Mirf.payload = sizeof(Sens2); Mirf.config(); } void loop() { Sensor1(); delay(500); Sensor2(); } void Sensor1(void) {
verwendeten Bibliotheken an? Oh ja... Ohne weit zu lesen mal eine Frage: Was _soll_ [c]Mirf.payload = sizeof(data);[/c] zurückliefern? Und was liefert auf deiner Architektur (welche das auch immer sein mag...) sizeof(float)?
-
Thread
C Array: Implizite Null-Initialisierung abfangen
doch einfach weg. Dann ist das Array so gross, wie Du Elemente drin hast. Im if benutzt du dann sizeof.
[c] #define ARRAY_SIZE(X) (sizeof(X) / sizeof(*(X))) _Static_assert (ANZAHLELEMENTE == ARRAY_SIZE (adressen), "Bug"); [/c] oder [c]_Static_assert (ANZAHLELEMENTE == ARRAY_SIZE ((uint32_t*[]) { INITIALISIERUNG }), "Bug");[
-
Thread
Indizes statt Pointer
multipliziert, nicht mehr auf Quelltextebene. Also ist die Gleichsetzung von a[i] mit *(a+(i*sizeof(a[0]))) einfach FALSCH.
>> >> a[i] >> >> so, als ob du *(a+i) geschrieben hättest. > War's nicht eher *(a+(i*sizeof(a[0]))) Du meinst eher * (typeof(*a)*)( ((char*)a) + ( i * sizeof(*a) ) ) Dann stimmt es (wenn ich mal so frei sein darf und einen Operator typeof postulieren darf), da sizeof(char) per
-
Thread
pointer auf typedef array
Wenn wie hier, bei der Übergabe an eine Funktion nicht, weil C dann eh > castet. Beim Benutzen von sizeof schon. Deshalb hat der Holger auch einen eigenen Thread zum Thema sizeof. Weil's darum hier nicht geht.
char volatile v; > v = T (g, g); > v = T (g, &g[0]); > __typeof(g) b; > v = sizeof (g); > v = sizeof (b); > } > dann werden nacheinander folgende Werte in v gespeichert: 0, 1, 21, 21. > > Die beiden letzten Werte sind klar, aber warum hat g nicht den Typ von g > sondern
-
Thread
AVR C/ASM Verständnisfrage
x) { if (x==EEREAD) // +62 bytes flash eeprom_read_block((void*)&cfg, (const void*)&cfg_ee, sizeof(cfg)); else eeprom_write_block((const void*)&cfg_ee,(void*)&cfg, sizeof(cfg)); } #else #define EEREAD 0 #define EEWRITE 1 void ee(char x) { char i; // +78 bytes flash for(i=
next address }while( --len ); } void save_eedata() { eeprom( (void*)&eedata, EESTART, sizeof( eedata ), EE_WRITE ); } void read_eedata() { eeprom( (void*)&eedata, EESTART, sizeof( eedata ), EE_READ ); } [/c] eedata ist die Struct im SRAM. Peter
-
Thread
Datei einlesen und Sortieren
]; name[j]=temp; } } } for(i = 0; i < sizeof(name)/sizeof(int); i++) printf("%s\n", name[i]); return EXIT_SUCCESS; return 0; }
. . . PS: Das hier [C] for(i = 0; i < sizeof(name)/sizeof(int); i++) { [/C] ist Unsinn. Du kannst innerhalb der Funktion nicht mit sizeof arbeiten. Deine Funktion bekommt lediglich einen Pointer übergeben und kein Array. sizeof kann man nur
-
Thread
char String Null im Array verhindern
Funktionen besser verwendbar. Eine Frage noch: char Array[]={"x"} Wenn ich die Funktion sizeof(Array) verwende, dann müsste sie mir als Ergebnis "2" zurückgeben, richtig?
Array schrieb im Beitrag #4750289: > Wenn ich die Funktion sizeof(Array) verwende, dann müsste sie mir als > Ergebnis "2" zurückgeben, richtig? Wobei es Du sizeof oder strlen meist nicht brauchst. Bei Strings oder Streams ist ein for i oder ein memcpy selten
-
Thread
Shell ersetzen in Windows 2000/XP
pos = 0; fp = fopen("programs.ini", "r"); if (fp) { while (fgets(fullpath, sizeof(fullpath), fp)) { STARTUPINFO si; PROCESS_INFORMATION pi; ZeroMemory( &si, sizeof(si) ); si.cb = sizeof(si); ZeroMemory( &pi, sizeof(pi) );
i++) { STARTUPINFO si; PROCESS_INFORMATION pi; ZeroMemory( &si, sizeof(si) ); si.cb = sizeof(si); ZeroMemory( &pi, sizeof(pi) ); strncpy(cpath, paths[i].c_str(), sizeof(cpath)); printf("**************************************
-
Thread
Arduino & EEprom
also Adresse 29 und 30 Was vorher auf 30 stand, ist unwiederbringlich verloren Ein einfaches sizeof(12) beweist dir das.
nicht mit der Eeprom Lib blind vergleichen. Doch! Wenn man in die Lib schaut, sieht man, dass sizeof() verwendet wird. [c] template< typename T > const T &put( int idx, const T &t ){ EEPtr e = idx; const uint8_t *ptr = (const uint8_t*) &t; for( int count = sizeof(T
-
Thread
Syntax-Highlighting Test
stdint.h> #define CHECK_OVF 0 #define ENTRIES_TAB1 4000 #define ENTRIES_TAB2 255 #define SIZEOF_TAB1S (32 + 16) / 8 #define SIZEOF_TAB2S (8 + 16) / 8 #define EE_ADR_END 0x0FFF typedef struct tab1_s { uint32_t a; int16_t b; } tab1_t; typedef struct tab2_s {
ENTRIES_TAB1]; tab2_t tab2[ENTRIES_TAB2]; #define EE_ADR_TAB1 (0) #define EE_ADR_TAB2 (EE_ADR_TAB1 + (SIZEOF_TAB1S * ENTRIES_TAB1)) #if(((EE_ADR_TAB2 + (SIZEOF_TAB2S * ENTRIES_TAB2)) > EE_ADR_END) && CHECK_OVF) # error "Tabelsize overflow!" #endif int main(void) { printf("\n\n");
-
Thread
Stringabfrage verständnisproblem
Warum benutzt du diese Konstruktion für die Ermittlung der Stringlänge? Es gibt doch die sizeof-Funktion. sizeof(string) ermittelt die Länge incl. Stringende-Zeichen.
> Warum benutzt du diese Konstruktion für die Ermittlung der Stringlänge? > Es gibt doch die sizeof-Funktion. > sizeof(string) ermittelt die Länge incl. Stringende-Zeichen. *O nein*. Wenn "string" als Array deklariert ist, liefert /sizeof/ die Gesamtanzahl der Arrayelemente, ohne sich deren
-
Thread
ARM Cortex M3/M4: Software-Breakpoints
CoreDebug_DEMCR_VC_MMERR_Pos) ; } // Flag RTOS Stack memories memset(tcp_stack , 0xcc, sizeof(tcp_stack )); memset(timer_stack , 0xcc, sizeof(timer_stack )); memset(..._stack , 0xcc, sizeof(..._stack )); #else JTAG_Lock(); #endif [/c]
CoreDebug_DEMCR_VC_MMERR_Pos) ; } // Flag RTOS Stack memories memset(tcp_stack , 0xcc, sizeof(tcp_stack )); memset(timer_stack , 0xcc, sizeof(timer_stack )); memset(..._stack , 0xcc, sizeof(..._stack )); #else JTAG_Lock(); #endif [/c]
-
Thread
ESP8266 SD Card / AES256
functionen einbauen.. [c] // standardkey.. void aes_set_standardkey(){ for ( i = 0; i < sizeof(key);i++) key[i] = i; // dumpx("key:set ", i, key, sizeof(key)); } // beispiel aus dem video // anderer key void aes_set_kndkey(){ for ( i = 0; i < sizeof(key);i++) key[i] = i+3; // dumpx("key:knd ", i, key, sizeof(key)); } [/c] usw. wer nicht klar kommt, bitte schreibt es. lg rudi ;-) und bis zum wochenende dann :)
-
Thread
Pointer Gymnastik Ist mein Code zulässig?
// als beispiel int i=0; if(str&&offset<strlen(str)) for(str+=offset;*str&&*str!=c&&i<sizeof(buff)/sizeof(buff[0]);) buff[i++]=*str++; buff[i]='\0'; return buff; }
Und i<sizeof(buff)/sizeof(buff[0]) sollte 1+i<sizeof(buff)/sizeof(buff[0]) sein, ich mache dies meistens mit Konstanten arbeite, z.B. LINE_LEN und dann bei der Deklaration einfach buff[LINE_LEN+1] ,
-
Thread
ATxmega128a1 und RFM70 Problem.
); // init address registers in bank 0 writeRegPgmBuf((uint8_t *)RFM70_cmd_adrRX0, sizeof(RFM70_cmd_adrRX0)); writeRegPgmBuf((uint8_t *)RFM70_cmd_adrRX1, sizeof(RFM70_cmd_adrRX1)); writeRegPgmBuf((uint8_t *)RFM70_cmd_adrTX, sizeof(RFM70_cmd_adrTX)); // activate Feature register
); // init address registers in bank 0 writeRegPgmBuf((uint8_t *)RFM70_cmd_adrRX0, sizeof(RFM70_cmd_adrRX0)); writeRegPgmBuf((uint8_t *)RFM70_cmd_adrRX1, sizeof(RFM70_cmd_adrRX1)); writeRegPgmBuf((uint8_t *)RFM70_cmd_adrTX, sizeof(RFM70_cmd_adrTX)); // activate Feature register
-
Thread
C++, Problem bei Auslesen von COM-Port
char buffer[1024] = { 0 }; ... WriteFile(hCom, buffer, sizeof(buffer), &nBytesRead, NULL); ... ReadFile(hCom, buffer, sizeof(buffer), &nBytesRead, NULL); ... Drei mal darfst raten was da passiert ...
cbInQue). ReadFile wird dann halt nur noch aufgerufen, wenn cbInQue > 0 ist und nicht mehr nur mit sizeof(buffer), sondern mit min(stat.cbInQue, sizeof(buffer)).
-
Thread
sprintf in C - Nullen dynamisch auffüllen
evtl. char fmt[32]; snprintf(fmt, sizeof(fmt) "%%0%ui", X); snprintf(MyCharArray, sizeof(MyCharArray), MyInt);
evtl so (korrigiert). char fmt[32]; snprintf(fmt, sizeof(fmt) "%%0%ui", X); snprintf(MyCharArray, sizeof(MyCharArray), fmt, MyInt);
-
Thread
SDCC: warning 158: overflow in implicit constant conversion
Der SDCC scheint es mit den Integer-Typen nicht so drauf zu haben. Beispiele: [pre] sizeof (char) -> 1 richtig sizeof (int) -> 2 richtig sizeof 0 -> 2 richtig sizeof (0 + 0) -> 1 falsch sizeof (0xff + 0) -> 1 falsch sizeof (0xff + 1) -> 2 richtig sizeof (0 - 0x80) -> 1 falsch sizeof (0 - 0x81) -> 2 richtig [/pre] Da darf man sich nicht wundern, wenn da mal eine nicht nachvollziehbare Overflow-Warnung ausgegeben wird.
-
Thread
C array in sruct mit array initialisieren
diesem Satz sagen willst, aber mit memcpy geht das sicherlich : ram_var* ram; memcpy(ram->a, aa, sizeof(aa));
aber nur wenn ich es in einer Funktion aufrufe: [c] void Init(void) { memcpy(ram.a, aa, sizeof(aa)); } [/c] Aber gehts auch ohne eine solche Init-Funktion?
-
Thread
Endian Umwandlung einer unbekannten Struktur
Umwandlungsfunktion zu haben ist doch sehr aufwendig, selbst wenn man einen Codegenerator dafür hat. An eine sizeof-Möglichkeit habe ich auch gedacht, jedoch dürfte diese so nicht umsetzbar sein. Klar kann man sizeof benutzen, jedoch nur wenn ich an eine Funktion immer die gleiche Struktur übergebe. Wenn ich jedoch
( sizeof(MyStruct) != 42 ) // oder wie groß die struct halt ist { // Strukturgröße paßt nicht! return 1; } &bufLen = sizeof(MyStruct); buf[0] = data->ch; ... return 0; }
-
Thread
Frage zu Zeiger
printf("New Value of p_char : %u\n", p_char); printf("Size of datatype char : %u\n", sizeof(char)); printf("Size of p_char : %u\n\n", sizeof(p_char)); printf("New Value of p_int : %u\n", p_int); printf("Size of datatype int : %u\n", sizeof(int)); printf("Size of p_int : %u\n\n", sizeof(p_int)); printf("New Value of p_ui64 : %u\n", p_ui64); printf("Size of datatype uint64_t : %u\n", sizeof(uint64_t)); printf("Size of p_ui64 : %u\n\n", sizeof(p_ui64)); printf
-
Thread
zwei if-Anweisungeg funktionieren nicht zusammen
müsste man daher anpassen. Auch das kann dein Compiler für dich erledigen! In C gibt es den sizeof() Operator. Der bestimmt die Größe in Bytes von einer Variablen. sizeof( sin ) gibt dir daher die Größe in Bytes, die das komplette Array verbraucht. Dividiert man das durch die Größe von einem
Umstellen und die Behauptung folgt daraus. Das kann man aber auch in C schreiben uint8_t nrSin = sizeof( sin ) / sizeof( sin[0] ); und schon hast du alles was du brauchst um diese magische Zahl aus dem Programm zu verbannen. [C] int main(void) { uint8_t sin[] = { 0, 10, 20, 30, 40,
-
Thread
Ringbuffer & Interrupt Problem
Interrupt der den ringbuffer füllt ... char data = lesedatenVonIrgedwoher(); if(nBytes == sizeof(buffer)/sizeof(char)) // buffer Voll - Fehler; else { buffer[inPtr++] = data; nBytes++; // ein byte mehr drin if(inPtr == sizeof(buffer)/sizeof(char))
; if(inPtr > 0) { retByte = buffer[outPtr++]; nBytes--; if(outPtr == sizeof(buffer)/sizeof(char)) outPtr = 0; if(nBytes == sizeof(buffer)/sizeof(char)-1) // handshake_operation - gebe datenquelle frei } else buffer_empty_error
-
Thread
gcc beschwert sich über zu kurze char arrays
Vlad Tepesch schrieb im Beitrag #4059613: > ich hätte halt nur gern das `sizeof` bzw, ARRAY_SIZE die richtige größe > liefert; Für den ersten Fall gibt es strlen. Wenn du weißt was du tust, kannst du bei /sizeof/ ja auch -1 rechnen. (Aber bitte mit Kommentar dabei)
TFT_FKT(x) tft_wr( sizeof(x) - 1, x, 1 )[/c]
-
Thread
Hilfe nötig für vereinfachung einer c Funktion
t finalout[20]; >> for (int i = 0 > > warum wählst du int für i? Besser wäre size_t, da sizeof auch diesen Typ zurückgibt. > kann denn dein i je negativ werden? Gegenfrage: Muss es einen Bereich von mehr als 2 Milliarden abdecken können?
char input[] = "69:66:84:1A:0E:E7:E5:51:30:82:60:A7:27:F2:A5:54:56:B9:15:19"; uint8_t output[sizeof(input)/3]; assert(parsehex(sizeof(input)-1, input, output) != -1); for(size_t i=0; i<sizeof(output); i++){ if(i) printf(", "); printf("0x%.2X", output[i]); } puts(""); } [/c
-
Thread
uint32_t => float (32) ohne cast!
memcpy(&int, &float, sizeof(float));
wäre zumindest memcpy akzeptabel, falls in ein uint32_t aber nur, wenn man noch ein static_assert(sizeof(float)==sizeof(uint32_t),"Float wasn't 4 bytes big"), einbaut. Bei einem cast ist nur nach char* in Ordnung, wegen aliasing. Wenn man jedoch zwischen verschiedenen Geräten Daten austauschen will,
-
Thread
Malloc speicher auf dem Heap holen.
= malloc(sizeof(XY)); XY_costruct(myXY); /* do something */ XY_destruct(myXY); free(myXY); } [/c] Wenn ein XY-Objekt sowiso immer ein Datensatzobjekt enthält, bräuchtest du natürlich
! Und das Argument, dass ich zb in diesem Fall int * pI; pI = (int*) malloc( 10 * sizeof( int ) ); vom Compiler eine (gewünschte) Warnung bekomme, wenn sich der Datentyp von pI ändert und ich auf den malloc vergesse double * pI; pI = (int*) malloc( 10 * sizeof( int ) );
-
Thread
Aus X Buchstaben Y Wörter bilden - Programmieren
"nine", "no1", "2no", "n30" }; const size_t num_words = sizeof (words) / sizeof (*words); for (size_t i = 0; i < num_words; i++) { bool is_valid = true; for (size_t j = 0; j < strlen (words[i]); j++) { if (toupper (words[i][j])
"niner", "no1", "2no", "n30" }; const size_t num_words = sizeof (words) / sizeof (*words); for (size_t i = 0; i < num_words; i++) { bool is_valid = true; for (size_t j = 0; j < strlen (words[i]); j++) { if (toupper (words[i][
-
Thread
Wie habt ihr C gelernt?
C, damals der allerbeste ;) > > Genau! Denn bei dem war im Gegensatz zum Lattice-C-Compiler sizeof (int) > == 2 und nicht 4, was Vorteile auf den 16-Bit-68000ern hatte :) Und den gab es auch als Crosscompiler für den 6502 ;)
Yalu X. schrieb im Beitrag #3286144: > Genau! Denn bei dem war im Gegensatz zum Lattice-C-Compiler sizeof (int) > == 2 und nicht 4, was Vorteile auf den 16-Bit-68000ern hatte :) ... und Nachteile, wenn man Unix-Sourcen portierte, die damals ziemlich häufig von sizeof(int) == sizeof(char *) ausgingen
-
Thread
Tutorial für _sauberen_ C-Code
ich meine Hand nicht ins Feuer halten. In C gibt es keine Regel, die einen Zusammenhang zwischen sizeof(int) und sizeof(void*) herstellt.
meine Hand nicht ins Feuer halten. > In C gibt es keine Regel, die einen Zusammenhang zwischen sizeof(int) > und sizeof(void*) herstellt. In C darf ein Zeiger in einen ausreichend großen Integer umgewandelt werden (K&R, Seite 191), die Umwandlungsfunktion ist aber nicht näher bestimmt. So war das
-
Thread
Arduino: Ist boolean intern als Bit oder byte (char) organisiert?
Boolean type bool - type, capable of holding one of the two values: true or false. The value of sizeof(bool) is implementation defined and might differ from 1. [/pre]
> bool - type, capable of holding one of the two values: true or > false. The value of sizeof(bool) is implementation defined and > might differ from 1. > boolean is a non-standard type alias for bool defined by Arduino. > It’s recommended to instead use the standard type bool, >
-
Thread
Anzahl in struct zählen
mit [c] sizeof WasserSim_Menu / sizeof WasserSim_Menu[0] [/c]
sizeof( WasserSim_Menu ) / sizeof( struct menu_list )
-
Thread
MEGA32U4 und malloc -> App stürzt ab :(
Jan H. schrieb im Beitrag #5241609: > (char*)malloc(sizeof(char)*10); Der typecast ist überflüssig, und sizeof char ist per Definition immer 1.
Rufus Τ. F. schrieb im Beitrag #5241689: > Jan H. schrieb im Beitrag #5241609: >> (char*)malloc(sizeof(char)*10); > > Der typecast ist überflüssig, und sizeof char ist per Definition immer > 1. Danke für den Hinweis.
-
Thread
Ab und zu Programmabsturz, wahrscheinlich wg. verketteter Liste
mpd_data_get_next( data ) ) { // neuen Listeneintrag erzeugen newItem = malloc( sizeof(*newItem) ); strncpy( newItem->name, data->playlist->path, sizeof( newItem->name ) ); newItem->name[ sizeof( newItem->name ) - 1 ] = '\0'; // nur um sicher zu gehen newItem
Kann es sein, dass beim malloc (sizeof(*playlist)) der Stern weg muss?
-
Thread
Codesize WinAVR 20060421 vs WinAVR-20090313
aufgerufen: [c] uchar *pInfo= (uchar*)&savedKeys; eeprom_write_block(pInfo, (uchar*)EE_SAVEKEYS, sizeof(savedKeys)); uchar *pInfo= (uchar*)&savedKeys; eeprom_read_block(pInfo, (uchar*)EE_SAVEKEYS, sizeof(savedKeys)); [/c] 2. Viele funktionen werden nur "etwas größer" in folgenden Beispiel 2 byte
aufgerufen: > [c] > uchar *pInfo= (uchar*)&savedKeys; > eeprom_write_block(pInfo, (uchar*)EE_SAVEKEYS, sizeof(savedKeys)); > > uchar *pInfo= (uchar*)&savedKeys; > eeprom_read_block(pInfo, (uchar*)EE_SAVEKEYS, sizeof(savedKeys)); > [/c] Die ziehen die Prolog und Elipog-Funktionen nach sich, weil sie
-
Thread
C Speicherzugriffsfehler
out = (float *)a; int end; int i; int j; int k; float ****value = (float ****)malloc(xdim * sizeof(float ***)); for(i = 0; i < xdim; i++) { value[i] = (float ***)malloc(ydim * sizeof(float **)); for(j = 0; j < ydim; j++){ value[i][j] = (float **)malloc(numparam * sizeof(float
value[i][j] = (float **)malloc(numparam * sizeof(float *)); for (k = 0; k < numparam; k++) value[i][j][k] = (float *)malloc(points+numparam * sizeof(float )); } } fread(b,4,2,
-
Thread
MSP430G2553 als Schnittstelle zwischen MODBUS und I2C
der zu sendenden Bytes. Und dann sieht der Aufruf von "send" so aus: [c] send(BATT_VOLTAGE, sizeof (BATT_VOLTAGE)); [/c] Nein, der sizeof-Operator muss beim Aufruf der Funktion angewandt werden, /in/ der Funktion selbst funktioniert das nicht, da liefert sizeof nicht die Größe des (vermeintlich
sendenden Bytes. > > Und dann sieht der Aufruf von "send" so aus: > > [c] > send(BATT_VOLTAGE, sizeof (BATT_VOLTAGE)); > [/c] > > Nein, der sizeof-Operator muss beim Aufruf der Funktion angewandt > werden, /in/ der Funktion selbst funktioniert das nicht, da liefert > sizeof nicht die Größe
-
Thread
24 bit - 3byte Variable in C
Wie hast du das festgestellt? Was passiert bei MYTIME_T Times[100]; Wie gross ist sizeof(Times) ?
_t time :24; // 24Bit => 3Byte Laenge } MYTIME_T; MYTIME_T Times[100]; // 100 * 3Byte sizeof(Times) ist somit 300, zumindest mit GCC ;-)
-
Thread
Anzahl der Arrayelemente in einer Funktion ermitteln
unsigned long iSize; char i=0; char aChar[2]; aChar[0]='a'; aChar[1]='b'; iSize=sizeof(aChar); printf("size: %lu\n",iSize); // 2 } [/c] Übergebe ich jedoch das Array an eine Funktion, zählt er 1 hinzu: [c] void xxx(char aChar[]) { unsigned long iSize; iSize=sizeof
auf das erste Element des >> Array Kann man das wieder irgendwie "dezeigerisieren", damit dann sizeof wirklich mit den richtigen Daten arbeitet?
-
Thread
Schwach im Kopfrechnen
if (sizeof(double) > sizeof(float)) printf("das ist garantiert kein WinAVR\n");
und weil ich Hilfe benötige - Ich kann halt nicht alles wissen, deshalb sind Hinweise wie: if (sizeof(double) > sizeof(float)) printf("das ist garantiert kein WinAVR\n"); oder der Hinweis "Satire live." über... Wenn Du magst, dann bin ich gerne bereit, gemeinsam mit Dir oder allen anderen
-
Thread
C - struct inklusive CRC - Padding-Bytes
9]; uint16_t crc; } conf_t conf_t config; get_default_config(&config); uint8_t crc_size = sizeof(config) - sizeof(config.crc); config.crc = calc_crc(&config, crc_size); [/c] scheiterte, da auch am Ende Padding-Bytes eingefügt wurden. Die zweite Lösung empfinde ich als unsauber, funktioniert
("%d\n", sizeof(conf_t)); //14 [/c] Alternativ: [c] typedef struct __attribute__((packed)) { uint8_t param_1; uint16_t param_2; uint8_t param_3[9]; uint16_t crc; } conf_t; printf("%d\n", sizeof
-
Thread
double oder float in I²C EEPROM speichern
float eeFooFloat EEMEM; oid schreiben(float dWert) { union { float r; uint8_t i[sizeof(float)]; } u; u.r = dWert; // Float in EEPROM eeprom_write_block(&(u.r),&eeFooFloat,sizeof(float)); } float lesen(void) { float dWert = 00.01; union { double r; uint8_t i[sizeof(float)]; } u; u.r = dWert; eeprom_read_block(&(u.r),&eeFooFloat,sizeof(float)); return u.r; } [/c] Wär gnaz hilfreich, wenn jemand nen Code-Schnipsel parat hätte, was ich ich
-
Thread
Wie am geschicktesten DD Synthese in C Programmieren?
[0]; //-- zyklisch aufrufen, zB im Timerinterrupt z += x; // x: Tuningbyte if ( z > (sizeof(iArray)/sizeof(iArray[0]) ) { z -= (sizeof(iArray)/sizeof(iArray[0]); } PORTD = *z; [/c] >Byte einfach überspringen indem ich z++; z++ geht nur zum Nächsten. Zum Überspringen musst du mindestens
@ Matthias Lipinsky Nicht dein Tag heute? ;-) Das > if ( z > sizeof(iArray)/sizeof(iArray[0]) ) ist doch das selbe wie > if ( z > 251 ) und müsste, damit es keinen amoklaufenden Pointer gibt, zumindest so heissen > if ( z >= 251 ) damit nicht hinter das Array
-
Thread
Float über RS232 ausgeben
> Haben die Intel Prozessoren nicht ein 80-Bit Fließkommaformat? [c] float flt; printf("sizeof(float)=%d\n", sizeof(flt)); double dbl; printf("sizeof(double)=%d\n", sizeof(dbl)); [/c] Ergibt: sizeof(float)=4 sizeof(double)=8 Was anderes hätte mich (mit Defaulteinstellungen am
-
Thread
Was beachten bei Umstieg AVR --> Arduino
Safari schrieb im Beitrag #5468396: > funktioniert so etwas wie: > printf("%d", sizeof(analogRead())) > ? Nein! Da fehlt ein Parameter Wenn, dann sizeof(analogRead(A0)) So stimmt wenigstens die Syntax, in soweit, dass der Kompiler durchläuft [c] void test() { auto var = analogRead(A0); Serial.println(sizeof(var)); } [/c] Liefert auf einem UNO: 2 Wird auf dem ESP 4 liefern. *ungetestet*