-
Thread
HID Gerät Ansprechen
PreparsedData; HIDP_CAPS Capabilities; ZeroMemory(&spdid, sizeof(spdid)); spdid.cbSize = sizeof(spdid); HidD_GetHidGuid(&guid); hDevInfo = SetupDiGetClassDevs(&guid,NULL,NULL,DIGCF_DEVICEINTERFACE | DIGCF_PRESENT); if(hDevInfo == INVALID_HANDLE_VALUE
GetProcessHeap(),HEAP_ZERO_MEMORY,dwSize))) continue; pspdidd->cbSize = sizeof(*pspdidd); ZeroMemory((PVOID)&spdd, sizeof(spdd)); spdd.cbSize = sizeof(spdd); if(SetupDiGetDeviceInterfaceDetail(hDevInfo,&spdid,pspdidd,dwSize,&dwSize,&
-
Thread
STM32: Bitbanding für Arrays?
include <stdbool.h> #include <stddef.h> bool getBit (size_t index) { const size_t entrySize = sizeof(ee_fat[0]) * CHAR_BIT; return ee_fat [index / entrySize] & (1 << (index % entrySize)); } void setBit (size_t index, bool value) { const size_t entrySize = sizeof(ee_fat[0]) * CHAR_BIT; const
ne lokale Variable. [c] bool getBit (uint8_t* p, size_t index) { const size_t entrySize = sizeof(p[0]) * CHAR_BIT; return p[index / entrySize] & (1 << (index % entrySize)); } void setBit (uint8_t* p, size_t index, bool value) { const size_t entrySize = sizeof(p[0]) * CHAR_BIT; const
-
Thread
Array und Stack overflow
oder sizeof()
Michael Reinelt schrieb im Beitrag #3161890: > oder sizeof() Obacht beim Einsatz von sizeof mit Arrays bei Verwendung als Funktionsargument.
-
Thread
NRF24L01+ über mehrere Kanäle kommunizieren?
radio.stopListening(); radio.openWritingPipe(pipe); senden[0]=99; radio.write( senden, sizeof(senden) ); } if (modus == 1){ radio.openReadingPipe(1,pipe1); radio.startListening(); radio.read( empfangen, sizeof(empfangen) ); Serial.println(empfangen[0]); } } [/c]
radio.stopListening(); radio.openWritingPipe(pipe1); senden[0]=23; radio.write( senden, sizeof(senden) ); } if (modus == 0){ radio.openReadingPipe(1,pipe); radio.startListening(); radio.read( empfangen, sizeof(empfangen) ); Serial.println(empfangen[0]); } } [/c]
-
Thread
Arduino put() get() ein ppar Fragen dazu.
der Versionsnummer die passende Struktur befüllen: immer ab Eeprom Adresse 0 mit dem passenden sizeof(EEPDATA). Schreiben erfolgt ebenfalls mit dem aktuellen sizeof(EEPDATA) ab Adresse 0. Es empfiehlt sich, in der Struktur erst die 32Bit Variablen, dann die 16Bit Variablen und erst am Ende die
der Versionsnummer die passende Struktur befüllen: > immer ab Eeprom Adresse 0 mit dem passenden sizeof(EEPDATA). > > Schreiben erfolgt ebenfalls mit dem aktuellen sizeof(EEPDATA) ab Adresse > 0. put und get benötigen kein externes sizeof(). Das haben sie selber im Bauch. offsetof() ist da viel
-
Thread
Struct-Typ erkennen
{ Fixedstruct_t Fixed; Piggyback_t Piggyback; } Genericunion_t; //static_assert( sizeof(Fixedstruct_t) == sizeof(Piggyback_t) ); //static_assert( sizeof(Fixedstruct_t) == sizeof(Genericunion_t) ); enum { magic0 = INT_MIN, magic1 = 0xFF, magic2 = 0xFF, magic3 =
magic3 ) return 1; else return 0; } int main(void) { assert( sizeof(Fixedstruct_t) >= sizeof(Piggyback_t) ); assert( sizeof(Fixedstruct_t) == sizeof(Genericunion_t) ); uint8_t somethingToPointTo; Payload_t Pl; Fixedstruct_t A = {.a = &somethingToPointTo
-
Thread
c++ Laufzeitsenken finden/vermeiden erster Teil
//dauert so 0.3 Sekunden { timer t(0); for(int m=0; m<100000; m++) for(int n=0; n<(sizeof(names)/sizeof(names[0])); n++) { if( !(pl=find(names[n])) ) pl = add(names[n]); pl->val = 42; } } //dauert so 4.irgendwas Sekunden { timer t(2); for(int m=0; m<100000; m++) for(int n=0; n<(sizeof(names)/sizeof(names[0])); n++) { chr_map[names[n]] = 0; } } //dauert so 13 Sekunden { timer t(1); for(int m=0; m<100000; m++) for(int n=0; n<(sizeof(names)/sizeof(names
-
Thread
heap wächst höher als __heap_end
extern T_WORD *__heap_end; // main()... UA1_OffBoardTransmit(D_UartChannelOffBoardA,sizeof(__heap_start),&__heap_start); UA1_OffBoardTransmit(D_UartChannelOffBoardA,sizeof(__heap_end),&__heap_end); UA1_OffBoardTransmit(D_UartChannelOffBoardA,sizeof(__brkval),&__brkval) [
also unsigned int brkval; > brkval = __brkval; > UA!_offBorardTransmit(xxx,sizeof(yyy),&brkval); brkval = __brkval; -> brkval = (unsigned int)&__brkval;
-
Thread
2-dimension. Array dynamisch erzeugen
** schrieb im Beitrag #2423541: > array[i]=malloc(Größe des Strings) also x*sizeof(char)
; char string[]="This is very bad."; uint8_t i,j,k; uint8_t nbel=0; array=malloc(1*sizeof(char*)); for(i=0;i<strlen(string);i++) { for(j=i;j<strlen(string)&&string[j]!=' ';j++); nbel++; array=realloc(array,nbel*sizeof(char*)); array[nbel-1]=malloc((j-i+1)*sizeof
-
Thread
malloc, realloc und free Gesperrt
TaskList.Task[j + 1]; } TaskList.nbrOfTasks--; realloc(TaskList.Task, GetNbrOfTasks()*sizeof(tTask)); } else { if(TaskList.Task[i].HasFinishedTask) { TaskList.Task[i].HasFinishedTask = FALSE; } } } } [/c]
dass dein Memory Manager nicht WO gibt falsch: [C] realloc(TaskList.Task, GetNbrOfTasks()*sizeof(tTask)); [/C] richtig: [C] TaskList.Task = realloc(TaskList.Task, GetNbrOfTasks()*sizeof(tTask)); [/C] das deine erste Version nicht richtig sein kann, ersiehst du schon daran,
-
Thread
Arduino Nano Led runterzählen
sieht mir Dein Gebrauch des &-Adressoperators falsch aus. Statt: [c] if (radio.write( &message,sizeof(message))) [/c] müßte es wohl eher heißen: [c] if (radio.write( message,sizeof(message))) [/c] Frißt der Compiler das so?
Programm auch so verwenden. Also auf der Sendeseite senden mit [c] if (radio.write( message,sizeof(message))) [/c] Und auf der Empfangsseite empfangen mit: [c] radio.read( message,sizeof(message)); [/c] Und zwar nicht mit verschieden großen Message-Längen, sondern mit gleich großen Message-Puffern
-
Thread
ESPNOW senden mit ESP12 geht schief, warum ?
Helmut H. schrieb im Beitrag #7664806: > esp_now_send(broadcastAddress, (uint8_t *)&Puffer, sizeof(Puffer)); sizeof() gibt die Größe des gesamten Puffers zurück. Ist denn die Nachricht auch wirklich exakt so lang, oder ist sie kürzer, so daß dahinter Mumpitz gesendet wird? Für Textnachrichten
Anscheinend sendest du zu viel, da kann sich der Empfänger dran verschlucken. memcpy(&Puffer, &myData, sizeof(myData)); esp_now_send(broadcastAddress, (uint8_t *)&Puffer, sizeof(Puffer)); Müsste es in der zweiten Zeile nicht sizeof(myData) heißen?
-
Thread
C: Zeiger auf Array mit struct Elementen
versuche ich auf die Palette zuzugreifen: [c] if (gct_size) { palette = calloc(gct_size, sizeof(struct rgbtriple)); if (palette == NULL) { printf("calloc() failed!\r\n"); return -1; } fread(palette, gct_size, sizeof(struct rgbtriple), fp); for (
Hättest du ein repräsentatives Beispiel für C Expressions, in dem der Datentyp(!) Array ausserhalb sizeof/cast auftaucht? Grad sizeof ist auch nicht unbedingt sehr logisch, denn in sizeof(a) ist a ein Array, in p=a oder *a aber ein Pointer.
-
Thread
"printf" for small pockets || für ganz arme uC
[c] #define PRINTBIN_TYPE uint16_t void printBin(PRINTBIN_TYPE val) { for (uint8_t i=0; i!=sizeof(val)*8; val<<=1,i++) { if (i && !(i % 4)) putc(' '); putc(val & (1<<(sizeof(val)*8-1)))? '1' : '0'); } } [/c]
Review komme, dann könnte es "kitzlig" werden ... :-) [c] #define mPrintBin(val) printBin(val, sizeof(val)) void printBin(uint32_t val, uint8_t sizeofVal) { for (uint8_t i=0; i!=sizeofVal*8; val<<=1,i++) { if (i && !(i%4)) printf("%c", ' '); printf("%c", (val & (1<<(sizeofVal*8-1
-
Thread
Liste in Funktion initialisieren
int allocateListMemory(List **list) { if(!(*list = malloc(sizeof(List)))) { *list = NULL; return OUT_OF_MEMORY_ERROR; } *list->content.place_name = NULL; *list->content.description = NULL; *list->header.identifier = INITIALISATION_CONSTANT_ZERO
doch ein Fehlercode zurückgegeben: Hans M. schrieb im Beitrag #2467462: > if(!(*list = malloc(sizeof(List)))) > { > *list = NULL; > return OUT_OF_MEMORY_ERROR; > }
-
Thread
crc8 Tabelle Ich versteh es einfach nicht :(
int n, k; // make exclusive-or pattern from polynomial poly = 0; for ( n = 0; n < sizeof( p ) / sizeof(unsigned char) ; n++ ) poly |= 1 << ( 7 - p[n] ); [/c] ? Im 4. Durchlauf durch die Schleife 7 - 8 ergibt -1 was ergibt 1 << (-1)? Gute Frage. Bin ich ehrlich gesagt
int n, k; // make exclusive-or pattern from polynomial poly = 0; for ( n = 0; n < sizeof( p ) / sizeof(unsigned char) ; n++ ) poly |= 1 << ( 7 - p[n] );[/c] Den Inhalt des Array habe ich auch mit anderen crc8 mit Polynom 0x8c verglichen. Die Arrays waren gleich. Deswegen
-
Thread
Integer zu String, aber (Speicher-)effizient.
Dass ich (sizeof(int)*8+1)-Char Werte reserviere obwohl unter Umständen nur viel weniger gebraucht werden. Die Zahl, die umgewandelt wird, ist wohl meist doch kleiner als 10.
Christian H. schrieb im Beitrag #2414361: > [c]char len[sizeof(int)*8+1]; > (void) sprintf(len,"%d",i);[/c] warum sizeof(int)*8+1? selbst wenn du die berechnung sehr einfach halten willst wäre da eine 3 statt einer 8 angebrachter (und +2 statt +1 -> vorzeichen
-
Thread
FreeRTOS Taskaufruf nur, wenn eine Task vorhanden
pvParameters; > for(;;) > { > > Error = UART_SendBlock(MySerialPtr, pcTaskName, > sizeof(pcTaskName)); /* Send block of characters */ > Es ist nun > aber so, dass mir die sizeof() Funktion nicht 20 zurückgibt, wie ich > eigentlich erwarte? > Woran mag das liegen? pcTaskName ist definiert als pointer auf char, nicht als char-Array. sizeof() liefert dir also die Größe des Pointers, nicht die Große des Arrays worauf der Pointer zeigt. Entweder musst du die Größe irgendwie mitübergeben als Task-Parameter, oder im Task den String Byte
-
Thread
hex -> text und andersrum konvertieren
mal was und man kann's ja ausbauen: Exakt. Ich hätt es dann so gemacht: [c] for (i=0; i<sizeof(data__index_html)/sizeof(*data__index_html); ++i) { if( data__index_html[i] == 0x00 ) printf( "\\0" ); else if( data__index_html[i] == 0x0D ) printf( "\\r" ); else
: Konverter mit einem weiteren Fall erweitern (denn das wird oft vorkommen) [c] for (i=0; i<sizeof(data__index_html)/sizeof(*data__index_html); ++i) { if( data__index_html[i] == 0x00 ) printf( "\\0" ); else if( data__index_html[i] == '"' ) printf( "\\\"" ); else
-
Thread
Merkwürdigkeit mit PROGMEM Array
Fehler "only initialized variables can be ..." erhalten, sondern dafür "invalid application of 'sizeof' to incomplete type of blabla []". der eigentliche witz ist aber : kopiere ich die betreffende tabelle in das selbe modul benenne diese um (und auch die variable in sizeof) funktioniert das ganze
indem auch die tabellen liegen. liegen die tabellen außerhalb des moduls habe ich keine chance mit sizeof darauf zuzugreifen. ist das normales verhalten. vllt dadurch bedingt das ich im headerfile "extern xxxx [] FLASHMEM" stehen hab ?! irgendwie steh ich aufm schlauch ...
-
Thread
Suche MP3 to WAV decoder
unsigned char mp3_buffer[MP3_SIZE]; mp3data_struct mp3data = {0}; memset(pcm_buffer, 0, sizeof(pcm_buffer)); memset(pcm_buffer1, 0, sizeof(pcm_buffer1)); memset(pcm_buffer2, 0, sizeof(pcm_buffer2)); memset(mp3_buffer, 0, sizeof(mp3_buffer)); lame_t lame = lame_init(); hip_t
memcpy(pcm_buffer, pcm_buffer1, sizeof(pcm_buffer1)); memcpy(&pcm_buffer[PCM_SIZE], pcm_buffer2, sizeof(pcm_buffer2)); write = lame_encode_buffer_interleaved(lame, pcm_buffer, read, mp3_buffer, MP3_SIZE); fwrite(mp3
-
Thread
linux manpage - inotify Verständnisfrage
Ach da ist wohl dein Problem: "sizeof" ist ein Operator, der zur Compilezeit (!) die Größe des Datentyps ermittelt, wobei er ein Array unbestimmter Größe als 0 rechnet. Somit ermittelt sizeof für diese Struktur nur die Summe der Größen
ist. Was mich irritiert hat, dass len quasi zwei Mal berücksichtigt wird. Einmal innerhalb von sizeof(struct inotify_event), denn len ist ja ein Member dieser Struktur und dann noch einmal über event->len. >Ach da ist wohl dein Problem: "sizeof" ist ein Operator, der zur >Compilezeit (!) die
-
Thread
Formular auslesen in C
char* userpw = getFormValue("User", BUFFER); char* username = (char*)calloc(strlen(userpw)+1, sizeof(char)); strcpy(username,userpw); userpw = getFormValue("Password", BUFFER); char* password = (char*)calloc(strlen(userpw)+1, sizeof(char)); strcpy(password,userpw); . .// Überprüfung
char*)calloc(len + 1, sizeof(char)); strncpy(rvalue, value, len); value = rvalue; free(newKeyword); free(rvalue); return value; }[/C] Bis jetzt läuft alles korrekt, und ich konnte noch kein Fehlverhalten
-
Thread
For Schleife nur bestimmte Werte hochzählen lassen
5); i[z]; PORTC=i} Er zählt von 1 bis 9 hoch. Bleibt bei 9 stehen. Wenn ich in die Klammer "i<sizeof(x)" schreibe zählt er bis 15.
Index 8! > > Er zählt von 1 bis 9 hoch. Bleibt bei 9 stehen. Wenn ich in die Klammer > "i<sizeof(x)" schreibe zählt er bis 15. kein Wunder. sizeof liefert die Größe in Bytes und nicht in int Einheiten die Anzahl der Elemente in einem Array kann man so bestimmen sizeof(x)/sizeof(x[0])
-
Thread
Array - Zeiger erst ab 2ten Element
uint8_t *tmp = puffer + 10*sizeof(puffer[0]);
> uint8_t *tmp = puffer + 10*sizeof(puffer[0]); das kann der compieler schon selber. uint8_t *tmp = puffer + 10
-
Thread
Größe eines arrays innerhalb einer Struktur bestimmen ?
16, { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 4, 8, 16, 32, 64, 128, 8, 9, 10 } }; sizeof(testmap.data) bringt die fehlermeldung "main.c:57: error: invalid application of `sizeof' to an incomplete type" sizeof(testmap.height) geht dagegen. Am Progmem liegts nicht, ohne progmem gibts
denke ich. Nicht die des Datenfeldes... Und immer dran denken: C ist case-sensitive, soll heissen SizeOf != sizeof!
-
Thread
union mit bitfeld in struct in c
ich mich erinnern kann werden, selbst wenn man nur 1 Bit verwendet, dennoch als kleinste Einheit sizeof(int) reserviert. Die restlichen Bit des Byte "liegen brach". Was die Verwendung von Bitfeldern mit geringer Größe meiner Meinung nach obsolet macht. Aus C von A bis Z von Jürgen Wolf struct
Jetzt benötigt die Struktur im Grunde nur noch acht Bits (ein Byte). Wenn Sie allerdings mit sizeof prüfen, werden Sie feststellen, dass dieses Bitfeld trotzdem vier Byte belegt. Dies liegt daran, dass das kleinstmögliche Rechnerwort, das der Compiler für ein Bitfeld reserviert, sizeof(int) groß
-
Thread
Array als define definiert
ERROR_NO_ARRAY const char ERROR_NO[] = { 18, 19, 20, 21, 22, 23, 24, 25}; #define ERROR_NO_ARRAY_SIZE (sizeof ERROR_NO / sizeof ERROR_NO[0]) [/c]
ERROR_TO_LOW, ERROR_TO_HIGH ); #define ERROR_NO_ARRAY_SIZE (sizeof Errors / sizeof Errors[0]) [/C]
-
Thread
Long in char Array umwandeln
Rolf Magnus schrieb im Beitrag #2896137: > char b[sizeof a]; Hmrpf, muß natürlich unsigned char statt char heißen.
aus unsigned char > gleicher Größe per memcpy kopieren, also so: > long a = 1234567; > char b[sizeof a]; > > memcpy(b, a, sizeof a); > > Das dürfte aus ISO-C-Sicht die sauberste Variante sein und beim gcc auch > nicht langsamer oder umständlicher als irgendwelche union-Verrenkungen > oder
-
Thread
Mikrocontroller Klausur Aufgabe Speichertest
zurückgeben else begin+=uint8_t umeinserhoehen; //nächste Adresse also um sizeof(uint32_t)erhöhen } return 0; } [/c]
auf uint8_t, uint16_t, uint64_t etc genauso analog. Vollautomatisch. Also: Du brauchst kein Sizeof-Gewurschtel, das kann der Compiler alles selber. Pfusch ihm da nicht rein, er kann das nämlich nicht nur selbst, sondern auch besser als du mit deinem aktuellen Kenntnisstand.
-
Thread
interruptgesteuerte UART, string empfangen ATMEGA
ja: Misserfolg ist Teil des Lernprozesses. > > > ISR(USART0_RXC_vect) > { > if (i <= sizeof(Buffer)) Das kleiner-gleich ist Unsinn. Es muss kleiner heißen. In C wird bei 0 angefangen zu zählen.
ist das Element [C] Array[ sizeof( irgendein_typ ) / sizeof( *irgendein_typ) ] [/C] nicht existent.
-
Thread
C++ Array in einer Klasse -> Grösse bestimmen
test(); read(); uint16_t buffer[20]; }; test::read(void){ for(uint16_t i = 0; i < (sizeof(buffer)/sizeof(buffer[0])); i ++){ // etwas } } [/c] Die Schlaufe wird irgendwie durchlaufen, aber nur nicht 20 mahl. Was mache ich falsch? MFG Patrick
uint16_t buffer[127]; }; void test::read(void) { cout << "Size of array buffer[]: " << (sizeof(buffer)/sizeof(buffer[0])) << endl; } int main() { test a; a.read(); return 0; } [/c] Size of array buffer[]: 127
-
Thread
C: Pointer in Funktion verändern
zb im Flash stehen) [C] const uint16_t Values[] = { 3, 8, 12, 2, 25, 8 }; for( i = 0; i < sizeof(Values)/sizeof(*Values); i++ ) { OutputPWM( SearchNearest( PWMtable, Values[i] ) ); ... } [/C] oder .... [C] const uint16_t Values[] = { 3, 8, 12, 2, 25, 8 }; uint16_t MappedValues[ sizeof(Values)/sizeof(*values) ]; // same size as Values for( i = 0; i < sizeof(Values)/sizeof(*Values); i++ ) { // wenn sicher gestellt ist // das immer was gefunden wird MappedValues
-
Thread
Strings im Flash in zentraler Datei
uiTextID, char* caString) { uiTextID--; // weil die ID bei 1 beginnen soll if(uiTextID >= sizeof(strings)/sizeof(char*)) return -1; // ID existiert nicht strcpy_P(caString, strings[uiTextID]); return 0; } [/c]
int uiNr){ if (uiNr >= (sizeof(strings)/sizeof(strings[0]))) uiNr =0; return (const char*)(pgm_read_word(&(strings[uiNr]))); } [/c]
-
Thread
Probleme mit recvfrom Funktion - UDP
, (sockaddr*) &socketAddr, sizeof(sockaddr))); if (bind(ulSocket2, &tSocketAddr, sizeof(sockaddr)) != 0) { rs232_printf("Bind connection FAILED\n"); } __delay_cycles(10000000); sockLen = sizeof(sockaddr);
unsigned long timeout = 100; if(setsockopt( ulSocket2, SOL_SOCKET, SOCKOPT_RECV_TIMEOUT, &timeout, sizeof( timeout ) ) != 0) { rs232_printf("FATAL ERRROR in open_socket\n"); return -1; }[/c]
-
Thread
Bluetooth-Module Datenübertragung
ok danke aber wieso machst du immer sizeof(float)? stimmt das oder muss man sizeof(zahl)?
Das ist völlig egal sizeof(float) ist gleich sizeof(Zahl). Dahinter steckt jeweils die Zahl 4.
-
Thread
C, VS, Struct
ofstream bmpdata("test.bmp", std::ios::out | std::ios::binary); bmpdata.write((char*)&fheader, sizeof(fheader)); bmpdata.write((char*)&bheader, sizeof(bheader)); char test[60] = { 0 }; for (int i = 0; i != 14; ++i){ test[i] = *((char*)&bheader + i); for (int ii = 7; ii >= 0; --
//# continue; } } bmpdata.close(); //# printf("Headersize: %d & %d\n", sizeof(fheader), sizeof(bheader)); printf("dazasize: %d\n\n", zähler); printf("bmp headerdata:\n|"); for (int i = 0; i != 10; i++){ printf(" %ld |", *((long *)&bheader + i)); } scanf("
-
Thread
C: conversion rules, kennt jemand ein Beispiel dazu?
integer type. > > 4 kenne ich nicht, und kann mir kein Beispiel konstruiren. Annahme: sizeof( unsigned char ) == 1 sizeof( int ) == 2 unsigned char c = 200; int i; i = c; i ist signed und seine sizeof ist gross genug, so dass es alle Werte, die mit einem unsigned char
the type of the operand with signed > integer type. Das müsste den Fall regeln sizeof( unsigned int ) == 4 sizeof( long ) == 4 unsigned int i = 200; long j = -200; if( i < j ) Der 'rank' von long ist höher als der von int, auch wenn beide gleiche sizeof haben
-
Thread
Unterschiedliche Architekturen und Structe
for fan stop */ } fan_t; fan_t fanvar[3]; // es gibt 3 Lüfter usb_send_buffer( (U8*)fanvar, sizeof( fanvar)); [/c] Der PC hat nun das identische Struct und liest dieses über [c] fan_t fans[3]; ret = usb_bulk_read( udev, IN_ENDPOINT, (char*)&fans, sizeof(fans), TIMEOUT); [/c] ein.
defines eventuell noch ganz brauchbar lösen. 2) Hier ist mein Problem. Wärend der AVR bei einem sizeof( fanvar) 14 zurück gibt, sind es beimi PC 42... Wenn ich mir jedoch mal die verschiedenen sizeof(uint8_t) oder sizeof(uint16_t) ausgeben lasse, so stimmen diese mit 1 resprektive 2 sauber mit dem vom
-
Thread
Bytes auslesen und in ein Array schreiben "C"
es denn int sein soll: [c] union { int i; unsigned char c[sizeof(int)]; } int_oder_char; int_oder_char.i = 4711; // in int_oder_char.c[0] bis int_oder_char.c[sizeof(int)-1] stehen jetzt die Bytes [/c]
Klaus Wachtler schrieb im Beitrag #1964901: [c] > unsigned char c[sizeof(int)]; [/c] Das ist natürlich sehr elegant und gegebüber dem struct zu bevorzugen!
-
Thread
STM32 CUBEMX und Printf() über UART
schätzt die maximale Größe schnell mal falsch ein. Da ist es doch viel einfacher, immer snprintf+sizeof zu nutzen. Das funktioniert dann auch nach Änderung der Puffer-Größe, Format-String oder Eingaben noch. Als schlampige Programmierung würde ich es sehen, wenn die Sicherheit der Anwendung davon abhängt
as "in use" txComplete=0; // copy the string into the buffer (with size limit) if (len>sizeof(buffer)) { len=sizeof(buffer) } memcpy(buffer,ptr,len); // send the buffer HAL_UART_Transmit_IT(&huart1, buffer, len); return len; } [/c] Bei diesem Code dürfen die Strings
-
Thread
C++17, Macro-Parameter mit :: Verbinden?
Produktiv-Codes [c] struct MemberInfo { const char* name; size_t alignof_; size_t sizeof_; size_t offsetof_; }; #define MEMBER_INFO( Struct, Member ) MemberInfo { #Member, alignof( Struct##::##Member ), sizeof( Struct##::##Member ), offsetof(Struct,Member) } [/c]
int main() { constexpr MemberInfo mi = MEMBER_INFO(A, b); return mi.sizeof_; } [/c]
-
Thread
Arrays in C
char* ar; ar = (char*)malloc(sizeof(char)*n); ar[0] = 'g'; ar[2] = '1'; usw...
um die Ohren haut, solche Plattformen soll's geben). Des weiteren garantiert der Standard, daß sizeof(char) == 1 ist, Du kannst also gleich 1*n oder nur n hinschreiben. Das ist per Definition so, weil sizeof(foo) die Größe von foo in Vielfachen der Größe von char angibt und sizeof(char)/sizeof(char
-
Thread
Byteorder PIC32?
<sizeof(T)>{}); } else if constexpr (E == std::endian::big){ [&]<auto... II>(std::index_sequence<II...>) { ((data[sizeof(T) - 1 - II] = std::byte(value >> ((8 * II)))), ...); }(std::make_index_sequence<sizeof(T)>{}); } else { static_assert(std::false_v<T>); } return data; } volatile auto r = 0x04030201; int main() { auto [b1] = bytesOf(uint8_t{0x01}); auto [
-
Thread
Nicht Kompilieren bei einem bestimmten Wert in einem const array
const int test[][4] = {{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4} }; #define ARRAY_COUNT(a) (sizeof(a)/(sizeof(a[0]))) int main() { // Assertions: Parameter 2 jedes Datendsatzes muss kleiner 5 sein // Schleife wird durch -O1 vollständig raus optimiert. for(size_t i=0; i<ARRAY_COUNT(test
if( !(cond)) {assert_by_nonexisting_function__##msg();} \ } while(0) #define ARRAY_COUNT(a) (sizeof(a)/(sizeof(a[0]))) const int test[][4] = {{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,222,3,4},{1,2,3,4}, {1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4}}; /* Const Assertions
-
Thread
Problem mit C Programm
Samuel K. schrieb im Beitrag #1962590: > i < sizeof(float) * size; wo bitte willst du hier sizeof() verwenden?
Samuel K. schrieb im Beitrag #1962590: > i < sizeof(float) * size; Unsinn, i ist doch ein Index i<size ist richtig
-
Thread
Integer-Berechnungen mit grossen Zwischenwerten
sicher? dieser Code liefert bei mir für: [c] long long int n = LLONG_MAX; printf("sizeof(long long int) = %d, n=%lld\n", sizeof(n), n); [/c] den korrekten Output: [code] sizeof(long long int) = 8, n=9223372036854775807 [/code] sowohl auf einem CM4 als auch auf dem PC in VS2019
drin. unsigned geht natürlich auch: [c] unsigned long long m = ULLONG_MAX; printf("sizeof(unsigned long long) = %d, m=%llu\n", sizeof(m), m); [/c] [code] sizeof(unsigned long long) = 8, m=18446744073709551615 [/code] aber keine 128 Bit, auch nicht auf dem 64 Bit Core-irgendwas.
-
Thread
STM32 24Bit Bmp nach 565RGB Format
= f_open(&fsrc, aa, FA_OPEN_EXISTING | FA_READ); //´òÉÏͼƬÎļþÃû res = f_read(&fsrc, &bmp, sizeof(bmp), &br); if((bmp.pic_head[0]=='B')&&(bmp.pic_head[1]=='M')) { res = f_lseek(&fsrc, ((bmp.pic_data_address_h<<16)|bmp.pic_data_address_l)); for(tx=0;tx<bmp.pic_h_l;tx++){
f_open(&fsrc, name, FA_READ); if ( res == FR_OK ) { f_read(&fsrc, (uint8_t *)&bmp, sizeof(bmp), &br); if( (bmp.pic_head[0]=='B') && (bmp.pic_head[1]=='M') ) { f_lseek(&fsrc, ((bmp.pic_data_address_h<<16)|bmp.pic_data_address_l)); for(ty=0;ty<bmp.pic_h_l;ty
-
Thread
typ: "size_t"
stddef.h> The types are .... size_t which is the unsigned integer type of the result of the sizeof operator; ....
Wenn man für die AMD64-Architektur kompiliert, ist häufig sizeof(int) == 4, aber sizeof(size_t) == 8. Deswegen sollte man immer den geeigneten Typ verwenden und nicht "unsigned int" schreiben, wenn man "size_t" meint.
-
Thread
Paramterübergabe pow
1000, 10000, 100000, 10000000 }; double Round(double Zahl, int Stellen) { if( Stellen >= sizeof( Faktoren ) / sizeof( *Faktoren ) ) Stellen = sizeof( Faktoren ) / sizeof( *Faktoren ) - 1; if( Stellen < 0 ) Stellen = 0; long i = Faktoren[Stellen]; ... [/C] Das dürfte
Größe_des_ersten_Array_Elementes T Feld[] = { .... } Größe des kompletten Arrays in Bytes sizeof( Feld ) Größe des ersten Array Elements in Bytes sizeof( *Feld ) oder sizeof( Feld[0] ) oder sizeof( T ) Die Anzahl der Elemente ist daher sizeof( Feld ) / sizeof( *Feld )