-
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
Inhalt vom Array austauschen
[c] memcpy(&A[3], B, sizeof(B)); [/c]
-
Thread
Dynamisches 2D Array in C
; i<count; i++) { printf("%i\n", i); test = (int**) realloc(test, i+1 * sizeof(int*)); test[i] = (int*) malloc(5 * sizeof(int)); } } [/c] Ich erhalte folgende Konsolen-Ausgabe: [c] 0 1 2 3 4 realloc(): invalid next size Aborted (core dumped) [/
2D Array idiot... schrieb im Beitrag #5832572: > test = (int**) realloc(test, i+1 * sizeof(int*)); Hier fehlen die Klammern um "i+1". BTW count x realloc ist suboptimal. leo
-
Thread
warum wird char mit 4 Bytes dargestellt?
){ signed char test = 'a'; signed char neg_test = ~'a'; printf("test = %d Byte \n", sizeof(test) ); printf("Integer: %d\n", test ); printf("ist in Hex: x%x\n", test); printf( "neg_test = %d Byte(s) \n", sizeof(neg_test) ); printf("Integer: %d\n", neg_test ); printf("ist
Walter K. schrieb im Beitrag #5832429: > printf("test = %d Byte \n", sizeof(test) ); Das ist übrigens /immer/ 1, denn sizeof gibt die Größe in Vielfachen von "char" an, und "test" ist vom Typ "char", und char ist nunmal genau 1 char groß.
-
Thread
Bit-Felder per structs verschachteln
bit-Feldern lösen. Das folgende Beispiel, auf einem STM32F070 mit Atollic Studio erzeugt laut sizeof eine Größe von 2 Byte. Kann ich dem Compiler sagen, dass es das trotzdem in einem Byte packen darf/soll? [c] typedef struct{ uint8_t MSB : 6; } s_component; typedef struct { uint8_t
auf Anhieb ob für dieses Problem relevant sein könnte, aber ich habe vor einigen Wochen C-Code für sizeof() und offsetof() für Bitfelder (insb. in structs) entwickelt (dabei heisst es ja man kann die C-Operatoren sizeof und offsetof nicht bei Bitfeldern benutzen, was ja auch stimmt; meine Lösung ist ein
-
Thread
Interfaces - fixed-width value types
= 0x0001; int save_bla(bla* bla){ return bla_memory->type->write(bla_memory, bla_location, sizeof(*bla), bla); } [/c] Vermutlich würde ich mir dann noch eine memory registry/factory basierend auf allgemeinen registry/factory funktionen bauen und die statischen Memories sich darin selbst registrieren
-
Thread
LwIP Problem mit Sockets
0); if ( socket_fd < 0 ) { printf("socket call failed"); exit(0); } memset(&sa, 0, sizeof(struct sockaddr_in)); sa.sin_family = AF_INET; sa.sin_addr.s_addr = inet_addr(SENDER_IP_ADDR); sa.sin_port = htons(SENDER_PORT_NUM); ... Aber bei "struct sockaddr_in sa,ra,isa;" bekomme
-
Thread
pure Interface Hierarchy per se virtual ableiten?
>Virtuelle Ableitungen machen Objekte größer. aber immer nur um Pointer size, oder? sizeof() ohne virtual derive + ohne pure virtual = 1 byte ohne virtual derive + mit virtual = 8 byte mit virtual derive + mit pure virtual = 16 byte >Ist es wirklich notwendig, aus den Interfaces
-
Thread
10x mehr Speicherbelegung bei Array von main in Funktion verschieben
const int ROW = 3; int *arr1[ROW]; for(int i=0; i<ROW; i++){ arr1[i]=malloc(sizeof(int)*COL); } for(int i=0; i<ROW; i++) for(int j=0; j<COL; j++) arr1[i][j]=rand()%10; printf("ptr_diff(arr1): %td\n", &arr1[ROW-1][COL-1]-&arr1[0][0]);
int *arr1[ROW]; int *dummy_arr[ROW]; for(int i=0; i<ROW; i++){ arr1[i]=malloc(sizeof(int)*COL); dummy_arr[i]=malloc(sizeof(int)*COL); } .... [/c] Und schon ist die Pointerdifferenz noch größer.
-
Thread
Warum wird beim Inkrementieren eines Doppelpointers immer um 8 Speicheradressen inkrementiert?
Spiel doch mal mit dem sizeof-Operator. Die meisten Compiler wissen was sie tun.
-
Thread
IntToHex function
Bitshifting(barrel shifter): Leftshift anstelle von Rightshift Höchtes Nibble runterholen mit >> (sizeof Zahl * 8 -4) ,.. and 0xf wenn Null, nicht in String einfügen, ansonst normal von links weg einfügen
-
Thread
Cache Strategien für E2PROM in uC
0; i < used; ++i) if (cache[i].addr == addr) return i; if (used == sizeof(cache)/sizeof(*cache)) EEIntCacheFlush(); cache[used].addr = addr; cache[used].data = read_it ? EEPROM.read(addr) : 0; return used++; } uint8_t EEIntCacheRead(uint16_t
-
Thread
Motordrehzahl eingeben Arduino
] = '\0'; strcpy(serial_in_command, serial_in_buff); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); chr_cnt = 0; stringComplete = true; } else // Falls kein Enter kommt muss der Text gespeichert werden in dem inText Array { if(isprint(incomingByte))
else { Serial.println(F("serBUF ov-> DEL")); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); memset(&serial_in_command[0], 0, sizeof(serial_in_command)); chr_cnt=0; } // if(chr_cnt<(MAXBUFFER-2)) } // if(isprint(incomingByte)) }
-
Thread
Am besten C lernen
gültiges C und C++ gleichzeitig. Aber auch wenn der Compiler nicht meckert gibt es Fallstricke: sizeof('0') liefert in C das gleiche wie sizeof(int) (z.B. 2 oder 4), in C++ hingegen immer 1. Hättest du das in deinem Code verwendet, hättest du festgestellt dass .ino eben nicht als C aufgefasst wird.
paar Beispiele für Unterschiede, es gibt aber natürlich noch viel mehr, wie zB das schon genannte sizeof, die designated Initialzier, kein int xyz[n] mit zB int n = 42, kein restrict, etc. pp. [code] int main() { // geht nicht in c++ int b(a) int a; { } // geht nicht in c++
-
Thread
Automatische Variable vs. malloc()
LargeStructPtr = NULL; } /* Malloc */ void fooMalloc(void) { LargeStructPtr = malloc(sizeof(SomeLargeStruct_t)); while( manyManyIterations ) { caller(); } free(LargeStructPtr); } [/c] Vorausgesetzt, dies ist nicht der einzige Aufruf von malloc() im gesamten
-
Thread
Einfacher Algorithmus möglich?
//zusammengesetztes Array deklarieren int arr_len=num_1+num_0; int* arr=malloc(sizeof(int)*arr_len); //zusammengestztes Array initialisieren int i=0; int j=0; int k=0; int num_of_pairs=(num_1>num_0)?num_0:num_1; int num_of_single_digits=abs(num_1-num_
-
Thread
STM32 mit Simulink und TrueSTUDIO
rtmSetErrorStatus(test_M, (NULL)); /* block I/O */ (void) memset(((void *) &test_B), 0, sizeof(B_test)); /* states (dwork) */ (void) memset((void *)&test_DW, 0, sizeof(DW_test)); test_DW.clockTickCounter = 0; }[/c] Das ganze wirft aber beim compilieren einen
-
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
C++17 Simple if/else Konstruktion durch Variadic Template ersetzbar?
{ if(id == InterfaceId<T>::id) throw reinterpret_cast<T*>(this); if constexpr(sizeof...(Args) > 0) typed_throw<Args...>(id); else throw this; } void typed_throw(int id) { return typed_throw_helper<Interface...>(); } [/c] Ginge zwar auch wie oben
-
Thread
undefined reference to __HEAP_END/ __HEAP
Hallo, ich möchte einen speicher für einen Array reservieren. [c] long long *encrypted = malloc(sizeof(long long)*message_size);[/c] diesen möchte ich dann als return wert von der Funktion zurück geben. wenn ich das bauen möchte, bekomme ich in ../tricore/lob\libos.a in function sbrk die Fehler
-
Thread
Arduino: Nach kleiner Änderung nicht mehr compilierbar
// Change 'SS' to your Slave Select pin, if you arn't using the default pin if (ether.begin(sizeof Ethernet::buffer, mymac, SS) == 0) Serial.println(F("Failed to access Ethernet controller")); #if STATIC ether.staticSetup(myip, gwip, dnsip); #else if (!ether.dhcpSetup()) Serial.println
-
Thread
Samd21 (Adafruit Feather or Cortex M0 Mini board) mit NRF24L01 funktioniert nicht
{ // While there is data ready radio.read( &got_time, sizeof(unsigned long) ); // Get the payload } radio.stopListening(); // 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.
-
Thread
Array an Funktion übergeben
uint8_t length, uint8_t* data) { daten.length = length; memcpy(daten.data, data, length * sizeof(*data)); } [/c]
-
Thread
WinApi Hauptschleife
hWnd; MSG msg; WNDCLASSEX wndclassex; wndclassex.cbSize = sizeof (WNDCLASSEX); wndclassex.style = CS_HREDRAW | CS_VREDRAW; wndclassex.lpfnWndProc = &WndProc; wndclassex.cbClsExtra = 0; wndclassex.cbWndExtra = 0; wndclassex.hInstance
-
Thread
Empfangene SPI Message über USART ausgeben
//HAL_GPIO_WritePin(GPIOB,GPIO_PIN_11,GPIO_PIN_SET); HAL_UART_Transmit(&huart3,aRxBuffer,sizeof(aRxBuffer),10); //HAL_UART_Transmit(&huart3,test,3,10); /*HAL_UART_Receive(&huart3,uartbufefr,sizeof(uartbufefr),10); memcpy(txbuffer, uartbufefr, sizeof(uartbufefr));
-
Thread
C String einlesen, wieso geht das?!
Eingabe ist, braucht es eine Begrenzung auf den benutzten Puffer. Man kann es zB mit fgets(buf, sizeof(buf),stdin);
beispielsweise erst zur Laufzeit dynamisch Speicher zugewiesen werden: [c] char name[ 123 ]; // sizeof( name ) = 123 - Der Compiler kennt die Größe char* p = NULL; // sizeof( p ) = 4 p = name; // sizeof( p ) = 4 p = new char[64]; // sizeof( p ) = 4 [/c] Ein "sizeof( pointer )" ergibt
-
Thread
C-Variablen aus I2C EEPROM "booten". Wie deklarieren
auf die Struct und die Startadresse im EEPROM zu übergeben, sowie die Größe der Struct in Byte (sizeof(struct)). Und die andere kopiert vom RAM in den EEPROM. Entweder es gibt schon eine eeprom.h, die beide Routinen verfügbar macht oder Du schreibst sie selber.
Struct und die > Startadresse im EEPROM zu übergeben, sowie die Größe der Struct in Byte > (sizeof(struct)). > Und die andere kopiert vom RAM in den EEPROM. > Entweder es gibt schon eine eeprom.h, die beide Routinen verfügbar macht > oder Du schreibst sie selber. Ja danke, ich glaube, so
-
Thread
Sendefunktion
fülle Rest mit Nullen auf } } HAL_UART_Transmit(&UART1_HANDLER, string, sizeof(string), 1000); // Drucke dann alle Zeichen im string aus [/c]
index] = '-'; } else { index++; } HAL_UART_Transmit(&UART1_HANDLER, string + index, sizeof(11 - index), 1000); }[/c]
-
Thread
Typenproblem
in der Funktion und gibt die Zahl aber mit einer einfachen Genauigkeit zurück. [c] printf("sizeof(%f)=%zd\n", 10.5, sizeof(10.5)); printf("sizeof(%ff)=%zd\n", 10.5f, sizeof(10.5f)); [/c] Ausgabe: [code] sizeof(10.500000)=8 byte sizeof(10.500000f)=4 byte [/code]
-
Thread
geschicktes Suchen von Elementen im Array Gesperrt
85, 0, 0, 0, 0, 0}; int magic_number=arr2[0]; int offset=7; int arr_len=sizeof(arr1)/sizeof(arr1[0]); int m_wert1=mittelwert(arr1, arr_len, magic_number, offset); int m_wert2=mittelwert(arr3, arr_len, magic_number, offset); printf("Mittelwert: %d\n", m_wert1
[]={13,14}; int arr3[]={7,8,9,10,11,12,13,14,15,16,17,18,19}; const int arr1_len=sizeof(arr1)/sizeof(arr1[0]); const int arr2_len=sizeof(arr2)/sizeof(arr2[0]); const int arr3_len=sizeof(arr3)/sizeof(arr3[0]); double temp; int magic_number=0; int offset=7;
-
Thread
Probleme mit C Code und hilfe bei änderung
hingeschrieben hast, ist es *kein* Zeiger, sondern tatsächlich ein Array. Den Unterschied zeigt Dir der /sizeof/ -Operator: [c] void test(char[] p) { printf("sizeof = %d\n", sizeof p); } void main(void) { char array[10]; printf("sizeof = %d\n", sizeof array); test(array); } [/c]
Rufus Τ. F. schrieb im Beitrag #5782991: > Den Unterschied zeigt Dir der /sizeof/ -Operator: > > [c] > void test(char[] p) > { > printf("sizeof = %d\n", sizeof p); > } > > void main(void) > { > char array[10]; > > printf("sizeof = %d\n", sizeof array); >
-
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
GCC cleanup-Funktion / longjmp
#_t* ac); \ void ac_ ## N ## _func(ac_ ## N ##_t* ac){ \ memcpy(&ac_next_jmp,&ac->ac_jmp,sizeof(ac->ac_jmp)); \ ac_ ## N ## _func_sub(ac); \ } \ static inline void ac_ ## N ## _func_sub(ac_ ## N ##_t* ac) #define AUTOCLEANUP(N,ID) \ __attribute__((cleanup(ac_ ## N ## _func))) ac_ ## N ##_t ID; \ memset(&ID, 0, sizeof(ID)); \ if(memcmp(&ac_next_jmp, &ac_unset_jmp, sizeof(ac_unset_jmp))){ \ memcpy(&ID.ac_jmp, &ac_next_jmp, sizeof(ac_next_jmp)); \ if(setjmp(ac_next_jmp)){ \ ac_ ## N ## _func(&ID
-
Thread
qsort array funktioniert nicht
getNumberOfArrayElements(result2); array_[2] = getNumberOfArrayElements(result3); int8_t size = sizeof(array_) / sizeof(array_[0]); qsort((void*)array_, size, sizeof(array_[0]), comparator); return array_[0]; } [/c]
-
Thread
static const oder define in c-Datei
. Eine Konstante ist ein Sprachelement. Mit einem Makro geht nicht: [c]fwrite (&numberOfBlocks, sizeof (numberOfBlocks), 1, file);[/c] Dies führt zu Problemen [c]void foo (void) { int numberOfBlocks = 42; }[/c] und bei überladenen Funktionen oder templates ist unklar was jetzt genau bei "foo(numberOfBlocks
-
Thread
Funktion soll Zeiger auf Struct zurück liefern
EE_ReadDataSet(logfile_t *ptr, uint16_t nr) { char *p = (char*)ptr; uint16_t pos = (nr * sizeof(ptr)); for (int i = pos; i < (pos + sizeof(ptr)); i++) { *p++ = eeprom.readByte(pos); } } [/c] Bisher.... hätte aber gerne *p = EE_ReadDataSet(i); [c] /* Externes EE auslesen ins
EE aus */ logfile_t EE_ReadDataSet(uint16_t nr) { logfile_t *res; uint16_t pos = (nr * sizeof(res)); for (uint16_t i = pos; i < (pos + sizeof(res)); i++) { *(char*)res++ = eeprom.readByte(pos); } return (*res); } [/c]
-
Thread
I2C-ADC: Meßwert mit zwei statt einem Byte abholen
reg_addr; messages[0].addr = deviceAddress; messages[0].flags= 0; messages[0].len = sizeof(outbuff); messages[0].buf = &outbuff; inbuff = &data; messages[1].addr = deviceAddress; messages[1].flags = I2C_M_RD; messages[1].len = sizeof(*inbuff); messages[1].
-
Thread
Zu blöd für sscanf?
int %hu ist für unsigned short %hhu ist für unsigned char (seit C99) Bei %u beschreibt scanf sizeof(int) Bytes Wenn die Variable aber weniger Bytes belegt, wird über deren Grenze hinaus geschrieben und andere Variablen überschrieben.
-
Thread
PIC24 UART Rx Interrupt
uint8_t readBuffer[5]; unsigned int data, numBytes = 0; unsigned int readbufferLen = sizeof (readBuffer); UART1_Initialize(); while (numBytes < readbufferLen) { //Check for data at a particular place in the buffer data = UART1_Peek(3); if (data == 5)
-
Thread
Array einer Variable übergeben in C
Hans schrieb im Beitrag #5775707: > val = sizeof(sumArray)/sizeof(sumArray[0]); Warum so umständlich? Da du das Array vorher explizit auf diese Größe festgelegt hast, genügt doch: [c] val = (limitIndexRight - limitIndexLeft) * sizeof(uint16
limitIndexLeft; Jörg W. schrieb im Beitrag #5775714: > val = (limitIndexRight - limitIndexLeft) * sizeof(uint16_t); Was will der TO? Die Anzahl der Array-Member oder die Größe des dynamischen Arrays in Bytes? Nach den verzweifelten Versuchen mit "sizeof(sumArray)/sizeof(sumArray[0])" zu urteilen
-
Thread
Compilierung des EU1KY AA unter Linux.
jede Zeile Code erstmal anschauen ob die so funktioniert. Mögliche Probleme sind da zum Bleistift sizeof(int) oder Alignment beim Cortex-M0 (armv6-m).
-
Thread
[C] Böse Falle: Datentyp korrekt angegeben, falscher verwendet
im Beitrag #5764572: > "Standard": > 30000 * 2 --> int16_t * int16_6 => int16_t Nur wenn sizeof(int16_t) == sizeof(int). Präziser: int * int => int, egal wie gross.
Yalu X. schrieb im Beitrag #5768551: > In > > a * b + c * d > > müssen für sizeof(int)=sizeof(x)=2 (x∈{a,b,c,d}) und a*b ≥ 65536 ≤ c*d Kannst du die Regeln zitieren, aus denen das folgt?