-
Thread
JPG format kurios - tjpgdec oder libjpeg funktionieren nicht
case 0xDA: /* SOS */ if( huff == 0 ){ rc = create_huffman_tbl(jd, huffman1 , sizeof(huffman1)/sizeof(unsigned char) ); rc = create_huffman_tbl(jd, huffman2 , sizeof(huffman2)/sizeof(unsigned char)); rc = create_huffman_tbl(jd, huffman3 , sizeof(huffman3)/sizeof(unsigned char)); rc = create_huffman_tbl(jd, huffman4 , sizeof(huffman4)/sizeof(unsigned char)); } [/c] ja ich suche schon 2 tage ... bin gerade per zufall auf einen hinweis gestoßen und hab das mal probiert. ist Quick and dirty .. aber läuft
-
Thread
zeiger auf zeiger
Pointern, sodass man sie quasi als Pointer nutzen kann. Unterschiede gibts z.B. bei der Verwendung von sizeof (sizeof(arr) gibt die Größe des Arrays und sizeof(ptr) gibt nur die Größe des Pointers).
-
Thread
Structure löschen
löschen? Geht so: [c] struct bla { int suelz; char laber; } fusel; memset(&fusel, 0, sizeof (struct bla)); // oder memset(&fusel, 0, sizeof (fusel)); [/c] Struktur aus dem Speicher entfernen? Bei lokalen/automatischen Variablen: Einfach den Gültigkeitsbereich verlassen, das war's
Du Dir mal dynamische Speicherverwaltung ansehen: [c] struct bla *pfusel; pfusel = malloc(sizeof (struct bla)); if (!pfusel) { // Fehlerbehandlung } else { pfusel->suelz = 3; free(pfusel); } [/c]
-
Thread
Externen I2C (F)RAM bequem verwalten
her, ob es tatsächlich kompiliert weiß ich gar nicht): [c] char[32] str; fram_read_block(0 + sizeof(version_t) + sizeof(length) + sizeof(prefs_sub_t) * 17, str, 64); [/c] Das erscheint mir etwas unpraktisch und erfordert wohl viel Rechnerei. Vorallem erfordert es Anpassungen, sobald sich die
> ich muss händisch die jeweiligen Offsets berechnen Es gibt neben sizeof auch offsetof(struct_t,member), damit wird es kürzer und unempfindlich(er) gegen Änderungen einer struct Definition. Zweitens könnte man z.B. eine Funktion schreiben, die ein komplettes Element
-
Thread
C - warning: incompatible integer to pointer conversion assigning to 'void *' from 'int' [-Wint-conv
Zeiger-Typen, damit die armen C-Programmierer nicht ständig casten müssen (ala "int* f = (int*) malloc (sizeof(int));"). In C++ schreibt man halt einfach "new int".
> damit die armen C-Programmierer nicht ständig casten müssen (ala "int* f > = (int*) malloc (sizeof(int));"). In C++ schreibt man halt einfach "new > int". Oh, okay. Ich habe bei malloc() immer gecastet... hat immer funktioniert ;-)
-
Thread
String in Array reinschreiben
NummernTabelle[] = { "+494353453", "+494345", "+494345345345", }; #define ANZAHL_NUMMERN (sizeof(NummernTabelle)/sizeof(NummernTabelle[0])) ... printf("Nummer 2: %s\n", NummernTabelle[2]);
unsigned int anzahl=2; char** nummern = (char**)malloc(sizeof(char*)*anzahl); nummern[0]=calloc(sizeof(char),25); sprintf(nummern[0],"+49 123 4556"); so oder so ähnlich
-
Thread
Probleme mit einer struct
eeprom_data.format_delay_control[ 0 ]++ ; DAS GEHT KOMISCHERWEISE ! eeprom_write_block ( &eeprom_data , 0 , sizeof ( eeprom_data ) ) ; } /*Funktion Lesen des EEPROMs */ DIE FUNKTIONIERT AUCH ! void eeprom_read ( void ) { eeprom_read_block ( &eeprom_data , 0 , sizeof ( eeprom_data ) ) ; for (uint8_t i=0; i < sizeof ( eeprom_data.format_delay_control ); i++) printf("%X",eeprom_data.format_delay_control[i]) ; for (uint8_t i=0; i < sizeof ( eeprom_data.chroma_gain_control ); i++) printf("%X",eeprom_data.chroma_gain_control
-
Thread
memcpy bei unterschiedlichen Größen
// copy for (i = 0; i < 10; i++) { d[i] = c[i]; } // äquivalent memcpy(d, c, 10*sizeof(int));
besser else // sonst copiere { //besser erst prüfen // sizeof(data_old) >= sizeof(data) // dann malloc oder realloc speicher + oder - erst dann ! memcpy(Data_old,Data,16) }
-
Thread
Speicheradressierung
0x153FFA; > char huge * Formabf = 0x153FFC; *Adresse Gehört zu* 0x153FFA *Baudrate | bei sizeof(int) == 2 0x153FFB *Baudrate | 0x153FFC *Formabf | sizeof(char) == 1 0x153FFD nächster Variable1 oder Füllbyte je nach Alignment 0x153FFE (noch) Variable 1 oder Variable2 je nach
michi wrote: > hallo stefan wieviel speicher besitzt die adresse 0x153FFA denn?? Genau sind es sizeof(int) Bytes. Bei deinem System scheint sizeof(int) 2 Bytes zu sein, jedenfalls ist das die Differenz zwischen dem ini huge Pointer und dem char huge Pointer nach den Zuweisungen. Bei µC kann man
-
Thread
[Eclipse] - Größebestimmung von selbstdefinierten Datentypen / Structs etc.
Funktionszeiger sind wie alle Zeiger abhängig von der Maschine 16, 32 oder 64 Bit. ansonsten sizeof()
mit sizeof() ist klar. Geht das auch zur Laufzeit von Eclipse?
-
Thread
double seriell übertragen
Ach ja, versuch' doch per 'sizeof' die Länge der Variablen zu ermitteln und damit den Outputstream zu füttern. So wird's auch beim EEPROM-Beschreiben gemacht.
beschreibe ich das EEPROM z.B.: eeprom_busy_wait(); eeprom_write_block(&Variable,(uint8_t*)2,sizeof(Preheat)); mit 'sizeof(...)' wird die Länge festgelegt, mit '&Variable,(uint8_t*)2' die Variable mit Zeiger ab Adresse 2 gschrieben.
-
Thread
Probleme, struct zu übergeben und Größe zu bestimmen
> uint8_t num = sizeof(ledarray); // Liefer nicht den richtigen Wert zurück Jeder anständige C-Compiler sagt Dir das als Warnung - jene sind entgegen landläufiger Meinung halt nicht dazu da, um ignoriert zu werden.
herhalten muss. Was schöner oder einfacher ist hängt aber immer vom Kontext ab. Ich würde [code]sizeof(gruppex) /sizeof(gruppex[0])[/code] in die Liste der tatsächlichen Parameter mit aufnehmen, ggf. auch in ein schönes Makro à la [code]#define GIB_MICH_GROESSE(x) (sizeof(x) /sizeof((x)[0]))[/code
-
Thread
FatFs Daten falsch herum
0x11223344; testarray[1] = 0x12223344; testarray[2] = 0x13223344; f_write(&fil, testarray, sizeof(testarray), &bw); [/c] Auch hier sind die Daten verdreht auf der Karte, ohne das ich irgendwas sortiert oder geändert habe... [c] 44 33 22 11 44 33 22 12 44 33 22 13 [/c]
vom STM32 aus. Wo ist das Problem? Man sichert ganze Structs einfach ab mit f_write(&struct...., sizeof struct(....)); Und liest das Ganze auch komplett wieder zurück als Struct direkt in die Struktur ein. Da steht alles wo es soll. Wie die Maschine das macht spielt für den Programmierer normalerweise
-
Thread
FT800 / FT810 Library
320), BEGIN(FT8_POINTS), VERTEX2II(192,133,0,0), END(), }; #define LIST_ELEMENTS(x) (sizeof(x)/sizeof(Long_t)) FT8_start_cmd_burst(); FT8_cmd_dl(CMD_DLSTART); for (i=0; i<LIST_ELEMENTS(items1); i++) { FT8_cmd_dl(items1[i]); } FT8_cmd_dl(COLOR_RGB(255,255,0)); FT8_
(MEM_ADR_MONTSERRAT_BLACK_20, Montserrat_Black_20_L8_ZLib, sizeof(Montserrat_Black_20_L8_ZLib)); size = EVE_cmd_getptr(); ESP_LOGI("hmi", "ptr: %u", size); [/c] Resultat: I (1000) hmi: writing light to: 1000 I (1063) hmi: ptr: 33638 I (1063) hmi:
-
Thread
verschiedene arrays aus EEPROM lesen
sizeof(const char array) ist nun mal 1. Erweiter den Funktionsaufruf um einen Parameter: void funktion (const char array, unsigned char len) { char dummy[8]; eeprom_read_block(dummy, array, len); .... .... } funktion(testX, sizeof(testX)); Weiss jetzt aber nicht ob sizeof mit EEMEM Arrays arbeitet.
-
Thread
Prüfen: Wert existiert in Array
suchen willst. Du musst also die Laenge als Parameter mit uebergeben: [c] inarray(liste, wert, sizeof liste); [/c] Den Rest duerftest du alleine hinbekommen.
return true; } return false; } uint8_t code = 13; if(inarray(codearray,code,sizeof codearray)) > warning: passing argument 1 of 'inarray' discards qualifiers from pointer target type
-
Thread
die 5 kleinsten werte rausfiltern
0] = MAXDIST; results[j][1] = 0; } waypoints = fsaccess_file_get_size(waypointfile)/sizeof(WAYPOINT); for(i=0; i < waypoints; i++) { read(waypointfile,(unsigned char *) &WayPoint, sizeof(WAYPOINT)); distance = coord2strecke(Gps.lat,Gps.lon,WayPoint.latitude,WayPoint.longitude
} } } for(j=0; j<nbPoints; j++) { seek(waypointfile,results[j][1]*sizeof(WAYPOINT),FS_SEEK_SET); read(waypointfile,(unsigned char *) &WayPoint, sizeof(WAYPOINT)); distance = coord2strecke(Gps.lat,Gps.lon,WayPoint.latitude,WayPoint.longitude); sprintf (line
-
Thread
Seltsames Programmverhalten
TaskScheduler(void) { const uint32_t QUEUE_LENGTH = 1; const uint32_t QUEUE_ITEM_SIZE = sizeof(STC_MSG_TELEGRAM*); qh = xQueueCreate(QUEUE_LENGTH, QUEUE_ITEM_SIZE); sma_rx_qh = xQueueCreate(QUEUE_LENGTH, QUEUE_ITEM_SIZE); oCTelegram = new CTelegram(sma_rx_qh); ###############
TaskScheduler(void) { const uint32_t QUEUE_LENGTH = 1; const uint32_t QUEUE_ITEM_SIZE = sizeof(STC_MSG_TELEGRAM*); qh = xQueueCreate(QUEUE_LENGTH, QUEUE_ITEM_SIZE); sma_rx_qh = xQueueCreate(QUEUE_LENGTH, QUEUE_ITEM_SIZE); CTelegram oCTelegram(sma_rx_qh); #####################
-
Thread
Arduino und char-Tabelle
] = {"Sonntag ","Monday","Dien ","Mi ","Do ","Friday!!! ","Sa ","--"}; size_t arr_len=sizeof(text)/sizeof(text[0]); for(size_t i=0; i<arr_len; i++){ size_t str_len=strlen(text[i]); for(size_t j=0; j<str_len; j++){ printf("%c", text[i][j]);
es 20 Zeichen mit den /0 am ende ? Na teste das doch selbst aus: [c] printf("%zd\n", sizeof(text)); [/c] Du hast ein Array von Zeigern, die auf Strings zeigen. (die wiederum char-Array sind). Also [][].
-
Thread
c prog, usefull macros, u32->f, f->u32, better do/while block
... next und immer wieder gern gesehen! [c] #define sizeofmem(t,m) sizeof(((t*)0)->m) // size of struct member #define sizeoflen(a) (sizeof(a)/sizeof(a[0])) // size of array element [/c]
-
Thread
Probleme mit ld und Vektortabelle
*(.rodata*) . = ALIGN(4); _etext = . ; } .data 0x200000 : AT ( ADDR (.text) + SIZEOF (.text) ) { _sdata = .; *(.vectors) *(.data) _edata = .; } .bss (LOADADDR(.data) + SIZEOF(.data)) (NOLOAD) : { . = ALIGN(4); _sbss = .; *(.bss) _ebss
.text) *(.rodata) *(.rodata*) . = ALIGN(4); } .data : AT ( ADDR (.text) + SIZEOF (.text) ) { *(.data) _etext = . ; } .vector 0x200000 : AT ( ADDR (.data) + SIZEOF (.data) ) { _sdata = .; *(.vectors) _edata = .; } .bss (LOADADDR(.vector
-
Thread
String leeren
= '\0'; return start; } int main() { char string[3] = ""; canfuegen( string, sizeof( string ), 'a' ); canfuegen( string, sizeof( string ), 'b' ); canfuegen( string, sizeof( string ), 'c' ); } [/C]
-
Thread
Arrays aus C in Assembler
blah[1] = blah + sizeof (int), Angenommen, blah wäre 0x8000 und sizeof (int) auf Deinem System 2. Dann ist blah[1] äquivalent zum Inhalt von 0x8002, blah[2] = Inhalt von 0x8004 etc.
> blah[1] = blah + sizeof (int) Rufus meint das übrigens nur als Pseudo-Code, in C würde das auf Grund der Pointer-Arithmetik bereits auf blah[2] zeigen, sizeof(int) == 2 vorausgesetzt. Nicht daß das hier jemand falsch interpretiert
-
Thread
C-Frage zu einem Warning in einer if-Anweisung
Du musst die Variablen umkopieren: [c] unsigned long nm, ip; memcpy(&nm, netmask, sizeof(netmask)); memcpy(&ip, myip, sizeof(myip)); if ((dest_ip & nm) == (ip & nm)) { DEBUG("MY NETWORK!\r\n"); } else { DEBUG("ROUTING!\r\n"); memcpy(&dest_ip, router_ip, sizeof(router_ip)); } [/c] Keine Sorge, der Compiler kennt memcpy und merkt schon, dass er gar nichts kopieren muss. Die memcpy werden wegoptimiert.
-
Thread
C++17: Templates, Index zu meinem variadic Parameter unpacking
alle Stellen die für mich wichtig sind Problem: in der Result::fetch fehlt mir der Index [1-sizeof...(OutputTypes)] hat jemand eine Idee wie man das lösen kann? Da soll am Ende ein typesafer-rer SQLite Wrapper werden [c] template<typename T> struct Converter; template<> struct Converter
return Output{Converter<OutputTypes>::value(II)...,}; }(std::make_index_sequence<sizeof...(OutputTypes)>{}); output_ = r; } [/c]
-
Thread
mit eingänge rechnen
breit ist, gibt es schlicht kein uint8_t, denn char ist der kleinstmögliche Typ, da per Definition sizeof(char)==1.
gibt > es schlicht kein uint8_t, denn char ist der kleinstmögliche Typ, da per > Definition sizeof(char)==1. Au weia. Du hast recht. Ich bitte um Entschuldigung. Leider passiert mir das nicht das erstemal. Ich werde hier lieber nichts mehr zu C sagen und mich vorerst auf Fragen beschränken,
-
Thread
Com Port unter Linux auslesen für Verarbeitung in C
} while ((p = strchr(port, '/')) != NULL) { *p = '_'; } snprintf(lockfile, sizeof(lockfile), LOCK, port); snprintf(tempfile, sizeof(tempfile), LOCK, "TMP.XXXXXX"); free(port); if ((fd = mkstemp(tempfile)) == -1) { error("mkstemp(%s) failed: %s", tempfile, strerror
strerror(errno)); close(fd); unlink(tempfile); return -1; } snprintf(buffer, sizeof(buffer), "%10d\n", (int) getpid()); len = strlen(buffer); if (write(fd, buffer, len) != len) { error("write(%s) failed: %s", tempfile, strerror(errno)); close(fd); unlink(tempfile
-
Thread
RAM speicherverbrauch von int16 arrays im ESP8266
Alt G. schrieb im Beitrag #7238848: > Wieviel speicher braucht obige deklaration? Ein sizeof() könnte Aufschluss geben. https://learn.microsoft.com/de-de/cpp/c-language/sizeof-operator-c
Johnny B. schrieb im Beitrag #7238872: > Ein sizeof() könnte Aufschluss geben. Size of array: 7200 bei 4 devices TY
-
Thread
byte alignement mit gcc
Hallo Kann mir bitte jemand sagen wieso sizeof(Info) den Wert 32 liefert? #pragma pack(1) typedef struct { unsigned int a ; unsigned int Speed; unsigned char time; unsigned char val2 ; unsigned int temp; unsigned char
>nach meiner Rechung müsste das Ergbenis 18 sein dann schau nochmal in ein C Buch was >sizeof(Info) bedeutet.
-
Thread
AVR-gcc kennt keine Adresslimits?
(2); _edata = . ; PROVIDE (__data_end = .) ; } > data ASSERT((ADDR(.calram) + SIZEOF(.calram)) <= ADDR(.data), ".calram exceeds page size") [/c] Grüße
) ; *(.stack*) . = stacksize; PROVIDE (__stack_end = .) ; } > data ASSERT(SIZEOF(.stack) <= (stacksize), "stack size exceeded") .eeprom : [/c] Aber Recht hast Du sicher: Der "normale" User wird das nicht unbedingt benötigen...
-
Thread
ESP8266 und WS2812-Streifen
rufe ich wie folgt auf: [c] uint8_t ledBuf[180]; //... noInterrupts(); ws2812_write( ledBuf, sizeof(ledBuf) ); interrupts(); [/c] Das funktioniert meistens. Leider kommen treten sporadisch LED-Glitches auf, bei denen Farbwerte teilweise in die Farbe der nächsten LED rutschen (also blau 1->grün2
einfach einen statischen Buffer mit 100Hz sende, Hardcore-Test mit: [c] memset(ledBuf, 0xAA, sizeof(ledBuf)); noInterrupts(); ws2812_write( ledBuf, sizeof(ledBuf) ); interrupts(); memset(ledBuf, 0x55, sizeof(ledBuf)); noInterrupts(); ws2812_write( ledBuf, sizeof(ledBuf) ); interrupts(); [/c]
-
Thread
MMC/SD Bootloader füt ATMega16
kann man zwar deren "logische Herkunft" nicht mehr so >gut erkennen, z.B. sowas >if ((entry_num * sizeof(direntry_t) / 512) >= RootDirRegionSize) >wird ersetzt durch >if ((entry_num / 16) >= RootDirRegionSize) sizeof(direntry_t) ist nun mal 32. Das wirds wohl auch immer bleiben. Deine Klammersetzung zwingt den Compiler aber erstmal entry_num * sizeof(direntry_t) auszurechnen und danach durch 512 zu teilen. Selber ausrechnen ist hier der bessere Weg. Das meiste haben die Bitschubsereien mit SectorsPerCluster gebracht. Echte Multiplikation
-
Thread
Exitcodes spawn(), system() [Win32, c]
Set the bInheritHandle flag so pipe handles are inherited saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); saAttr.bInheritHandle = TRUE; saAttr.lpSecurityDescriptor = NULL; // Create a pipe for the child process's STDOUT if ( ! CreatePipe
SetHandleInformation() - pipe STDOUT read handle failed for inheritance"); ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION)); ZeroMemory( &siStartInfo, sizeof( STARTUPINFO)); siStartInfo.cb = sizeof( STARTUPINFO); siStartInfo.hStdError = wPipe; siStartInfo.hStdOutput
-
Thread
Bitfeld zuweisen: Warum optimiert der Compiler nicht?
anderer Wert. Fragt nicht, woher ich das weiß. udok schrieb im Beitrag #6807313: > memset(&Out, 0, sizeof(Out)); Das ist ein anderes Spiel. Das ist ja wirklich implementationsabhängig.
Walter T. schrieb im Beitrag #6807320: > udok schrieb: >> memset(&Out, 0, sizeof(Out)); > > Das ist ein anderes Spiel. Das ist ja wirklich implementationsabhängig. Du kannst die Variable natürlich anders initialisieren... Warum soll das aber implementierungsabhängig sein
-
Thread
C/C++: Zielvariable (für Returnwert) als Referenz innerhalb einer Funktion verwenden?
virtual void Write(char* data, int32_t count) = 0; inline char ReadChar(void) {char ret; Read(&ret, sizeof(char)); return ret;} // <--- inline void WriteChar(char data) {Write(&data, sizeof(char));} } [/c] Alle SerialDevice's müssen also Read/Write implementieren. Die Basisklasse kann aber schon ReadChar
Folgendes erlauben würde? [c] char ReadChar(void) {Read(&<OrtAnDenReturnwertGespeichertWerdenWird>, sizeof(<Returnwerttyp>);} [/c] Also direkt den Zugriff auf den Ort an den der Returnwert der Funktion hinübergeben wird und z.B. auch eine Abfrage des Typs mit sizeof() ohne den Rückgabetyp explizit anzugeben
-
Thread
eeprom_write_block / Wie schreibt man es richtig?
"))); [/c] im Programm so ins EEPROM kopieren: [c] eeprom_write_block(&ram_var, &ee_var, sizeof(ee_var)); [/c] und so wieder zurückholen: [c] eeprom_read_block(&ram_var, &ee_var, sizeof(ee_var)); [/c] Wenn Du einen ganzen Schwung voller Settings hast, die Du praktisch immer gemeinsam
void *eepromAdresse) { float localfloat=wert; eeprom_write_block(&localfloat, eepromAdresse, sizeof localfloat); } und dann write_endschalter (az_min, (void *)0x0140); ich hab übrigens keine Idee für was dein char where[3] gut sein soll
-
Thread
Wie schreibe ich eine struct ins EEPROM ?
/* chroma_control*/ void eeprom_write ( void ) { eeprom_write_block ( &eeprom_data , 0, sizeof (eeprom_data)) ; } void eeprom_read ( void ) { eeprom_read_block (&eeprom_data, 0 , sizeof (eeprom_data)) ; /* Ausgabe zum Test */ for (uint8_t i=0; i < sizeof ( eeprom_data.format_delay_control ); i++) printf("%X",eeprom_data.format_delay_control[i]) ; for (uint8_t i=0; i < sizeof ( eeprom_data.chroma_gain_control ); i++) printf("%X",eeprom_data.chroma_gain_control[i]) ; for (uint8_t i=0; i < sizeof ( eeprom_data.chroma_control ); i++) printf("%X",eeprom_data.chroma_control
-
Thread
Dereferenzierung und Postinkrement von Zeiger in einer Zeile
anderes? [c] uint8_t *PtrSPI_RecBuff; PtrSPI_RecBuff = (uint8_t*) &SPI_RecBuff; for (i=0; i < sizeof SPI_RecBuff; i++) { while (!(UCB1IFG&UCTXIFG)); // USCI_B1 TX buffer ready? UCB1TXBUF = 'a'; // turn on master for clock signal while(UCB1STAT&UCBUSY); // wait until
c] > uint8_t *PtrSPI_RecBuff; > PtrSPI_RecBuff = (uint8_t*) &SPI_RecBuff; > > for (i=0; i < sizeof SPI_RecBuff; i++) { > while (!(UCB1IFG&UCTXIFG)); // USCI_B1 TX buffer ready? > UCB1TXBUF = 'a'; // turn on master for clock signal > while(UCB1STAT&UCBUSY); //
-
Thread
problem mit TCP_KEEPIDLE
socket(AF_INET, SOCK_STREAM, 0); opt = 1; setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); setsockopt(server_sock, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(opt); opt = 4; setsockopt(server_sock, IPPROTO_TCP, TCP_KEEPIDLE, &opt, sizeof(opt); opt = 4; setsockopt(server_sock, IPPROTO_TCP, TCP_KEEPINTVL, &opt, sizeof(opt); opt = 1; setsockopt(server_sock, IPPROTO_TCP, TCP_KEEPCNT, &opt, sizeof(opt); [/c] Wenn ich das Programm kompiliere, bekomme ich folgenden Meldungen: error: `TCP_KEEPIDLE' undeclared
-
Thread
avr-g++ bindet ungenutzen code mit ein!
signature) } > text2 .bss SIZEOF(.data) + ADDR(.data) : { PROVIDE (__bss_start = .) ; *(.bss) *(COMMON) PROVIDE (__bss_end = .) ; } > data __data_load_start = LOADADDR(.data); __data_load_end = __data_load_start + SIZEOF(.data); /* Global data not cleared after reset. */ .noinit SIZEOF(.bss) + ADDR(.bss) : { PROVIDE (__noinit_start = .) ; *(.noinit*) PROVIDE (__noinit_end = .) ; _end
-
Thread
Gdb: Speicherbezeichnung unklar
Vielleicht solltest du mal die komplette Ausgabe hier reinkopieren ... Ich würde erwarten dass das 16*sizeof(passwort) Bytes ausgibt. Wenn das die komplette Ausgabe ist (warum dann die Punkte?) und sizeof(passwort) = 2, dann passt doch alles.
Es sind doch Hexa-Zahlen... Wenn 16*sizeof(passwort)=16*2byte!=16^32
-
Thread
Atmega8-Spannungswert an LED-Reihe ausgeben.
0b00000111111, 0b00001111111, 0b00011111111, 0b00100000000, }; FACT =( ( 1024 / ( sizeof( Leds ) / sizeof(*Leds) ) ) + 1 ); int main() { int Value = 0; DDRB = 0xFF; ADCSRA = ( 1 << ADEN ) | ( 1 << ADPS2 ) | ( 1 << ADPS1 ); ADMUX = ( 1 << MUX0 ); ADCSRA |= ( 1 <<
> FACT =( ( 1024 / ( sizeof( Leds ) / sizeof(*Leds) ) ) + 1 ); auch interessant... weder ein #define noch sonst irgendwas dabei, was für einen sinnvollen Zusammenhang sorgen würde. >Wie stelle ich es an das ich noch mehr
-
Thread
Google Test mit -fshort-enums --> Segmentation fault
#define PACKED __attribute__ ((__packed__)) typedef enum PACKED { // sizeof == 1 OT_NO_NC, OT_NC_NO, OT_NO, OT_NC } settings_outtype_t; [/c]
#define PACKED __attribute__ ((__packed__)) typedef enum PACKED { // sizeof == 1 OT_NO_NC, OT_NC_NO, OT_NO, OT_NC } settings_outtype_t; Mir war nicht bewusst, daß man das Attribut __packed__ auch bei Enums benutzen kann. @Cer Entsprechend Bernds
-
Thread
pragma pack(1) funktioniert nicht
Hallo sizeof(DC) liefert mir unter gcc auf einem ARM LPC1768 compiliert eine Länge von 70 Byte. Bisher waren es 62 Byte. GNU Tools ARM Embedded\7 2017-q4-major [c] DataPacket.DataLen = sizeof(DC); #
Compilieren folgende Warnung: "../Controller/devinfo.h(383): warning: empty declaration" und die sizeof liefert immer noch 70 Byte. >Aber ist natürlich auf einer 32-Bit-Maschine eine blöde Idee, die >verschiedenen Elemente in so einer Form zu mischen. Irgendwer muss dann >hingehen, und CpuClockRate
-
Thread
Struct ins EEprom sichern
jegliche Angaben zum System. Evtl. so in der Art: uint8_t * ptr = &flags; for (i = 0; i < sizeof(flags); i++;) { eeprom_update_byte(i, *ptr); } Nur eine Vermutung…
[c] #include <avr/eeprom.h> struct { ... } flags; ... eeprom_read_block(&flags, 0, sizeof(flags)); ... eeprom_update_block(&flags, 0, sizeof(flags)); ... [/c]
-
Thread
GCC Statische initialisierung.
usw. }; constexpr uint8_t ANZAHLPINS = ( sizeof(baseAddr) / sizeof(baseAddr[0]) ) ; } ---------------------------------------------------------------------------- AVRxDB_Pin.h (wird in main.cpp inkludiert) #pragma once namespace
usw. }; constexpr uint8_t ANZAHLPINS = ( sizeof(baseAddr) / sizeof(baseAddr[0]) ) ; } ---------------------------------------------------------------------------- AVRxDB_Pin.h (wird in main.cpp inkludiert) #pragma once namespace
-
Thread
Pointer auf gespeicherte Adresse
ich meinen Text dorthin kopieren. [c] info->btn_text_addr = malloc((strlen(ButtonText) + 1) *sizeof(char)); strcpy( info->btn_text_addr ???? ,ButtonText ); [/c] Nun das Problem. strcpy möchte einen Pointer auf das erste Element des Textes. Ich habe jedoch nur die Adresse als "Klartext"
uint32_t. Ändere das zu char*. Oder verwende einen typecast, aber "sauber" ist das nicht (weil sizeof (pointer) nicht zwingend gleich sizeof (uint32_t) ist). Außerdem sollte der Compiler bereits bei der Zuweisung des Ergebisses von malloc an Deinen uint32_t ungnädig sein; ignorierst Du hier die
-
Thread
Was tun wenn der Stack überschrieben wird?
anderen > Situationen auch schon funktionierte. > ... >Die übergebene Länge, ermittelt mit sizeof > ist 132... Autsch. Ich befürchte es gibt konkurrierende Definitionen der > Struktur die ich kopieren möchtes (fd_set), einmal vom Netzwerkstack und > einmal vom Betriebssystem. > Oder
Inhalt übergeben wurde. So wäre dann der Stack das Ziel und damit kaputt sobald die Kopierlänge > sizeof(void*).
-
Thread
Netzwerkkarte auf 10MBit stellen
} SP_PROPCHANGE_PARAMS PropChangeParam; PropChangeParam.ClassInstallHeader.cbSize = sizeof(SP_CLASSINSTALL_HEADER); PropChangeParam.ClassInstallHeader.InstallFunction = DIF_PROPERTYCHANGE; PropChangeParam.StateChange = DICS_PROPCHANGE; PropChangeParam.Scope = DICS_FLAG_GLOBAL;
SetupDiSetClassInstallParams(HDevInfo,&DeviceInfoData,(SP_CLASSINSTALL_HEADER*)&PropChangeParam,sizeof(PropChangeParam)); SetupDiCallClassInstaller(DIF_PROPERTYCHANGE,HDevInfo,&DeviceInfoData); return 0; } [/c]
-
Thread
STM32 TIM4 Interrupt zur Ansteuerung LEDs ähnlich PL9834
MANN!!! Manchmal sollte ich das zwischen meinen Ohren prüfen lassen... [c] for(int i=0; i<sizeof(ledValues);i+=2) { [/c] dabei sollte das heißen: [c] #define array_length(x) (sizeof(x)/sizeof((x)[0])) for(int i=0; i<array_length(ledValues);i+=2) { [/c] Und schon klappt es, wenn ich alle sizeof durch array_length ersetze. Ich will da die Anzahl der Array-Elemente und nicht die bytes haben... Geh jetzt erstmal in eine Ecke und schäm mich. Danke für die Hilfe! Jörg