-
Thread
Startadresse eines Arrays?
> for (loop=0;loop<sizeof (Light_time_data_ee) ;loop++) das wird nicht das tun, was du dir davon erwartest. sizeof liefert die Größe in Bytes. Und es ist ziemlich unwahrscheinlich, dass ein unsigned int auf deinem System eine sizeof von 1 hat :-)
-
Thread
Deklaration von main()
Pointer auf allozierte Speicherbereiche. Wesentlicher Unterschied: [c]int *ptr; ptr = calloc(a, sizeof(int)); ptr++;[/c] ist legal. [c]int arr[a]; arr++;[/c] ist nicht legal.
s1; const char* cs2 = s2; // decay f1(cs1); f2(cs2); // decay assert(sizeof(s1) == 4); assert(sizeof(s2) == 10); assert(sizeof(cs1) == sizeof(char*)); assert(sizeof(cs2) == sizeof(char*)); } [/c] [1] hier ist zu beachten, dass der Address-Operator den
-
Thread
Probleme mit String der HEX-Zahlen senden soll
Länge in Bytes, sondern in Elementen an. Aufrufseitig heist das dann: [C] Transfer( Data, sizeof( Data ) / sizeof( *Data ) ); [/C]
[2]); putc (j[3]);} } void main { DataPtr = Data; Transmit (data, sizeof(data)); }
-
Thread
Pointer Problem bei Uart Zeichenkette
sizeof(4) ist beim AVR-GCC gleich 2, nämlich die Größer eines Integers. Ich habe deinen Code nicht komplett angeschaut, aber ersetze erst mal alle sizeof(4) durch sizeof Line und schau,
3 Zeichen. Das letzte Byte muß für die abschliessende 0 reserviert bleiben. >uart_gets(Line, sizeof(4)); sizeof(4) dürfte 2 ergeben.
-
Thread
Anzahl der Felder eines struct array
sizeof(message) / sizeof(message[0]) ist dein Freund.
struct schrieb: > void funktionsname (CAN_MSG_T *canmsg){ > for (uint8_t mob=0; mob<(sizeof(canmsg)/sizeof(canmsg[0])); mob++ ){ Das geht so nicht. Du hast von einem Array gesprochen, nicht von einem Zeiger. sizeof(canmsg)/sizeof(canmsg[0]) wird dir Unsinn zurückgeben, weil du die Größe
-
Thread
Arduino Uno Serial stört Timer1 Interrupts?
[c] void resetLEDs() { for (int i = 0; i < sizeof(LED_PINS); i++) { digitalWrite(i, LOW); } [/c] Nö, so nicht. Da fehlt der Zugriff auf LED_PINS[]. Eher so [c] void resetLEDs() { for (int i = 0; i < sizeof(LED_PINS); i++) {
for (int i = 0; i < sizeof(LED_PINS); i++) { pinMode(i, OUTPUT); } Hier fehlt das auch. Hier ist es drin. void setLEDs(byte input) { for (int i = 0; i < sizeof(LED_PINS); i++) { byte mask = 1 << i;
-
Thread
Unterschied zwischen bei Compiler MPLAB® C und MPLAB® XC
/Language code string descriptor ROM struct{BYTE bLength;BYTE bDscType;WORD string[1];}sd000={ sizeof(sd000),USB_DESCRIPTOR_STRING,{0x0409 }}; //Manufacturer string descriptor ROM struct{BYTE bLength;BYTE bDscType;WORD string[11];}sd001={ sizeof(sd001),USB_DESCRIPTOR_STRING, { 'G','m','b','
//Product string descriptor ROM struct{BYTE bLength;BYTE bDscType;WORD string[31];}sd002={ sizeof(sd002),USB_DESCRIPTOR_STRING, { 'D', }}; #pragma romdata SERIAL ROM struct{BYTE bLength;BYTE bDscType;WORD string[8];}sd003={ sizeof(sd003),USB_DESCRIPTOR_STRING,{'6','9','0','0','0','0','0
-
Thread
Problem bei Erweiterung des ARRAY_SIZE(x) Hilfsmakros
struct innerhalb eines anderen structs zurückgeben würde. Beispiel: [c] #define ARRAY_SIZE(x) (sizeof(x)/sizeof(*x)) /* ___ Menu defines ___ */ typedef void (*MenuFnct)(void); struct DisplayElements // Elements to display on TFT screen { uint8_t posx; // "x" element position (the
einer loop Schleife alle "DisplayElements" abarbeiten möchte. Im *Prinzip* sowas: [c] size = sizeof(Menu[1].elements)/sizeof(DisplayElements); [/c] Wie Programmiert man das? Werde noch wahnsinnig.. :D
-
Thread
Mehrdimensionale Felder mit verschiedenen Zeilenlängen?
ExtractString( GPGGA->N_S, sizeof(GPGGA->N_S), &GPGGA_Ptr ); ExtractString( GPGGA->Longitude, sizeof(GPGGA->Longitude), &GPGGA_Ptr ); ExtractString( GPGGA->E_W, sizeof(GPGGA->E_W), &GPGGA_Ptr );
ExtractString( GPGGA->Reference2, sizeof(GPGGA->Reference2), &GPGGA_Ptr ); ExtractString( GPGGA->Empty1, sizeof(GPGGA->Empty1), &GPGGA_Ptr ); ExtractString( GPGGA->Empty2, sizeof(GPGGA->Empty2), &GPGGA_Ptr );
-
Thread
Problem mit realloc?
das Alignment das sizeof mit größer oder halt nicht. Dann gibt es auch keine lücken.
Peter II schrieb im Beitrag #3332290: > p[i] = p + (i * sizeof(p)) p[i] = *(p + (i * sizeof(p))) dereferenzieren nicht vergessen :-)
-
Thread
C: Strukt zugriff auf n. Element innerhalb des Structs
richtig. rein theoretisch könnte man unions als struct implementieren, oder steht irgendwo, dass sizeof(union) = max(sizeof(unionmember)) sein muss?
#2314610: > rein theoretisch könnte man unions als struct implementieren, oder steht > irgendwo, dass sizeof(union) = max(sizeof(unionmember)) sein muss? Nein, nur sizeof(union) >= max(sizeof(unionmember)). Aber der Standard fordert, dass alle Unionmember auf der selben Adresse liegen müssen.
-
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
Suche ein SPI-Analyser
// Interface string index /* CDC Class-Specific Descriptors */ sizeof(USB_CDC_HEADER_FN_DSC), CS_INTERFACE, DSC_FN_HEADER, 0x10,0x01, sizeof(USB_CDC_ACM_FN_DSC), CS_INTERFACE, DSC_FN_ACM, USB_CDC_ACM_FN_DSC_VAL, sizeof(USB_CDC_UNION_FN_DSC), CS_INTERFACE, DSC_FN_UNION, CDC_COMM_INTF_ID, CDC_DATA_INTF_ID, sizeof(USB_CDC_CALL_MGT_FN_DSC), CS_INTERFACE, DSC_FN_CALL_MGT, 0x00, CDC_DATA_INTF_ID, /* Endpoint Descriptor */ //sizeof(USB_EP_DSC),DSC_EP,_EP02_IN,_INT,CDC_INT_EP_SIZE,
-
Thread
C-Code Kleinste Zahl ausgeben
Zahlen moechten Sie eingeben?\n"); scanf_s("%d", &anzahl, 1); zahlen = (int *)calloc(anzahl, sizeof(int)); //Wir reservieren Speicher für "Anzahl" int-Werte mit calloc for (i = 0; i < anzahl; i++) { printf("Zahl eingeben: ", n + 1); scanf_s("%d", &a, 1); zahlen[n++] = a; }
} int main(int argc, char* argv[]) { int x[] = {4,5,2,3,1,0,9,8,6,7}; qsort (x, sizeof(x)/sizeof(*x), sizeof(*x), comp); for (int i = 0 ; i < 10 ; i++) printf ("%d ", x[i]); return 0; } [/pre]
-
Thread
µC - UART - Linux
also als größe gebe ich an sizeof(raw_data[i] damit sollte ja immer 1 byte gemeint sein und damit ok. was das ONDELAY macht weiß ich ehrlich gesagt gar nicht. ich hab nur das was wir letztes semester benutzt haben wieder hergenommen
float *result) { char get_TSIC[] = {0x01}; char buffer[8]; int n, i = 0; while ( i < sizeof(get_TSIC) ) if ( (n = write(fd, get_TSIC+i, sizeof(get_TSIC)-i) < 0 ) { perror("read_TSIC: write"); return -1; } else i += n; for ( i=0, i<100, ++i ) if
-
Thread
Elemente in einfache verkettete Liste speichern
input_file, name_of_file, "rb"); do { fread(&(first_element_of_single_linked_list->header), sizeof(Header), 1, input_file)) whole_content_string = malloc(sizeof(char) * first_element_of_single_linked_list->header.content_length); fread(whole_content_string,
Funktion *error_code = allocateListMemory(&list); aufrufe, welche den Befehl [c]list = malloc(sizeof(List));[/c] beinhaltet. Mit diese malloc(sizeof(List)) füge ich ja schon ein neues Element ein und diese Zeile mit list = list->next; ist ein Schwachsinn bzw. nicht notwendig.
-
Thread
Unterschied zwischen strcpy und memcpy ?
Nase fallen. [C] char dst[4]; strncpy( dst, "123456", sizeof(dst) ); dst[sizeof(dst)-1] = '\0'; char dst[4] = 0; strncpy( dst, "123456", sizeof(dst)-1 ); [/C] Beide Varianten sind schon besser. Zumindest wird der String wieder korrekt terminiert
Ich sehe mehr das Problem mit dem sizeof(dst) das geht wirklich bloss wenn ein array übergeben wurde. Aber sogut wie jede funktion bekommt ein char* rein. Damit kann sizeof() nicht sinnvollen anfangen.
-
Thread
verständnisfrage code
Static_assert(_Alignof(settings_t) >= 4, "settings_t must be aligned by at least 4"); _Static_assert(sizeof(settings_t) % 4 == 0, "settings_t size must be multiple of 4"); _Static_assert(sizeof(settings_outtype_t) == 1, "enum size must be 1"); [/c] In Deinem Beispiel gibts halt eine vollkommen absurde
unschön ehrlich gesagt.. wenn es um die Ausführung geht reicht die zweite Hälfte völlig [c]if(sizeof(*parameter) == 850){}[/c] macht NULL Sinn, ausser dass ein Fehlerfall ausgelöst wird falls sizeof NICHT 850 liefert beim compilieren. Aber das lässt sich mMn auch eleganter abfragen .. ein
-
Thread
Problem: Float in String umwandeln mit memcpy
ich sizeof verwende (wie wird sizeof bei einer float z.B. 1.25 berechnet? 3?)
snprintf gemacht. int main () { char buffer[8]; int value = 1.25; snprintf(buffer,sizeof(value), "%f",value); return 0; }
-
Thread
Programm bzw. Ablaeufe steuern
t currentState; ExecuteFnct execute; }; struct Task AllTasks[8]; #define MAX_TASKS ( sizeof( AllTasks ) / sizeof( *AllTasks ) ) void RegisterTask( uint8_t Nr, ExecuteFnct fnct, uint8_t StartState ) { if( Nr < MAX_TASKS ) { AllTasks[Nr].currentState = StartState; AllTasks[
man auch machen können. > Aber warum macht man das dann so? Gewohnheit :-) Im Ernst: Die sizeof Variante hat den Vorteil, auch dann korrekt zu funktionieren, wenn man so etwas macht .... [C] int Values[] = { 1, 3, 7, 9 }; #define NR_VALUES ( sizeof( Values ) / sizeof( *Values ) ) [/C]
-
Thread
Index von Array: welcher Datentyp in C
auf den Anfang des Arrays. Der Code bleibt abgesehen davon, > dass ich die Größe nicht mehr mit sizeof bestimmen kann, genau gleich. Genau, hier hast Du mal ein Beispiel dafür, wo ein array-Bezeichner nicht zerfällt und anschließend, wo er in einen Zeiger zerfällt. > Eurer Argumentation nach
bis +4 int a[] = { 16, 9, 4, 1, 0, 1, 4, 9, 16 }; // Aanzahl der Elemente von a #define n (sizeof a / sizeof a[0]) // Index des mittleren Elements von a (die 0) #define k (n / 2) // Zeiger in die Mitte von a int *p = a + k; // p kann nun wie ein Array mit dem Indexbereich [-4,+4] verwendet
-
Thread
Probleme mit send() C
printf("socket failed\n"); return -1; } if (bind(servSock, (struct sockaddr *)&ServAddr, sizeof(ServAddr)) < 0){ printf( "bind failed\n"); return -1; } if (listen(servSock, 10000) < 0){ printf("listen failed\n"); return -1; } clntLen = sizeof(ClntAddr);
printf("socket failed\n"); return -1; } if (bind(servSock, (struct sockaddr *)&ServAddr, sizeof(ServAddr)) < 0){ printf( "bind failed\n"); return -1; } if (listen(servSock, 10000) < 0){ printf("listen failed\n"); return -1; } clntLen = sizeof(ClntAddr);
-
Thread
FreeRTOS - ESP8266 "vergisst" Bytes beim Senden über SPI
WRITE_CMD, addrMSB, addrMLSB, addrLSB, 133 }; while(true) { send_spi(writeMsg, sizeof(writeMsg)); vTaskDelay(10 / portTICK_PERIOD_MS); send_spi(readMsg, sizeof(readMsg)); vTaskDelay(25 / portTICK_PERIOD_MS); const uint8_t resp = read_spi();
WRITE_CMD, addrMSB, addrMLSB, addrLSB, 133 }; while(true) { send_spi(writeMsg, sizeof(writeMsg)); vTaskSuspend(master_write_task); send_spi(readMsg, sizeof(readMsg)); vTaskSuspend(master_write_task); const uint8_t resp = read_spi(); /* ... */
-
Thread
Eigenes Malloc
kleiner als size+sizeof(struct block) ist.
current->next->free == true)) //merge { current->size+=(current->next->size)+sizeof(struct block); current->next=current->next->next; } if((current->free) && (current->size > size + sizeof(struct block)) && (current->size < min_size + sizeof(struct
-
Thread
Verständnisfrage: Pointer auf Array
Der Arrayoperator für x[y] ist identisch zu: *(x+sizeof(*x)*y) Nix Plattenbauweise, sondern völlig logisch und nachvollziehbar.
Auf gar keinen Fall! array1 ist vom Typ int* und array2 ist vom Typ int[4]. Einfacher Beweis: sizeof (array2) == 4 * sizeof(int) sizeof (array1) == 1 * sizeof(int*) Und je nach Maschine ist dies unterschiedlich. > array[1] wird dann zB. auf b dereferenziert, genauso wie > *(array1+1). Ja, unter
-
Thread
Problem mit Zähler
sizeof adc_used_pins / sizeof adc_used_pins[0]) volatile unsigned char adc_used_pins[1] = {0}; volatile int virtual_adc[1] = {0}; [/c] Verstehe jetzt zwar noch nicht ganz warum das vorher nicht geklappt
(sizeof adc_used_pins / sizeof > adc_used_pins[0]) > volatile unsigned char adc_used_pins[1] = {0}; > volatile int virtual_adc[1] = {0}; > [/c] Hmm. Das kanns aber noch nicht gewesen sein. Rein formal
-
Thread
STM32F7 - DCache & DMA
x[] = {'a', 'b', 'c', 'd'}; SCB_CleanInvalidateDCache_by_Addr(reinterpret_cast<uint32_t*>(&x), sizeof(x)); cmd::Serial::transmitDma(&x[0], sizeof(x)); [/c] bzw. [c] uint8_t x[] = {'a', 'b', 'c', 'd'}; SCB_CleanDCache(); cmd::Serial::transmitDma(&x[0], sizeof(x)); [/c] Eine reine DSB
schrieb im Beitrag #5256749: > SCB_CleanInvalidateDCache_by_Addr(reinterpret_cast<uint32_t*>(&x), > sizeof(x)); > cmd::Serial::transmitDma(&x[0], sizeof(x)); So ist's sauberer: [c]SCB_CleanInvalidateDCache_by_Addr(reinterpret_cast<uint32_t*>(x), sizeof(x)); cmd::Serial::transmitDma(x, sizeof(x));[
-
Thread
Ineffiziente Berechnung von AVR-GCC Gesperrt
Außerdem muss seine Größe ein ganzzahliges Vielfaches der Größe von char sein. Und dann gilt noch sizeof(char)<=sizeof(short)<=sizeof(int)<=sizeof(long)<=sizeof(long long). Ein Compiler dürfte also laut C-Standard theoretisch also auch so aufgebaut sein, dass char, short, int, long und long long alle
[c] template<typename A, typename B> B Mul(const A a, const B b) { const uint8_t shift = (sizeof(B) - sizeof(A)) * 8; return static_cast<A>(b >> shift) * a ; } [/c] Und hier produzieren leider alle gcc > 4.6.4 denselben Murks. Ich werde auch dazu ein PR erstellen, falls der TO das
-
Thread
Array aus struct in EEPROM
int array[100] = {0}; (vorausgesetzt wird int 4 byte gross) memset( array, -1, sizeof(array)/sizeof(&array[0]) ); sizeof(array) = 400 (Bytegrösse des gesamten arrays) sizeof(&array[0]) = 4 (Bytegrösse eines Feldes) 400/4 = 100 Anzahl der Felder Die Nichtanwendung von "sizeof
Decius schrieb im Beitrag #4069836: > sizeof(&array[0]) = 4 (Bytegrösse eines Feldes) Falsch. sizeof(&array[0]) = sizeof(void*) Bytegrösse eines Feldes = sizeof(array[0]) = sizeof(int)
-
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
EEPROM
Hi! Probiers mal mit void *block1 = (void *) 10; eeprom_write_block (&ee_buf, block1, sizeof (ee_buf)); oder eeprom_write_block(&ee_buf, (void *) 10, sizeof (ee_buf));
float eeFooFloat EEMEM; float myFloat = 20,5; union { float r; uint8_t i[sizeof(float)]; } u; int main() { u.r = myFloat; /* float in EEPROM */ eeprom_write_block(&(u.i),&eeFooFloat,sizeof(float)); //EEPROM_write(&eeFooFloat,sizeof(float)); /* float
-
Thread
C befehle für anfänger
int my_strlen(char* str) { char *start = str; while (*str++); return (str - start - 1) / sizeof( char ); }
das elegant. Carsten: >>int my_strlen(char* str) { >> char *start = str; >> while ( *str+=sizeof(char) ); >> return str - start - 1; Erstmal: Der Code ist falsch. Ganz einfach deshalb, weil in der Schleife "1" (sizeof(char)) zu *str addiert wird und dann das Ergebnis davon überprüft wird. Siehe
-
Thread
Iteration über Struct
main(void) { static uint16_t init_values[] = { 0xBAD, 0xDEAF, 0xACDC, 0xBABE }; assert(sizeof(FilterArrayAll)/sizeof(*FilterArrayAll)==sizeof(init_values)/sizeof(*init_values)) for ( int i=0; i<sizeof(FilterArrayAll)/sizeof(*FilterArrayAll), ++i ) FilterArrayAll[i]->InputValue = init_values[i]; for ( int i=0; i<sizeof(FilterArrayAll)/sizeof(*FilterArrayAll), ++i ) printf("%X\r\n", FilterArrayAll[i]->InputValue); printf("Ende.\r\n"); getch(); //Auf "Enter" warten. return 0; } [/C]
-
Thread
Funktion mit Pointerübergabe
struct Numbers{ uint8_t data[3]; }; HAL_SPI_Transmit(&hspi1, (uint8_t*) number->data , sizeof(number->data), x_ms); Gruß
Sebastian Kaulitz schrieb im Beitrag #5479482: > HAL_SPI_Transmit(&hspi1, &number , sizeof(number), x_ms); Das &number im Aufruf ist schon falsch, da number bereits ein Pointer ist. Pointer von Pointer ist hier Murks. sizeof() wird ebenso falsch angewendet, weil das der Größe des Pointers
-
Thread
Viele logische Verknüpfungen.
19200, 28800, 38400, 57600, 115200, 230400 }; return std::any_of (baudrates, baudrates + (sizeof(baudrates) / sizeof (baudrates [0])), [&](uint32_t x) { return x == baud; }); } // Variante 2 bool isbaud2 (uint32_t baud) { static const std::array<uint32_t,13> baudrates {{ 300,
4800, 9600, 14400, 19200, 28800, 38400, 57600, 115200, 230400}; static const size_t length = sizeof (baudrates) / sizeof (baudrates [0]); for (size_t i = 0; i < length; ++i) if (baudrates [i] == baud) return true; return false; }[/c] Solche Konstrukte nach Schema F können Compiler
-
Thread
Programmabsturz eines Consolenprogramms unter Windows - wie Fehler finden?
Kommando zurrück. Hatte es in der falschen filter.c geändert. Ja, muss natürlich [c] f=malloc(sizeof(FILTERSTATE_t)); [/c] heißen: [c] printf("%i\n", sizeof(FILTERSTATE_t)); printf("%i\n", sizeof(f)); [/c] gibt: 128 4 Vielen Dank schon mal! Gerhard PS: bin halt eigentlich Pascal
Du kannst auch [C] sizeof *f [/C] schreiben.
-
Thread
C: Unterwartetes Vorzeichen
type ‘int’, but argument 2 has type ‘long unsigned int’ [-Wformat=] printf("size=%i,%i ", sizeof(*enc), sizeof(enc)); ^ mi.c:41:22: warning: format ‘%i’ expects argument of type ‘int’, but argument 3 has type ‘long unsigned int’ [-Wformat=] printf("size=%i,%i ", sizeof
mit dem falschen Format %i > aus. Hier solltest Du %lu verwenden. printf("size=%lu,%lu ", > sizeof(*enc), sizeof(enc)); Nein. Wie ich schon schrieb, ist %zu (hatte nur %z geschrieben) das richtige. sizeof gibt einen size_t zurück, der ein Typedef für unsigned long sein _kann_, aber nicht _muss
-
Thread
Was mache ich falsch mit pointer, array
vorhanden"); nl return 0; } } return matrix; } [/c] > matrix=malloc(zeile*sizeof(int)); Das ist Murks. matrix ist kein int*, sondern ein int**, also ist hier sizeof int nur dann zufälligerweise korrekt, wenn sizeof int == sizeof int* ist. Warum übergibst Du der Funktion
Rufus Τ. F. schrieb im Beitrag #4807215: > *matrix = malloc(zeile * sizeof (int*)); Ich würde den Compiler selber den richtigen Typ finden lassen: [C] *matrix = malloc(zeile * sizeof **matrix); [/C] > *matrix[i] = malloc(spalte * sizeof (int)); > if (*matrix
-
Thread
EIn cast auf (BYTE*) bei einer größeren Variable
p. p ist der Zeiger, *p ist das, worauf er zeigt. Das worauf p zeigt ist immer gleich gross: sizeof(*p) liegt fest. Er will vmtl. auf die Adressrechnung raus: (char *)p + sizeof(*p) hat den gleichen Wert wie (char *)(p + 1)
worauf er zeigt, ist dagegen vom Typ abhängig. Also gilt: [C] struct A * a; sturct B * b; sizeof a == sizeof b; // immer wahr sizeof *a == sizeof *b; // hängt von den Definitionen von A und B ab [/C]
-
Thread
expected declaration specifiers or '.' before '(' token
. [c]#define projectRamUsage 380 + 64 #define bufSize ((RAMEND - 0x100 - projectRamUsage) / sizeof(uint16_t)) // use as much RAM as possible #define RANGE_EXTENSION_BITS 4 // factor for upper measurement range = 2^(RANGE_EXTENSION_BITS+1)[/c]
projectRamUsage = 380+64 }; static const uint16_t bufSize = ((RAMEND - 0x100 - projectRamUsage) / sizeof(uint16_t)); static const uint8_t RANGE_EXTENSION_BITS = 4; [/c] So müsste es gehen
-
Thread
"C" Verketette Listen
feldi schrieb im Beitrag #2146704: > Worin liegt der Unterschied zweischen strlen und sizeof (ist der > unterschied nur dass bei strlen die Abschließende Null nicht mitgezählt > wird?) Diese Frage ist beinahe ebenso sinnlos, wie die ursprüngliche. strlen und sizeof sind zwei verschiedene Dinge: [c] char *a = "Hallo"; strlen(a) -> 5 sizeof(a) -> 2, oder 4, oder 8, (je nach dem wie groß ein Pointer auf dem Zielsystem ist) [/c][c] char b[100] = "Hallo"; strlen(b) -> 5 sizeof(b) -> 100 [/c]
-
Thread
Malloc - Fehler
> sizeof (char) * 4 * 2 + 1 Durch die Verwendung von Klammern im #define-Ausdruck ließe sich das Problem beseitigen. Davon abgesehen > Feld=(char**)malloc(sizeof(char*)* DIM_ZEILE); > for(i=0
von Operatoren gestört wird: [c] sizeof(char*)* GROESSE_FELD * 2+1 [/c] ist nämlich was ganz anderes als [c] sizeof(char*)* (GROESSE_FELD * 2+1) [/c]
-
Thread
Alle Pixeln eines LED-Displays löschen
Makro: Ein "Pixel" löschen > */ ... Also ich wuerde es einfach so machen: memset(&leds, 0, sizeof(leds));
(&leds, 0, sizeof(leds)); > > Als definition, oder wie genau? Definition? Das ist ein Funktionsaufruf.
-
Thread
Offset von Feldern einer Struktur
putIntoHashMap(void* object, int keyOffset, int keySize) { ... } putIntoHashMap(&adam, ?, sizeof(name)); // oder: putIntoHashMap(&adam, ?, sizeof(personalnummer)); [/code] Ich möchte eine HashMap programmieren, die Zeiger auf beliebige Objekte (Strukturen) speichern kann. Um den HashCode
war das auch gedacht. Ich hab's nur falsch hingeschrieben. > Das 3. Argument ist tückisch, weil sizeof nicht unbedingt die Größe > Objekts angibt sondern auch Füllbytes und oder -bits enthalten kann. Bei einfachen Typen (nicht structs) liefert sizeof() aber die richtige größer, oder? Wenn ja,
-
Thread
Wert im Array zugreifen
wollte ich eine schleife machen und auf jedes einzelne Element zugreifen. [code] int moveLength = sizeof(moves)/sizeof(moves[0]); [/code] Allerdings bekomme ich die Fehlermeldung: file.c on line 16:48: error: subscripted value is neither array nor pointer nor vector int moveLength = sizeof(moves
Felix schrieb im Beitrag #5540669: > int moveLength = sizeof(moves)/sizeof(moves[0]); Das ist korrekt. Der von Dir gepostete Rest aber hat mit C nur wenig zu tun. > typedef struct arr_##name ## ist in Bezeichnern nicht zulässig. > // arr_#
-
Thread
print binary
************************************************ char *pbuf = rxBuf; for (uint8_t i=0; i!=sizeof(val)*8; d? val>>=1:val<<=1, i++) { if (i && !(i%4)) *pbuf++ = '.'; *pbuf++ = (val & (d? 1:((typeof(val))1<<(sizeof(val)*8-1))))? '1':'0'; } *pbuf++ = '\n'; *pbuf = '\0'; Serial.print
>::value, "Can only print unsigned types"); char* pbuf = rxBuf; const std::size_t maxBuf = sizeof (rxBuf); // Maximale Anzahl ausgebbarer Bits (lasse 2 Bytes frei für Zeilenumbruch & 0-Byte) const std::size_t maxBits = std::min<std::size_t> (maxBuf - 2, sizeof(val)*CHAR_BIT); if (d) {
-
Thread
Deklaration von external memory
dieser Stelle kann ich mich noch nicht auf den Member folge beziehen und kann daher auch noch nicht sizeof benutzen. [c] union { folge_t folge[255]; unsigned char folgeBytes[ 255 * sizeof(folge_t) ]; } data EXTMEM; [/c] ich nehm bei einem sizeof immer lieber den Variablennamen als den
code (siet_t n, size_t m) { read_block_from_eemem (& folgen[n].part, & ee_folgen[m].part, sizeof (part_t)); } [/c]
-
Thread
String Ausgabe löst Reset aus
Ui, ich meinte natürlich [c] memset(s, 0, sizeof(s) / sizeof(char)); [/c] In deinem Fall macht die Version 1 und 2 keinen Unterschied, aber wenn z.B. ein uint16_t array wäre, würdest du ausserhalb des Speicherbereichs schreiben. Gruß
Jean Player schrieb im Beitrag #2343655: > ich meinte natürlich > memset(s, 0, sizeof(s) / sizeof(char)); Ein sizeof(char) is per Definition immer 1, ist also äquivalent zu dem oben geposteten. > In deinem Fall macht die Version 1 und 2 keinen Unterschied, aber wenn > z.B.
-
Thread
Microcontroller über Windows Applikation anpassen. Aber wie?
ROT | GELB, GRUEN | BLAU, KEINE, GRUEN, KEINE, BLAU }; uint8_t lenSequence = sizeof( Sequence ) / sizeof( *Sequence ); uint8_t nextNr; uint8_t command; int main(void) { DDRC = 0b00011110; // Pinc.1,2,3,4 as Output, the Rest as Input nextNr = 0; while(1
t Sequence[] = { ROT, GELB, GRUEN, BLAU, }; uint8_t lenSequence = sizeof( Sequence ) / sizeof( *Sequence ); while(1) { command = Sequence[nextNr]; nextNr++; if( nextNr == lenSequence ) { nextNr = 0; } PORTC &= ~(1<
-
Thread
float nach string mit einer nachkommastelle
Irgend W. schrieb im Beitrag #7002112: >> sprintf(result,"%f",num) > > eher: sprintf_s(result, sizeof(resault), "%.1f", num); oder noch eher: sprintf_s(result, sizeof(resault), "%.1f", num/10.);
return target; } int main() { char buf[5]; printf("%s\n", toString(buf, sizeof buf, 1)); printf("%s\n", toString(buf, sizeof buf, 10)); printf("%s\n", toString(buf, sizeof buf, 100)); } [/c] Newbie schrieb im Beitrag #7002943: > In anderen Programmiersprachen