-
Thread
stm32duino pinname datentyp
DocRaptor schrieb im Beitrag #6287966: > int size = sizeof(digitalPins); BTW: das gibt die *nicht* die Anzahl der Elemente im Array retuour. Du willst: [c] #define ARR_SIZE(arr) (sizeof(arr)/sizeof(arr[0])) [/c] leo
leo schrieb im Beitrag #6288112: > DocRaptor schrieb: >> int size = sizeof(digitalPins); > > BTW: das gibt die nicht die Anzahl der Elemente im Array retuour. > Du willst:#define ARR_SIZE(arr) (sizeof(arr)/sizeof(arr[0])) define war Gestern [c] template<typename
-
Thread
speicher allokierung
Array allokieren. Beispiel Buffer[10][25]; wenn ich so schreibe: char[25]* Buffer = malloc(14 * sizeof(char[25])); bekomme ich einen Fehler. Danke
sizeof(char[25])); Was soll z.B. char[25] * sein? Das ist syntaktisch nicht korrekt. Und was soll 14 * sizeof(char[25]) sein? Wo kommt die 14 her? Und wenn dann sollte es 25 * sizeof(char) heissen. Die
-
Thread
Größenangabe von Feldern
sizeof(int) == 2
es ist schlich falsch. Der generische Weg, die Anzahl der Feldelemente zu ermitteln ist: sizeof Feld / sizeof Feld[0]
-
Thread
Pointer auf Integerwert im Flash (ohne explizit eine Variable anzulegen)
doch auch nur > ein Zeiger). Weil ein Array kein Zeiger ist und ein Zeiger kein Array. 1) sizeof verhält sich anders. 2) Einem Zeiger kann ein Wert zugewiesen werden, einem Array nicht (damit ist nicht ein /Element/ des Arrays gemeint). [c] void test (void) { int *p; int array[5]; p = array; // Ok array = p; // Fehler sizeof (p); // = sizeof (int*) sizeof (array); // = 5 * sizeof (int) }[/c]
-
Thread
UART empfängt nur 2 zeichen
ich sende mit einem mega328 über uart ein string [c] char* test = "TEST"; rs485_puts(test,sizeof(test)); void rs485_putc(unsigned char c){ while (!(UCSR0A & (1<<UDRE0))) /* warten bis Senden moeglich */ { } UDR0 = c; /* sende Zeichen */ //return 0; }
tue ich mit einem zweiten mega328 [c] if((UCSR0A & (1<<RXC0))){ uart_gets(uart_string, sizeof(uart_string)); //uart_readline(uart_string); } if(uart_str_complete == 1){ lcd_gotoxy(0,0); if(uart_string[0] == 0x42){ UCSR0A &= ~(1<<MPCM0);
-
Thread
Automatische Initialisierung von Variablen & Co.
hintereinander im Speicher liegen. Ansonsten: [c] struktur_t mein_array; memset(&mein_array, 0, sizeof(struktur_t)); [/c] Vielleicht kann jemand noch mal erläutern wo der Unterschied zwischen meiner Struktur (die kann auch anders aussehen!) und dem verlinkten Thread ist? Gruß Dennis
einzeln "Nullen"? nein, brauchst du nicht. Selbst wenn Lücken vorhanden sind, werden sie ja bei sizeof mit berücksichtig.
-
Thread
Absturz bei "insmod"
weil man es dynamisch allokiert [C] ... struct tps1_net *tps; int main() { tps = malloc( sizeof(struct tps1_net) ); .... free( tps ); } [/C] ist erst mal egal. Wichtig ist, dass der Pointer auf ein Objekt zeigen muss! Das tut er nicht automatisch. Nur weil du einen Pointer hast
lange weg schrieb: > dev = alloc_etherdev(sizeof(struct tps1_net)); >dev ist vom type net_device allozierst aber tps1_net größe, sind die >gleich groß, ist das die gleich struktur? Es wird in dem enc28j60 Treiber genauso gehandhabt. Ich habe
-
Thread
Ausgabe Sendername statt Frequenz
sender[42]={{100, "Radio1"}, {105, "Radio2"},...}; void ausgabe(void) { uint i; for(i=0;i<sizeof(sender)/sizeof(sender_t);i++) { if(frequenz==sender[i].frequenz) break; } if(frequenz==sender[i].frequenz) gebe_name_aus(); else gebe_freq_aus(); [/c]
1. Die Schleife läuft zu oft. sizeof(Sender) gibt Dir den Speicherverbrauch des Arrays in Byte, nicht die Anzahl der Einträge. Wie es richtig geht, hat troll schon geschrieben. 2. In der Schleife wird Index immer auf 255 gesetzt, außer
-
Thread
Hardware TWI,I²C, I²C EEPROM
angesprochen: const char Text[] PROGMEM = "Test Text\n"; { if (i2cMemWrite(0xA0, 123, Text, sizeof Text, 1) == sizeof Text) { printf("Daten geschrieben"); } char Daten[sizeof Text]; if (i2cMemRead(0xA0, 123, Daten, sizeof Daten) == sizeof Daten) { printf(Daten); } } 0xA0
-
Thread
verschiedene Typen an eine Funktion übergeben
ich das bisher gesehen habe bekommt man erstmal nur das mit was der compiler selbst kann, also zb sizeof(). Alle anderen Sachen wie iostream usw fehlen. Seh ich das richtig? Ist da irgendwas in Arbeit? Wie schwierig/sinnvoll ist es die STL anzupassen und zu verwenden?
; } TypContainer; Nachteil: Vor Gebrauch muss der gewünschte Typ "eingestellt" werden und sizeof (TypContainer) ist sizeof (enum) + sizeof (größter enthaltener Typ). Geht aber ohne STL, Boost, iostream, SEH etc.
-
Thread
AVR C Programmierung unter Linux
volatile double d = 10./9; #include "avrtest.h" int main() { printf ("Layout: %d/%d/%d\n", sizeof (float), sizeof (double), sizeof (long double)); LOG_FMT_FLOAT ("f = %.20f\n", f); LOG_FMT_DOUBLE ("d = %.20f\n", d); LOG_FMT_FLOAT ("81*f^2 = %.20f\n", 81*f*f); LOG_FMT_DOUBLE
; usart0.println("Hallo ich bin USART.0."); usart0.println(sizeof(float)); usart0.println(sizeof(double)); float f = 1.123456789; float g = 3.0; double d = 1.123456789;
-
Thread
USB IR Remote Receiver (V-USB + IRMP)
usbPoll(); // check if USB int is ready usbSetInterrupt(&replyBuf[0], sizeof(irmp_data) + sizeof(uchar)); // send ReportID + IR data[/c] Neu: [c] usbSetInterrupt(&replyBuf[0], sizeof(irmp_data) + sizeof(uchar)); // send ReportID + IR data[/c] Das
(); // check if USB int is ready > usbSetInterrupt(&replyBuf[0], sizeof(irmp_data) + sizeof(uchar)); // send ReportID + IR data > Neu: usbSetInterrupt(&replyBuf[0], sizeof(irmp_data) + sizeof(uchar)); // send ReportID + IR data funktioniert wunderbar
-
Thread
nRF24L01+ und Arduino Nano
// First, stop listening so we can talk radio.write( &got_time, sizeof(unsigned long) ); // Send the final one back. radio.startListening(); // Now, resume listening so we catch the next packets.
[] = "Hello World"; Serial.println("------In der LOOP"); radio.write(&text, sizeof(text)); Serial.println("------Daten geschrieben"); delay(1000); } [/c] Leider bleibt er in der Zeile "radio.write(&text, sizeof(text))" bzw, heißt die Ausgabe: [code]
-
Thread
LINUX - C - RS232 - Raw output & input
füllen oder nach dem > tcgetattr() mit oldtios vorbelegen. Damit meinte ich memset(&options,0,sizeof(options)); oder options = oldtios; um sicherzugehen, dass die gesamte Struktur definierte Werte aufweist. Deswegen: "This structure contains at least the following members:".
ich habe jetzt folgendes eingefügt: [c] struct termios oldtios,options; memset(&options,0,sizeof(options)); memset(&oldtios,0,sizeof(oldtios)); int currstat = 0; [/c] doch die Steurcodes bei der Ausgabe werden immer noch beachtet. [code] -opost -olcuc -ocrnl -onlcr -onocr -onlret -
-
Thread
Alternative zu sprintf
Norbert schrieb: [c]void debug_time() { uint8_t slen = sizeof("Time: nn:nn:nn:nnn\n"); char *TxData = alloca(slen); if(TxData) { snprintf(TxData, slen, "Time: %02d:%02d:%02d:%03d\n", 23, 59, 59, 999); SendUartData(TxData, slen - 1)
Foobar schrieb im Beitrag #7383076: [c] > uint8_t slen = sizeof("Time: nn:nn:nn:nnn\n"); > char *TxData = alloca(slen); [/c] Für diesen Fall kann man übrigens auch schreiben: [c] char TxDat[sizeof("Time: nn:nn:nn:nnn\n")]; [/c] alloca macht hier keinen
-
Thread
crc über struct c#
[code] struct Protocol x = ..; int länge = sizeof(struct Protocol) -sizeof(int16*) +x.len; byte[] b = new byte[länge]; int i = 0; b[i] = x.adress; i++; b[i] = x.command; i++; b[i] = x.len; i++; for (int j = 0; j < x.len; j++) { b[i] =
und wenn der receiveBuffer[] eine unbestimmte Länge hat wird sizeof(struct Protocol) nichts brauchbares liefern.
-
Thread
Länge eines Array bestimmen für Mittelwertbildung
unsigned int filterwert = 0; array[*position] = input; *position++; if(*position > (sizeof(array) - 1)) { *position = 0; } for(unsigned char x = 0; x < sizeof(array); x++) { filterwert += array[x]; } // und jetzt?!? return (unsigned char)filterwert; } [/c] Klar kann ich schreiben: [c] if(sizeof(array) == 2) { filterwert >>= 1; } else if(sizeof(array) == 4) { filterwert >>= 2; } . . . [/c] Aber schön ist auch anders :) . Wie komme ich geschickt an diese Information?! Danke
-
Thread
String Bearbeitung
pPtr = strtok( Data, " " ); if( pPtr == NULL ) return 0; strncpy( Command, pPtr, sizeof( Command ) ); // Extrahiere das Erste Argument, falls es eines gibt pPtr = strtok( NULL, " " ); if( pPtr == NULL ) return 1; strncpy( CmdArg1, pPtr, sizeof( Command ) ); /
pPtr = strtok( NULL, " " ); if( pPtr == NULL ) return 2; strncpy( CmdArg2, pPtr, sizeof( Command ) ); // Extrahiere das Dritte Argument, falls es eines gibt pPtr = strtok( NULL, " " ); if( pPtr == NULL ) return 3; strncpy( CmdArg3, pPtr, sizeof( Command ) );
-
Thread
C/C++: Warum ist a[n] äquivalent zu n[a]?
Beispiel 4 Bytes. int a[]{1, 2, 3}; 1000 1 1004 2 1008 3 Bei a[2] also sinngemäß a + 2 * sizeof(int) = 1000 + 2 * 4 = 1008 a[2] -> *(a + 2 * sizeof(int)) -> 3 Aber warum funktioniert das umgekehrt? 2[a] 2 + a * sizeof(int) = 2 + 1000 * 4 = 4002 (?) a "degeneriert" hier doch zu einem int
August schrieb im Beitrag #4900418: > Aber warum funktioniert das umgekehrt? > 2[a] > 2 + a * sizeof(int) = 2 + 1000 * 4 = 4002 (?) Eben nicht. a ist ein Pointer und der wird nicht mit sizeof multipliziert. 2 ist ein integer und der wird mit dem sizeof vom Pointertyp multipliziert.
-
Thread
Zugriffsverletzung C-Programm
Albert schrieb im Beitrag #4967951: > if( (realloc(data, sizeof(weatherdata) * 10))!=NULL); Das geht ganz gewaltig in die Hose, denn Du schmeißt den Rückgabewert von realloc weg ...
Albert schrieb im Beitrag #4968084: > data = realloc(data, sizeof(weatherdata) * (sizeOfDataSpace+10)); Das ist zwar besser, aber immer noch ungeschickt. Stell' Dir folgende Situation vor: Vor dem Aufruf von /realloc/ zeigt /data/ auf Speicher, den Du mühsam
-
Thread
STM32 UART buffer rx
void Daten_Holen(RS232 *_rs232) { HAL_UART_Receive_IT(_rs232->RS232_HT,_rs232->buffer_uart, sizeof(_rs232->buffer_uart)); for(uint8_t i = 0; i < sizeof(_rs232->buffer_uart); i++) { if(_rs232->buffer_uart[i] == 0x0A) { for(uint8_t i = 0; i < sizeof(_rs232->buffer_uart);
_rs232->buffer[i] = _rs232->buffer_uart[i]; } for(uint8_t i = 0; i < sizeof(_rs232->buffer_uart); i++) { _rs232->buffer_uart[i] = ' '; } } } } [/c] Leider klappt das mit der Startadresse nicht und das Löschen des buffers klappt auch nicht
-
Thread
Array mit Kommas getrennt ausgeben in C
[c]int array[] = {9, 4, 7, 8, 10, 5, 1, 6, 3, 2}; printf ("Array: "); for (size_t i = 0; i < sizeof(array)/sizeof(array[0]); ++i) { if (i) printf (", "); printf ("%d", array [i]); }[/c]
int array[] = {9, 4, 7, 8, 10, 5, 1, 6, 3, 2}; > printf ("Array: "); > for (size_t i = 0; i < sizeof(array)/sizeof(array[0]); ++i) { > if (i) printf (", "); > printf ("%d", array [i]); > } Warum so kompliziert? Und ineffizient (doppelter printf-Aufruf, Division...)?
-
Thread
Timer Problem
> also ich bin mir auch nicht sicher ob sizeof viel mehr Zeit kostet > wenn es zur Laufzeit berechnet wird. sizeof war bis C99 eine reine Compile-time-Berechnung. Erst mit C99 sind dynamische Arrays in der Szene erschienen und erzeugten die
optimiert (zumal sizeof(unsigned char) per Definition 1 ist)
-
Thread
Arduino Uno / Atmega 328P Sinus PWM
gehen wir nicht mehr void loop() { } //Timer Interrupt ISR(TIMER2_COMPA_vect){ if(i<sizeof(lookUp1)/sizeof(int)){ i++; OCR2A = lookUp1[i]; //->AusgangsSpannung }else{ i=0; } }
der Zählvariable machen? Code: //Timer Interrupt ISR(TIMER2_COMPA_vect){ if(i<sizeof(lookUp1)/sizeof(int)){ i++; }else{ i=0; } OCR2A = lookUp1[i]; //->AusgangsSpannung }
-
Thread
C-Problem bei Array-Pointer-Übergabe
sizeof (arData) len verwenden. } Aufruf der Funktion: SPI_SendBytes(SET_CURSOR_HM_1, sizeof (SET_CURSOR_HM_1)); gutes Google-Suchwort: "C passing arrays"
Dummy-Byte senden _delay_us(10); SPI_MasterTransmit(0xFF); } SPI_SendBytes(SET_CURSOR_AM_1,sizeof(SET_CURSOR_AM_1)); [/c]
-
Thread
Commando aus String suchen..
{ Serial.println(F("serBUF ov-> DEL")); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); // 30.554 Bytes memset(&serial_in_command[0], 0, sizeof(serial_in_command)); // 30.554 Bytes // *serial_in_command=0; chr_cnt=0;
} // if( !strcmp(serial_in_command, "hell??") ) memset(&serial_in_command[0], 0, sizeof(serial_in_command)); } // if( !strcmp(serial_in_command, "hell") ) [/c]
-
Thread
Nachkommastellen in c verwenden
double test = 42.123456789; unsigned int test1; char s[30]; test1= atoi(strchr((snprintf(s,sizeof(s),"%f",test),s),'.')+1); [/c] (sofern garantiert ist, dass es überhaupt Nachkommastellen gibt) Aber wie Walter S. schon schreibt: mit fester Anzahl wärs einfacher.
Markus Weber schrieb im Beitrag #4118651: > test1= atoi(strchr((snprintf(s,sizeof(s),"%f",test),s),'.')+1); das gibt aber immer eine feste Anzahl von Nachkommastellen, also z.B. 1.33 ergibt 330000 oder so der TO sollte erst Mal schreiben was er überhaupt erreichen will
-
Thread
Menü - Array in Struct
Programmierung. Ich denke, diese Zeile ist das, was ich gesucht hab. [c] #define NR_ENTRIES(x) (sizeof(x)/sizeof(*x)) [/c] Ich werde Deinen Vorschlag am Wochenende gleich mal testen.
die > Größe eines Arrays zu ermitteln. C-Buch! Solange dein Array ein Array ist, funtioniert sizeof perfekt. Nur wenn du das Array an eine Funktion übergibst, dann übergibst du nicht wirklich das Array sondern einen Pointer auf das erste Array Element. sizeof liefert dann klarerweise die Größe eines
-
Thread
free() führt zu Exception
Setzen der '\0' nicht versehentlich vergessen: [c] plaindata = (char *) calloc(datasize + 1, sizeof (char)); fread(plaindata, sizeof (char), datasize, input); // kann wegfallen plaindata[datasize] = '\0'; [/c]
Setzen der '\0' nicht > versehentlich vergessen: > plaindata = (char *) calloc(datasize + 1, sizeof (char)); > fread(plaindata, sizeof (char), datasize, input); > > // kann wegfallen > plaindata[datasize] = '\0'; finde ich aber hierfür nicht sinnvoll. Es nur Resourcenverschwendung,
-
Thread
MemleakErrormeldung
Peter II schrieb im Beitrag #5132297: > char* RecPointer = (char*) malloc(sizeof(char) * strlen(buf)); Das war oben schon falsch. Richtig ist: [c] char* RecPointer = (char*) malloc(strlen(buf) + 1); [/c] Die Multiplikation mit sizeof(char) ist zwar nicht falsch, kann aber weggelassen werden, da sizeof(char) immer 1 ist.
-
Thread
[C] Pointer auf Array
(nämlich ein Array mit unspezifizierter Größe) zeigt, kann die Größe des Arrays nicht mit sizeof bestimmt werden: [c] sizeof *p1_pointer // Fehler [/c] - Aus demselben Grund kann der Pointer auch nicht indiziert werden: [c] p1_pointer[i] // Fehler [/c] Vielleicht
nämlich ein Array mit > unspezifizierter Größe) zeigt, kann die Größe des Arrays nicht mit > sizeof bestimmt werden: > > sizeof *p1_pointer // Fehler Da habe ich noch gar nicht drüber nachgedacht. Yalu X. schrieb im Beitrag #4351035: > In der Praxis macht das aber niemand so, > allein
-
Thread
Führende Nullen unterdrücken wenn == 0
was er sucht. [c] char *itoa(int val, char *s, int radix) { unsigned int u; char buf[1 + sizeof(val) * 8 + 1]; char *p; int sign = 0; if ((radix < 2) || (radix > 36)) { s[0] = 0; return (s); } u = val; /* assume positive */ buf[sizeof(buf) - 1] = 0; p = &buf[sizeof(buf) - 2]; /* last character position */ if (radix == 10 && (int) u < 0) { sign++; u = -u; } while (1) { *p = (u % radix) + '0'; if (*p > '9') *p += 'a'-'0'-10;
-
Thread
Funktionsaufruf springt an falsche Adresse
noch: [C] // size of data[] + size of size, write and read; size_t memory=size*sizeof(unsigned char)+3*sizeof(unsigned char); [/C] Das ist sehr umständlich geschrieben, denn sizeof(unsigned char) ist per Definition in C immer 1. Das oben ist also das gleiche wie: [C] size_t memory = size + 3; [/C] Aber warum nicht gleich: [C] size_t memory = size + sizeof(struct uc_fifo); [/C]
-
Thread
C: Programm mit Textanzeige für mehrere Sprachen
#define ENGLISH 1 #define GERMAN 2 void printf_t(char *txt) { int i; for(i=0;i<sizeof(language)/sizeof(language[0]);i++) { if (strcmp(lang_array[i].english_text, txt)==0) { break; } } if (i==sizeof(language)/sizeof(language[0]))
(da sind natürlich einige Fehler enthalten sizeof language -> sizeof lang_array etc., aber der Ablauf sollte klar sein)
-
Thread
C Programmierung Array und strings
Pointern. Ein Pointer zeigt auf eine Speicheradresse. Er hat einen Datentype. Seine grösse ist immer sizeof(void*). Sein wert ist die Stelle wo er hinzeigt. Pointer können auch auf Pointer zeigen. Mit ausname eines Pointers auf void ist jeder Pointer ein Arithmetischer Datentype (man kann damit rechnen).
Die Adresse eines Arrays ist also gleich der Adresse des ersten Elements. Die andere Ausnahme ist sizeof. Ähnliches gibts für Funktionen. Wenn man den Namen einer Funktion benutzt aber dann keinen Funktionsaufruf macht verhält es sich wie ein Pointer auf die besagte Funktion.
-
Thread
size_t Problem
Wer ist Hagenbuch? Weil C keine size_t kennt, C++ aber schon std::size_t PS: in C ist das sizeof().
In dem Fall war ich natürlich falsch In C braucht es dafür einen Cast und kein sizeof(). Grüsse, René
-
Thread
Array im RAM - Zugriff auf nicht genutzte Bits
uint16_t *Speicher; uint16_t* Speicher_init() { Speicher = (uint16_t*) malloc(SPEICHERGROSSE* sizeof(uint16_t)); return *Speicher; } Ist es möglich, die übrigen 6 leeren Bits später dann noch zu belegen? Außerdem noch eine weitere Frage: Das Array soll Daten im RAM-Speicher aufnehmen.
zum beispiel so: *pressure = NULL; //Deklaration pressure=(double*)onedimmem(pressure,3 * sizeof(double)); //speicher anlegen pressure=(double*)onedimmem(pressure,6 * sizeof(double)); //Grösse verändern, der Vorteil bei dieser Methode ist das der Speicherinhalt bestehen bleibt pressure=(
-
Thread
Nicht nachvollziehbares Verhalten!
ist das hier [C] void ParameterRestor(void) { eeprom_read_block(scaleoffset,EE_saleoffset,sizeof(scaleoffset)); eeprom_read_block(menuParameters,EE_menuParameters,sizeof(menuParameters)); for (uint8_t i =0;i<MENU_SIZE;i++) { if ((menuParameters[i]<MENU_LIMITS_MIN[i])||(menuParameters
0, 0, " Calib Voltage3 " }, { 0, 0, 0, " Calib Voltage4 " }, }; #define PARAM_SIZE sizeof( paramValues ) / sizeof( *paramValues ) [/C] und damit arbeitest du dann in weiterer Folge. Du hast das komplette Array von paramValues. Von diesem Array einen spezifischen Eintrag, zb paramValues
-
Thread
schadet übermäßiges verwenden von uint16_t?
dor ist ein int immer mindestens 16 Bits weit. avr-gcc kennt den Schalter -mint8, mit dem ein sizeof (int) = 1 ist. Aber der erzeugte Code entspricht wie gesagt dem, was der C-Standard vorschreibt
Johann L. schrieb im Beitrag #2788364: > avr-gcc kennt den Schalter -mint8, mit dem ein sizeof (int) = 1 ist. > Aber der erzeugte Code entspricht wie gesagt dem, was der C-Standard > vorschreibt Hast Du dich da nicht verschrieben? Der erzeugt Code ist nicht mehr C-konform, da sizeof(
-
Thread
Mehrere Werte über RS485 versenden
in eine Zahl zu zerlegen. Der Vorteil: * Egal welche Endian ein System hat oder welche sizeof(int) * Mitlesen der Daten funktioniert im Klartext, man muss nicht extra ein Tool dafür basteln. * Für die Sicherheit reicht es oft, Parity einzuschalten, Framing-Errors auszuwerten und daraufhin
sensors.getTempC(Thermometer2); txData.dritterWert = wasAuchImmer(); crc8.restart(); crc8.add(txData, sizeof(txData) - sizeof(txData.crc)); txData.crc = crc8.getCRC(); serial.write((char *) &txData, sizeof(txData)); delay(1000); } [/c] Durch die Pause (die durchaus auch noch länger sein dürfte
-
Thread
AVR, Structs zur Laufzeit reservieren
anwende, also welche Größe ich den Funktionen übergebe. Funktioniert da? [c] xyz = realloc(*array, (sizeof(array) / sizeof(array[0]))+sizeof(array[0])) [/c] Ich würde im Quellcode bereits einen "Prototypen" jedes Arrays erstellen, funktioniert dann realloc auch noch? Habe gelesen daß das eigentlich
Die Anzahl der Bytes die du haben möchtest. > Funktioniert da? > [c] > xyz = realloc(*array, (sizeof(array) / > sizeof(array[0]))+sizeof(array[0])) > [/c] Das kommt einzige und alleine auf deine Arrays an. Aber so richtig sinnvoll sieht das nicht aus. Zeig ein bischen was von deiner Umgebung
-
Thread
C-> Größe eines Array in einem Union initalisieren?!
_t _firstChar; uint8_t _charCount; uint8_t _widths[11]; uint8_t _fontData[sizeof(fontData)]; }; }; [/c]
t _widths[11]; Aber hier hast du doch schon gerechnet. X = die größe gesamten Arrays y = sizeof(_width)+sizeof(_height)+....+sizeof(-widths) dann (X-Y) / sizeof(uint8_t) Vielleich so?
-
Thread
SPI angeschlossener Chip muss nach dem Reset initialisiert
Hi Peter, Kannst du mir ein Ansatz geben ? Wie meinst du mit sizeof-Operator ? Ich bin eigentlich Neuling in den Sachen. Ich danke dir. Beranger
"Wie meinst du mit sizeof-Operator ?" Du solltest Dir ein C-Buch oder einen Compiler mit guter Hilfe zulegen, um solche grundlegenden Dinge zu klären. sizeof(x) gibt die Größe von x in Bytes zurück. Mit sizeof(Tabelle
-
Thread
Gefahren bei Interrupts
} } } } ISR(TIMER_INTR_NAME) { if(counter == NULL) { counter = calloc(1, sizeof(uint8_t)); } else if(*counter >= 255) { uint8_t i = 1; for(; *(counter + i) >= 255; ++i) ; counter = realloc(counter, (i + 1) * sizeof(uint8_t)); ++*(counter + i
} ISR(TIMER_INTR_NAME) { changed = 1; if(counter == NULL) { counter = malloc(sizeof(uint8_t)); *counter = 1; } else if(*counter >= 255) { uint8_t i = 1; for(; *(counter + i) >= 255; ++i) ; counter = realloc(counter, (i + 1) * sizeof(uint8_t));
-
Thread
SSD1306/1309 Library zum Darstellen von Text auf OLED Displays
_SEGREMAP = 0xA0; uint8_t SSD1306_COMSCANINC = 0xC0; lcd_command(SSD1306_SEGREMAP | 0x0, sizeof(SSD1306_SEGREMAP)); lcd_command(SSD1306_COMSCANINC, sizeof(SSD1306_COMSCANINC)); } [/c] Das funktioniert leider nicht. Zeigt dann nur Müll an...
0x80, 0xA0}; uint8_t SSD1306_COMSCANINC[2] = {0x80, 0xC0}; lcd_command(SSD1306_SEGREMAP, sizeof(SSD1306_SEGREMAP)); lcd_command(SSD1306_COMSCANINC, sizeof(SSD1306_COMSCANINC)); } [/c]
-
Thread
C: "rollierender Index" in Array möglichst elegant realisieren?
int MyArray[100] = {1,2, ..., 100}; for(int i=-200; i<=200; i++) { int var = MyArray[i%(sizeof(MyArray)/sizeof(int))]; } [/c] MyArray sei ein abgeschlossener Wertebereich ... d.h MyArray[99+1] wird wieder zu MyArray[0] vergleichbar z.B. mit Sinus von 0 bis 2PI. Durch die modulo-Operation
MyArray[100] = {1,2, ..., 100}; > > for(int i=-200; i<=200; i++) > { > int var = MyArray[i%(sizeof(MyArray)/sizeof(int))]; > } > [/c] Was soll das bringen, in einer Schleife immer wieder die gleiche Rechnung zu machen, soll das ne Delay-Schleife werden? Insbesondere die (Modulo-)Division
-
Thread
Programmierbare Relaiskarte - Konfigurationsdaten Lesen/Speichern/Übertragen
macht sich ein entsprechendes #define mit einer konstanten Zahl dafür, oder man arbeitet gleich mit sizeof. Dann sucht sich der Compiler selbst die Größe des Arrays raus. [c] #define ARRAY_LEN(x) (sizeof(x) / sizeof(*x)) [/C] [C] if (temp == ';' || StringLen > ARRAY_LEN - 2 ) { ..
= 1; NumDS <= CurrNumDS; NumDS++) > { > Addr = CONF_DATASETS_START_ADDR + ((NumDS -1) * sizeof(keyDesc)); > eeprom_read_block(&keyDesc, (void*)Addr, sizeof(keyDesc)); > > if (keyDesc.keyCode == code) > { > *pfound = keyDesc; > return TRUE; > } > } >
-
Thread
Flexible Array Member initialisieren in C
; uint8_t MusterA_Werte[3] = { }; uint8_t MusterB_Werte[1000] = { }; Muster_t MusterA = { sizeof(MusterA_Werte), MusterA_Werte }; Muster_t MusterB = { sizeof(MusterB_Werte), MusterB_Werte }; [/c] Aber schöner wird das alles nicht.
MasterPtrCreate(unsigned char *p, unsigned n) { Master_t *m = (Master_t *) p; m->Anzahl= n-sizeof m->Anzahl; return m; } ... void x(void) { static unsigned char buf[1234]; Master_t *m=MasterPtrCreate(buf, sizeof buf); ... } [/c]
-
Thread
Länge der Tabelle berechnen
woran erkennt jetzt die Funktion das "sizeof (Tabelle[0])" 4 ist?
Oder (auch nicht dynamisch): [c]... int Elemente = sizeof( Tabelle ) / sizeof( int ); ...[/c]
-
Thread
Rückgabewert von strlen() unsigned, aber warum?
diese Option anbieten will, dann doch bitte richtig: [c] char str[10]; memset(str, 0, sizeof(str)); strcpy(str,"hallo"); [/c] Das ist mein String. Und diese Anweisung [c] printf("%p\n", strrchr(str, '\0')); [/c] gibt die gleiche Adresse vom letzten '\0'-Zeichen wie diese
Model von x86 C. Aber die Pointer vom Large Model lagen quer zur damaligen C Tradition, die von sizeof(int)==sizeof(int *) ausging.