-
Thread
Verständnisfrage zu sprintf und der Ausgabe negativer Zahlen
man so nicht sagen. Das ist grob sinnentstellend. Nirgends in C ist festgelegt, das sizeog(int) == sizeof(void*) sein muss. Das hier zu einem "wird als int" übergeben, ist einfach nur missverständlich. > Wenn Du einen größeren Datentyp als int > übergibts, wird dieser in Form von mehreren ints hintereinander
davon ausgegangen, daß die Parameterübergabe unabhängig von der Plattform per "natural type size" (= sizeof(int)) am einfachsten und effizientesten zu implementieren ist. Da ist ja auch was dran...
-
Thread
#define oder wie geht man am besten vor?
int main() { std::cout << "Size of index for a 100 element buffer: " << sizeof(RingBuffer<100>::IndexType) << '\n' << "Size of index for a 10000 element buffer: " << sizeof(RingBuffer<10000>::IndexType) << '\n'; } [/C]
-
Thread
Musikalisches Diskettenlaufwerk
Wow, das klappt auf Anhieb! Danke dir Falk =). Ich verstehe nur nicht wieso anzahl = sizeof(Noten)/4; du hier durch vier und nicht durch zwei teilst. Das Array hat doch 2 Elemente pro Ton? Und ja du hast Recht, das meiste C das ich "kann", hab ich aus irgendwelchen Tutorials zusammenüberflogen
> Wow, das klappt auf Anhieb! Danke dir Falk =). > Ich verstehe nur nicht wieso > > anzahl = sizeof(Noten)/4; > > du hier durch vier und nicht durch zwei teilst. Das Array hat doch 2 > Elemente pro Ton? Ein Array-Eintrag (eine Zeile) besteht aus 2 uint16_t. Das sind in Summe 4 Bytes.
-
Thread
esp32 isr in Klasse
isr_data data = {.pinNumber = INPUT_PIN, .isr_time = 0}; interputQueue = xQueueCreate(10, sizeof(isr_data)); xTaskCreate(LED_Control_Task, "LED_Control_Task", 2048, NULL, 1, NULL); gpio_install_isr_service(0); gpio_isr_handler_add(INPUT_PIN, gpio_interrupt_handler,(void*) INPUT_PIN
); gpio_set_intr_type(inputPin, GPIO_INTR_POSEDGE); interputQueue = xQueueCreate(10, sizeof(isr_data)); xTaskCreate(LED_Control_Task, "LED_Control_Task", 2048, this, 1, &xLedTaskHandle); gpio_install_isr_service(0); gpio_isr_handler_add(inputPin, gpio_interrupt_handler, (void
-
Thread
LPC1857 ARM Cortex M3 Problem mit EMC und SDRAM
der NXP AppNote 10771 { unsigned int i; // 32 bits access for (i = 0; i < 0x2000000; i+=sizeof(unsigned int)) { *(unsigned int *)((unsigned int )SDRAM_BASE_ADDR+i) = i; } for (i = 0; i < 0x2000000; i+=sizeof(unsigned int )) { if (*(unsigned int *)((unsigned int )SDRAM_BASE_ADDR
der NXP AppNote 10771 { unsigned int i; // 32 bits access for (i = 0; i < 0x2000000; i+=sizeof(unsigned int)) { *(unsigned int *)((unsigned int )SDRAM_BASE_ADDR+i) = i; if (*(unsigned int *)((unsigned int )SDRAM_BASE_ADDR+i) != i) { return(0);
-
Thread
HardFault_Handler bei LPC11C14 mit can_onchip
// msgobj_rx 6, // msgobj_tx 1, // isr_handled sizeof(myConstOD)/sizeof(myConstOD[0]), // od_const_num (CAN_ODCONSTENTRY *)myConstOD, // od_const_table sizeof(myOD)/sizeof(myOD[0]), // od_num (CAN_ODENTRY *)myOD, // od_table
-
Thread
C++, festellen ob operator new nutzbar verfügbar ist?
vereinfachte Darstellung, was beim anlegen eine Objektes passiert: Heap new T(a,b,c): - p = malloc(sizeof(T)) - ((T*)p)->ctor(a,b,c) - return (T*)p Stack T(a,b,c): - p = stack - stack = stack + sizeof(T) - ((T*)p)->ctor(a,b,c) Wie du siehst sieht das Objekt selbst nicht, wo der Speicher herkommt
-
Thread
Linux/raspberryPi: Daemon für serielle Schnittstelle (Wetterstation) in C?
systemcall poll ans Herz legen. ungefähr so (Achtung auch pysdocode) [c] #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) struct pollfd pfd[] = { { .fd = port , .events = POLLIN, } }; while (1) { ret = poll(pfd, ARRAY_SIZE(pfd), timeout); if ( ret == 0) { /* timeout */
-
Thread
C++: Segmentation fault in meinem WebsocketServer
sieht eher nach "schönstem" C aus. [c] c_worker** _workers = (c_worker**)realloc(workers,(i+1)*sizeof(c_worker*));[/c] Was ist das?! Schonmal von std::vector gehört? [c] new server("0.0.0.0",80);[/c] Speicher aufräumen, braucht ja keiner?! etc. etc. ...
BUFF_MAX]); }[/c] Und schon wird der "buff" automatisch gelöscht und du sparst dir das Post-It. sizeof(unsigned char) ist übrigens *immer* 1.
-
Thread
uint16_t Array im PROGMEM; erste Elemente stimmen nicht
Also ist die 2 von sizeof(uint16_t) bzw. sizeof(*c3) ?
-
Thread
C returne char[][] („String“-Array)
int i = 0; char* token; // allocate string memory char ** temp = malloc(10 * sizeof(char*)); for (int i =0 ; i < 10; ++i) { temp[i] = malloc(20 * sizeof(char)); temp[i][0] = 0; } /* have a look first */ token = strtok(StringToSplit, delimiters
-
Thread
Potenzen in defines nicht möglich?
übrigens nur auf 16-Bit-Systemen erforderlich, auf 32-Bit-Systemen kann es entfallen. Das liegt an sizeof (int).
übrigens nur auf 16-Bit-Systemen erforderlich, auf >32-Bit-Systemen kann es entfallen. Das liegt an sizeof (int). Na aber mit L wirds systemunabhängig wasserdicht. Wer diesem Müll mit unterschielichen INT Grössen eingeführt hat sollte an die Wand gestellt werden. MFg Falk
-
Thread
AVR-GCC Linker Symbol als Initializer verwenden
> ram /* _siccmdata is used in startup code to init vars in ccm */ _siccmdata = __etext + SIZEOF (.data); .ccmdata : AT ( _siccmdata ) { __ccmdata_start__ = .; _sccmdata = __ccmdata_start__; *(.ccmdata*) . = ALIGN(4); /* All data end */ __ccmdata_end__ = .; _eccmdata = __ccmdata_end__; } > ccm _usedromend = _siccmdata + SIZEOF (.ccmdata); .bss : { ... [/code] Vielleicht hilft das ja... PS: Gerade ausprobiert: [c] const uint32_t *rompointer = &_usedromstart; [/c] im Code compiliert einwandfrei. Also sollte
-
Thread
Problem Uart aus TWI
nop(); UDR = c; #else // loop until we have space while (txpos >= (sizeof(txbuffer)-2)) { nop(); } [/C] tja. da kannst du lange warten. Die Funktion wird aus einer ISR heraus aufgerufen und zu diesem Zeitpunkt sind Interrupts daher gesperrt. Kein Interrupt
nop(); } UDR = c; #else // loop until we have space while (txpos >= (sizeof(txbuffer)-2)) { BACKLIGHT_TOGGLE; nop(); } ATOMIC_BLOCK ( ATOMIC_RESTORESTATE ) { txbuffer[txpos] = c; txpos++; UCSRB |= _BV (UDRIE);
-
Thread
SQL-Befehl für Datenbankservertyp;
Datenquelle abfragen statt per SQL: [c]SQLGetInfo(dbc, SQL_DBMS_NAME, (SQLPOINTER)dbms_name, sizeof(dbms_name), NULL); SQLGetInfo(dbc, SQL_DBMS_VER, (SQLPOINTER)dbms_ver, sizeof(dbms_ver), NULL); [/c] Den Datentyp INT sollten meiner blassen Erinnerung nach aber beide Datenbanksysteme
-
Thread
Code wird nicht immer ausgeführt
Proto.analog[2]=analog[2]; Proto.analog[3]=analog[3]; Proto.crc = CalcCRC16(&Proto,sizeof(Proto)-1); Transmit(&Proto,sizeof(Proto)); protoflag &= ~(1<<RxComp); } if( get_key_short( 1<<KEY1 )) { PORTA ^= 1<<PA0; } if( get_key_long( 1<<KEY1
-
Thread
Array in C/C++ initialisieren
statisch: unsigned int ar[500][500]; dynamisch: unsigned int *p_ar; p_ar = malloc( sizeof(unsigned int) *500*500 ); oder c++ mässig unsigned int *p_ar = new unsigned int[sizex][sizey];
void foo(void) { /* "values" initialisieren */ values = malloc(500 * sizeof values[500]); if (values == NULL) { /* Oha, nicht genug Speicher! */ } /* ... */ } Hilft das bei Ihrer Frage weiter? Gruß Martin
-
Thread
ADC Rauschen beim Bitwechsel
eeprom_read_word(&eeChXOffset[Ch]); uint16_t tmp; tmp = 0; uint8_t k; for (k=0; k<(sizeof(arr[Ch])/sizeof(arr[Ch][0])); k++) tmp += arr[Ch][k]; if (abs(arrsum[Ch]-tmp) > MaxI) { arrsum[Ch] = tmp; TempChX[Ch] = tmp>>MaxIBit; } } [/c] Irgendjemand
-
Thread
Mega128 + gcc + 32k externes SRAM --> läuft nicht
feld; // Zeiger auf Integer // 1000 Zahlen feld=malloc(2000); oder besser: feld=malloc(1000*sizeof(uint16_t); *feld=1; // 1 in den ersten Speicherort *(feld+10)=5; // Zahl in die 10. Speicherstelle, aber 20. Byte!
Achja, richtig wärs natürlich immer so zu schreiben: feld=malloc(1000*sizeof(uint16_t)); if (feld==NULL) printf("Scheisse"); Grad bei MCs hat man nicht unbegrenzt RAM :-)
-
Thread
Millis in while-Schleife
Udp.endPacket(); Serial.println("Clienthash versendet"); memset(recieveddata, 0, sizeof(recieveddata)); memset(serverpollzeithashbuffer, 0, sizeof(serverpollzeithashbuffer)); arraygroesse = 0; memset(clientzeitbuffer, 0, sizeof(clientzeitbuffer)); memset(clienthasharray, 0, sizeof(clienthasharray)); pollidstate1 = 0; pollidstate2 = 0; pollidstate3 = 0; } //IF3 } //IF2 } //IF1 } //Arraygroesse //###############
-
Thread
Attiny2313 - DMX-Receiver - eingestellte Startadresse != reale Startadresse
== STARTADR) { DmxRxField[DmxCount++] = DmxByte; //get channel if (DmxCount >= sizeof(DmxRxField)) //all ch received? { gDmxState = IDLE; //wait for next break } } } [/c] Die von mir einstellte Startadresse ist tatsächlich '1'. Der
DmxRxField[DmxCount - (DmxAddress - 1)] = DmxByte; DmxCount++; if(DmxCount > DmxAddress + sizeof(DmxRxField)) DmxState = IDLE; } } [/c]
-
Thread
#defines in jeder Datei nutzen??
oder berechnet sie explizit, z.B. durch Konstruktionen wie diese: [c] #define arraysize(x) (sizeof x / sizeof x[0]) [/c] Im Übrigen ist von der Benutzung von dynamischen Speicherbereichen auf kleinen µCs unbedingt abzuraten.
-
Thread
Stringteilung in C
return(-1); do { i++; if(*str == token) { dest[cnt] = (char *) malloc ((i * sizeof(char)) +1); memcpy(dest[cnt], str-(i-1), (i-1)); dest[cnt++][(i-1)] = 0; if(cnt > (MAX_STR-1)) return(-1); i=0; } } while(*str++); if(cnt > (MAX_STR-1)) return(-1); dest[cnt] = (char *) malloc ((i * sizeof(char)) +1); memcpy(dest[cnt], str-i, i); dest[cnt++][i] = 0; return(cnt); } int main() { char *str = "Hallo, Welt. Dies ist ein Test zum Tokenizer."; char *dest[MAX_STR];
-
Thread
immer verrücktere Anschreiben von Recruitern
[c]memset(&EDAG, 0, sizeof(EDAG));[/c]
(any.Arbeitgeber) { Claus.bewerben(&EDAG); } else { Claus.weiterhartzen(); memset(&Claus, 0, sizeof(Claus)); } return 0; }
-
Thread
vprintf: region rom overflowed by 6932 bytes
char buffer[256]; if (!L.quiet) { va_list args; va_start(args, fmt); snprintf(buffer, sizeof(buffer), "%s:%d: %s: %s\r\n", file, line, level_name(level), fmt); vprintf(buffer, args); fflush(stdout); va_end(args); } /* Release lock */ unlock(); } [/c] Mein Code ist in
Auf buffer kann man auch ganz verzichten. Alt: [c] snprintf(buffer, sizeof(buffer), "%s:%d: %s: %s\r\n", file, line, level_name(level), fmt); vprintf(buffer, args); [/c] Neu: [c] printf ("%s:%d: %s: ", file, line, level_name(level)); vprintf (fmt, args);
-
Thread
Übergeben eines Textstrings in C
include <stdlib.h> #include <string.h> main(){ char **ptr; int i; ptr=(char**)malloc(5*sizeof(char*)); for(i=0;i<5;i++){ *(ptr+i)=(char*)malloc(20*sizeof(char));} *ptr=strcpy(ptr[0],"teststring1"); *(ptr+1)=strcpy(ptr[1],"teststring2"); *(ptr+2)=strcpy(ptr[2],"teststring3")
-
Thread
C Problem mit Funktionspointern, Watcom C
char* - kein Compiler würde da falschen Code erzeugen. Solche Sachen wie qsort( &arr, count, sizeof(char*), strcmp); schluckt er aus unerfindlichen Gründen auch nicht mehr. Die Funktion muß neu deklariert werden. Nichts gegen Tests des Compilers, da ist aber Erbsenzählerei ...
zurückgegeben wird). Entsprechende Warnungen könnte auch der Linker von sich geben. qsort( &arr, n, sizeof( char*), strcmp) geht nicht mehr - ich muß strcmp umdeklarieren. Eigentlich auch nicht so unbedingt notwendig ...
-
Thread
Zeigerübergabe
Pointer in main eben nicht. Entweder: > unsigned int *pADC = 0; > pADC=(unsigned int*)malloc(sizeof(unsigned int)) oder: > unsigned int pADC = 0; > [...] > SPI0_ADC(&pADC,1); sollten gehen. Aber ohne Gewähr. Beste Grüße, Bartl
Pff. [C] unsigned int* pADC; pADC = malloc(sizeof(int)); [/C] ist viel einfacher.
-
Thread
AVR-UART Interruptgesteuert oder nicht?
uart_puts("AT Z"); // OBD Reader initialisieren _delay_ms(20); uart_gets( input, sizeof( input ) / sizeof( input[0] ) ); zwischen[0]=input[7]; zwischen[1]=input[8]; zwischen[2]=input[9]; zwischen[3]=input[10]; zwischen[4]=input[11]; zwischen[5]=input
-
Thread
char an String anhängen
des Zeigers mit eingerechnet wird. Wenn p also ein Int-Pointer ist, dann wird i automatisch mit sizeof(int) multiplizert, ist p ein Double-Pointer, so wird i mit sizeof(double) multipliziert usw. Hier drinn steckt die Erklärung, warum die Pointer-Array_Index Dualität überhaupt funktioniert. schreibst
-
Thread
Casten macht Probleme
ein konstanter Zeiger, wo noch 10 Char's auf'm Stack reserviert werden 'char * const s = alloca(sizeof(char) * 10);'.
konstanter Zeiger, wo noch 10 Char's > auf'm Stack reserviert werden 'char * const s = alloca(sizeof(char) * > 10);'. Vorsicht damit... [c] char *s = "Hallo"; char v[10] = "Welt"; printf("%p <--> %p\n", s, &s); printf("%p <--> %p\n", v, &v); [/c] [pre] kamajii:~/temp $
-
Thread
Struktur auf Adresse (Zeiger) schreiben
Sizeof?
Ja, das war es. Danke. Hätte ich selbst drauf kommen müssen. Schließlich nutze ich das SIZEOF seit einer Woche fast täglich ;D. Liegt wohl an der Uhrzeit... Danke euch beiden
-
Thread
Probleme mit malloc
previous; // Vorgänger }; struct data *stack_ptr; int stackinit(void) { stack_ptr=malloc(sizeof(struct data)); if(stack_ptr != NULL) { return 1; } else return 0; } [/c]
ganz einfach. Mach vor dein malloc einfach einen cast: [c]stack_ptr=(struct data *)malloc(sizeof(struct data));[/c] MfG Marius
-
Thread
Eine Variable, 2 Typen
[pre]ist sizeof("Datentyp A") gleich sizeof("Datentyp B")?[/pre] Wenn ja, sollte eine union helfen. Man kann sich auch etwas mit typcasts, void-pointern, Konvertierungsfunktionen und/oder einer Universalstruktur a
-
Thread
STM32F4 GCC Linker section nur global?
> ram /* _siccmdata is used in startup code to init vars in ccm */ _siccmdata = __etext + SIZEOF (.data); .ccmdata : AT ( _siccmdata ) { _sccmdata = .; *(.ccmdata*) . = ALIGN(4); /* All data end */ _eccmdata = .; } > ccm _usedromend = _siccmdata + SIZEOF (.
stack_dummy section */ __StackTop = ORIGIN(ccm ) + LENGTH(ccm ); /*__StackLimit = __StackTop - SIZEOF(.co_stack);*/ PROVIDE(__Stack = __StackTop); /* Check if data + heap + stack exceeds ram limit */ /*ASSERT(__StackLimit >= __HeapLimit, "region ram overflowed with stack")*/ ASSERT
-
Thread
C++: Serialisierung: Client/Server Kommunikation über Klassen Objekte
c] bool Socket::send ( const std::ofstream ofs ) const { int status = ::send ( m_sock, ofs, sizeof(ofs), MSG_NOSIGNAL ); if ( status == -1 ) { return false; } else { return true; } } [/c]
bool Socket::send ( const std::ofstream ofs ) const > { > int status = ::send ( m_sock, ofs, sizeof(ofs), MSG_NOSIGNAL ); Wie Rolf schon schrieb, solltest Du Dir Deinen eigenen stream um den Socket her schreiben. Genau genommen ist es sogar der stream buffer, den Du selbst schreiben musst (es
-
Thread
V-USB mit ADC und Schieberegister als SW-SPI-Master
case USB_DATA_OUT: // Works usbMsgPtr = replyBuf; return sizeof(replyBuf); case USB_Check:// Works if(PINB &(1<<PINB3))//wenn PB3 HIGH ist { usbMsgPtr = Highpin; PORTB |= (1<<PB1); return sizeof(Highpin); } else { usbMsgPtr = Lowpin; PORTB |= (1<<PB0); return sizeof(Lowpin); } case USB_Disco://works PORTB |= (1<<PB0); _delay_ms(50); PORTB |= (1<<PB1); _delay_ms(50); PORTB |= (1<<PB2); _delay_ms
-
Thread
Tastenentprellung
) { int i; for ( i = 0 ; i < sizeof( KEYBOARD_DATA ) ; i++ ) { GPIO_setdirection( GPIO_IN , pgm_read_byte( &KEYBOARD_DATA[ i ] ) ); #if defined( GPIO_IN_PULLUP ) GPIO_setPullUp( pgm_read_byte( &KEYBOARD_DATA[ i ] ) );
NONE * \return NONE */ void KEYBOARD_Interrupt( void ) { int i; for( i = 0 ; i < sizeof( KEYBOARD_DATA ) ; i++ ) { // checken ob Taster gedrueckt, wenn ja, Timer hoch zaehlen sonst auf 0 setzen if ( GPIO_getPin( pgm_read_byte( &KEYBOARD_DATA[ i ] ) ) ) { #if defined
-
Thread
Socket richtig beenden in C
if (setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) error("setsockopt SO_REUSEADDR: %s", strerror(errno)); /* Only communicate in IPv6 over AF_INET6 sockets. */ if (ai->ai_family
hinzufügen von: [c] int optval = 1; if (setsockopt(servSock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof optval) < 0) { printf( "setsockopt failed\n"); return -1; } [/c] hat leider nichts gebracht.
-
Thread
unsignet char zusammensetztzen
0x0A }; char *sql_ptr = sql_string; unsigned char c; int val, n; write(fd, prefix, sizeof prefix); if (sscanf(sql_ptr, "%i%n", &val, &n) == 1) { do { sql_ptr += n; c = (unsigned char)val; write(fd, &c, 1); } while (sscanf(sql_ptr, ",%i%n", &val, &n) == 1); } write(fd, suffix, sizeof suffix); return 0; } [/c] Erst werden die Bytes 0x2f und 0x3f gesendet. Dann wird der SQL-String mit sscanf auseinandergeflückt und jedes einzelne darin enthaltene Byte gesendet. Dabei
-
Thread
Operatorüberladung in C++
( F faktor, DataClass<T>& data ) { T *field; field = (T*) mem_malloc( data.getElements()*sizeof(T) ); for( int i = 0; i<data.getElements(); i++ ) { field[i] = faktor + data.field[i]; } DataClass<T> dat; dat.setData( field ); dat.setElements( data.getElements() );
wirklich notwendig, dass ... [C] T *field; field = (T*) mem_malloc( data.getElements()*sizeof(T) ); ... dat.setData( field ); dat.setElements( data.getElements() ); [/C] ... sich der Verwender der Klasse um die Speicherallokierung kümmert? Das sollte nicht sein und läuft
-
Thread
Fehler beim Linken : relocation truncated
int.o(.isr) *(.text) *(.init4) *(.text.avr-libc) *(.fini0) } > text .data : AT (ADDR (.text) + SIZEOF (.text)) { PROVIDE (__data_start = .); PROVIDE (__data_load_start = .); *(.data) PROVIDE (__data_end = .); PROVIDE (__data_load_end = .); } > data .bss : AT (ADDR (.data) + SIZEOF (.data)) { PROVIDE (__bss_start = .); *(.bss) PROVIDE (__bss_end = .); PROVIDE (__heap_start = .); PROVIDE (__heap_end = .); RAMEND = 0x20ff; __stack = RAMEND