-
Thread
Ich versuch es ja, aber ich werde mit C++ einfach nicht warm :(
spielen soll, oder man den "Komfort" einer Klasse an der Stelle haben möchte (z.B. data.size() anstatt sizeof(data)/sizeof(data[0]). Du must es nicht nutzen. In C++ wurden Arrays nicht abgeschafft. > Das einzige was hier besser werden mag, ist die Arbeit fuer den > Compiler. Für jeden Entwickler, und
Auswertung des Index-Lookup geschieht zur Laufzeit, wobei der Compiler das schon optimiert. Das Konstrukt sizeof(array)/sizeof(item) wurd extra nicht betrachtet, weil nur eingeschränkt nutzbar. Bei einer anderen Variante wird das sichtbarer: [c] uint8_t foo(size_t v) { return v + 1; } int main
-
Thread
Wert aus Array an eine Union übergeben
dieses Problem vor einiger Zeit mit der Funktion memcpy((BYTE*)&OUTPacket,&receivedDataBuffer,sizeof(receivedDataBuffer)) lösen können. Diese Funktion scheint mir während der Laufzeit im µC Probleme zu machen. Vielleicht gibt es eine andere sichere oder einfachere Methode? Bei mir ist eine struct
Rumburak schrieb im Beitrag #4819617: > memcpy((BYTE*)&OUTPacket,&receivedDataBuffer,sizeof(receivedDataBuffer)) Du kopierst 512 Bytes in einen wenige Bytes großen Buffer? Ja, das macht wohl Probleme. Es sei denn, eines der übrigen Elemente der Union ist mindestens 512 Bytes groß. Rumburak
-
Thread
avr-gcc 5.3.1: lto Problem mit Flash > 64k
FRAME_SIZE] PROGMEM = { ... }; uint8_t frame_buffer[FRAME_SIZE]; memcpy_P(frame_buffer, frame_name, sizeof(frame_name)); update_display(frame_buffer); [/c] Das funktioniert bis 64k auch ganz normal mit dem PROGMEM-Attribut. Über der 64k-Grenze sind die Daten ja nicht mehr mit 16bit adressierbar, was
uint8_t frame_buffer[FRAME_SIZE]; memcpy_PF(frame_buffer, pgm_get_far_address(frame_name), sizeof(frame_name)); update_display(frame_buffer); [/c] Das funktioniert auch so weit, ABER: Nur ohne -flto, also ohne link-time-optimizations Wenn man lto aktiviert werden zwar immer noch die richtigen
-
Thread
sizeof von Stringarray
C-Grundlagen! Wort ist ein Zeiger. Und mit sizeof bekommst du die Größe vom Zeiger und *nicht* von dem, worauf er zeigt. Du *musst* die Größe mit einem weiteren Parameter übergeben.
Strings werden in C IMMER als Pointer übergeben. [c] char meinstring[] = "Hallo Welt"; int l = sizeof(meinstring); [/c]
-
Thread
128 Bit Risc
immernoch 32bit breit ist, bei der 64bit Version dann aber doch 64bit! [code] printf("\nsi=%u", sizeof(short int)); printf("\ni=%u", sizeof(int)); printf("\nli=%u", sizeof(long int)); printf("\nlli=%u", sizeof(long long int)); printf("\nf=%u", sizeof(float)); printf("\nd=%u", sizeof(double)); printf("\nld=%u", sizeof(long double)); mgw32: si=2 i=4 li=4 lli=8 f=4 d=8 ld=12 mgw64: si=2 i=4 li=4 lli=8 f=4 d=8 ld=16 [/code] Ich weiß jetzt nicht, wie das beim GCC unter Linux ausschaut, wenn
-
Thread
STM32F429 WM8789 MP3
als Header -> Decodefehler) my_frame_size = 0; while ((my_frame_size < 2) || (my_frame_size > sizeof(filebuff)-10)){ //jaja, Billig FIFO filebuff[0] = filebuff[1]; filebuff[1] = filebuff[2]; filebuff[2] = filebuff[3]; filebuff[3] = fgetc(file_fd); my_frame_size = mp3decode_findheader
restlichen Frame nachladen (Offset von 4, den Header haben wir ja schon) fread ((void*)&filebuff[4], sizeof(char), my_frame_size - 4, file_fd); //In den Decoder kippen [/c]
-
Thread
Verkettete Liste für Mikrocontroller Gesperrt
nicht so wie es sein sollte. Was mache ich hier falsch? [c] node pnode; pnode = (node)malloc(sizeof(struct list_node)); insert_right(pnode, 123); insert_right(pnode, 345); [/c]
[c] void main(void) { node pnode; pnode = (node)malloc(sizeof(struct list_node)); [/c] Normalerweise nimmt man einen Nullzeiger, um eine leere Liste anzuzeigen. Keinen leeren Knoten. Wie willst Du den denn schnell erkennen ? Also : [c] void main(void
-
Thread
Strings direkt in Funktion eintragen
Adressen, d.h. der "call by reference" ist implizit. Deswegen ist es auch nicht möglich, den sizeof-Operator in einer Funktion auf ein (vermeintliches) Array-Funktionsargument anzuwenden. Oh, und auf dem AVR solltest Du dran denken, daß die Stringkonstanten kostbares RAM(!) belegen.
-
Thread
init typedef , structure , bitfield c code
mask3.c); printf("Mask8: %d a:%d b:%d c:%d\n", mask8, mask8.a, mask8.b, mask8.c); // test sizeof struct: printf ("Groesse struct (3) : %d\n", sizeof(struct bitfields3) ); printf ("Groesse struct (8) : %d\n", sizeof(struct bitfields8) ); // test sizeof type printf ("Groesse typedef (3) : %d\n", sizeof(bitfields3_t) ); printf ("Groesse typedef (8) : %d\n", sizeof(bitfields8_t) ); } [/c] sizeof stimmt bei struct und type (1) Wo liegt aber mein Denkfehler für die vorgesehene Wert Ausgabe
-
Thread
Was mache ich falsch mit pointer, array
vorhanden"); nl return 0; } } return matrix; } [/c] > matrix=malloc(zeile*sizeof(int)); Das ist Murks. matrix ist kein int*, sondern ein int**, also ist hier sizeof int nur dann zufälligerweise korrekt, wenn sizeof int == sizeof int* ist. Warum übergibst Du der Funktion
Rufus Τ. F. schrieb im Beitrag #4807215: > *matrix = malloc(zeile * sizeof (int*)); Ich würde den Compiler selber den richtigen Typ finden lassen: [C] *matrix = malloc(zeile * sizeof **matrix); [/C] > *matrix[i] = malloc(spalte * sizeof (int)); > if (*matrix
-
Thread
GCC - Rundungsfehler ?
float sein Um es zu präzisieren: AVR-GCC verwendet für float und double den gleichen Datentyp; sizeof float == sizeof double == 4. Es hat sich bislang niemand die Mühe gemacht, 64-Bit-floatingpoint-Aritmetik auf den AVR zu portieren.
sein > > Um es zu präzisieren: > AVR-GCC verwendet für float und double den gleichen Datentyp; sizeof > float == sizeof double == 4. > > Es hat sich bislang niemand die Mühe gemacht, > 64-Bit-floatingpoint-Aritmetik auf den AVR zu portieren.
-
Thread
Pointer String mit PROGMEM?!
flashtexts.h #ifndef FLASHTEXTS_H #define FLASHTEXTS_H #undef TEXT #define TEXT(NAME,VALUE) NAME[ sizeof(VALUE) ]; extern const __flash struct { #include "flashtexts.inc" } texts; #endif [/c] 3) C Modul worin die Texte angelegt werden: [c] // flashtexts.c #include "flashtexts.h" #undef
-
Thread
Lazarus: Wo ist mein Fehler bei "Blockread"?
Reset(log_datei,1); while not Eof(log_datei) do begin blockread(log_datei,x,sizeof(x)); end; Einfach die Datai ab.log öffnen, aber es kommt immer Run-Error (100) Wer kann mir da bitte kurz helfen? Vielen Dank
sein ... Ob Reset(log_datei,1); in Ordnung war, kann man Überprüfen. Ob blockread(log_datei,x,sizeof(x),gelesen); in Ordnung ist kann man... Die Schreiber der Funktionen/Prozeduren haben es zumindest vorgesehen.
-
Thread
40 Bit in 5 Bytes abbilden mit Bitfeld
Hast Du dir mal sizeof(tx_data) angesehen? Ich würde erwarten, dass entweder die Größe nicht deinen Erwartungen entspricht, oder aber Padding Bits an stellen sitzen, an denen Du sie nicht erwartest.
Micha schrieb im Beitrag #4802124: > Hast Du dir mal sizeof(tx_data) angesehen? Mathias G. schrieb im Beitrag #4801393: > Ich komme auf 8 Byte
-
Thread
rf Empfänger-Sketch
buf[i]); } sscanf(StringReceived, "%i", &ledData); } memset( StringReceived, 0, sizeof(StringReceived)); delay(1000); Serial.println(ledData);} doch es wird immer nur 0 im Seriellenmonitor ausgegeben. Ich weiß nicht wo der Fehler hier liegt. Kann mir da jemand helfen? heike.
-
Thread
Probleme mit "Asyncroner" Verarbeitung bei C
//aufgabe 1 ausführen } //selbiges gilt auch für aufgabe 2... for( t = 0; t < (sizeof( cnt ) / 4); t++ ) { cnt[t]++; } int tSleep = speed * 5 * 1000; // ca 5ms usleep( tSleep ); } return 0;[/c] ich weiß, dass ich hier keine genauen zeiten hinbekomme... das
.. einen SLEEP kann ich nicht einbauen, weil sonst das programm steht :( [c]for( j = 0; j < (sizeof( cmd ) / 4); j++ ) { printf( cmd[j] ); // HIER BRAUCH ICH DIE PAUSE, ABER SO, DASS MEIN HAUPTSCRIPT WEITERLÄUFT }[/c]
-
Thread
Falsche Bytefolge bei UART-Übertragung
ankommenden Bytes. */ read_message = fread(&message_array, sizeof(char), sizeof(message_array), uart_pointer); if (read_message != sizeof(message_array)) // Konnten alle Bytes gelesen werden? { printf("Es ist ein Fehler beim Auslesen der UART-Schnittstelle
-
Thread
windows7 comm port event problemm
ihr könnt mir helfen, find den Bug einfach nicht. [c] --COMN INIT-- memset( &sOverlRd, 0, sizeof(OVERLAPPED) ); sOverlRd.hEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); memset( &sOverlWr, 0, sizeof(OVERLAPPED) ); //If the 2nd parameter is TRUE, the function creates a manual-reset
released. sOverlWr.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); memset( &sOverlSt, 0, sizeof(OVERLAPPED) ); sOverlSt.hEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); hCOM = CreateFile( pname, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL ); SetCommMask
-
Thread
std::array of objects in initializer list
typename ...Ts > struct unroll_actors< std::tuple< Ts... > > { static const actor actors[ sizeof ...(Ts) ]; }; template < typename ...Ts > const actor unroll_actors< std::tuple< Ts... > >::actors[ sizeof ...(Ts) ] = { generate_actor< Ts >::a... }; template < typename A, typename B > struct
Iterator last) { using T = typename std::iterator_traits<Iterator>::value_type ; char buffer[sizeof(std::array<T,N>)] ; auto *p = reinterpret_cast<std::array<T,N>*>(&buffer) ; for (size_t i=0 ; i<N ; ++i) { if (first == last) throw std::runtime_error("make_array:underflow") ;
-
Thread
Problem mit For Schleife
; uint16_t min[MIN_LENGTH]; uint16_t max[MAX_LENGTH]; // initialize memset(min, 0, sizeof(min)); memset(max, 0, sizeof(max)); // do measurements for(uint16_t i = 0; i < NR_OF_MEASUREMENTS; i++) { value = GET_MEASUREMENT_VALUE(); // check with minima for(uint16
-
Thread
Informationen zu C vs C++ / aka Futter für die Diskussion
just enough memory to store "big_lambda" auto del_big_lambda { delegate<int(), spec::inplace_triv, sizeof(big_lambda)>(big_lambda) }; [/c] Ebenfalls erwähnenswert ist, dass delegate 3x verschiedene Konfigurationen besitzt. Dies ist am 2. Template Parameter ersichtlich. Je nach benötigtem Verhalten
Funktionen etwa 3.5x, für Lambdas 1.75x schneller. /edit Die Default Größe von Delegate ist mit "sizeof(size_t) * 4" für die in diesem Forum am häufigsten verwendeten Platformen natürlich etwas groß gewählt... also aufpassen hier.
-
Thread
Multi-dimensionale Arrays mit unterschiedlichen Größen in C
kostet aber dann je Befehl 5 Byte mehr Speicher. Unschön! [c]#define MAKE_CMD_ENTRY(cmd) { sizeof(cmd), cmd } typedef struct { const uint8_t size; sonst uint8_t* cmd; } CMD; const uint8_t Steuerung_Befehl_A[] = {<n=3>}; const uint8_t Steuerung_Befehl_B[] = {<n=18>}; const uint8
-
Thread
EEPROM Verständnis
value); } eeprom_read_block (PWM_Values_OFF, 0x00, sizeof(PWM_Values_OFF)); eeprom_read_block (PWM_Values_STD, 0x12, sizeof(PWM_Values_STD)); eeprom_read_block (PWM_Values_AKT, 0x24, sizeof(PWM_Values_AKT)); SendToLamps
-
Thread
RS485 bus mit Fleury Uart
received = 0; c = uart_getc(); // receive data uart_gets( Line, sizeof( Line ) ); UCSR0A |= (1<< MPCM0); // set MPCM-bit lcd_setcursor(0,3); lcd_string(Line); counter +=1; lcd_setcursor(0,4); lcd_string
-
Thread
Raspberry Pi In C system() verwenden um Kommandobefehle auszuführen und Inhalt speichern
das Modell: [c] GPIO = fopen("/sys/class/thermal/thermal_zone0/temp", "r"); fgets(Daten, sizeof(Daten), GPIO); fclose(GPIO); printf("Temperatur ist:\n"); printf("%s", Daten); GPIO = fopen("/sys/firmware/devicetree/base/model", "r"); fgets(Daten1, sizeof(Daten1), GPIO); fclose
-
Thread
Vektor "Rechnung" mit C
++) a[index_V][index_U] = (double)(index_U * index_V); memcpy(b, a, 50*50*sizeof(double)); for(size_t index_U = 0; index_U < 50 ; index_U ++) for(size_t index_V = 0; index_V < 50 ; index_V ++) printf("%d %d %f %f\n", index_V,index_U,b[index_V][index_U
Elemente mit den Indizes 2 bis 9 zu kopieren, schreibst du: [c] memcpy(ziel, array+2, 8*sizeof array[0]); [/c] Falls du kein Freund von Zeigerarithmetik bist, kannst du statt array+2 auch &array[2] schreiben, was exakt dasselbe ist. Das funktioniert unabhängig vom Elementyp des Arrays
-
Thread
"Driverless" HID, bidirektional, je 64 Byte - möglich?
DSC_RPT, // Report descriptor type HID_RPT01_SIZE,0x00, //sizeof(hid_rpt01) report descriptor /* Endpoint Descriptor */ 0x07,/*sizeof(USB_EP_DSC)*/ USB_DESCRIPTOR_ENDPOINT, //Endpoint Descriptor HID_EP | _EP_IN, //EndpointAddress
code string descriptor const struct{uint8_t bLength;uint8_t bDscType;uint16_t string[1];}sd000={ sizeof(sd000),USB_DESCRIPTOR_STRING,{0x0409 }}; //Manufacturer string descriptor const struct{uint8_t bLength;uint8_t bDscType;uint16_t string[27];}sd001={ sizeof(sd001),USB_DESCRIPTOR_STRING, {'A'
-
Thread
Cortex-M0: FreeRTOS + UART-Interrupt = Problem.
} uint8_t lower_heap[5*1024]; HeapRegion_t xHeapRegions[] = { { (uint8_t*)lower_heap, sizeof(lower_heap) }, { NULL, 0 }, { NULL, 0 } }; /* Main Program */ int main (void) { Board_Init(); USB_Init(); CLI_Init(); /* Setup UART for 38.4K8E1 */ Chip_UART_Init(LPC_USART
-
Thread
dsPIC33EV32GM102 Direct Memory Access
unsigned int i, k, n; unsigned int j = 0; unsigned int number_of_bytes = sizeof(data_bytes)+1; n = (number_of_bytes/8)+1; //determine how many messages are needed if(number_of_bytes % 8 == 0) n--; for(k=0;k<n;k++) //send n messages { for(i=0
-
Thread
Interessante g++ Erweiterung für user-defined literals
operator<< (T& dst, FlashConst<~>& src) { pgm_read_block((void*)&dst, (const void *)src.addr(), sizeof(D)); }[/c] (Das ist nur das Konzept und hat Auskassungen (die beiden "~") sowie wurde auf dem Pad getippt, hat also sicher Syntax-Probleme) Das geht für die Strings des TO mit einer operator
-
Thread
Konstanter String - zu lang!?
Was sagt denn sizeof() im ersten Fall? Kann man das Array händisch mit byte MyArray[3456] fix auf die richtige Größe definieren?
ein Icon usw.). Hast du beim Aufruf mal die Länge mit übergeben? [pre] client.write(MyString,sizeof(MyString))[/pre]
-
Thread
Auf Strukturen in Funktion zugreifen
0; x < 10; x++) { p[x].u16_Age = x; p[x].u16_pow = x*x; } print_structs(p, sizeof(p)/sizeof(Person_t)); } [/c]
-
Thread
dsPIC33EV ECAN-DMA Problem
unsigned int i, k, n; unsigned int j = 0; unsigned int number_of_bytes = sizeof(data_bytes)+1; n = (number_of_bytes/8)+1; //determine how many messages are needed if(number_of_bytes % 8 == 0) n--; for(k=0;k<n;k++) //send n messages { for(i=0
-
Thread
Seriell Schnittstelle Steuerleitungen
printf("Fehler: Device kann nicht geöffnet werden.\n"); return 1; } memset(&options,0,sizeof (struct termios)); cfmakeraw(&options); cfsetispeed(&options,B9600); cfsetospeed(&options,B9600); tcsetattr(fd,TCSANOW,&options); tcflush(fd,TCIOFLUSH); int i; printf("TEST
-
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
AtTiny85 - Software UART die Zweite
/CK/2 OCR1A = 1; TIMSK |= (1<<OCIE1A); //enable compare interrupt queue = (char*)malloc(sizeof(char)); sei(); //Enable Interrupts } void printChar(char c){ queue[queueLength] = c; queueLength++; enablePrinting = 1; } int main(void) { DDRB |= (1<<PINB3); //PINB1 as output
Ich vergaß: >queue = (char*)malloc(sizeof(char)); Ist natürlich Unsinn. Immer eine feste Portion Speicher reservieren, widerspricht dem Konzept der dynamischen Speicherverwaltung. In diesem Falle ist es sinnvoller einen fixen Speicherbereich