-
Thread
Long int in EEPROM schreiben + lesen
einfach sowas wie: [C] void schreibe(long int wert) { eeprom_write_block(&eeFooWord, &wert, sizeof(long int)); } [/C]
int adresse=1; alle 10 sec. { .... adresse+=512; eeprom_write_block(eememory, adresse, sizeof(eememory)); .... } long int ende[10]; eeprom_read_block(ende,eememory,sizeof(eememory)); nun habe ich das Problem das er mir die EEPROM Daten für das Display FONT Daten überschreibt bekomme
-
Thread
C++ unordered_set
required from here /usr/include/c++/4.9/ext/aligned_buffer.h:44:34: error: invalid application of ‘sizeof’ to incomplete type ‘Foo’ : std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value> ... [/code]
Member-Variablen vom Typ T, sondern nur welche vom Typ T* verwendet werden und auch nirgends ein sizeof auf den T angewendet wird.
-
Thread
type/typedef of struct member element?
#define QOVRP_ON return QOVERRUN //write protection on //helper function #define mQSIZE(s) (sizeof(s)/sizeof((s)[0])) /*****************************************************************************/ #define QUEUE(QNAME, QTYPE, QNUM, QCALL_RV, QOVRP
schrieb im Beitrag #6923735: > Einfach die 0 weglassen... ... dann gibt es eine Brandmauer mit sizeof()
-
Thread
ANSI C Programmierung große Struktur
struct mstp_iface_struct *mstp_struct_ptr; mstp_struct_ptr = ( struct mstp_iface_struct *)malloc (sizeof( struct mstp_iface_struct) ); mstp_struct_ptr->preamble1 = 5; MSTP_Master_Node_State_Machine ( mstp_struct_ptr ); } void MSTP_Master_Node_State_Machine ( struct mstp_iface_struct
struct mstp_iface_struct *mstp_struct_ptr; mstp_struct_ptr = ( struct mstp_iface_struct *)malloc (sizeof( struct mstp_iface_struct) ); dann kann ich doch auch auf mstp_struct_ptr schreiben mstp_struct_ptr->irgendwas = 200; und anderen funktionen übergeben func ( mstp_struct_ptr )
-
Thread
Double in Byte Array und zurück
gehen könnte? Etwa so (ohne Test hingekritzelt): [c] float f = 3.14; unsigned char bytes[sizeof (f)]; unsigned char * pf = (unsigned char *) &pf; for (int i = 0; i < sizeof(f); i++) { bytes[i] = pf[i]; } [/c]
[c] union floatmem { float f; unsigned char pch[sizeof(float)]; } foolunion; ... foolunion.f = 3.141; for (int i=0;i<sizeof(float);i++) dosomething(foolunion.pch[i]); [/c]
-
Thread
[C] Tiny 44 - Rundungsfehler?
[c] char s[sizeof("4294967295")]; //Buffer für Ausgabe über LCD char t[sizeof("4294967295")]; //Buffer für Ausgabe über LCD char u[sizeof("4294967295")]; //Buffer für Ausgabe über LCD char v[sizeof
-
Thread
Atmega8A - C-Code PWM Erzeugung was mache ich falsch?
; OCR1A = array[n1]; OCR1B = array[n2]; n1++; n2++; if (n1 == sizeof(array)) then n1=0; if (n2 == sizeof(array)) then n2=0; } } [/c]
Einbindung der Bibliotheken #include <avr/interrupt.h> #include <util/delay.h> #define arraysize(x) (sizeof(x)/sizeof(uint16_t)) // 50Hz Sinus-Ausgangssignal (Grundschwingung) // -> T/2 = 10ms uint16_t samples [36];
-
Thread
struct aus eeprom an funktion übergeben
&IRFunctions[i], &eIRFunctions[i], sizeof(structIR) ); [/c]
structIR_ptr_dest, size); } [/c] Aufruf [c] setIrDataToEeprom(&IRFunctions[0],eIRFunctions[0], sizeof(structIR)) [/c] Es wäre super, wenn mir hier jemand erklärend unter die Arme greifen kann. Ich welze jetzt mal weiter mein C Buch ;) Gruß Stefan
-
Thread
GCC: 8bit x 8bit -> 16bit ?
> auszulösen. wie kann ich im Preprocessor den size von int am besten diskrimieren? #if (sizeof(int) < sizeof(uint16_t) #warning "mint8mul" ... #else ... #endif gibt Fehler, sizeof versteht wohl nur der Compiler.
-
Thread
C Speicher >1Gb
1073741824LLU char *example1; char *example2; char *example3; example1 = (char*)calloc(STORAGE, sizeof(char)); if(example1 == NULL) { printf("Storage1 failure\r\n"); return 0; } example2 = (char*)calloc(STORAGE, sizeof(char)); if(example2 == NULL) { printf("Storage2 failure\r\n"); return 0; } example3 = (char*)malloc(sizeof(char) * STORAGE); if(example3 == NULL) { printf("Storage3 failure\r\n"); return 0; } [/c] Also 1Gb kann ich immer Reservieren. Bei mehr, funktioniert das Programm nicht mehr. Ich benutze GCC
-
Thread
DS18B20 Datenformat
Habe es jetzt mal so versucht: snprintf(temp_po_str, sizeof(temp_po_str-1), "12.5"); anstatt der float Variablen temp_po habe ich jetzt mal "12.5" eingefügt. Ergebnis = Mist was kann ich da eintragen um einen definierten "float" Wert zu haben?
Björn Hiekel schrieb im Beitrag #3470022: > snprintf(temp_po_str, sizeof(temp_po_str-1), "12.5"); > > anstatt der float Variablen temp_po habe ich jetzt mal "12.5" eingefügt. > > Ergebnis = Mist Du hast nun die float-Variable 'temp_po' durch eine Zeichenkette ersetzt
-
Thread
(Aquariencomputer) Zeitschaltuhr mit mehreren Kanälen
[8]; lichtkanal[0].stunde = 12; eeprom_write_block(&lichtkanal, &lichtkanal_preset[0], sizeof(struct_lichtkanal)); }[/code] Wenn ich was im EEPROM gespeichert hab hab ich das bisher immer mit manuell festgelegten Adressen gemacht, irgendwie war mir das ein bisschen suspekt das dem Compiler
] // das ganze Array eeprom_write_block( lichtkanal, lichtkanal_preset, sizeof(lichtkanal_preset) ); // oder nur 1 Element davon eeprom_write_block( &lichtkanal[2], &lichtkanal_preset[2], sizeof(*lichtkanal_preset) ); [/C] > Wenn ich was im EEPROM gespeichert hab
-
Thread
Sortieralgorithmus für Struktur-Daten
> mess2->energie) return 1; else return 0; } qsort((void *)messwerte,sizeof(messwerte)/sizeof(messwerte_t),sizeof(messwerte_t),(compfn)messwerte_sort); [/c]
-
Thread
Komisches Arduino-Phänomen mit PROGMEM und DCF77-Empfang
RTC_Zeit.day(); Flag_Tagesereignis = false; for (int i = 0; i < sizeof(Ereignis) / sizeof(event_type); i++) { // über die Tabelle loopen und Tag/Monat mit aktuellem Datum vergleichen // dann den Namen anzeigen etc. memcpy_P (&Ereignis_SRAM, &Ereignis[i], sizeof(event_type)); // zuerst einen Eintrag des PROGMEM-Arrays ins SRAM (Variablenspeicher) kopieren if (Ereignis_SRAM.Tag == RTC_Zeit.day() && Ereignis_SRAM.Monat == RTC_Zeit.month
-
Thread
Separates Hex File. Geht das ?
ist der das ich eben die ganzen Funktionen die mir der C-Compiler zur Verfügung stellt (Zeiger, Sizeof, Berechnungen mittels Konstanten usw) nutzen können möchte. Wenn ich z.b. ein 2. EEProm oder ein DataFlash habe das ich dann z.b. sowas machen kann : char Text1 [] DATAFLASH = { "Hallo ", };
*ArrayText [] DATAFLASH = { Text1, Text2, Text3, Text4, Text5, }; char EEPEntry [] EEMEM = { sizeof (ArrayText), sizeof (ArrayText) / sizeof (char *), }; und in dem seprarat erzeugten Hex-File automatisch die richtigen Verweise von ArrayText auf die einzelnen Texte gesetzt werden. Hintergrund
-
Thread
Einstellung im EEPROM speichern
if(Frequenz > Max_Frequenz) Frequenz = 0; eeprom_write_block(&Frequenz,&ee_Frequenz,sizeof(Frequenz)); } if(Tasten == Up_Taste) { Frequenz += Offset; if(Frequenz > Max_Frequenz) Frequenz -= Offset; else eeprom_write_block(&Frequenz,&ee_Frequenz,sizeof(
savecnt--; if (savecnt = 0) { eeprom_write_block(&Frequenz,&ee_Frequenz,sizeof(Frequenz)); } } } } } [/c] ... speichert den letzten Wert immer zeitversetzt, die 10000 entsprechend anpassen Sascha
-
Thread
STM32 USB HOST HID Anschlüsse direkt an Tastatur
Reset - USB SetAddress (address) - USB GetDeskriptor(Device,8) - USB GetDescriptor(Device,sizeof(USB_DEVICEDESCRIPTOR)) - USB GetDescriptor(Config,sizeof(USB_DEVICEDESCRIPTOR)) - USB GetDescriptor(Device,wTotalLength) - USB GetDescriptor(HidDescriptor,sizeof(USB_HIDDESCRIPTOR)) - USB SetConfiguration
-
Thread
Array Obergrenzen?
bei jedem Aufruf hinzu. Solange, bis du beim tatsächlichen Array angelegt bist, wo du mit einem sizeof die allokierte Größe feststellen kannst. [C] #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x)) .... char String[400]; .... GetRSData( 0, String, ARRAY_SIZE(String) ); ... [/C]
-
Thread
avr-gcc, C++ und PROGMEM
const char string1[] = "Blub"; int main(void) { char foo[20]; memcpy_P(foo, string1, sizeof(bar)); { static const char string2[] PROGMEM = "Bla"; memcpy_P(foo, string2, sizeof(bar)); } }[/c] Erzeugt für string2 die Warnung, für string1 aber nicht. Und man kann string2
string1[] = "Blub"; > > int > main(void) > { > char foo[20]; > > memcpy_P(foo, string1, sizeof(bar)); > > { > static const char string2[] PROGMEM = "Bla"; > > memcpy_P(foo, string2, sizeof(bar)); > } > }[/c] > > Erzeugt für string2 die Warnung, für string1 aber nicht.
-
Thread
GLUE: Variablenwert statt Textersatz gefordert
const char* Texte[] = { "Motor", "Kabel", "Batterie", }; #define ARRAY_SIZE(x) (sizeof(x)/sizeof(*x)) ... for( i = 0; i < ARRAY_SIZE(Texte); i++ ) UART1_send_string( Texte[i] ); [/c] jetzt brauchst du dich noch nicht mal mehr um die Anzahl kümmern. > Gibts denn da
typedef struct InfoPoint_ InfoPoint; typedef struct InfoPage_ InfoPage; #define ARRAY_SIZE(x) (sizeof(x)/sizeof(*x)) #define DEF_PAGE(n,t,a) \ InfoPage n = { t, ARRAY_SIZE( a ), a }; // -------------------------------------------- InfoPoint MotorInfos[] = {
-
Thread
STM32 Embitz: Code optimieren / nano-branch Lib vermeiden
*/ char grad[4]; char minuten[10]; memset(grad,0,sizeof(grad)); memset(minuten,0,sizeof(minuten)); p = nmea_fields[3]; if (*p != '\0') { strncpy(grad,p,2); strncpy
Latitude (Breite) 00910.09884 */ p = nmea_fields[5]; memset(grad,0,sizeof(grad)); memset(minuten,0,sizeof(minuten)); if (*p != '\0') { strncpy(grad,p,3); strncpy(minuten,p+3,8); gps_info.latitude
-
Thread
Menü Programmierung
uint8_t MenuSize, struct MenuEntry Menu[] ) { .... wie gehabt } #define ARRAY_SIZE(x) (sizeof(x)/sizeof(*x)) void Hours() { ... } void Minutes() { ... } struct MenuEntry TimeMenu[] = { { "Stunden", Hours }, { "Minuten", Minutes }, { "Exit", NULL } }; void
weiter geholfen. Aber nun hat sich bei mir eine Frage ergeben. [c] #define ARRAY_SIZE(x) (sizeof(x)/sizeof(*x)) [/c] Mit dieser Definition bekommt man die größe eines beliebigen Array und der Präprozessor (?) ersetzt diese durch den exakten Wert. Ich benutzte diese Definition damit ich mit
-
Thread
MSP430G2553 Energia RAM überlauf??
benötigt als der Controler Ram zur verfügung hat. Ein 60x8 Array belegt nunmal alleine schon 480*sizeof(Datentyp) Byte. Wenn dieses Array dann auch noch als globales Array definiert ist bleiben dem Compiler auch keine großen Optimierungen mehr. Womöglich brauchst du dieses Array nur in einer Funktion
Wenn man Scheiße fragt, kommt auch Scheiße zurück. Peter K. schrieb im Beitrag #4309447: > 480*sizeof(Datentyp) Genau DAS ist das Problem. Der OP hat es nicht nur versäumt, ein funktionierendes Codebeispiel bereitzustellen. Er hat es nicht einmal geschafft, zu schreiben welchen Datentyp er nutzt
-
Thread
Diverse Variablen remanent machen
Speicherroutine aufrufen indem du ihr die Adresse der Struktur und die Länge übergibst (mit dem sizeof-Operator). Natürlich prüft man die Länge nach, vor dem Schreiben. Dann kümmert sich der compiler darum, wo was steht. Eventuell habe ich dein Problem aber nicht verstanden, das ist durchaus drin
größe sizeof(struktur) ab der Adresse der Struktur. Man kann z.B. Dinge wie memcpy oder memset für eine Struktur verwenden. Oder sie auch einfach ins Flash schreiben (mit den Flash-Spezialfunktionen natürlich)
-
Thread
Speicherallokation in Klassen-Methoden
NULL-Zeiger temp = (char*) malloc(10*sizeof(char)); } [/c] So, das wären mal einige Beispiele. Viele Grüße!
> //Klassenvariable handelt --> bad_alloc > temp = new char(10); > temp = (char*) malloc(10*sizeof(char)); > } was genau erwartest du, was in dieser funktion passiert und was du hast, wenn die funktion zurückkehrt? Es macht überhaupt keinen Sinn einem Input-Pointer neuen Speicher zuzuweisen
-
Thread
Fügt free() freien Speicher eignetlich auch wieder zusammen?
und ich konnte mir beim besten Willen nicht erklären warum: [c]if (fp2 && (char*)fp2 + fp2->sz + sizeof(size_t) == __brkval) {[/c] Also habe ich etwas tiefer gegraben und bin über einen dicken Bug in realloc als Ursache gestolpert. Bei einem Shrink setzt realloc den freien Bereich 2 Bytes zu weit
die beiden realloc-Parameter. cp zeigt damit auf das erste freie Byte dahinter. Daher ist das "- sizeof(size_t)" hier [c] fp2 = (struct __freelist *)(cp - sizeof(size_t)); [/c]keine gute Idee. ;-) Bugreport folgt dann noch (morgen). Oder änderst du das gleich?
-
Thread
Micrium TCP/IP Stack
,sizeof(struct sockaddr_in)); Nachdem man den Sockel erzeugt hat bezieht sich der erste auf die Host Hardware und der zweite Teil auf den Server an den ich das Paket schicken will. Mein Task: while (1) { Led(); sendto(AppUDPSockID_1,&a,sizeof(a),0,(struct sockaddr*)&ServerAddr,sizeof(struct sockaddr)); OSTimeDlyHMSM(0,0,0,75); } Ich überwache den Traffic und ich sehe das das Board ein Arprequest für die richtige Ipadresse sendet
-
Thread
Atmega8 startet nicht
verstanden hab).. Wenn die Fuse gesetzt ist, dann ist die Reset-Behandlungsroutine bei 0x00, sonst bei sizeof(bootloader)? >> Taktfuse stimmt > > Stimmt, von hier aus sehen alle 4 Fusebits richtig aus. Könnte aber auch > ein Kratzer in der Kristallkugel sein. das angehängte Bild ist kratzerfrei
verstanden hab).. Wenn die Fuse gesetzt ist, dann ist die > Reset-Behandlungsroutine bei 0x00, sonst bei sizeof(bootloader)? Fast. Schau mal in Tabelle 82 im Datenblatt. Da steht wo der Bootloader-Bereich anfängt. Hängt von den BOOTSZx Fusebits ab. -> FLASH_END-sizeof(bootloader) > wissentlich gar
-
Thread
C: Struct und Array direkt initialisieren
int main() { // allokieren und für das Array 3 Elemente anlegen. s_x *myVar = malloc( sizeof(*myVar) + 3 * sizeof(*(myVar->c)) ); s_x->a = 5; s_x->b = 8; s_x->c[0] = 'a'; s_x->c[1] = 'b'; s_x->c[2] = 'c'; free( myVar ); } [/C] d.h. man entlässt den Compiler aus jeglicher
der Struktur. Nein. Es ist kein echtes Array, es hat "incomplete type". Man kann also zB kein sizeof darauf verwenden. C99 nennt sowas "flexible array member"; es ist als letzte Komponente (und nur dort) von Strukturen erlaubt. Syntaktisch sieht es auch wie ein char c[] in einer Deklaration/
-
Thread
Comileroptimierung - was kann er und was nicht?
behandeln. ich dachte das hosted environment nur dinge sind wofür man auch kein include braucht z.b. sizeof. strlen wird doch in der libc implementiert und kann dinge tun von dem der Compiler nicht weiß.
, letzteres nicht. sizeof ist kein Teil der Standardbibliothek. > strlen wird doch in der libc implementiert und kann dinge tun von dem > der Compiler nicht weiß. Was strlen macht, ist bei einem hosted environment genau
-
Thread
Serielle Daten bei Arduino auslesen
] = '\0'; strcpy(serial_in_command, serial_in_buff); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); // 30.554 Bytes chr_cnt = 0; stringComplete = true; } else // Falls kein Enter kommt muss der Text gespeichert werden in dem inText Array { if(isprint
else { Serial.println(F("serBUF ov-> DEL")); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); // 30.554 Bytes memset(&serial_in_command[0], 0, sizeof(serial_in_command)); // 30.554 Bytes // *serial_in_command=0; chr_cnt=0; } // if(chr_cnt
-
Thread
arduino no such file
b0PopCallback"); dbSerialPrint("ptr="); dbSerialPrintln((uint32_t)ptr); memset(buffer, 0, sizeof(buffer)); btn->getText(buffer, sizeof(buffer)); number = atoi(buffer); number += 1; memset(buffer, 0, sizeof(buffer)); itoa(number, buffer, 10); btn->setText
-
Thread
MMC/SD-Karte mit FAT16 an AVR
measurements */ uint8_t buffer[512]; while(fat16_read_file(fd, buffer, sizeof(buffer)) > 0) { } Ich verwende keine SPI, sondern ein externes CPLD, welches eine SPI mit 25MBits/Sek. enthält. Der Datenaustausch erfolgt rein über Speicherzugriffe und
error opening "); } else { fat_read_file(fd, buffer, sizeof(buffer)); } } } } else { // Init of SD-Card failed vLCD_Control(ZEILE_1, "SD-Card failed"); } } [/c]
-
Thread
#defines im sprintf - Formatter
define LEN 4 #define SLEN xstr(LEN) sprintf (buf, "%0"SLEN"d", nr); [/c] Aber: Zusammen mit sizeof wird das vermutlich nicht klappen, einfach weil der Präprozessor schon fertig ist, wenn das sizeof aufgelöst werden kann.
, nr); > > Die '5' im Formatter soll sich per #define ändern. Also so was: > > #define LEN sizeof(somebuf) > > sprintf (buf, "%0"LEN"d", nr); > > Geht natürlich so nicht. Alternative: sprintf(buf, "%0*d", sizeof (somebuf), nr); Mir ist allerdings nicht ganz klar, was Du damit
-
Thread
AVR EEMEM Initialisierung C++14
Speicherobjekte" im Block schreiben oder lesen. [c] eeprom_update_block (&dataRAM, &dataEEP, sizeof (DATABLOCK)); eeprom_read_block (&dataRAM, &dataEEP, sizeof (DATABLOCK)); [/c] Das muss doch im Sprachstandard von C++ erlaubt sein? Die Sprache kann mir doch nicht den direkten Zugriff
Entweder gibt man seinem EEProm-Typ einen Typumwandlungs-Ctor von etwa std::array<std::byte, sizeof(DT)>: dieses Array muss natürlich schon im RAM liegen, d.h. man muss es vorher durch plattformspezifische Funktionen wie etwa eeprom_read_block(...) füllen, oder man benutzt ein placement-new, oder
-
Thread
USB-Stringdeskriptor ohne Abzählen
auto landingpageurldesc_f(byte h,const char*s) { landingpageurldesc_t<N>A={}; static_assert(sizeof A<256,"URL too long!"); A.l=sizeof A; A.t=3; // Descriptor type: string (really!) A.h=h; // protocol, 0=http, 1=https for (int i=0;i<N;i++) A.s[i]=s[i]; return A; } #define LP(h,s) (landingpageurldesc_f
landingpageurldesc_f(byte h,const char*s) > { > landingpageurldesc_t<N>A={}; > static_assert(sizeof A<256,"URL too long!"); > A.l=sizeof A; > A.t=3; // Descriptor type: string (really!) > A.h=h; // protocol, 0=http, 1=https > for (int i=0;i<N;i++) A.s[i]=s[i]; > return A; > } > #define
-
Thread
Realloc in Methode
openDiagCache(){ // Allocate memory for diag-session diagCache = (char*) realloc (diagCache, 520*sizeof(char)); // HIER Stopt es. // Check if allocation was succesfull if (diagCache != NULL) { diagCacheOpen = 1; } return diagCacheOpen; } Das Problem ist der Code stoppt in der
warum ist dann vor Methodenaufruf genug RAM vorhanden um den Befehl durchzuführen? Selbst mit 1*sizeof(char) geht es nicht, also RAM schließe ich aus. Beim ersten aufruf hat diagCache den Wert NULL.
-
Thread
PIC16F1509/Sansmart LCD2004/I2C , benötige etwas Hilfe
unsigned char Data) { unsigned char tmpData = Data; I2C1_Host.Write(lcdAddress, &tmpData, sizeof(tmpData) ); } void IO_Expander_Write(unsigned char Data) { I2C__Write(Data | BackLight_State); } void LCD_Write_4Bit(unsigned char Nibble) { // Get The RS Value To LSB OF Data..
address, uint8_t *data, size_t dataLength) // & ? I2C1_Host.Write((uint16_t)lcdAddress, &data, sizeof(data) ); // Wire.endTransmission(); } [/c] Da in [c] I2C1_Host.Write((uint16_t)lcdAddress, &data, sizeof(data) ); [/c] alles "versteckt ist" was die I2C-Schnittstelle betrifft wird
-
Thread
Array in Funktion übergeben --> falsche Länge erkannt
übergeben wollte. Das schaut dann so aus: [c]int uartRead(char rxBuf[]) { ... memset(rxBuf, 0, sizeof(rxBuf)); ... }[/c] Nun stelle ich allerdings fest, dass die Funktion glaubt, dieser Array hätte nur eine Länge (sizeof()) von 4 Byte. Bei einem Zeiger ist mir schon klar, dass die Funktion nicht
übergibst die Adresse des Arrays. > [c]int uartRead(char rxBuf[]) > { > ... > memset(rxBuf, 0, sizeof(rxBuf)); > ... > }[/c] Du kannst an dieser Stelle kein sizeof verwenden. sizeof liefert dir hier die Größe des Pointers, der da in Wirklichkeit übergeben wird, auch wenn die Syntax etwas anderes
-
Thread
8 bit, 16 bit mischung in struktur - 8 bit breiten speicher vorgaukeln
bit 40..47 frei }struct_status_tx_16_A; // sizeof() liefert 6 Bytes, korrekt! typedef struct { Uint16 sta; // belegt bit 0..15 Uint8 adr; // belegt bit 16..23 Uint8 err; // belegt bit 24..31 }struct_status_tx_16_B; // sizeof() liefert 4 Bytes, korrekt!
-
Thread
32-Bit-µC: Möglichst viel uint8_t verwenden?
. Sie sind genauso leer, nur sind sie eben nicht Teil des Typs. Das erkennt man z.B. auch per sizeof. So ist sizeof(__float80) nicht 10, sondern 16.
Da wird man doch sowieso durch ein Array oder String iteririeren. Und sowohl strlen() als auch sizeof geben "size_t" zurück.
-
Thread
GCC [STM32] -> wie sehen wie ein struct realisiert wird?
Assemblerlisting auffindbar sind (oder einfach laufen lassen). - https://en.cppreference.com/w/cpp/language/sizeof - https://en.cppreference.com/w/cpp/types/offsetof
} printf("\r\n"); bp += 16; line += 16; } } ... hexdump(tu, sizeof(tu)); [/c]
-
Thread
Funktion, die 2 Variablen addiert, wenn es kein negatives Ergebnis gibt
source, int32 add) { int64_t tmp = (int64_t) source + add; if(tmp > 0 && tmp < (1 << sizeof(T))) return tmp; } Das würde man dann so aufrufen: uint16_t zahl = Add<uint16_t>(100, -50);
Damit könnte man doch Argumente übergeben, die unbekannt sind. Außerdem > könnte man dann doch mit sizeof die Größe bestimmen und dann die > Addition auc nicht zulassen wenn z.b. ein 16bit Wert übergeben wurde. nein das geht so nicht, weil sizeof zur compilezeit ermittelt wird. Bei einer Variabelen argumentenliste
-
Thread
Hashfunktion oder Trick für Lookup-Tabellen gesucht
data[] = { /* ... */ } int *pos; pos = bsearch(&n, data, sizeof(data)/sizeof(data[0])-1, sizeof(int), compare); return pos ? *(pos+1) : data[0]; } [/code] data sollte mit dem Wert INT_MAX aus limits.h (bzw. einem zum Datentyp
-
Thread
modern C für C++ Entwickler?
lösen muss. Naja, dies hier z.B. wäre ja gültiges C und C++: [code] foo* f = (foo*)malloc( sizeof( foo ) ); [/code] Ich bin mir aber sicher, schon mal gehört zu haben, dass man den cast in C weglässt. Genau diese "Dinger" suche ich gerade.
Nutzdaten angeben. Der Empfänger kann sich die jeweils andere Größe ebenso einfach mit Hilfe von sizeof(struct Command) berechnen, ohne die Länge des Dummy-Datenfelds addieren/subtrahieren zu müssen.
-
Thread
struct Array: Einträge verschieben. Wie?
Argument fehlt ein "&" memcpy(&SCHEDULER_HIGH_strTaskList[i2+1],&SCHEDULER_HIGH_strTaskList[i2],sizeof(strTaskEntry));
: memmove(SCHEDULER_HIGH_strTaskList + 11, SCHEDULER_HIGH_strTaskList + 10, sizeof(*SCHEDULER_HIGH_strTaskList) * 9);
-
Thread
Frage zu typedef bei Strukturen
des Typs und kann sich anschauen, wie groß er ist. Oder man startet den Debugger und lässt sich sizeof(Typ) ausgeben, wenn man es ganz genau wissen will.
definiert, dass du den Speicher byte (oder Char?) weise ab der Start-Adresse lesen kannst so gross wie sizeof() das angibt, und du hast die gesammte Struktur gelesen. Es können alignment gaps in dem Speicher auftauchen, die von den einzelnem Elementen nicht belegt werden. aber die müssen in sizeof() enthalten