-
Thread
Unterschied zwischen Zeiger und Referenz
bekommt die Adresse des referenzierten Objekts, analog mit sizeof. Was du wohl meinst, ist daß man an eventuelle Hilfsdaten (heimlicher Zeiger o.ä.) nicht herankommt.
ich vom Adressoperator bei einem pointer und was bei einer > Referenz? [code] int * pI; sizeof( pI ) -> die Größe der Pointervariablen sizeof( *pI ) -> die Größe dessen, worauf der Pointer zeigt. In diesem Fall die Größe eines int int i; int& j = i; sizeof
-
Thread
WriteFile und ReadFile
Wie frage ich denn dwBytesRead ab? So? [CODE] int laenge_read_buffer = sizeof (dwBytesRead); [/CODE] Bin gerade unterwegs und kanns nicht testen.
// end of message break; } read_index++; } if(read_index == sizeof(read_buffer)) { //error occurred (buffer overflow). Report to user return -1; } read_buffer[read_index] = '\0'; wchar_t print_buffer[sizeof(read_buffer)]; mbtowc
-
Thread
Offset eines Struktur-Elements bestimmen ohne vorhandene Variable
typeA_t varA; typeB_t varB; int main (void) { eeprom_read_block (&varA, &eeprom.varA, sizeof (varA)); eeprom_read_block (&varB, &eeprom.varB, sizeof (typeB_t)); return 0; } [/c] Beim Zugriff hat man die entsprechenden Objekte doch zur Hand.
<eeprom source address>; copy_from_eeprom_to_ram(&ram_destination, &(eeprom_source->common), sizeof(common_data)); [/c] Ach ja, alles unter der Annahme man hat das Allignment im Griff.
-
Thread
STM32F105 Parameter im Code zur Laufzeit updaten
FLASH_ErasePage(0x08019200); FLASH_ProgramWord(0x08019200, data1); FLASH_ProgramWord(0x08019200 + sizeof(uint32_t), data2); FLASH_ProgramWord(0x08019200 + 2 *sizeof(uint32_t), b); FLASH_ProgramWord(0x08019200 + 3 * sizeof(uint32_t), c); FLASH_ProgramWord(0x08019200 + 4 * sizeof(uint32_t), (uint8
FLASH_ErasePage(0x08019200); FLASH_ProgramWord(0x08019200, data1); FLASH_ProgramWord(0x08019200 + sizeof(uint32_t), data2); FLASH_ProgramWord(0x08019200 + 2 *sizeof(uint32_t), b); FLASH_ProgramWord(0x08019200 + 3 * sizeof(uint32_t), c); FLASH_ProgramOptionByteData(0x08019200 + 4 * sizeof(uint32
-
Thread
Wie seriellen String empfangen?
... int Line [40]; // Puffer für "Line" anlegen uart_gets( Line, sizeof (Line) / sizeof (Line[0] )); [/c] Somit ist Line vom Typ int* und nicht char* wie erwartet. Und Zeile 93: [c] x = Line;[/c] x ist ein int und Line ist ein Array. Das geht nicht.
int Line [40]; // Puffer für "Line" anlegen uart_gets( Line, sizeof (Line) / sizeof (Line[0] )); Ähm. uart_gets will ein char Array, in welches es den Text hineinlegt, den es empfangen hat! Text, nicht Zahl! x = Line; Was versprichst du dir davon?
-
Thread
PROGMEM Array an Funktion übergeben
_t step = 0; uint8_t sizePattern = sizeof(pattern)/sizeof(pattern[0]); ledValue1 = pgm_read_byte(patter[step]); step++; } [/c]
kann ich mit sizeof(pattern) nicht die Größe auslesen. > Ergebnis ist immer 1. Siehe oben.
-
Thread
Blöde warning
die Zuweisung ist vollkommen legitim, ist halt "Zeigerarithmetik". Nein, das wäre sie nur, wenn sizeof (uint8_t) == sizeof (void*). Das aber ist nicht der Fall. "Legal" wäre sie, wenn n vom Typ uint16_t wäre. (Vorausgesetzt, daß sizeof (void*) == 2 ist, was auf 8-Bit-Maschinen wie AVR etc.
Zuweisung ist vollkommen legitim, ist halt "Zeigerarithmetik". > > Nein, das wäre sie nur, wenn sizeof (uint8_t) == sizeof (void*). Bei einem type cast ist in klassischem C89 fast alles zulässig was sich irgendwie in Code umsetzen lässt. "To cast" heisst nicht zufällig "wegwerfen", und das Ergebnis
-
Thread
Struct Array an Funktion übergeben
dieser Stelle äquivalent zu &arr[0] my_array* p2 = &arr; printf("Größe von arr: %zd\n", sizeof arr); // bei sizeof ist &arr[0] nicht äquivalent zu arr printf("Größe von &arr[0]: %zd\n", sizeof &arr[0]); printf("Größe von dem, worauf p1 zeigt: %zd\n", sizeof *p1); printf("Größe von dem, worauf p2 zeigt: %zd\n", sizeof *p2); } [/c]
-
Thread
Speicherverwaltung bei modularer Echtzeitsoftware
zusätzlich mitführen. Eine Variable ist dagegen dem Compiler bekannt, ihr Name ist die Startdaresse und sizeof() ihre Länge.
wie oben in main allokiert wird, weil im Modul kann man ja kein sizeof verwenden. sizeof funktioniert ja nur in main. Einfachste Lösung ist get_alloc_size() zu übergeben oder im Modul aufzurufen. Ist immer noch weitaus billiger als malloc. Eine denkbare Bremse
-
Thread
Neuling: Latch Signal an Spielekonsole auslesen
digitalWrite(datapin,HIGH); latches = 0; clocks = 0; } void loop(){ Serial.println((sizeof(input) / sizeof(input[0]))); while(true){ } } void clockfunction(){ counter++; for(int j=0;j<(sizeof(input) / sizeof(input[0]));j++){ if(input[j]==counter+1) {
digitalWrite(datapin,HIGH); } } void latchfunction(){ counter = 0; for(int i = 0;i<(sizeof(input) / sizeof(input[0]));i++){ if(input[0] == 0){ digitalWrite(datapin,LOW); } } } [/code]
-
Thread
Atmega32U2, LUFA, mehrere HID Geräte
PROGMEM ConfigurationDescriptor = { .Config = { .Header = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration}, .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t), .TotalInterfaces = 3, .ConfigurationNumber
.HIDReportType = DTYPE_Report, .HIDReportLength = sizeof(GenericReport) }, .HID_ReportINEndpoint = { .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, .EndpointAddress
-
Thread
C-Problem Funktionsaufruf
her, aber darf man char * wirklich so initialisieren? ich haette char *XString = mallo( sizeof(char) * 3 ); *XString = "ABC"; return XString; erwartet.
> char *XString = mallo( sizeof(char) * 3 ); Yep, mein Buch zielt in etwa auf die gleiche Lösung. Werd wohl n paar Basics auffrischen müssen...
-
Thread
Wie Array übergeben?
Problem. Du kannst die Grösse mit übergeben. [c] int Func1 (char buf [128]) { ... ... sizeof (buf); } int Func (char buf [128]) { int success; buf[index]..... ... sizeof (buf); Func1 (buf); return success; } main { char buf[128]; Func (buf); } [/c]
Kleine Anmerkung noch zu Deiner sizeof Frage. Es ist ein Irrtum anzunehmen, das sizeof innerhalb einer mit Func (char * buf) deklarierten Funktion die Grösse "falsch" zurückgibt. Es gibt die Grösse durchaus richtig an. Aber, im Gegensatz
-
Thread
C++/placement new: irgendein Grund warum std::string problematisch sein sollte?
{ char buffer[sizeof(std::string)]{}; std::string* c = new (buffer) std::string(); std::string& rc = *c; rc = "hallo"; rc = "bert"; rc = std::string("uwe"); rc.assign(std::string
in dem buffer initialisiert jetzt ist im buffer der Aufbau --- 0: sizeof(double) bytes 8 8: sizeof(int8_t) bytes 1 10: sizeof(std::string(der hat selbst einen Zeiger)) bytes (~30-40) --- der buffer sieht jetzt exakt so aus wie ein C++ struct der Art im Speicher -
-
Thread
Extension: Enum kann mit char*
"GETFILE", "SETFILE", }; uint8_t cmpEnum( char*c){ for (uint8_t i = 0 ; i >= sizeof(c)/sizeof(char); i++){ // "sizeof(c)/sizeof(char)" get elements of char* Array if (strcmp(c , getEnumMODEString[i]) !=0 ) return i ; } } bool setMode(char* c ){ switch (cmpEnum
> for (uint8_t i = 0 ; i >= sizeof(c)/sizeof(char); i++) Da i bei 0 nicht die Bedingung erfüllt ist es völlig unerheblich, dass sizeof(c) nicht das ist, was hier beabsichtigt ist. ;-)
-
Thread
need help AVR Atmel eeprom STRING oder array of char
ist keine Ahnung, man versucht ja alles wenns nicht klappt eeprom_read_block(setup_loc, tach, sizeof(tach)); // eeprom_read_block((void *)setup_loc, (const void *)tach, sizeof(tach)); sei(); // ob's noetig ist keine Ahnung, man versucht ja alles wenns nicht klappt Serial.print(F("\n\n sizeof(tach):")); Serial.println(sizeof(tach)); // klappt // sizeof(tach):14 Serial.print(F(" sizeof(i2c_found):")); Serial.println(sizeof(i2c_found)); // klappt auch, zumindest sizeof() wird richtig erkannt // sizeof
-
Thread
strlen() und __flash (Atmel Studio7)
das Problem? [C] ... const __flash char s[] = "Irgendein Text"; ... c = strlen(s); c = sizeof(s); ... [/C]
: %i\n", strlen(x)); printf("sizeof: %i\n", sizeof(x)); return 0; } [/c] strlen gibt 5, sizeof 200 zurueck. Der Unterschied sollte halbwegs offensichtlich sein. Peter schrieb im Beitrag #4835558: > strlen gibt nicht die
-
Thread
C: int * rückgabewert bei einer Funktion
stdlib.h> int main() { int n = 30; int index = -1; int * zeiger = (int *) malloc(n * sizeof(int)); randomZeiger(zeiger, n); print_memory(zeiger, n); int * index_zeiger = &index; firstEight(zeiger, n, index_zeiger); printf("index: %i", index); } void print_memory
firstEight(int * memory, int size, int * index) { int i; int *return_z = (int *) malloc(sizeof(int)); for(i = 0; i < size; i++) { if( memory[i] == 8 ) { *index = i; return_z = &memory[i]; return(return_z); } } return(NULL
-
Thread
SPI Komunikation
} ISR(SPI_STC_vect) { byte c = SPDR; //kopieren der Daten von SPI Buffer if (pos < sizeof buf) { buf [pos++] = c; //hinzufuegen des naechsten Zeichens if (c == '\n') senden = true; } } void Paket_Text() { if (pos1 < sizeof buf1) for (const char * p =
Hallo, ich habe da so mein Problem mit der Schreibweise von sizeof(<type>) in deinem Code. Ich kenne die Anwendung nur als Funktionsaufruf: https://www.geeksforgeeks.org/sizeof-operator-c/
-
Thread
Probleme mit dynamischem 2dimensionalem Array in C
buffer); if(new_packet_pointers > 0){ *buffer = (int **)realloc(**buffer, new_packet_pointers*sizeof(int *)); // <-- if(*buffer == NULL) return 1; } /* Allozieren des Speichern für das Paket */ *buffer[packet_number] = (int *)malloc(packet_size*sizeof(int)); if(*buffer[packet_number
nr_of_packets(*buffer); if(new_packet_pointers > 0){ *buffer = realloc(*buffer, new_packet_pointers*sizeof(Array_1)); if(*buffer == NULL) return 1; } /* Allozieren des Speichern für das Paket */ *buffer[packet_number] = malloc(packet_size*sizeof(ArrayType)); if(*buffer[packet_number
-
Thread
größter Wert eines Array
, counter=0; for (i = 1; counter < min; i++) { counter = 0; max_val = feld[((sizeof feld)-i)]; for (j=0; j < sizeof(feld); j++) { if (feld[j] == max_val) { counter++; } } } return max_val; } int main(void) {
find_max_value (char *feld, uint8_t min, uint8_t max_val) Innerhalb von find_max_value() liefert dir sizeof(feld) die Größe des Pointers (4 Bytes vermutlich).
-
Thread
Vergleichsoperatoren und Typen abhängig?
} Controller_ID=temp_Controller_ID; eeprom_write_block(&Controller_ID,(void *)0x0080,sizeof Controller_ID); Key = 0; }
Übrigens ist noch ein weiter Fehler drin, denn "%d" gilt für "int", nicht für "int16_t", passt nur wenn sizeof(int16_t) <= sizeof(int), was immerhin in allen ANSI-Fällen klappt, aber beispielsweise nicht bei dem unter µC-Compilern nicht so seltenen Fall sizeof(int)=1. Generell ist in printf() mit den stdint.h-Typen
-
Thread
Fehler bei Rückgabe einer Liste
; list = malloc((*list_cnt) * sizeof(int16_t)); for(n=0; n < *list_cnt; n++){ list[n] = global.final[n]; } /* **************************************************** PROCESS THE DATA IN QUEUE *********
Ist diese Zeile richtig angewendet: [c]queue = calloc(queue_size, sizeof(int16_t));[/c] Ich habe die Variable "queue_size" mal vergrößert. Es kommt zum selben Absturz. :-/
-
Thread
Funktionspointer Deklaration xhuge Problem / KEIL Compiler
..\RTS\SRC\C\RTSEVENT.C(231): error C72: sizeof returns zero ..\RTS\SRC\C\RTSEVENT.C(244): error C72: sizeof returns zero ..\RTS\SRC\C\RTSEVENT.C(259): warning C72: sizeof returns zero ..\RTS\SRC\C\RTSEVENT.C(260): warning C72: sizeof returns zero ..\RTS\SRC\C\RTSEVENT.C(261): warning C72: sizeof returns zero ..\RTS\SRC\C\RTSEVENT.C(262): warning C72: sizeof returns zero ..\RTS\SRC\C\RTSEVENT.C(263): warning C72: sizeof returns zero ..\RTS\SRC\C\RTSEVENT.C(264): warning C72: sizeof returns
-
Thread
STM32F7: Eigener Bootloader startet die Applikation nicht
sizeof(APP_HEADER)) ); Jump_To_Application();
die Applikation gestartet: __set_PRIMASK(1); addr = GetApplicationStartAddress() + sizeof(APP_HEADER)+4; JumpAddress = *(__IO uint32_t*) addr; Jump_To_Application = (pFunction) JumpAddress; __set_MSP(*(__IO uint32_t*)(GetApplicationStartAddress() + sizeof(APP_HEADER
-
Thread
unions structs bildfields
von floats, 8 oder 9 Bit pro char/Byte, Es ist aber explizit erlaubt, mit einem byteptr und sizeof(Struktur) die komplette Struktur in Bytes zu zerlegen.
int8_t kann es auf einer Platform zwar geben, > muss es aber nicht. Wenn es sie gibt, dann ist sizeof(char) == 1 Byte. sizeof(char) ist immer 1 Byte, egal ob es uint8_t gibt oder nicht. Ansonsten soweit richtig. > Tja, damit ist jeder Code, der uint8_t benutzt "implemantation defined". Wenn
-
Thread
UART Schleife MC stürzt ab
&& ci < sizeof( command ) > - 1 ) { [/C]
Rolf Magnus schrieb im Beitrag #3962842: > while( c != ENDE && ci < sizeof( command ) > - 1 ) { ??? Jetzt hast Du's verhunzt. --> while( c != ENDE && ci < sizeof( command ) - 1 ) {
-
Thread
Struct Arduino dynamisches Array verarbeiten
executeAction(actionOne, sizeof(actionOne) /sizeof(actionOne[0])); HTH
Ausführung. Die ist einleuchtend. Ist ja nicht PHP. :) Verfahre ich dann damit "falsch"? [code] sizeof(actionOne) / sizeof(ServoLoop) [/code] Ich habe jetzt [code] sizeof(actionOne) / sizeof(actionOne[0]) [/code] in Verwendung.
-
Thread
Speicher/Array kommt durcheinander/wird überschrieben ?
(wert_min): %u\n", array_min(wert_min,(sizeof(wert_min) / sizeof(wert_min[0]))));uart_puts(buffer); sprintf(buffer, "\tarray_max(wert_min): %u\n", array_max(wert_min,(sizeof(wert_min) / sizeof(wert_min[0]))));uart_puts(buffer); sprintf(buffer, "\tarray_avg(wert_min): %u\n\n",array_avg(wert_min,(sizeof(wert_min) / sizeof(wert_min[0]))));uart_puts(buffer); sprintf(buffer, "\tarray_min(wert_max): %u\n", array_min(wert_max,(sizeof(wert_max) / sizeof(wert_max[0]))));uart_puts(buffer);
-
Thread
Datenpaket in Programmspeicher - C
0xef, 0xba, 0xdc, 0x00, 0xff, 0xee }; int main(void) { uint8_t i; for (i = 0; i < sizeof(configvals)/sizeof(uint8_t); i++ ) { PORTA = pgm_read_byte(&configvals[i]); } while(1) { } } [/c] Vorgehensweise bringt nichts, wenn die Progammiersoftware Chip Erase vor Flash-Programmierung
}; const uint8_t pgmDaten2[] PROGMEM = { #include "dat2.txt" }; #define DATEN_SIZE1 ( sizeof(pgmDaten1) / sizeof(*pgmDaten1) ) #define DATEN_SIZE2 ( sizeof(pgmDaten2) / sizeof(*pgmDaten2) ) int main() { uint16_t i; uint8_t value1; uint8_t value2; for( i = 0; i < DATEN_SIZE1
-
Thread
C++ Mc gcc Object löschen
void *alloc(size_t bytes) { // einfacher Fall, keine bzw. leere freelist heaptop-=bytes+sizeof(bytes); *(size_t *)heaptop=bytes; return heaptop+sizeof(bytes); } void free(void * ptr) { if(ptr==heaptop+sizeof(size_t)) heaptop+=*(size_t *)heaptop; else // aufwändiger } [
Elementen. Bei unterschiedlich grossen kann man nicht berechnen, dass das dritte Element bei 2+sizeof(element) steht. Man braucht Pointer, geht aber auch, gern gemacht um strings in Worte zu zerlegen oder so: [c] element ** mem=malloc(elementanzahl*sizeof(element *)+elementgesamtgrösse); for(
-
Thread
Rückgabewerte von va_list auf einem Arduino Mega2560
}) void RangeCheck_MOD (uint16_t ZeilenNr, uint8_t MOD_ix) { char jou[30]; snprintf(jou,sizeof(jou),P("MOD RangeErr in %d: %d"),ZeilenNr,MOD_ix); println(jou); } [/c] Verwende ich stattdessen [c] snprintf_P(jou,sizeof(jou),"MOD RangeErr in %d: %d",ZeilenNr,MOD_ix); [/c] wird mehr RAM verbraucht. Logisch. Mache ich [c] snprintf_P(jou,sizeof(jou),PSTR("MOD RangeErr in %d: %d"),ZeilenNr,MOD_ix); [/c] dann ist die RAM-Nutzung auch wie bei meiner Lösung. Dann bleibt es Geschmacksache oder eine Stilfrage.
-
Thread
strcpy mit automatischer Längenprüfung
Ohne Aufwand ganz simpel: char d[100], *s; strncpy(d, s, sizeof(d))[sizeof(d) - 1] = '\0';
automatisch angefügt wird. [c] char d[100] = {0}; // initialisierung like memset((void*) d, 0, sizeof(d)); char *s; strncpy(d, s, sizeof(d)-1); [/c]
-
Thread
C++ template mit typabhängiger Behandlung
call this function from ISR context. */ MemoryPool() { memset(_pool_mem, 0, sizeof(_pool_mem)); osMemoryPoolAttr_t attr = { 0 }; attr.mp_mem = _pool_mem; attr.mp_size = sizeof(_pool_mem); attr.cb_mem = &_obj_mem; attr.cb_size = sizeof(
die Verzeigerung der freigen Blöcke: [c] MemoryPool() { memset(_pool_mem, 0, sizeof(_pool_mem)); osMemoryPoolAttr_t attr = { 0 }; attr.mp_mem = _pool_mem; attr.mp_size = sizeof(_pool_mem); attr.cb_mem = &_obj_mem; attr.cb_size = sizeof(
-
Thread
AVR EEPROM verliert Daten Gesperrt
im Beitrag #1075385: > void eeprom_write(uint8_t adr, uint8_t data) > { > if ((adr<0) || adr>sizeof(ee_params)) Die Abfrage ist fehlerhaft. if (adr >= sizeof(ee_params))
>= schrieb im Beitrag #4673412: > Die Abfrage ist fehlerhaft. > > if (adr >= sizeof(ee_params)) Erstens das und zweitens macht sizeof NICHT das was er denkt, schon garnicht nach einem Reset!
-
Thread
Call by reference mit Array - wieso klappt das nicht
ist ein Array aus Pointern auf char. Das nächste Problem ist das hier: [c]size_t dataLength = sizeof(*someData) / sizeof(char);[/c]Du hast keine Chance innerhalb der Funktion über sizeof an die Anzahl der Elemente des Arrays zu kommen. Entweder du packst eine eindeutige Ende-Kennung an das Ende des
Zeiger auf einen Zeiger auf char. > Das nächste Problem ist das hier: > size_t dataLength = sizeof(*someData) / sizeof(char); > Du hast keine Chance innerhalb der Funktion über sizeof an die Anzahl > der Elemente des Arrays zu kommen. Richtig. *someData ist vom Typ "Zeiger auf char", sizeof
-
Thread
STM32: Adresse mit Rest als uint32_tinterpretieren
unsigned char uca[1000]; int idx = 17+4; /* rin inne Kartoffeln*/ memcpy(kartoffeln, uca+idx, sizeof(kartoffeln)); /* aus ausse Kartoffeln*/ memcpy(uca+idx+200, kartoffeln, sizeof(kartoffeln));
mittels sizeof).
-
Thread
Nachkommastellen Arduino
ja mal den Compiler anzeigen lassen, da sollte auch 4/8/8 rauskommen: [c] Serial.println( sizeof(float) ); Serial.println( sizeof(double) ); Serial.println( sizeof(1.20658453) ); [/c] Wenn nicht, dann ist irgendwo versteckt etwas verbogen. Per default rechnet der gcc mit ARM eabi mit
gegenüber dem was das Programm berechnet. Das Programm rechnet also korrekt mit 64 Bit FP. [code] sizeof(float) = 4 sizeof(double) = 8 sizeof(1.20658453) = 8 ta = 1.206584530000000 eps = 43717.667965170294337 Los geht's! JD von: 29 8 2020 2459090 obli 23.436605537634907 ta= 1.206584531143053
-
Thread
Warnmeldung bei Pointerinitialisierung
Stefan Kein Zufall. Ich habe (da ich mir nicht sicher war) die Größe eines doublewertes mit dem sizeof-Operator ermittelt (4 Bytes)
ersetze die beiden 4er mit *sizeof* Stephan
-
Thread
"while" Bedingung hält nicht was es verspricht
uartstr(rein,11); weil rein 11 char groß ist. Oder eben char rein[11] uartstr( rein, sizeof(rein) ); dann brauchst du das nicht selber abzählen sondern der Compiler macht das für dich.
*buffer++=i; i=receive(); } *buffer='\0'; } Aufruf geht so: uartstr(rein,sizeof(rein),','); Funktioniert, sieht besser aus, löst aber mein Problem nicht: Ich versuche es mal zu beschreiben: Ich habe ein Programm geschrieben welches den Kurs von einer Koordinate zu einer
-
Thread
Was ist sizeof(pointer) auf 128KB-AVR?
[c]printf("%d", sizeof(uint8_t *));[/c]
sizeof (uint8_t *) sollte exakt dasselbe ergeben wie sizeof(void *) , nämlich 2. Derartige Pointer zeigen nämlich ins (kleine) RAM. Bernhard
-
Thread
USB:String-Descriptor
String3 }; const unsigned char* getStringDescriptor(unsigned char idx) { if(idx >= (sizeof(pStrings) / sizeof(pStrings[0]))) return(NULL); return(pStrings[idx]); } [/c]
USB_PRODUCT_NAME L"Demo" ... static struct string_descriptor const PROGMEM product_name = { .bLength = sizeof(struct string_descriptor) + sizeof(USB_PRODUCT_NAME) - sizeof(wchar_t), .bDescriptorType = STRING_DESC, .bString = USB_PRODUCT_NAME }; [/c]
-
Thread
C-Funktion verstehen
aber eines besseren: [c] #include <stdio.h> #include <stdint.h> int main() { printf ("sizeof(int): %ld\n", sizeof(int)); printf ("sizeof(long): %ld\n", sizeof(long)); printf ("%x\n", ~1); printf ("%lx\n", ~1L); printf ("%lx\n", (unsigned long)(~1)); printf ("%lx\n", (unsigned long)(~1U)); return 0; } [/c] [code] $ cc a.c && ./a.out sizeof(int): 4 sizeof(long): 8 fffffffe fffffffffffffffe fffffffffffffffe fffffffe [/code] Es liegt an der Sign-Extension, dass "(unsigned long)(~1)" trotzdem funktioniert. Rufus hatte den richtigen
-
Thread
Hilfe bei Code um von Mikrocontroller auf SD zu schreiben
fil, "wert.txt" , FA_CREATE_ALWAYS | FA_WRITE | FA_READ); if(&fil) { fresult = f_lseek(&fil,sizeof(fil));} fresult = f_write(&fil, wert_char, sizeof(wert_char) ,&written); fresult = f_close(&fil); } [/c] Was ist mein Fehler`?
du willst hier [c] fresult = f_write(&fil, wert_char, sizeof(wert_char) ,&written); [/c] nicht sizeof benutzen. Du willst den String, der in wert_char steht, so wie er ist aufs File geschrieben haben. sizeof liefert dir die Größe des Arrays in Bytes. Die
-
Thread
eeprom_write_block und Fleury urat lib Problem
Karsten K. schrieb im Beitrag #3809483: > eeprom_read_block(Vdata, eedata, sizeof(Vdata)); Hier fehlt ein eeprom_busy_wait (); > eeprom_write_block(Vdata, eedata, sizeof(Vdata)); Und hier erst recht. auserdem vorher: uint8_t tmp_sreg = SREG; cli();
Versuchs mal mit cast: eeprom(Vdata, (uint16_t)eedata, sizeof(Vdata), EE_READ);
-
Thread
dll in c erstellen
dieses Array mit [c] FILE *fl; fl = fopen("testFileOwn.txt","a+"); for(int i=0; i<=sizeof(argument)/sizeof(double);i++){ fprintf(fl,"%s%d","\r\nInput:",argument[i]); } fclose(fl); [/c] in die datei zu schreiben. Habe ich ewtl. einen Fehler dabei gemacht??
Einerseits kannst Du die Anzahl der Elemente im Array nicht so bestimmen: for(int i=0; i<=sizeof(argument)/sizeof(double);i++) argument ist ein Pointer, sizeof davon ist 4 (auf 32-Bit-Systemen), sizeof von double ist 8, also wird Deine Schleife nicht sehr oft ausgeführt werden. Wenn Deiner
-
Thread
Hilfe bei einem C-Programm fuer einen ASCII Art Dekodierer
e = strtok(NULL,"=;"); //bereits initialisiert > > int y = 0; > b=0; > for(y; y<sizeof(e)-2; y++){ //Berechnung Breite sizeof(e) liefert dir hier die Größe in Bytes des Pointers und nicht die Länge des Strings, dafür ist strlen da. Beschäftig dich lieber mal mit den /Grundlagen
Also reserviere ich mir mit malloc einfach meinen Speicher? [c]array = (int *) malloc(size * sizeof(int));[/c]
-
Thread
Datei einlesen mit C
zurueckstellen // reserviere speicher fuer den array array = (int*) malloc(zaehler * sizeof(int)); // lese den Dateiinhalt in den array while (!feof(datei)) // sind wir schon am Dateiende ? { if (fgets(zeile, sizeof(zeile), datei) != 0) // Lies die naechste Zeile
zurueckstellen // reserviere speicher fuer den array array = (int*) malloc(zaehler * sizeof(int)); // lese den Dateiinhalt in den array while (!fgets(datei)) // sind wir schon am Dateiende ? { if (fgets(zeile, sizeof(zeile), datei) != 0) // Lies die n aechste Zeile
-
Thread
Warum werde ich beim Programmieren nicht besser?
werden soll. Wenn ich so was sehe wie: (*(*ang_zeiger).chef).chef = (struct ang_info *) malloc(sizeof(struct ang_info)); dann kann ich das beim besten Willen nicht begreifen. Nicht mal ansatzweise verstehen, was da los ist. Habt ihr Tipps für mich?
#4723408: > Wenn ich so was sehe wie: > (*(*ang_zeiger).chef).chef = (struct ang_info *) malloc(sizeof(struct > ang_info)); Benutze doch mal den Debugger. Dann siehst du, was die Software aus der Befehlszeile macht und das Schritt für Schritt. Struct, Malloc und Sizeof stehen ja im Tutorial und
-
Thread
Progmem&uart
mit ++ um die Anzahl an Bytes erhöht, die ein Objekt des Datentyps im Speicher belegt. Also: sizeof (uint16) == 2, ++ erhöht den Pointer um zwei. sizeof (uint8) == 1, ++ erhöht den Pointer um eins. sizeof (uint32) == 4, ++ erhöht den Pointer um vier. Die Pointer selbst sind alle gleich groß,
>Also: >sizeof (uint16) == 2, ++ erhöht den Pointer um zwei. >sizeof (uint8) == 1, ++ erhöht den Pointer um eins. >sizeof (uint32) == 4, ++ erhöht den Pointer um vier. vielen dank, ich denke ich hab das mit