-
Thread
Strings und Newlib
dem String selber? und nein. sizeof(file_name) wird ziemlich sicher nicht 5 sein. 4 klingt plausibel, wenn wir davon ausgehen, dass ein Pointer auf deinem System eine Länge von 4 Bytes hat, was bei einem ARM nicht ungewöhnlich sein sollte
sizeof(file_name) liefert 4, weil file_name ein pointer ist. Und der hat wohl 4 byte. Was du willst, kann C von haus aus nicht. strlen () ist dein Kandidat. Damit bekommst du die stringlänge raus.
-
Thread
Library für EA-DOGM Grafikdisplays inkl. Font-Generator
pointer to the selected fonts data */ inline PGM_P font_data(FONT_P font) { PGM_P tmp; if (sizeof(tmp) == 2) tmp = (PGM_P)pgm_read_word(&(font->data)); else memcpy_P((char*)&tmp,&(font->data),sizeof(tmp)); return tmp; } /**************************************************
pointer to the selected fonts data */ inline PGM_P font_data(FONT_P font) { PGM_P tmp; if (sizeof(tmp) == 2) tmp = (PGM_P)pgm_read_word(&(font->data)); else memcpy_P((char*)&tmp,&(font->data),sizeof(tmp)); return tmp; } [/code] Wieso wird hier auf "sizeof(tmp)" verglichen
-
Thread
Out of Memory Error im STM32 mit LWIP
[/c] oder [c] int optval = 1; lwip_setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval)) [/c]
, SOL_SOCKET, SO_RCVTIMEO, (char *)&interval, sizeof(struct timeval)); int tmp = 1; lwip_setsockopt( sock , SOL_SOCKET, SO_REUSEADDR, (const char *) &tmp, sizeof( tmp ) ); lwip_listen(sock,3); return sock; } void http_server_send( const
-
Thread
Frage zu realloc()
_t*)realloc(newLength, sizeof(uint8_t)); } [/c]
und Speicherplatz zuweisen (statisch)? z.B.: uinit8_t * ptr = (uint8_t*)malloc(MAX_SIZE * sizeof(uint8_t)); bool b = false; char c = 'c'; int16_t i = 0; ... usw.
-
Thread
C: Kann man mittels #define einen Wert zurück geben?
einen "byte-Puffer". Dann ist kein Makro für Create: Beispiel: [c] #define STRUCT_SIZE(n) (sizeof(myStruct_t) + sizeof(unsigned)*n) static unsigned char buf_A[STRUCT_SIZE(50)]; p_myA = CreateMyStruct(buf_A, sizeof(buf_A), "myA" ); [/c] Aufruf nur mit Speicher, Größe und Namen. CreateMyStruct
/* und aufruf Deiner Funktion wie bisher */ return _CreateStruct(p, name, a, size/(sizeof unsigned) ); } [/c]
-
Thread
Welchen Sinn hat der Datentyp "bool"?
Wobei der fehlende Ptr viele weitere Dinge impliziert, z.b. Ansicht im Debugger, Arraxs, memcpy, sizeof...
Datentypen keine Angst zu haben, dass nur die unteren Bits beachtet werden. 0x40000 in einen bool mit sizeof(bool) == 1 zu casten, liefert 1. Das gleiche in einen uint8_t zu casten, liefert 0.
-
Thread
Mit C++ feststellen welche Betriebsystem
Die Win32-API-Funktion GetVersionEx machts: osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO) GetVersionEx (&osvi); bIsWindows98orLater = (osvi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) && ( (osvi.dwMajorVersion > 4) || ( (osvi.dwMajorVersion == 4) && (osvi.dwMinorVersion
Etwas ausführlicher als das MS'sche Code-Fragment: OSVERSIONINFO osvi; memset(&osvi, 0, sizeof (OSVERSIONINFO)); osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO) GetVersionEx(&osvi); Das ist bereits die ganze Versionsabfrage. BOOL bIsWindows98orLater = (osvi.dwPlatformId
-
Thread
PROGMEM initialisieren mit verschiedenen Typen
+); switch (display_typ) { case 1 : display_text_P(pgm_ptr); pgm_ptr+= sizeof(display_text_t); break; case 2 : display_long_P(pgm_ptr); pgm_ptr+=sizeof(display_long_t); break; case 3 : display_rechteck_P(pgm_ptr); pgm_ptr+=sizeof
Element der union. Dementsprechend muss man beim Auslesen in der Schleife seinen Zeiger NICHT um sizeof(display_long_t) oder sizeof(display_rechteck_t) weiter setzen, sondern immer um sizeof(display_irgendwas_t), egal welchen Typ man ausliest - wenn man es unbedingt über ein char* hinmurksen will.
-
Thread
array über pointer auslesen
, schonmal was von Pointerarithmetik gehört ? Z.B eine Schleife ... while (ptr <= (Array+(sizeof(Array)/sizeof(int)))) printf("0x%x\n", *ptr++); ...
Edit: So ist es besser while (ptr < (Array+(sizeof(Array)/sizeof(int)))) Gruß Sebastian
-
Thread
Sinn dieses Codes?!
irgendeines/ Typs wie einen 16- oder 32-Bit-unsigned-Int beschreiben zu können. Das setzt voraus, daß sizeof int < sizeof long ist, was z.B. beim AVR der Fall ist. Etwas "portabler" wird das, wenn statt "unsigned int" und "unsigned long" die Typen "uint16_t" und "uin32_t" verwendet werden. Das Konstrukt
Rufus Τ. F. schrieb im Beitrag #5866933: > Das setzt voraus, daß sizeof int < sizeof long ist, was z.B. beim AVR > der Fall ist. Nein. Es ist erstmal egal, wie der User WORD und LONG in seinem Universum interpretiert. Und er kann mit plattformspezifischer Anpassung dieser
-
Thread
Array in GCC
Wieso sollte das nicht gehen? sizeof() wird nicht während der Laufzeit ausgewertet - oder schreibt die avr-gcc Dokumentation da anderes? IMHO wird vom Compiler sizeof(wasauchimmer) zur Übersetzungszeit durch eine Konstante ersetzt.
ist es. Gängige Methode, einen Feldindex bis zum Ende zu zählen ist: for (size_t i = 0; i < sizeof array / sizeof array[0]; i++)
-
Thread
MSP430 UART senden
USCI0TX_ISR(void) { // TX next character UCA0TXBUF = string[i++]; // TX next character if (i == sizeof string - 1) // TX over? UC0IE &= ~UCA0TXIE; // Disable USCI_A0 TX interrupt } [/c]
> { > // TX next character > UCA0TXBUF = string[i++]; // TX next character > if (i == sizeof string - 1) // TX over? > UC0IE &= ~UCA0TXIE; // Disable USCI_A0 TX interrupt > } sizeof? Damit wirst du noch viel Freude haben. Vor allen Dingen bei variabel langen Strings. :-) Warum
-
Thread
Probleme mit malloc und free
unsigned char *GetMem(unsigned int *len) { unsigned char *ptr; ptr = (unsigned char *)malloc(sizeof(unsigned char) * *len); if(ptr == NULL) return NULL; return ptr; } void test(void) { unsigned char *ptr2; unsigned short number = 23; ptr2 = (unsigned char *)malloc(sizeof
Lars schrieb im Beitrag #3629080: > sizeof(unsigned char) Ist gleich 1 per Definition. Aus der Multiplikation also wegfallen lassen.
-
Thread
eDIP 240-7 Problem
strlen nicht, da Befehle 0-Bytes enthalten können. Abhilfe, lege die Befehle im Flash an und nimm sizeof. Und man muß erstmal prüfen, ob der Empfangspuffer groß genug für den nächsten Befehl ist. Peter
; [/c] Und gesendet wird dann mit: [c] #define TFT_FKT(x) tft_wr( sizeof(x) - 1, x, 1 ) [/c] Kommandos sind ja oft konstant und dann geht sizeof. Peter
-
Thread
Pointer verstehen mit malloc und free
printf("pxx: \t%p\t Addr: %p\n\n", ppx, &ppx); } void f2(){ int x = 0; int *px = malloc(sizeof(int)); int **ppx = malloc(sizeof(int *)); *px = x; *ppx = &px; printf("x: \t%d\t\t Addr: %p\n", x, &x); printf("px: \t%p\t Addr: %p\n", px, &px); printf("pxx: \t%p\t Addr:
=NULL; und auch prüfen ob du von malloc auch speicher bekommen hast ! [c] int *px = malloc(sizeof(int)); if(px){}; [/c] Außerdem gibt malloc den Type void zurück besser ist int *px=(int*)malloc(sizeof(int)); warum wirt du noch Festellen
-
Thread
Function-Pointer Problem nach Stromunterbrechung
fn Seh ich mir zb deine menu_init an [C] void ui_menu_init(void){ menu = malloc(sizeof(menu_t)); menuentry_t *entry = malloc(sizeof (menuentry_t)); entry->position = -1; entry->data = "NO ENTRY"; // loop around entry->next = entry; menu->firstentry
eine eigen Funktion [C] menuentry_t *ui_menu_allocEntry() { menuentry_t *newEntry = malloc( sizeof menuentry_t ); if( newEntry ) { newEntry->next = NULL; newEntry->parent = NULL; newEntry->submenu = NULL; newEntry->data = NULL; newEntry->fn = NULL; }
-
Thread
ESPnow sendet nur die ersten 32 Bit
Eine Möglichkeit: Versuch mal ein unsigned char Array zum Testen. Zweite Möglichkeit: sizeof() durch festen Wert ersetzen.
void OnDataRecv(const uint8_t * mac, const uint8_t *temp, int len) { int lenLim =len; if(lenLim>sizeof(inmstrg)) { lenLim = sizeof(inmstrg); } memcpy(&inmstrg, temp,lenLim); Serial.print("Bytes received: "); Serial.println(lenLim); for ( int i = 0; i < 4; ++i ) { // loop through
-
Thread
In Konstruktor dynamisch instanz einer Klasse generieren, vererbung, C++
+) { RGB_STRING::string[i*sizeof(RGB_LED)]->set_colors(red,green,blue); } } void RGB_STRING::write_RGB_STRING() { for (int i=0; i < RGB_STRING::number_of_LEDs;i++) { RGB_STRING::string[i*sizeof(RGB_LED)]->set_LED
fehlt eine Größe. Auch das ergibt in mehrererlei Hinsicht keinen Sinn: [C] > RGB_STRING::string[i*sizeof(RGB_LED)]=(RGB_LED*)malloc(sizeof(RGB_LED)); [/C] > Bei > RGB_STRING::string[i*sizeof(RGB_LED)]->RGB_LED::RGB_LED(); > bekomme ich ein: > Error cannot call constructor 'RGB_LED::RGB_LED' directly
-
Thread
MS Visual C++ 2008, Kommandozeilenargument, zu öffnende Datei
Andreas B. schrieb im Beitrag #2589011: > strncpy(commandlinestring,argv[1], sizeof(commandlinestring)); nein man sollte schon strncpy(commandlinestring,argv[1], sizeof(commandlinestring)-1 ); verwenden und sichersteleln das am ende ein 0 byte steht.
Beitrag #2589027: > Andreas B. schrieb im Beitrag #2589011: >> strncpy(commandlinestring,argv[1], sizeof(commandlinestring)); > > nein man sollte schon > strncpy(commandlinestring,argv[1], sizeof(commandlinestring)-1 ); > > verwenden und sichersteleln das am ende ein 0 byte steht. grml... Da
-
Thread
Artikel und Bibliothek zu Serialisierung
void *memcpy(void *dst, const void *src, size_t len) { size_t i; if ((uintptr_t)dst % sizeof(long) == 0 && (uintptr_t)src % sizeof(long) == 0 && len % sizeof(long) == 0) { long *d = dst; const long *s = src; for (i=0; i<len/sizeof(long); i++)
-
Thread
vorhandenes struct im RAM auf Spiflash oder SDCard speichern
{ if (!f_read(&fil,ptr,sizeof(panel),&bytesread)) { if (bytesread == sizeof(panel)) err = 0; }else{ err = 1; //Read err } f_close(&fil); }else{
if (!f_write(&fil,ptr,sizeof(panel),&byteswritten)) { if (byteswritten == sizeof(panel)) err = 0; }else{ err = 1; //Read err } f_close(&fil); }else
-
Thread
Berechnung " Wieviel Datensätze sind in einer Struktur gespeichert"
uint8_t data4; ExecuteDataFnct execute; } struct Daten AllDaten[10]; #define NR_ALLDATA (sizeof(AllData) / (sizeof(*AllData)) [/c] Nun möchte ich nach der Initialisierung die Anzahl der Datensätze berechnen. Hat vielleich jemand einen Ansatz oder Idee? Danke Thomass
Naja müsste doch einfach mit [c] anzahl = sizeof(Arrayname) / sizeof(Structname) [/c] gehen?
-
Thread
Einmal void-Pointer und zurück
haben, ist ein durchaus legitimer > Wunsch. Zumal man es mit einer Zeile [c] static_assert((sizeof(voidFcn_t)==sizeof(uint8_t*)),\ "Error: Pointers to functions and objects differ in size. Implementation"\ "won't work."); [/c] problemlos automatisch im Auge behalten kann.
Walter Tarpan schrieb im Beitrag #3613708: > Zumal man es mit einer Zeile > static_assert((sizeof(voidFcn_t)==sizeof(uint8_t*)),\ > "Error: Pointers to functions and objects differ in size."\ > "Implementation won't work."); > problemlos automatisch im Auge behalten kann. mit einer gepflegten
-
Thread
Arduino mit neuronalem Netz überlastet?
size[1] = unnamed_idx_1; c->size[0L] = 20; emxEnsureCapacity((emxArray__common *)c, br, (int)sizeof(float)); unnamed_idx_1 = c->size[1]; for (br = 0; br < unnamed_idx_1; br++) { for (cr = 0; cr < 20; cr++) { c->data[cr + c->size[0] * br] = 0.0F; } } if (xp1->size[1]
0] = 20; b_a1->size[1] = a1->size[1]; emxEnsureCapacity((emxArray__common *)b_a1, br, (int)sizeof(float)); unnamed_idx_1 = a1->size[0] * a1->size[1]; for (br = 0; br < unnamed_idx_1; br++) { b_a1->data[br] = a1->data[br] + c->data[br]; } emxFree_real32_T(&c); emxInit_real32
-
Thread
struct übergeben füllen und wieder zurück.
data übergeben ? Also von main -> Func1 und dann -> Func2 ? Und kann ich mit Arrsize = (Data,sizeof(Data) / sizeof(Data[0])) die Anzahl Elemente ermitteln ? und wofür genau steht * am Funktionsnamen in Deinem Beispiel ? Danke , ich glaub das waren genug Fragen für heute.....
Genauer einen Wert vom Typ (unsigned char *). Die Anzahl der Elemente geht mit [c]Arrsize = (sizeof(Data) / sizeof(Data[0]) )[/c] ACHTUNG. Das geht aber nur da, wo das Array auch bekannt ist. In der Funktion machwas() geht das nicht mehr. Und klar kannst du die Daten weiterreichen. Zu der
-
Thread
Linkerskript Fragen
LONG( ADDR(.bss)); LONG( SIZEOF(.bss)); LONG( ADDR(.bss_RAM2)); LONG( SIZEOF(.bss_RAM2)); __bss_section_table_end = .; __section_table_end = . ; /* End of Global Section Table */
ADDR (.bss) 0x00000100 0x4 LONG 0x0 SIZEOF (.bss) 0x00000104 0x4 LONG 0x20000000 ADDR (.bss_RAM2) 0x00000108 0x4 LONG 0x0 SIZEOF (.bss_RAM2) 0x0000010c __bss_section_table_end
-
Thread
Problem mit usb_bulk_write bei libusb
begin ret := usb_get_string_simple(udev, dev^.descriptor.iManufacturer, S, sizeof(S)); if (ret > 0) then begin writeln('- Manufacturer : ', S); if (S[0] = 'W') and (s[1] = 'e') then
failed\n"); usb_close(dev); return 0; } if(usb_bulk_write(dev, EP_OUT, tmp, sizeof(tmp), 5000) != sizeof(tmp)) { printf("error: bulk write failed: %s\n", usb_strerror()); } if(usb_bulk_read(dev, EP_IN, tmp, sizeof(tmp), 5000) != sizeof(tmp)) {
-
Thread
keil array => string
'g'; aChar[8]='\n'; aChar[9]='h'; aChar[10]='\n'; // Array durchlaufen: char iI=0; for(;iI<sizeof(aChar);++iI) { if(aChar[iI]=='\n') { // jetzt aus den vorhergehenden Zeichen den String erzeugen.?.?.? } }[/c]
Heinz B. schrieb: > for(;iI<sizeof(aChar);++iI) > { > if(aChar[iI]=='\n') > { > // jetzt aus den vorhergehenden Zeichen den String erzeugen.?.?.? Wo erzeugst du den String? In welchem Array? > } > } unsigned
-
Thread
Tasten entprellen
, ( 1 << LED2 ) }, { 248, 253, ( 1 << KEY3 ), ( 1 << LED3 ) } }; unsigned char NrStufen = sizeof( Stufen ) / sizeof( *Stufen ); Damit programmieren wir: for( i = 0; i < NrStufen; ++i ) { if( ADCH >= Stufen[i].ADCMin && ADCH <= Stufen[i].ADCMax ) taster &= ~ Stufen[i].
, ( 1 << LED2 ) }, { 248, 253, ( 1 << KEY3 ), ( 1 << LED3 ) } }; unsigned char NrStufen = sizeof( Stufen ) / sizeof( *Stufen ); Damit programmieren wir: for( i = 0; i < NrStufen; ++i ) { if( ADCH >= Stufen[i].ADCMin && ADCH <= Stufen[i].ADCMax ) taster &= ~ Stufen[i].
-
Thread
EEprom lesen und schreiben bei AVR
,sizeof(float)); /* u.r wieder 12.34 */ //... [/c]
// Variable aus dem Ram ins EEprom kopieren eeprom_write_block(&myRamFloat,&myEEpromFloat,sizeof(float)); // Variable aus dem EEprom ins Ram kopieren eeprom_read_block(&myRamFloat,&myEEpromFloat,sizeof(float)); } Gruß Rene
-
Thread
vb to c convertieren
x<8;x++) // auch hier wieder: die 8 kann auch vom Compiler bestimmt // werden for( x = 0; x < sizeof( boot_seq ); x++ ) { printf("%c",boot_seq[x]); } [/C] Anstatt den sizeof da im Code zu verstecken, kann man auch den Präprozessor hier sinnvoll einsetzen [C] char boot_seq[] = { 0xe6,0xf0,0x60,0xfa,0x9a,0xb7,0xfe,0x70 }; #define BOOT_SIZE ( sizeof( boot_seq ) / sizeof( *boot_seq ) ) for( x = 0; x < BOOT_SIZE; x++ ) { printf("%c",boot_seq[x]); } [/C] Hmm. Wer vergibt denn solche Auftraege? Da kann einer nicht ordentlich C und auch
-
Thread
Bitdekodierung aus Bytepuffer
*p; for(p=Dsc; p->z; p++) { signed long i; memcpy(i, data + p->s/8, sizeof(i)); i<<=sizeof(i)-p->n-p->s%8; i>>=sizeof(i)-p->n; p->z=(int16) i; } [/c] Nur für int16 als Ziel und wohl weder lauffähig noch kompatibel sondern so runtergetippt. Ich
müsste selbst erst googeln wie es richtig gemacht wird :D [c] int datatemp[10]; while (i < sizeof(datatp)) { datatemp[cnt] = int((unsigned char)(datapt++) << 24 | (unsigned char)(datapt++) << 16 | (unsigned char)(datapt++) << 8 | (unsigned char)(datatp));
-
Thread
memset() --> Speicher nicht nur auf 0 stellen sondern auf Wert
Wenn ich schreibe : [c]memset(int_array, 0, sizeof(int_array));[/c] dann wird alles schön brav auf 0 gesetzt. Jedoch wenn ich schreibe [c]memset(int_array, 3, sizeof(int_array));[/c] dann wird leider irgendwas in das int_array geschrieben, nur
ERER schrieb im Beitrag #3188694: > Wenn ich schreibe : > [c]memset(int_array, 0, sizeof(int_array));[/c] > dann wird alles schön brav auf 0 gesetzt. > > Jedoch wenn ich schreibe > [c]memset(int_array, 3, sizeof(int_array));[/c] > dann wird leider irgendwas in das int_array geschrieben
-
Thread
AVR "ret" springt zu 0x00
Hugo P. schrieb im Beitrag #4471062: > memset(&can_buffer, 0x00, sizeof(CAN_BUFFER)); Das ist fast sicher falsch (Pointer auf Pointer statt Pointer auf Array). Entweder [c] memset(can_buffer, 0x00, sizeof(CAN_BUFFER)); [/c] oder [c] memset(&can_buffer[0], 0x00, sizeof(CAN_BUFFER)); [/c]
-
Thread
Frage GCC-Tutorial: EEPROM-Variable auf feste Adressen legen
eeprom_t eeprom_ram; void init (void) { eeprom _read_block (& eeprom_ram, & eeprom, sizeof (eeprom_t)); } [/c] Die .eeprom-Section wird dann an die gewünschte Adresse gelegt, üblicherweise ist das 1 weil man 0 aussparen sollte. Als Makefile-Schnipsel: [pre] %_eeprom.hex: %.elf
genutzt werden) #define EE_VALUE1 0x001 // Eine Bytevariable #define EE_VALUE2 EE_VALUE1 + sizeof( unsigned char ) // unsigned char, weil EE_VALUE1 als Byte anzusehen ist #define EE_VALUE3 EE_VALUE2 + sizeof( double ) // weil EE_VALUE2 als double anzusehen ist [/C] Schön ist das
-
Thread
Atmega Dynamische Portzuweisung in Schleife
ports[] = { &PORTA, &PORTC, &PORTD, &PORTE, /* ... */ } for (uint8_t i=0; i<(sizeof(ports)/sizeof(ports[0]); i++) { *(ports[i]) |= /* ... */; } [/c] Wie man drauf kommt? Man liest die Dokumentation: https://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_port_pass
&PORTA, > &PORTC, > &PORTD, > &PORTE, > /* ... */ > } > > for (uint8_t i=0; i<(sizeof(ports)/sizeof(ports[0]); i++) > { > *(ports[i]) |= /* ... */; > } > [/c] > > Wie man drauf kommt? Man liest die Dokumentation: > > https://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_port_pass
-
Thread
gcc und Optimierung
c) { digit_bits db; segment_bits sb; memcpy_P(&db, dbits + (unsigned)(uint8_t)digit, sizeof(db)); if (patternmode) memcpy_P(&sb, sbits + (unsigned)(uint8_t)c, sizeof(sb)); else memcpy_P(&sb, font + (unsigned)(uint8_t)c, sizeof(sb)); for (uint8_t i = 0; i < sizeof(db) / sizeof(db[0]); i++) { SPDR = db[i]; while ((SPSR & _BV(SPIF)) == 0) /* wait */; } for (uint8_t i = 0; i < sizeof(sb) / sizeof(sb[0]); i++) { SPDR = sb[i]; while
-
Thread
[MSP430] Struct Daten auf FLASH Speicher dauerhaft sichern
memcpy(DeinStrukt, SEGMENT_A, sizeof(TS_MAIN_STRUCT));
Lass dir doch die Größe mit SizeOf Berechnen. Kannst du in einer variable zum Test mal ausgeben und im Debugger auslesen....dann weißt du es genau. Kommt ja drauf an, wie der die Padding Bytes einfügt...
-
Thread
Mehrere Texte aus EEPROM per Variablen auswählen
sizeof(meinHilfsString)); LCD_WriteString8x8(meinHilfsString); // } [/c]
eeprom_read_word(&eetext_array1[zaehlvariable]); eeprom_read_block(&meinHilfsString, my_pointer, sizeof(meinHilfsString)); [/c]
-
Thread
Daten via USART senden auf SAM V71
pt_amplitude = (signed char*)&fTFTAmplitude[1][i][finished_result_counter%5]; memcpy(&data[(i*3)*sizeof(float) + config_bytes],pt_amplitude,4); pt_phase = (signed char*)&fTFTPhase[1][i][finished_result_counter%5]; memcpy(&data[(i*(3) + 1)*sizeof(float) + config_bytes],pt_phase,4); pt_frequency = (signed char*)&fTFTFrequency[i][finished_result_counter%5]; memcpy(&data[(i*(3) + 2)*sizeof(float) + config_bytes],pt_frequency,4); } //send_data_function(FUNCTIONCODE_Phasor, data, size); [/c] Da ich also ein Array mit einer gewissen Datengröße übertragen möchte, muss die Übertragung
-
Thread
Projekt wird trotz Parser-Fehlern compiliert. Warum?
required from here /usr/include/c++/8.2.1/bits/unique_ptr.h:79:16: error: invalid application of 'sizeof' to incomplete type 'Ui::MainWindow' static_assert(sizeof(_Tp)>0, ^~~~~~~~~~~ [/code] wie erwartet. Was man aber machen kann, ist einen Destruktor deklarieren und im cpp
from here > /usr/include/c++/8.2.1/bits/unique_ptr.h:79:16: error: invalid > application of 'sizeof' to incomplete type 'Ui::MainWindow' > static_assert(sizeof(_Tp)>0, > ^~~~~~~~~~~ > > wie erwartet. > > Was man aber machen kann, ist einen Destruktor deklarieren und im cpp
-
Thread
C: Überkreuzabhängigkeiten structs in Headerfiles
typedef struct MyStructA > { > uint8 x; > uint8 y; > MyStructB z; > } MyStructA; also: sizeof(MyStructA) >= 2 + sizeof(MyStructB); > typedef struct MyStructB > { > uint8 af; > uint8 fe; > MyStructA be; > MyStructA af; > } MyStructB; also: sizeof(MyStructB) >= 2 + 2 * sizeof
(const B *b) { return b->wert; } B* B_construct (double value) { B *b = malloc (sizeof (B)); b->wert = value; b->pA = NULL; b->pB = NULL; return b; }[/c] Alles, was Module außer a.c über B zu wissen brauchen, ist der Name der Struktur, und alle Module außer
-
Thread
Autodetect Arraygröße bei Definition
> static const tBla Bla[] PROGMEM = "Blubb bla trallalla"; Und für die gerade aktuelle Größe: sizeof(Bla) / sizeof(Bla[0]) Öhh, die Klammern kann man wohl auch weglassen, bin ich bloss kein Fan davon...
[c] #include <stdio.h> int main(void) { const int foo[] = {123, 456, 789}; int le = sizeof foo / sizeof foo[0]; for (int i = 0; i < le; ++i) printf("%d\n", foo[i]); return 0; } [/c]
-
Thread
Maussensor PMW 3310 firmware (ASCII - textfile) einspielen
sehr gut per Block Edit. "const" nicht vergessen, sonst landet der Kram im RAM. Grösse bekommst per sizeof(). Dann durch den SPI (ggf. DMA) in den Sensor klappern. VG, /th.
stimmt :-) [c] const char image[] = { ... } int elements = sizeof(image) / sizeof(image[0]); [/c]
-
Thread
Malloc selber schreiben
heap[i] = 0; } Size_OF_Free_Space = SIZE_OF_HEAP; headerstart = mem_init_alloc(sizeof(struct header)); Size_OF_Free_Space -= sizeof(struct header); headerstart->size = SIZE_OF_HEAP-sizeof(struct header); // Header 12 Byte headerstart->state = 'F'; headerstart->speicher =
== NULL) { help = &heap[SIZE_OF_HEAP - Size_OF_Free_Space]; Size_OF_Free_Space -= sizeof(struct header); headerstart->size = Size_OF_Free_Space; help->size = size; help->state = 'A'; help->next = NULL; help->speicher = &heap[SIZE_OF_HEAP - Size_OF_Free_Space
-
Thread
C++ Codegüte und Operator Overloading
return a+b; } V set (void) { V v; v.v = 123; return v; } unsigned int sizeV = sizeof (V); [/c] Leider ist die Codegröße jenseits von Gut und Böse: Alle Operationen werden über den Frame bzw. this abgewickelt. In dem C-Projekt verwende ich 8-Bit Variablen für Fixpunkt-Arithmetik
const V b) { return a+b; } V set (void) { return V(128); } unsigned int sizeV = sizeof (V); [/c] ARGL, mann bin ich blöd, ich hatte -Os vergessen. Peinlich. Jetzt sieht's schon besser aus :-)
-
Thread
Anzahl buchtaben eines Strings bestimmen
gabs da nicht schon Standard-Methoden wie .sizeof() oder .find()...
Steve F. schrieb im Beitrag #3013542: > gabs da nicht schon Standard-Methoden wie .sizeof() oder .find()... nö, weil c gar keine Methoden kennt.
-
Thread
Routine, die Arrays von Structs kopiert funktioniert unerklärlicherweise nicht.
, &numbers[1] }, { plus, NULL }, { keines, &numbers[2] }, }; #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x)) int main() { double result; result = solve(&Expression[0], &Expression[ARRAY_SIZE(Expression)]); } [/C] Das wird dann bei komplexeren Ausdrücken übersichtlicher und
0.0 }, { keines, 3.0 }, { plus, 0.0 }, { keines, 5.0 }, }; #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x)) int main() { double result; result = solve(&Expression[0], &Expression[ARRAY_SIZE(Expression)]); } [/C] und die solve Funktion natürlich entsprechend anpassen. Da werden
-
Thread
Cmsis RTOS RTX: Stack Kontrolle
unnötiges Rauschen im Forum zu erzeugen: Zeile 51: [c] *stk_used = (size - ((virgin + 1))) * sizeof(stk); [/c] sollte lauten: [c] *stk_used = (size - virgin) * sizeof(stk); [/c] Das mit dem Idle-Task hat mir am Anfang auch sehr viel Kopfzerbrechen bereitet. Aber nachdem was ich so gelesen
nur das was ich wirklich brauche. Notfalls kann man ja auch mit einem assert(max_tasks == (sizeof(task_id_pool)/sizeof(task_id_pool[0])); schwerwiegende Fehler abfangen.
-
Thread
Was ein C++-"Guru" so ueber Geschwindigkeit erzaehlt.
i++) > dst[i] = src[i]; > } Ich haette es so geschrieben: memcpy(dst,src,elements * sizeof(int));
Und übrigens haben auch Compiler eine Vorstellung von memcpy, d.h. auf einer C-Implementierung mit sizeof(int) = sizeof(float) erzeugt sowas wie [c] unsigned type_pun_float (float f) { unsigned u; memcpy (&u, &f, sizeof (int)); return u; } [/c] schon überhaupt keine Kopier-Befehle