-
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
FTDI libMPSSE SPI-Problem
In der Funktion SPI_ReadWrite() heißt es da: [code] status = FT_Channel_Write(SPI, handle, sizeof(cmdBuffer),cmdBuffer, &noOfBytesTransferred); [/code] Richtig wäre: [code] status = FT_Channel_Write(SPI, handle, 3, cmdBuffer, &noOfBytesTransferred); [/code] sizeof(cmdBuffer) ist 4, es
CurrentXferSize); [/code] Das war wohl irgendwann mal so und da hätte dann (vielleicht) auch sizeof(cmdBuffer) (also 4) funktioniert. Und was mache ich jetzt mit dieser Erkenntnis? Es wäre sinnvoll, wenn das Problem "an der Wurzel" gepackt, d.h. von FTDI in deren Quellcode offiziell korrigiert
-
Thread
C++ Template Meta pass_by_auto überprüfen.
template <typename T> struct pass_by_auto { typedef typename when < sizeof (void*) <= sizeof (T) , T , T const& > :: type type; }; template <typename T> void f (typename pass_by_auto <T> :: type t) { cout << sizeof
praktischer: [C] template <typename T> using pass_by_auto = std::conditional_t< sizeof (void*) <= sizeof (T) , T , T const& >; template <typename T> void f (pass_by_auto <T> t) { }[/C]
-
Thread
C++ Definitions Zwickmühle
Suchst du etwas wie: [c] int x[] = {1,2,3,4}; int x_count = sizeof(x)/sizeof(*x); // ist 4 [/c]
und der Größe gefüllt wird. Am Besten per Makro unterstützt: [c] #define SET_MENU_ADM(x) x,(sizeof(x)/sizeof(x[0]), #x typedef struct { MenuEntry *p; int n; const char *MainTitle; }TMenuAdm; TMenuAdm SettingsAdm = {SET_MENU_ADM(Settings)}; [/c] Zwei Vorteile: -
-
Thread
nested structs und C / C++ -> too many initializers
implizit definierten Arrays" gibt. Ein Array hat immer eine Größe. Was sollte deiner Meinung nach sizeof(MyMenu) zurückgeben, wenn die Struktur ein Array unbekannter Größe enthalten könnte? Wie würden Arrays aus diesen Strukturen funktionieren?
des Speicherobjekts größer als die Größe der Struktur ist. > Was sollte deiner Meinung nach sizeof(MyMenu) zurückgeben, wenn die > Struktur ein Array unbekannter Größe enthalten könnte? Sizeof liefert die Größe der Struktur ohne das Array plus die Anzahl der Pad-Bytes die ggf. vor dem Array
-
Thread
AVR Inline Optimierung kaputt?
auch 2 Byte! Ach nee.... Und das Byte hat dann irgendwas zwischen 5 und 36 Bit. Oder? Tipp: sizeof(char) liefert immer 1 IMMER Egal auf welchem Bügelbrett der Code läuft.
Arduino Fanboy D. schrieb im Beitrag #6339669: > Tipp: > sizeof(char) liefert immer 1 Tipp: Standard lesen. sizeof(char) liefert zwar immer 1, das aber bedeutet nicht das, was du meinst. Denn, wie schon geschrieben wurde, kann ein char auch mehrer Byte groß
-
Thread
Problem mit serieller Schnittstelle beim beschreiben
verzweifelt, kann mir jemand helfen? Mir gehen die Ideen aus wo ich noch meinen Fehler suchen könnte... sizeof() habe ich überprüft; 8 und 13; dwBytesWrite ist ein DWORD Counter für die Anzahl der gesendeten Bytes.
5") korrekt verarbeitet wird? Da c_command1 ein char-Array zu sein scheint, solltest Du statt sizeof besser strlen verwenden; spätestens, wenn Du Deine Funktionalität in einer Funktion unterbringst, wird Dir sizeof sonst nur noch die Größe des übergebenen Pointers statt der erwarteten Stringlänge
-
Thread
c++ chat programmieren
MAKEWORD( 2, 0 ); if ( WSAStartup( wVer, &wData ) == 0 ) { if( gethostname ( hostname, sizeof(hostname)) == 0) { if((hostinfo = gethostbyname(hostname)) != NULL) { szIPAddress = inet_ntoa (*(struct in_addr *)*hostinfo->h_addr_list); } } WSACleanup(); } cout<
MAKEWORD( 2, 0 ); if ( WSAStartup( wVer, &wData ) == 0 ) { if( gethostname ( hostname, sizeof(hostname)) == 0) { if((hostinfo = gethostbyname(hostname)) != NULL) { szIPAddress = inet_ntoa (*(struct in_addr *)*hostinfo->h_addr_list); } } WSACleanup(); } cout<
-
Thread
[C] dynamische Arrays in Funktionen
main(void) { double *werteX = NULL; double *werteY = NULL; werteX = calloc(ARRAYSIZE, sizeof(double)); werteY = calloc(ARRAYSIZE, sizeof(double)); hauptmenue(&werteX, &werteY); } //Hauptmenü void hauptmenue(double **werteX, double **werteY){ int auswahl, anzahl
counter++; if (counter >= ARRAYSIZE){ test1 = realloc(*werteX, (counter + 1) * sizeof(double)); test2 = realloc(*werteY, (counter + 1) * sizeof(double)); if (test1 != NULL && test2 != NULL){ *werteX = test1; *werteY = test2; }
-
Thread
Pandaboard: Zugriff aug GPIO über Export
{ return 0; } else { rewind(fpointer2); fwrite("137",sizeof(char), 3, fpointer2); fclose(fpointer2); fpointer1 = fopen("/sys/class/gpio/gpio137/direction", "rb+"); } } rewind(fpointer2); fwrite("in", sizeof(char), 2, fpointer2
{ return 0; } else { rewind(fpointer2); fwrite("138", sizeof(char), 3, fpointer2); fclose(fpointer2); fpointer1 = fopen("/sys/class/gpio/gpio138/direction", "rb+"); } } rewind(fpointer1); fwrite("low", sizeof(char), 3, fpointer1
-
Thread
if (c >= 'A') zulässig?
uart_puts("Version 1\n"); } }else{ i = 0; memset(string, 0, sizeof(string)); } }else{ } [/c] Ihr hattet alle recht. Schönen Abend noch, Marc
Ich dachte dabei auch eher an die Zeile: [c] memset(string, 0, sizeof(string)); [/c] ...
-
Thread
[C++] Was passiert mit globalen Variablen nach Programmausführung?
überschreiten. [c] int main(int argc, const char *argv[]) { char myarr[10000000]; myarr[sizeof(myarr)-1]=22; return 0; } [/c] zeigt einem schnell wo die Grenzen sind.
5 int main(int argc, const char *argv[]) 6 { 7 char myarr[10000000]; 8 myarr[sizeof(myarr)-1]=22; 9 printf("%d\n", myarr[sizeof(myarr)-1]); 10 return 0; 11 } [/c]
-
Thread
Problem SRAM Optimierung AVR-GCC
nicht mehr durch > eine Konstante ersetzt werden kann. Meinst Du, wenn man statt strlen auch sizeof nehmen könnte? Peter
Peter Dannegger wrote: > Meinst Du, wenn man statt strlen auch sizeof nehmen könnte? Klar kann man auch sizeof verwenden, wenn du entsprechend berücksichtigst, dass sizeof einen anderen Wert liefert. Selbstverständlich könnte man auch gleich eine Zahl hinschreiben
-
Thread
C Array - neuen Wert in Array aufnehmen und die Werte zuvor nach rechts schieben
ständig rumzuschubsen. Benutz doch einfach einen Zeiger. Temp[index++]=TempRead; if (index >=sizeof...) index=0;
schmeissen, so die libc das hergibt. Damit wird das ganze Geschiebe zu: [c]memmove(Temp+1,Temp,sizeof(Temp)-sizeof(Temp[0])); Temp[0]= TempRead;[/c] Gruss WK
-
Thread
Logische Inverse in C
0b11101, 0b11000}, { 0b11101, 0b10100} }; int check(byte in) { for (size_t i = 0; i < (sizeof(data) / sizeof(data[0])); i++) { if ((in & data[i].mask) == data[i].filter) return i; } return -1; // not found } [/code]
, > { 0b11101, 0b10100} > }; > > > int check(byte in) > { > for (size_t i = 0; i < (sizeof(data) / sizeof(data[0])); i++) > { > if ((in & data[i].mask) == data[i].filter) return i; > } > return -1; // not found > } > [/code] Was sind eigentlich Ternärvektoren? Und was
-
Thread
C versus Assembler->Performance Gesperrt
code sind böse, was ist wenn die größe vom Puffer sich mal ändert? [c] memset( &DataRead, 0, sizeof(DataRead) ); [/c] würde ich hier vorschlagen.
aufrufen -------------------------------- uint8_t u8Idx = 0; uint8_t u8Max = (uint8_t) ( sizeof(scEsc_SysTick.apfct ) / sizeof(scEsc_SysTick.apfct[0]) ); while ( u8Idx != u8Max ) { void ( *pfct ) (void) = scEsc_SysTick.apfct[u8Idx++]; if ( pfct
-
Thread
probleme mit pointern.
double rddouble(unsigned int index) { return params[index].val; } [/c] Und so nebenbei: (sizeof(val)/2)>>1) Was denkst du, was bei diesem Konstrukt rauskommen soll?
1: (sizeof(val)/2)>>1) war der lezte versuch.... das /2 wa halt ne verbesserung... ist eigendlich quatsch... das macht mich ja auch so stutzig... weil teile ich es nicht durch 2 so bekomme ich nur jeden 4.ten
-
Thread
Mehrere Livestreams auf Raspberry Pi
dummys const uint8_t cams[] = { 1, 2, 3, 4 }; GstElement *pipeline[(sizeof(cams)/sizeof(cams[0]))]; GtkWidget* newCamera(uint8_t pipeNum) { GtkWidget *video_window; GstElement *source, *depay, *parse, *decoder, *converter, *sink; pipeline[pipeNum] = gst_pipeline_new
FALSE, 0); gtk_container_add(GTK_CONTAINER(window), hbox); for(uint8_t i = 0; i < (sizeof(cams)/sizeof(cams[0])); i = i + 1) { gst_element_set_state(pipeline[i], GST_STATE_PLAYING); } gtk_window_fullscreen(GTK_WINDOW(window)); gtk_widget_show_all(window);
-
Thread
.Variable : Was macht der Punkt
final = crc32_final, .finup = crc32_finup, .digest = crc32_digest, .descsize = sizeof(u32), .digestsize = CHKSUM_DIGEST_SIZE, .base = { .cra_name = "crc32", .cra_driver_name = "crc32-table", .cra_priority = 100, .cra_blocksize = CHKSUM_BLOCK_SIZE, .cra_ctxsize = sizeof(u32), .cra_module = THIS_MODULE, .cra_init = crc32_cra_init, } }; // /kernel/crypto/anubis.c static struct crypto_alg anubis_alg = { .cra_name = "anubis", .cra_flags
-
Thread
Interrupt-Klasse für ATXMegas
while (e->next) { e = e->next; } e->next = (interruptFunc_t*) malloc(sizeof(interruptFunc_t)); e->next->interrupt = this; e->next->next = 0; } else { e->interrupt = this; e->next = 0; } } void removeFromInterrupt
: > e->next = (interruptFunc_t*) malloc(sizeof(interruptFunc_t)); Warum "malloc" und nicht "new"? Was auch interessant wäre, statt virtueller Funktionen std::function zu verwenden. Dann könnte man auch Lambdas hinzufügen, zB so: [c]int main
-
Thread
String in EEPROm speichern und auslesen
t ee_HEADER EEMEM = 1; char* g_Header = "Unbekannt"; eeprom_update_block(g_Header, &ee_HEADER, sizeof(g_Header)); [/c] Würde mich über etwas Hilfe freuen. :D Gruß Jonas
g_Header = "Unbekannt"; g_Header ist ein Pointer. > eeprom_update_block(g_Header, &ee_HEADER, sizeof(g_Header)); Damit liefert sizeof(g_Header) die Größe eines Pointers. Nur ... die interessiert dich ja eigentlich überhaupt nicht. Du willst ja nicht wissen, wie groß die Referenz auf den String
-
Thread
UDP Client IP ändern
; memset(clientAddr.sin_zero, '\0', sizeof clientAddr.sin_zero); /*-----------------------------------------*/ /*Bind socket with address struct*/ bind(udpSocket, (struct sockaddr *) &serverAddr, sizeof(serverAddr)); /*Initialize
clientAddr.sin_addr.s_addr = inet_addr("192.168.40.170"); sendto(udpSocket,"#OK",3,0,(struct sockaddr *)&clientAddr, sizeof(clientAddr)); da reagiert der Client leider nicht :-( PS. das C++ Projekt läuft auf einem RasPi
-
Thread
24 Einzelne Bits zu 3 Byte zusammen fügen in c++?
uint8_t mix[] = { 1, 12, 18, 0, 24, 11 }; uint32_t ret = 0; for (int i = 0; i < sizeof(mix); i++) ret |= ((raw >> mix[i]) & 1) << i; return ret; } [/c]
0,7>, HWPin<0, 3>, HWPin<1, 4> > {}); std::cout << "0x" << std::hex << std::setw(CHAR_BIT * sizeof(packed) / 4) << std::setfill('0') << packed << std::endl; }[/c]
-
Thread
Dateistream "abfangen"
f.open("testDatei.txt", ios::in); while (!f.eof()) { f.getline(cstring, sizeof(cstring)); cout << cstring << endl; } f.close(); system("pause"); } [/code] und zu den tests, Löschen kann ich die Datei leider nicht, da auf sie zugegriffen wird... öffnen
schlecht ist) das in etwa so zu machen: [code] while (1) { if (f.getline(cstring, sizeof(cstring))!=NULL){ cout << cstring << endl; }else{ f.close(); f.open("testDatei.txt", ios::in); } } [/code] Heißt einfach, vorerst pack ich alles in eine Endlosschleife
-
Thread
[C++] Telnet Server
das hier: [c] //Empfangen und Ausgeben int BytesRec = recv(conn, Buffer, sizeof(Buffer), 0); Buffer[BytesRec] = 0; cout << "Client:" << Buffer << endl; //Befehle erkennen Befehl = Buffer; [/c] Funktioniert schonmal nicht. Dein Befehl muss nicht
> das hier: > [c] > //Empfangen und Ausgeben > int BytesRec = recv(conn, Buffer, sizeof(Buffer), 0); > Buffer[BytesRec] = 0; > cout << "Client:" << Buffer << endl; > > //Befehle erkennen > Befehl = Buffer; > > [/c] > Funktioniert schonmal nicht. Dein
-
Thread
MSP430 USART1 benutzen
interrupts ... } #pragma vector=UART1TX_VECTOR __interrupt void usart1_tx (void) { if (i < sizeof answer1-1) // string schon zu ende? TXBUF1 = answer1[i++]; // string ausgeben else if (i == sizeof answer1-1) // wenn erster string zu ende ... {
// ... dann den getippten buchstaben ausgeben i++; } else if (j < sizeof answer2-1) // wenn auch der ausgegeben ist ... TXBUF1 = answer2[j++]; // ... dann den zweiten string ausgeben } #pragma vector=UART1RX_VECTOR __interrupt void usart1_rx
-
Thread
16 Bit emulation mit GCC
verschwendet viel, wenn man mit ASCII arbeitet. 8 Bit breite Typen gibt es dort gar nicht. und sizeof(int) ist sizeof(char), beides ist 16 Bit. Wobei sizeof(int) = 1 ist, da ja nur eine Adresse belegt wird. Vielleicht solltest du einfach mal über den Tellerrand schauen und dich mit verschiedenen
-
Thread
Luminary 3s6965 Cortex-m3, Linker Problem
Problematisch ist folgende Section im Linkerfile: [c] .data : AT(ADDR(.text) + SIZEOF(.text)) { _data = .; *(vtable) *(.data*) _edata = .; } > SRAM [/c] AT und > zu mischen, kann zu diesen Fehler führen. [c] Versuch mal sowas wie
text sowohl *(.text*) als auch *(.rodata*), legst .data aber an die Adresse [c] ADDR(.text) + SIZEOF(.text). [/c] Meiner Meinung nach müßte das aber [c] ADDR(.text) + SIZEOF(.text) + SIZEOF(.rodata). [/c] heißen. Sobald Konstanten im Programm genutzt werden, müßte dann der Fehler kommen.
-
Thread
Interruptproblem USART Atmega3250
int temp = 0 ; temp < sizeof(number); temp++) { number[temp] = 0; } // Option löschen for( volatile int temp = 0 ; temp < sizeof(option); temp++) { option
Nullterminierung des Strings // Option löschen for( volatile int temp = ++j; temp < sizeof(option); temp++) { option[temp] = 0; } } // Buffer löschen for( volatile int temp = 0; temp < sizeof(buffer); temp++) // Buffer
-
Thread
raw socket - tcp checksum
; /** *set a socket option */ if(setsockopt(rawsock, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)) < 0){ perror("setsockopt()"); exit(1); } /** *initialize paket */ memset(&paket, 0, sizeof(struct hdr)); /** *create IP Header */ .... paket.ip.check
MSG_LENGTH); paket.tcp.check = compute_checksum((uint16*)&Pseudo, MSG_LENGTH + sizeof(struct tcphdr) + sizeof(struct pseudohdr)); /** *now the paket is sent */ se = sendto(rawsock, &paket, sizeof(struct hdr), 0, (struct sockaddr*)&addr, sizeof(struct sockaddr_in
-
Thread
Matlab - Mikrocontroller - serielle Schnittstelle
UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); sei(); while(1) { uart_gets (Line, sizeof(Line)); uart_puts(Line); uart_puts( "\n" ); } }[/c] In Matlab hab ich bis jetzt folgendes eingetippt: [c] clc close all; clear all; // Aktive Ports löschen delete
Steff G. schrieb im Beitrag #5300497: > while(1) > { > uart_gets (Line, sizeof(Line)); > > uart_puts(Line); > uart_puts( "\n" ); > } Du lässt vom uC lauter leere Zeilen zurücksenden, wenn nicht gerade ein Zeichen reinkommt... Da wundert es nicht, wenn beim Empfänger
-
Thread
C TCP / IP String senden
Socketadresse des Servers * Sie besteht aus Typ, IP-Adresse und Portnummer */ memset( &server, 0, sizeof (server)); if ((addr = inet_addr( argv[1])) != INADDR_NONE) { /* argv[1] ist eine numerische IP-Adresse */ memcpy( (char *)&server.sin_addr, &addr, sizeof(addr)); }
); /* Baue die Verbindung zum Server auf */ if(connect(sock,(struct sockaddr*)&server,sizeof(server)) <0) error_exit("Kann keine Verbindung zum " "Server herstellen"); /* Zweites Argument wird als "echo" beim Server verwendet */ echo_string = argv[2];
-
Thread
Zeiger auf ein Struct-Array-Element übergeben
Klassiker ist doch eher sowas wie: [C] void funktion(char arr[]) { for (size_t i = 0; i < sizeof arr; i++) { putchar(arr[i]); } } [/C] mit einer Frage wie: "Warum werden hier nur die ersten vier Zeichen ausgegeben?"
Yalu X. schrieb im Beitrag #2919098: > Neben den Extern-Deklarationen und dem Sizeof-Operator ist die > Unterscheidung zwischen Array und Pointer bei der Behandlung von Arrays > von Arrays (im Volksmund auch mehrdimensionale Arrays genannt) von > Bedeutung. Da stößt man dann plötzlich
-
Thread
Viele Flags effizient speichern und schreiben/Byte in Bitfeld?
empfangsroutine */ void receiveMsg(TTypMsg typ, void *msg, int len) { if(typ == TYP_MSG_1 && len == sizeof(RcvMsg1)) { memcpy(RcvMsg1, *msg, len); } } /* senden (geschieht auch mit memcpy)*/ sndMsg(TYP_MSG_2, &msg2, sizeof(msg2)); [/c]
/ > void receiveMsg(TTypMsg typ, void *msg, int len) > { > if(typ == TYP_MSG_1 && len == sizeof(RcvMsg1)) > { > memcpy(RcvMsg1, *msg, len); > } > } > > /* senden (geschieht auch mit memcpy)*/ > sndMsg(TYP_MSG_2, &msg2, sizeof(msg2)); Auch das ist nicht portabel.
-
Thread
#define's zusammenfassen
"150071369AC8", }; #define ARRAY_SIZE(x) ((sizeof(x)/sizeof(*x)) ... for( i = 0; i < ARRAY_SIZE( Transponder ) ) { if( strcmp( cardID, Transponder[i] ) == 0 ) OK(); } ... [/c] Ich kann nur meine Standardaufforderung
auch nicht, so wie ich das verstehe is das ja keine 0 ????? Würde ggf. ein Vergleich von k und sizeof meines Transponder-Arrays was bringen? Nur als Idee? Wie ich das umsetzen könnte weiß ich auch noch nicht.
-
Thread
Mikrocontroller über Ethernet verbinden
Serial.print(mymac[i], HEX); if (i < 5) Serial.print(':'); } Serial.println(); if (ether.begin(sizeof Ethernet::buffer, mymac, 8) == 0) { Serial.println( "Failed to access Ethernet controller"); } else { Serial.println("Ethernet controller access: OK"); } ; #if STATIC Serial.println( "Getting
digitalWrite(ledPin10, LOW); } // show some data to the user memcpy_P(ether.tcpOffset(), page, sizeof page); ether.httpServerReply(sizeof page - 1); } void blinkLed(){ while (true){ digitalWrite(ledPin10, HIGH); delay(500); digitalWrite(ledPin10, LOW); delay(500); } }[/c]
-
Thread
msp430f147 amnesie
wohl sein ? FCTL1 = FWKEY + WRT; // Set WRT bit for write operation for (word i=0; i < sizeof data; ++i) flash[i] = data[i]; FCTL1 = FWKEY; // Clear WRT bit FCTL3 = FWKEY + LOCK; // Reset LOCK bit } btw der original firmware-code ist nicht von mir - unsere hatte 'probleme
readParamsFromFlash() { byte *flash = (byte *) 0x1000; // Segment pointer for (word i=0; i < sizeof data; ++i) data[i] = flash[i]; word CRCinFlash = (flash[sizeof data] << 8) + flash[1 + sizeof data]; return CRCinFlash == wordCRC(data,sizeof data); } also wenn checkSumme im flash != der
-
Thread
In C-Code auf Variable des Linker Scripts zugreifen
startOfRealWrapper = LOADADDR(.realWrapper) + 0xFFFF0000; endOfRealWrapper = LOADADDR(.realWrapper)+SIZEOF (.realWrapper) + 0xFFFF0000; } [....] Was da zugewiesen wird, ist erst mal egal. Im C-Text dann sowas: [...] extern unsigned char *startOfRealWrapper; extern unsigned char *endOfRealWrapper
PROVIDE (_etext = .) ; /* <====================== */ } > text .data : AT (ADDR (.text) + SIZEOF (.text)) { PROVIDE (__data_start = .) ; *(.data) *(.data*) *(.rodata) /* We need to include .rodata here if gcc is used */ ... [/pre]
-
Thread
Unterschied zw. uint8_t und unsigned int
Der Unterschied: 'int' ist in der Sprache C/C++ wie folgt definiert: sizeof(long) >= sizeof(int) >= sizeof(short) Die exakte Bit-Größe ist also nicht festgelegt. Sie hängt vom Compiler (nicht vom Prozessor) ab. Ein int8_t ist dafür immer 8 Bit Groß, ist aber, wie schon
-
Thread
FEHLER unsigned char defused(unsigned int*_last_ids[0])
Aufklärung. Also nehm ich nen "einfachen pointer" auf die 0te stelle. so kann ich innerh. der fkt. sizeof(_last_ids) nutzen richitg=
Timo P schrieb: > so kann ich innerh. der fkt. sizeof(_last_ids) nutzen richitg= Nein, kannst du nicht. Sizeof liefert dir die Größe des Pointers, nicht die Größe des Arrays. Du musst die Größe auf irgendeine Art mit in die Funktion geben. Z.B.
-
Thread
strings übergeben
ausschluss einer "Harakiri funktion" werde ich per sizeof sicherstellen oder halt genug an zeichen reservieren, bisher habe ich keine speicherprob. i durch zb. next_char zu ersetzen ist ja auch kein prob. würde trotzdem gerne wissen, warum die verschiedenen
volatile signed char next_char = -1; unsigned char uputs( const char *s ) { if( strlen( s ) > sizeof( protocol ) - 1 ) return FALSE; while( next_char != -1 ) ; strcpy( protocol, s ); next_char = 0; IE2 |= UCA0TXIE; return TRUE; } #pragma vector=USCIAB0TX_VECTOR
-
Thread
Mehrfache if.Verkleinern
char str1[] = "ledaus"; char str2[7] = "ledaus"; len = strlen(ptr); size = sizeof(ptr); printf("%s %d %d\n", ptr , len, size); len = strlen(str1); size = sizeof(str1); printf("%s %d %d\n", str1 , len, size); len = strlen(str2); size = sizeof(str2);
-
Thread
Byte Array/Word-Array
) > { > *(myBuffer++) = giveMeASixteenBitValue(i); > } Du kannst so nicht wissen, dass sizeof(uint_fast16_t) = 2 ist. Es ist die schnellste Version für 16 Bit. Das können auch 32 Bit sein. Oder 24, .... Aber schreib jetzt nicht statt der 2 sizeof(uint_fast16_t) sondern sizeof(bufferSize)
-
Thread
[Atmega32] UART / LCD
Zweites Problem: > char s[17]; > s[16] = ' '; > uart_gets( s, sizeof( s ) ); Ist ein potenzieller Bufferoverflow. Wie ist abgesichert, dass das letzte Zeichen in char s[17] ein Nullbyte ist? char s[17]; uart_gets( s, sizeof( s ) - 1 ); s[16] = '\0'
Stefan B. schrieb: > Zweites Problem: > >> char s[17]; >> s[16] = ' '; >> uart_gets( s, sizeof( s ) ); > > Ist ein potenzieller Bufferoverflow. Wie ist abgesichert, dass das > letzte Zeichen in char s[17] ein Nullbyte ist? Indem sich die uart_gets darum kümmert.
-
Thread
Enum zu char array mappen mit verschiedenen Datentypen
printf ("# %d:\n", i + 1); print_sensor (s++); } } #define ARRAY_SIZE(X) (sizeof (X) / sizeof (*X)) int main (void) { print_sensors (sensors, ARRAY_SIZE (sensors)); sensor_t *s = &sensors[3]; s->sensorC.name = "Sensor C.2"; s->sensorC.data[2] = 42;
sensor_list[] = { &light_sensor_1.super, &audio_sensor_1.super }; size_t sensor_count = sizeof(sensor_list)/sizeof(*sensor_list); int main(){ for(size_t i=0; i<sensor_count; i++) printf("sensor: ", sensor_list[i]); } [/c] In go ist das noch etwas schöner. Um von der Liste wieder
-
Thread
ESP32 IDFv3 Ethernet-Phy KSZ8863 funktioniert nicht
eth_config_t config = phy_lan8720_default_ethernet_config; memcpy(ð_config, &config, sizeof(eth_config_t)); } else if(type == ETH_PHY_TLK110){ eth_config_t config = phy_tlk110_default_ethernet_config; memcpy(ð_config, &config, sizeof(eth_config_t)); } else if
config.phy_power_enable = ksz_phy_power_enable; memcpy(ð_config, &config, sizeof(eth_config_t)); } else { Serial.printf("Bad ETH_PHY type: %u", (uint8_t)type); return false; } eth_config.phy_addr = (eth_phy_base_t)phy_addr; eth_config.clock_mode
-
Thread
copy_if
main () { int a[]={3,5,-7,-4,8,-9}; int b[]={4,-6,5,3,8,-9}; vector<int> v2(b,b+sizeof(b)/sizeof(int)); vector<int> v3; cout <<endl; Copy_if(v2.begin(),v2.end(),back_inserter(v3),isPos); copy(v3.begin(),v3.end(),ostream_iterator<int>(cout," ")); }
return x<0; } int main () { int b[]={4,-6,5,3,8,-9}; vector<int> v2(b,b+sizeof(b)/sizeof(int)); vector<int> v3; cout <<endl; Copy_if(v2.begin(),v2.end(),back_inserter(v3),isPos); copy(v3.begin(),v3.end(),ostream_iterator<int>(cout," ")); }
-
Thread
Variablenüberlauf bei Parameterübergabe
funktioniert nicht mehr. Naja... Soweit mir bekannt, ist int auf den SAM Dingern 32Bit groß. sizeof() würde dir das beweisen.
funktioniert nicht mehr. > > Naja... > Soweit mir bekannt, ist int auf den SAM Dingern 32Bit groß. > sizeof() würde dir das beweisen. Sollte sizeof (int) 2 ergeben, dann hilft es long anstelle von int zu verwenden
-
Thread
GCC Test2 Frage
= *uart_data_ptr; Aktuellere gcctest-Versionen sollte es irgendwo geben.) Ob und inwieweit sizeof(something) funktioniert ist eine Frage in erster Linie, wie "something" deklariert ist, MSVCC hin, avr-gcc her. sizeof hat eine ziemlich exakte Definition im Standard (es muß übrigens keineswegs
). Obiges Codeschnipsel legt nahe, daß es sich bei "uart_data_ptr" um einen Zeiger handelt. sizeof <any pointer> ergibt typischerweise eine Konstante für die jeweilige Architektur (2 im Falle von AVR). Nicht sehr hilfreich. Sizeof *<any pointer> würde die Größe des Objektes benennen, auf das
-
Thread
ISR-Rücksprungadresse feststellen
nicht. Die main sieht folgendermaßen aus: [c] int main(void) { memcpy(&sa, &SaveArea, sizeof sa); initErrorLED(); initWatchdog(WDTO_2S); initializeUART(); set_sleep_mode(SLEEP_MODE_IDLE); sei(); ... assert(!memcmp(&SaveArea, &sa, sizeof sa));
with text uart_puts_P(PSTR("Text: ")); uart_gets(SaveArea.stack, sizeof SaveArea.stack, '\r', 1); printHeadline(); break; case '*': // clear saveArea memset(&SaveArea, 0, sizeof SaveArea);