-
Thread
Binärdatei auslesen / reinterpret_cast / C++
wie folgt: [c] __time64_t Zeitstempel = 0; datei.read(reinterpret_cast<char*>(&Zeitstempel), sizeof(Zeitstempel));//Ließt Zeit aus [/c] Die Größe der Binärdatei beläuft sich im Moment auf 52MB. Um nun zu vermeiden, dass n Zugriffe auf die Festplatte durchgeführt werden wollte ich ersteinmal alle
[c] while(true) { __time64_t a; double b; double c; char d; fread( h, &a, sizeof( a ), 1 ); fread( h, &b, sizeof( b ), 1 ); fread( h, &c, sizeof( c ), 1 ); fread( h, &d, sizeof( d ), 1 ); //mach was mit a,b,c,d } [/c] fehlerbehandung und abbruchbedingung
-
Thread
MMC karte adressieren 32bit will nicht
Du kannst dir in sd_raw_send_command einmal die sizeof(uint32_t) ausgeben lassen.
SD_RAW_SDHC typedef uint64_t offset_t; #else typedef uint32_t offset_t; #endif[/c] sizeof(uint32_t) gibt 2 zurück. Das ist wohl das Problem. Was nun ?
-
Thread
C Programmierung Array/Funktion/pointer
char *result, int lenght_result) { FILE *ptr_file; char buf[22]; char buf_old[sizeof(buf)]; char candata_needed[4]; //while(1){ ptr_file =fopen("/home/pi/probe.txt","r"); if (!ptr_file){ return 1; } if (fgets(buf,sizeof(buf), ptr_file)!=NULL){ if(memcmp(buf, buf_old, sizeof(buf))) { memcpy(candata_needed, buf + 17, sizeof(buf)); strncpy(result, candata_needed, lenght_result);
-
Thread
strstr() & strncpy()
andere Funktion schicken ... [c] while (1) { res = read(fd, buffer, sizeof(buffer) -1); if (res >=0) { buffer[res]=0; ptr=strstr(buffer, "1-0:21.7.0*255"); char value[6]; strncpy(value
Segmentation fault :( [c] while (1) { res = read(fd, buffer, sizeof(buffer) -1); if (res >=0) { buffer[res]=0; ptr = strstr(buffer, "1-0:21.7.0*255"); char value[10]; strncpy
-
Thread
Probleme beim Schreiben in den Flash-Speicher
1000F000BFCDD002C01FCFE4B3846284BB8498AA72 [/c] Daraufhin habe ich einen kleinen Fehler korrigiert, denn sizeof(data) gibt ja die größe des Arrays in Byte zurück und habe die äußere For-Schleife folgendermaßen modifiziert: Aus [c] for (page_addr = 0; page_addr < sizeof(data)*2; page_addr += SPM_PAGESIZE) [/c] wird [c] for (page_addr = 0; page_addr < sizeof(data)/sizeof(int)*2; page_addr += SPM_PAGESIZE) [/c] Ergebnis im Flash: [c] :10000000C012C019C018C017C016C015C014C01344 :10001000C012C011C010C00FC00EC00DC00CC00B6C :10002000C00AC009C0082411BE1FE5CFE0D4BFDE5E
-
Thread
int Variable ins EEPROM speichern?
reinschreiben Zum Lesen aus dem EEPROM: eeprom_busy_wait (); eeprom_read_block(&setup, 0, sizeof(setup)); Zum Schreiben ins EEPROM: eeprom_busy_wait (); eeprom_write_block(&setup, 0, sizeof(setup));
. /* Write new key to eeprom */ eeprom_busy_wait(); eeprom_write_block((void*) &cur_key, 0, sizeof(cur_key)); eeprom_read_block((void*) &cur_key, 0, sizeof(cur_key));
-
Thread
c++ Newline-Größe für Txt-Dateien auf aktueller Platform ermitteln?
-4932L #define __DEC32_MAX__ 9.999999E96DF #define __SIZEOF_LONG__ 4 #define __DECIMAL_DIG__ 21 #define __gnu_linux__ 1 #define __LDBL_HAS_QUIET_NAN__ 1 #define __GNUC__ 4 #define __FLT_HAS_DENORM__ 1 #define __SIZEOF_LONG_DOUBLE__ 12 #define __DBL_MAX
1E-383DD #define __WINT_TYPE__ unsigned int #define __SIZEOF_SHORT__ 2 #define __LDBL_MIN_EXP__ (-16381) #define __LDBL_MAX_10_EXP__ 4932 #define __DBL_EPSILON__ 2.2204460492503131e-16 #define __SIZEOF_WCHAR_T__ 4 #define __DEC_EVAL_METHOD__ 2 #define
-
Thread
Namen der Com Schnittstellen in VB auflisten
szProperty[256]; GUID guid; ZeroMemory(&spdid, sizeof(spdid)); spdid.cbSize = sizeof(spdid); guid = GUID_DEVCLASS_PORTS; if(INVALID_HANDLE_VALUE == (hDevInfo = SetupDiGetClassDevs(&guid, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT
PSP_DEVICE_INTERFACE_DETAIL_DATA)new BYTE[dwSize])) continue; pspdidd->cbSize = sizeof(*pspdidd); ZeroMemory(&spdd, sizeof(spdd)); spdd.cbSize = sizeof(spdd); if(SetupDiGetDeviceInterfaceDetail(hDevInfo, &spdid, pspdidd, dwSize,
-
Thread
ATtiny85 - bei 3.5kB ist Schluss
0b00000, 0b11111, 0b01110, 0b00100 }; ... byte create[8]; memcpy_P(create,ch_down,sizeof(create)); lcd.createChar(4, create); memcpy_P(create,ch_up,sizeof(create)); lcd.createChar(5, create); ... [/c] LG, Sebastian
Hallo Sebastian, hatte ich so schon probiert, allerdings mit sizeof(quelle) statt sizeof(ziel), also sizeof(ch_up) statt sizeof(create). Warum macht das einen Unterschied? Sind doch beide gleich gross. Gruss, Helge
-
Thread
PWM Tonhöhe und Lautstärke
meine_daten; ISR(TIMER0_OVF_vect) { OCR0A = *pwm_data++; if (pwm_data == (&meine_daten + sizeof (meine_daten)) ){ pwm_data = &meine_daten; // Ende erreicht, neu anfangen } } [/c]
Timerinterrupt routine ist etwas falsch, da der Duty Wert nach (beim) jeden " if (pwm_data == (&Ton + sizeof (Ton)) ){" auf 255 ist, was eigentlich nicht sein darf. Kann jemand die Routine noch mal angucken, bitte? Danke schön. Viele Grüße
-
Thread
8 Array Bytes to float64
übertragen. [c] uint64 tempVar = 0; uint8 eightBitsProByte = 8; for(uint8 i = 0; i < ((sizeof(uint64))); i++) { tempVar |= (dataArray[i] << (eightBitsProByte * ((sizeof(uint64) - 1) - i))); } finalVar = (float64)(tempVar / 10000); //<-- ich glaube hier laufe
richtige Schritt. Über die Signatur, char oder void Pointer lässt sich allerdings streiten. Ein sizeof hinter einem Makro verstecken ist allerdings keine gute Idee.
-
Thread
IR Arduino Remote Receiver für TSOP7000 und Beo4
_2,sizeof(Beo4_TV_2)/4)) { Serial.println("Beo4_TV_2"); } if (IRcompare(numberpulses, Beo4_TV_3,sizeof(Beo4_TV_3)/4)) { Serial.println("Beo4_TV_3"); } if (IRcompare(numberpulses, Beo4_TV_4,sizeof(Beo4_TV_4)/4)) { Serial.println("Beo4_TV_4"); } if (IRcompare(numberpulses, Beo4_TV_5,sizeof(Beo4_TV_5)/4)) { Serial.println("Beo4_TV_5"); } if (IRcompare(numberpulses, Beo4_TV
-
Thread
[ATmega32] Verlassen der Schleife verlässt alle Schleifen
while (x < (sizeof(code) / sizeof(char))) { Das kann der Compiler komplett auflösen und wenn sich z.B. Datentypen ändern (nicht in diesem Fall, aber wenn statt char Strukturen vorhanden sind) muss keine Anpassung
: > > while (x < (sizeof(code) / sizeof(char))) { > > Das kann der Compiler komplett auflösen und wenn sich z.B. > Datentypen ändern (nicht in diesem Fall, aber wenn statt char Strukturen > vorhanden sind) muss keine
-
Thread
8Bit Variablen auf einem 32Bit Mikrocontroller
Probier's aus: "sizeof" existiert.
keiner bezweifelt. Kleines Rätsel für die Compilerkenner. [c] int8_t myarray[4]; int a = sizeof(myarray); [/c] Auf welchem Prozesor kommt für a == 4 raus, und es werden trotzdem 4x16Bit Speicher belegt? ;-)
-
Thread
Parsen klappt nur bis zur ersten Stelle.
sChar++; } } //----------------------------------------------- memset ( au8Value, 0, sizeof(au8Value) ); parse( sString, au8Value, 4 ); // in au8Value sollten jetzt die Ziffern stehen. [/c]
parsedArgs; uint8_t i; char String[] = "12|56|34|58"; parsedArgs = parse( String, Args, sizeof(Args)/sizeof(*Args) ); printf( "Anzahl geparster Argumente %d\n", (int)parsedArgs ); for( i = 0; i < parsedArgs; ++i ) printf( "%d ", Args[i] ); printf( "\n" ); } [/C] Der String
-
Thread
EEPROM macht mich völlig konfus: Kb,B, Word
byte-accesses-with-the-c28x-cpu.html "The TMS320C28x byte is 16 bits. By ANSI/ISO C definition, the sizeof operator yields the number of bytes required to store an object. ANSI/ISO further stipulates that when sizeof is applied to char, the result is 1. Since the TMS320C28x char is 16 bits (to make it separately
byte-accesses-with-the-c28x-cpu.html > > "The TMS320C28x byte is 16 bits. By ANSI/ISO C definition, the sizeof > operator yields the number of bytes required to store an object. > ANSI/ISO further stipulates that when sizeof is applied to char, the > result is 1. Since the TMS320C28x char is 16 bits (to
-
Thread
ARM - Probleme mit sprintf (Linkerfehler)
Tobias Plüss schrieb im Beitrag #4115262: > sprintf(buffer, sizeof(buffer), "%f", 123.456f); Normalerweise sollte float nach double promotet werden, aber für alle Fälle, probier mal: [c]sprintf(buffer, sizeof(buffer), "%f", 123.456);[/c]
snprintf() zu machen. Dann aber: Tobias Plüss schrieb im Beitrag #4115262: [c] sprintf(buffer, sizeof(buffer), "%f", 123.456f); [/c]
-
Thread
Suffix für uint8_t
Array-Größe mal nicht 256 sein sollte. Wenn schon, denn schon: [c]Array[(ZaehlVariable + 20) % (sizeof(Array) / sizeof(*Array))];[/c]
Grössenangaben, also z.B. für einen Index eines Arrays, würde ich jedoch size_t empfehlen. Da der Operator sizeof auf jedes Objekt angewandt werden kann und sein Ergebnis als size_t liefert, kann kein Objekt im Speicher, auch kein Array, mehr als SIZE_MAX Bytes belegen.
-
Thread
Problem mit Struczur in Eeprom zu schreiben!
ich falsch? C-Grundlagen. Eher so [c] eeprom_write_block( &local_config, &Eeprom_config, sizeof(local_config) ); [/c] Besser ist der config_t für den typdef, daran erkennt man einen Typ. Macht die libc vom avr gcc auch so.
eeprom_write_block( & RAM_Data.Foo, & EEP_Data.Foo, sizeof( RAM_Data.Foo ) ); [/c] so sieht das Beispiel aus was ist hier anders? Sorry ich sehe vorlauter Wald den Christbaum nicht!
-
Thread
[C] flexibles Array Memeber in struct initialisieren / memcpy
; struct data *createData(struct data *s, int id, int a_size, float a[]) { s = malloc( sizeof(*s) + sizeof(float) * a_size); s->data_id = id; s->a_size = a_size; memcpy(s->vals, a, sizeof(float) * a_size); return s; } void printData(struct data *s){ printf(
c] struct data *createData(struct data *s, int id, int a_size, float a[]) { s = malloc( sizeof(*s) + sizeof(float) * a_size); ... return s; } [/c] Den Pointer auf "struct data" zu übergeben ist hier ohne Wirkung. Auf folgende Art hast Du wesentlich sinnvolleren Code und man
-
Thread
stm32 HAL UART Receive_IT(.) sendet nur 1 Byte
strlen zaehlen, bis im Speicher irgendwann mal eine 0 steht. Willst du das? Oder wolltest du eher sizeof nehmen? [c] #include <iostream> #include <string.h> using namespace std; char docklight[10]; int main(void) { cout << "strlen is: " << strlen(docklight) << endl; cout << "sizeof is: " << sizeof(docklight) << endl; return 0; } [/c] [pre] $ c++ -Wall -Wextra -o main main.cpp && ./main strlen is: 0 sizeof is: 10 [/pre]
-
Thread
USART von Microcontroller zu GSM Modul funktioniert nicht
r\n"),1000);[/c]. Das "OK" Signal empfange ich mit [c]HAL_UART_Receive(&huart1,(uint8_t *)Reply,sizeof(Reply),1000);[/c] und gebe es am Terminal aus mit [c]HAL_UART_Transmit(&huart2,(uint8_t *)Reply,sizeof(Reply),1000);[/c]. Vielen Dank für die Hilfe! Grüße Sam_oe1
bitte nicht mit sizeof-1 Konstrukten anfangen.
-
Thread
RFM70 Wahnsinn..
); // init address registers in bank 0 writeRegPgmBuf((uint8_t *)RFM70_cmd_adrRX0, sizeof(RFM70_cmd_adrRX0)); //writeRegPgmBuf((uint8_t *)RFM70_cmd_adrRX1, sizeof(RFM70_cmd_adrRX1)); writeRegPgmBuf((uint8_t *)RFM70_cmd_adrTX, sizeof(RFM70_cmd_adrTX)); // activate Feature
); // init address registers in bank 0 writeRegPgmBuf((uint8_t *)RFM70_cmd_adrRX0, sizeof(RFM70_cmd_adrRX0)); //writeRegPgmBuf((uint8_t *)RFM70_cmd_adrRX1, sizeof(RFM70_cmd_adrRX1)); writeRegPgmBuf((uint8_t *)RFM70_cmd_adrTX, sizeof(RFM70_cmd_adrTX)); // activate Feature
-
Thread
Com Port Zugriff unter Windows 7 64 bit mit C++
Schließen: CloseHandle( h ); Lesen: DWORD nBytesRead = 0; char buffer[1024]; ReadFile( h, buffer, sizeof(buffer), &nBytesRead, NULL ); Schreiben: DWORD tmp = 0; char buffer[1024]; WriteFile( h, buffer, sizeof(buffer), &nBytesRead, NULL ); DTR setzen/löschen: EscapeCommFunction( h, SETDTR )
&dw ); if ( dw & MS_RING_ON ) { } Baudrate / Parameter setzen: DCB dcb; dcb.DCBlength = sizeof(DCB); dcb.BaudRate = <BAUDRATE>; dcb.fBinary = TRUE; dcb.fParity = <TRUE/FALSE>; dcb.fOutxCtsFlow = <TRUE/FALSE>; dcb.fOutxDsrFlow = <TRUE/FALSE>; dcb.fDtrControl = <DTR_CONTROL_HANDSHAKE/0>;
-
Thread
C /C++ Daten einlesen von TCP/UDP
serv_addr.sin_addr.s_addr = inet_addr("120.220.0.1"); if(bind(sochfd, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) == -1){ perror("bind()"); } if(listen(sockfd, 5) == -1){ perror("listen()"); } char buffer[1024]; int len; len = sizeof(client); if(recvfrom(sockfd, buffer, 1024, 0, (struct sockaddr
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); if(bind(sochfd, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) == -1){ perror("bind()"); } char buffer[1024]; socklen_t len; len = (int) sizeof(client); if(recvfrom(sockfd, buffer, 1024, 0, (struct sockaddr*) &client, &len) == -1){
-
Thread
Vektor int32_t mit 200 Stellen global
{ 1, -1, 1234, -4321}, {13, 42, 42000, -1337}, // ... }; #define MISCHMASCH_NUM (sizeof(mischmasch_array) / sizeof(*mischmasch_array)) void zeige_werte(void) { for (uint8_t i = 0; i < MISCHMASCH_NUM; i++) { mischmasch_t m; memcpy_P(&m, mischmasch_array + i, sizeof(*mischmasch_array
noch eine kleine Schönheitskorrektur. Statt [c]mischmasch_t m; memcpy_P(&m, mischmasch_array + i, sizeof(*mischmasch_array));[/c] ist es so hübscher: [c]mischmasch_t m; memcpy_P(&m, mischmasch_array + i, sizeof(mischmasch_t));[/c] Nur der Vollständigkeit halber, falls jemand das Beispiel als Vorlage
-
Thread
Dmx senden mit einem 89C52 (8052)
/Main Function void main(void) { for(x=0;x<sizeof(dmxField);x++) { dmxField[x] = 0 ; // Fülle Array mit Werten } //Werte zum Testen dmxField[0] = 0; dmxField[1] = 0; dmxField[2] = 30; dmxField[3] = 250; dmxField
0;x<sizeof(dmxField);x++) { dmxField[x] = 0 ; // Fülle Array mit Werten } dmxStart(); // Superloop for(;;){ dmxField[3] = 0; dmxField[1] = 254; dmxSender
-
Thread
memcpy funktioniert nicht
(&(pStruct->Info),(uint8_t*)pLocalInfo,sizeof(TypeInfo)); [/c] und so: [c] TypeInfo tempInfo; memcpy(&(tempInfo), pLocalInfo,sizeof(TypeInfo)); [/c] Seht ihr in der Verwendung irgendein Problem, oder muss ich den Fehler in pStruct
Hast du mal im Assemblerlisting nachgeschaut, ob [c] memcpy(&(pStruct->Info),pLocalInfo,sizeof(TypeInfo)); [/c] und [c] memcpy(&(pStruct->Info),(uint8_t*)pLocalInfo,sizeof(TypeInfo)); [/c] tatsächlich unterschiedlich übersetzt werden? Ich kann mir das nicht vorstellen und
-
Thread
C -> UART -> Übertragen von Strukturen
Struktur? Aufgrund von Padding nicht sinnvoll auf die dargestellte Weise. Man kann offsetof() und sizeof() auf die Elemente ansetzen. Beschreibt man dann jedes Element als sizeof()/offsetof() Pärchen z.B. in einem Array, kann man sich eine generische Funktion bauen, die Strukturen "verschicken" kann.
MSG_TYPE_EOL }; static const ITEM msg_type_1[] = { {offsetof(Filter_t::uiParameter), sizeof(Filter_t::uiParameter)}, //... }; static const MSG messages[] = { { sizeof(msg_type_1)/sizeof(msg_type_1[0]), msg_type_1 }, //... }; [/code] Dann kann man eine generische Funktion
-
Thread
AVR: Problem mit eeprom_read_byte()
uint8_t VarImEE[40][8] EEMEM; uint8_t letter[40][8]; ... eeprom_read_block( letter, VarImEE, sizeof(VarImEE) ); [/c]
oder nicht? Denn die einzige Verwendung davon ist nur die Abfrage der Arraygröße mit "sizeof(VarImEE)". Da ich weiß, dass ich ab der Adresse 0 auslesen will, klappt es bei mir auch in der Form: [c] eeprom_read_block(&letter, 0, sizeof(VarImEE)); [/c]
-
Thread
Mehrdimensionales char Array
> fgets ( sensorid[i][count], sizeof(sensorid), fp ) sizeof(sensorid) ist die Größe des ganzen Arrays, nicht nur eines einzelnen Eintrages. Ich denke, Du müsstest (neben den anderen oberen Ratschlägen) hier etwas in der Art fgets ( sensorid[i][count], sizeof(sensorid[i][count]), fp ) verwenden.
-
Thread
struct: mehrere variablen erstellen
Bernd Schuster wrote: > mit sizeof (struct data) bekomm ich den speicherplatz raus, der von > einem Buffer benötigt wird, die Startadresse vom Buffer habe ich, aber > wie ich diesen Speicher dann wirklich absichern kann - wahrscheinlich
Buchstaben, die du siehst und ein abschließendes \0 - Character. [c] unsigned physSize = sizeof Puffer; // 1024 unsigned logSize = strlen(Puffer); // 5 - \0 wird nicht mitgezählt. [/c]
-
Thread
Rätselspass für die Pros
Pointerarithmetik wird der nicht Pointer-Typ (in diesem Fall i) vor der Addition noch mit dem sizeof(*i) multipliziert. D.h. da steht dann irgendwann in der Verarbeitungskette des Compilers. j = *(int)( (unsigned char*)i + 5 * sizeof(*i) ); Und das liefert dann tatsächlich das gewünschte:
, dass Indexoperationen auch auf Pointer angewendet werden können: int * pI = malloc( 3 * sizeof(int) ); ... j = pI[2]; Wieder pI[2] <==> *(pI + 2); Anstatt dem Arraynamen i von vorher, steht jetzt bereits direkt ein Pointer da. Ab da läuft dann alles weiter wie im Arrayfall
-
Thread
STM32 GCC unknown typename
Willy M. schrieb im Beitrag #3691584: > sizeof(PEBMessages); Es muss "sizeof(union PEBMessages)" sein in C. Nur in C++ kann man das "union" an der Stelle weglassen. Willy M. schrieb im Beitrag #3691584: > struct BF_SCH_CANHS_R_02 SCH_CANHS_R
sind in C eigene Namespaces. Als üblicherweise entweder union U { ... }; union U *p; ... sizeof(union U) oder typedef union { ... } U; U *p; ... sizeof(U);
-
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
C++ RS485 Frequenz der Datenübertragung / Befehl senden
ahWait[1] = hevtStop; // Wait until something happens switch(::WaitForMultipleObjects(sizeof(ahWait)/sizeof(*ahWait) ,ahWait, FALSE,INFINITE)) { case WAIT_OBJECT_0: { // Save event const CSerial::EEvent eEvent = g_Serial.GetEventType(); // Handle
kann es sein das es an der ausgaben liegt? Denn hier do{ iResult = g_Serial.Read(szBuffer,sizeof(szBuffer)-1,&dwBytesRead); }while(something) würdest ja überhaupt nicht erkennen ob es daten ankommen. Kannst ja mal so testen: int test = 0; do{ iResult = g_Serial.Read(szBuffer,sizeof
-
Thread
kurze gcc Verständnisfrage
; [/c] mit dem Prototyp [c] void doSomething(char *); [/c] und lass mir dort die sizeof ausgeben, kommt irgendwas raus. Anhand des '/0' kann sizeof die Länge ja nicht ermitteln, da der komplette String ja normalerweise zu NULL initialisiert wird. Kann mich jemand aufklären? Viele
Die Software weiß das weil es der Compiler reingeschrieben hat, Zitat Wikipedia: "In most cases, sizeof is a compile-time operator, which means that during compilation sizeof expressions get replaced by constant result-values."
-
Thread
strstr() gibt keinen NULL pointer zurück? (atmega 2560)
uart_char; char_counter++; } uart_string[char_counter] = '\0'; for(int i = 0;i<sizeof(uart_string);i++){ USART_Transmit(uart_string[i]); } char *hier; char x_values[50][7]; char y_values[50][7]; int number_of_coordinates = 0; USART_Transmit(sizeof(uart_string
uart_char; char_counter++; } uart_string[char_counter] = '\0'; for(int i = 0;i<sizeof(uart_string);i++){ USART_Transmit(uart_string[i]); } char *hier; char x_values[50][7]; char y_values[50][7]; int number_of_coordinates = 0; USART_Transmit(sizeof(uart_string
-
Thread
Probleme bei schwieriger c++ Programmieraufgabe
die read Funktion um binaere Daten zu lesen hdr = new WAVEHEADER; fin.read((char*)&hdr, sizeof(WAVEHEADER)) /* TODO */ printWaveHeaderInfos(hdr); return hdr; } /* * Schreibt den Waveheader * \param fin: ifstream. * \param hdr: wavefile hdr * \return: false in case of an
der Main habe ich bereits eingefügt, ebenfalls habe ich bereits die Zeile "fin.read((char*)&hdr, sizeof(WAVEHEADER))" in WAVEHEADER *readWaveHeader(ifstream *fin) {..} eingeführt, jedoch kommt schon da die erste Fehlermedlung. Ich hoffe mir kann jemand ein paar Tipps zu den einzelnen Aufgaben geben
-
Thread
C - Pointer Arithmethik auf Strukturen?
while(fread(&entry[i], sizeof(HIGHSCORE), 1, highscore_file)) { //printf("Test %s - %d\n", entry[i].owner, entry[i].score); i++; } return entry;
file_size = ftell(highscore_file); rewind(highscore_file); entry_count = file_size / sizeof(HIGHSCORE); // Daten allozieren entrys = malloc(entry_count * sizeof(HIGHSCORE)); // Daten auslesen if(entrys > 0) { fread(entrys, sizeof
-
Thread
Index des kleinsten Wertes eines Arrays
, anzahl, min; min = 0; // Zählung ab 0. Element, welches erstmal das Kleinste ist. anzahl = sizeof(a) / sizeof(int); // Größe des Arrays durch die Größe eines Elementes ist die Anzahl der Elemente for (i = 1; i < anzahl; i++) if (a[i] < a[min]) min = i; [/c] Der Code ermittelt den Index des
anzahl, min, min_b; min = 0; // Zählung ab 0. Element, welches erstmal das Kleinste ist. anzahl = sizeof(a) / sizeof(int); // Größe des Arrays durch die Größe eines Elementes ist die Anzahl der Elemente for (i = 1; i < anzahl; i++) if (a[i] < a[min]) min = i; if (min == 0) min_b = 1; // Falls das
-
Thread
Float Variable wortweise swappen
Variable in zwei einzelne 16 Bit Werte. [c] float f = 3.14f; word[2] tmp; memcpy( &tmp, %f, sizeof( float ) ); send( tmp[1] ); send( tmp[0] ); [/c] Union finde ich unsauber
Portabel und allgemein gültig. Senden: [c] float f = 3.14f; word[2] tmp; memcpy( &tmp, &f, sizeof( float ) ); send( tmp[1] ); send( tmp[0] ); [/c] empfangen: [c] float f; word[2] tmp; read( tmp[1] ); read( tmp[0] ); memcpy(&f, &tmp sizeof( float ) ); [/c]
-
Thread
ESP8266 - Error Nachricht beim Start
ICACHE_FLASH_ATTR user_pre_init(void) { if(!system_partition_table_regist(partition_table, sizeof(partition_table)/sizeof(partition_table[0]),SPI_FLASH_SIZE_MAP)) { os_printf("system_partition_table_regist fail\r\n"); while(1); } } void ICACHE_FLASH_ATTR user_init(void) { }
undeclared (first use in this function) if(!system_partition_table_regist(at_partition_table, sizeof(at_partition_table) / sizeof(at_partition_table[0]), SPI_FLASH_SIZE_MAP)){ [/c] Wo ist denn das #define von dieser Konstante?
-
Thread
C++ Objektarray im Konstruktor initialisieren?
nein. Denn ein Objekt von einen Type brauch auch eine definierte Größe. was soll denn sizeof( Fahrrad ) liefern? Man könnte es mit Templates lösen.
cbe schrieb im Beitrag #5135691: > reifen = (Reifen*)malloc(sizeof(Reifen[4])); > for(int i = 0; i < 4; ++i) > new (&reifen[i]) Reifen(245); Sorry, aber malloc und new zu mischen ist Gewurschtel.
-
Thread
Speicherplatz global reservieren?!
Jan H. schrieb im Beitrag #5131491: > uint8_t *buff = (uint8_t *) calloc(11,sizeof(int)); > So versuche ich den Speicherplatz zu reservieren. Ist das falsch? In der > main() klappt es jedoch. Ds geht statisch so nicht ... Du würdest dann einfach uint8_t buff[11*sizeof(
eines calloc(11,sizeof(int)), wobei dann natürlich kein späterer realloc() mehr möglich und ein free() desselben sinnfrei ist.
-
Thread
Elegantes Füllen von Arrays (Netzwerk-Pakete)
destination_mac, 6); > memcpy(&packet[6], source_mac, 6); [c] memcpy(packet, destination_mac, sizeof (destination_mac)); memcpy(packet + 6, source_mac, sizeof (source_mac)); [/c] Und das gleiche Konzept kannst Du natürlich auch für Dein Ethernet-Frame anwenden. [c] char ethernet_frame = {
0x08, 0x00, 0x45, 0x00, 0x00, 0x34}; memcpy(packet + OFFSET_DESTINATION_MAC, destination_mac, sizeof (destination_mac)); memcpy(packet + OFFSET_SOURCE_MAC, source_mac, sizeof (source_mac)); memcpy(packet + OFFSET_ETHERNET_FRAME, ethernet_frame, sizeof (ethernet_frame)); [/c]
-
Thread
comtools Baudrate höher als 57600?
rauszusuchen, um nachzusehen, warum das so gemacht wurde): In ComTools.cpp statt [c] memset(&sDcb,0,sizeof(sDcb)); sDcb.DCBlength=sizeof(sDcb); ... [/c] den DCB zuerst vom System/Treiber ausfüllen lassen und dann die entsprechenden Parameter setzen [c] memset(&sDcb, 0, sizeof(sDcb)); sDcb.DCBlength
, für was dass das gut sein soll, und wie ich das im Code schreiben muss. [c] memset(&sDcb,0,sizeof(sDcb)); sDcb.DCBlength=sizeof(sDcb); if (!GetCommState(hFile, &sDcb)) { CloseHandle(hFile); return 0; } sDcb.BaudRate = Baud; sDcb.fParity = (Parity!=0)? TRUE:FALSE
-
Thread
ATmega128 double Werte in Flash (PROGMEM)
2 Bytes, also 16 Bit. Demnach ist ein Doppelwort 32 Bits breit. > Sieh mal nach welchen Wert sizeof(double) zurück gibt. Ich würde wetten, > daß es > 2 ist. Ja, 4...
memcpy_P(). double testpgm PROGMEM = 1.2345; double Result; memcpy_P( &Result, &testpgm, sizeof( double ) ); muesste das Gewünschte leisten.
-
Thread
Ringspeicher - wie am besten realisieren?
stRingBuffer buf2; void ringBufInit(void) { buf1.ucBuffer = ringBufMem1; buf1.length = sizeof(ringBufMem1)/sizeof(uchar); buf2.ucBuffer = ringBufMem2; buf2.length = sizeof(ringBufMem2)/sizeof(uchar); } Ob sowas auf einem kleinen µC nötig ist mußt du selbst entscheiden. >Und wie
-
Thread
c++ sockets recv
addr = inet_addr( "127.0.0.1"); memcpy( (char *)&server.sin_addr, &addr, sizeof(addr)); } else { //Server-IP-Adresse memcpy( (char *)&server.sin_addr, host_info->h_addr, host_info->h_length ); }
res == -1) { // error } else { // implies (fd.revents & POLLIN) != 0 recv(s,buf,sizeof(buf),0); // we can read ... }