-
Thread
Cast short zu char!
> RS232_OutData((unsigned char *)Daten, sizeof( Daten ) / sizeof(Daten[0]) ); RS232_OutData((unsigned char *)Daten, sizeof( Daten ) * sizeof(Daten[0]) );
*)Daten, sizeof(Daten) / sizeof(unsigned char) );[/c] Aber der C Standard garantiert sizeof(unsigned char) = 1, also kann man sich das sparen.
-
Thread
itoa in Großbuchstaben ausgeben
(s,sizeof(s)-1,"%04X",irmp_data.address); lcd_puts(s); Um anzudeuten, dass es sich um eine Hex-Zahl handelt: snprintf(s,sizeof(s)-1,"0x%04X",irmp_data.address); Verbrät allerdings 6 Stellen auf
*immer* '\0' Ergo: Der String wird *immer* terminiert. > Genaugenommen müsste noch eine s[sizeof(s)-1]=0; einfügt werden. Doppel-Falsch: a) sizeof(s)-1 ist falsch: Du hast ein Zeichen zu wenig, weil snprintf() bereits mit '\0' terminiert - und zwar bereits an der Stelle sizeof
-
Thread
Größe von einem "struct Array" bestimmen?!
"Neustart" ,3}, {"Exit" ,4}, }; void test(menue_t *m) { printf("%d",sizeof(m) / sizeof(m[0])); } [/C]
Rufus Τ. F. schrieb im Beitrag #5293242: > Ja. Mit einem simplen Macro: > #define MENUEANZAHL ((sizeof mainMenue) / sizeof menue_t) Ich würde diese Schreibweise wählen: #define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof((array)[0])) Aber das ist eine Feinheit.
-
Thread
Menüstruktur mit Pointern und structs
Die Sache mit sizeof( MENU_SET_ENTRIES ) / sizeof( *MENU_SET_ENTRIES ), ist dir klar?
ai ) / sizeof( *ai ); oder int size = sizeof( ai ) / sizeof( ai[0] );
-
Thread
Pointer auf Array
sizeof(uint8_t*)!=sizeof(uint8_t)
sizeof(pointer1), sizeof(pointer2) und sizeof(pointer3) ergeben denselben Wert (ohne *)
-
Thread
[C] Arrays zusammenführen, oder: Array als Funktionsrückgabe
/w/c/language/sizeof Gruß Herby
(sizeof eines Arrays mit variabler Größe) Herby
-
Thread
sizeof() funktioniert nicht bei Array im EEPROM
/sizeof/ funktioniert korrekt; Du übergibst einen Pointer, und /sizeof/ gibt Dir dessen Größe zurück. Und die ist auf einem AVR nunmal 2. Um die Größe eines Arrays zu bestimmen, sind andere Mechanismen
Block wie im AVR-GCC Tutorial beschrieben ? [c]eeprom_read_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));[/c]
-
Thread
Diagnose-Programm für Umgebungsparameter wie sizeof(int), Endianess, Alignment usw.?
__SIZEOF_PTRDIFF_T__ 2 #define __SIZEOF_SHORT__ 2 #define __SIZEOF_SIZE_T__ 2 #define __SIZEOF_WCHAR_T__ 2 #define __SIZEOF_WINT_T__ 2 #define __SIZE_MAX__ 65535U #define __SIZE_TYPE__ unsigned int [
auf meinem PC: Size of byte in bits is 8 Size of char (in bytes) is 1 Size of wide char is 4 sizeof(short) = 2 sizeof(int) = 4 sizeof(long) = 8 sizeof(long long) = 8 sizeof(float) = 4 sizeof(double) = 8 sizeof(long double) = 16 sizeof(void *) = 8 byte order = little endian char signedness
-
Thread
Bytes einsammeln, Überlauf Problem?
Hansi schrieb im Beitrag #5650105: > if ( index > sizeof(inStream) ) index darf nicht grösser als (sizeof(inStream)) - 1) werden.
@Stefanus Wo ist oben? Ich sehe nirgends ein sizeof(stream).
-
Thread
Atmega8A - PWM-Einstellung über Spannungsteiler mit AD Wandlung
Comparewertes für Q1/Q4 { n2=0; n1--; } if((x>=(2*sizeof(array)))&&(x<(3*sizeof(array)))) // Hochzählen des Comparewertes für Q2/Q3 { n1=0; n2++; } if((x>=(3*sizeof(array)))&&(x<(4*sizeof(array
des Comparewertes für Q1/Q4 { n2=0; n1--; } if((x>=(2*sizeof(array)))&&(x<(3*sizeof(array)))) // Hochzählen des Comparewertes für Q2/Q3 { n1=0; n2++; } if((x>=(3*sizeof(array)))&&(x<(4*sizeof(array))))
-
Thread
zufallsabhängig eine Anzahl von Instanzen? eines Structs erstellen
Zeigern auf die Zeilen: feld = (feld_t**)malloc( mFeld*sizeof(feld_t*) ); if( !feld ) ...Fehlerbehandlung...; size_t iZeile; for( iZeile=0; iZeile<mFeld; ++iZeile ) { feld[iZeile] = (feld_t*)malloc( nFeld*sizeof(feld_t) ); if( !feld[iZeile] ) ...Fehlerbehandlung
*/ srand(time(NULL)); printf("Ein unsigned ist %d byte groß\n\n", (int)sizeof(x)); printf("Ein Pointer auf ein unsigned ist %d byte groß\n\n", (int)sizeof(p)); printf("Ein Struct vom Typ sHase ist %d byte groß\n\n", size_sHase); //ersten Platz
-
Thread
Array ins Flash speichern STM32F103VDT6
Wieso berechnest du x durch: [c]int x = (sizeof(tSetup2) / sizeof(int));[/c] sollte es nicht eher wie folgt sein, wenn du 32bit-Daten auf den Flash schreibst?: [c]int x = (sizeof(tSetup2) / sizeof(uint32_t));[/c] Außerdem kann es dir dabei
werden? Im übrigen hast du in deinem letzten größeren Codebeispiel weiterhin: [c]int x = (sizeof(tSetup) / sizeof(int));[/c] Ist das nun ein Denkfehler von mir gewesen am Anfang, dass es: [c]int x = (sizeof(tSetup) / sizeof(uint32_t));[/c] heißen müsste? Wenn ja, warum muss es da int
-
Thread
struktur elemeten durchlaufen C
alles in ein array gepakt oder wie soll ich mir das vorstellen? size_t people_count = sizeof(people) / sizeof(people[0]); //sizeof(people) liefert doch 3 oder? also index 0-2 und was macht das teilen durch sizeof(people[0])? [/c]
person_ptr_ptr)->vorname; (**person_ptr_ptr).vorname; person_ptr_ptr[0][0].vorname; // etc. // Achtung: sizeof(person_ptr_ptr) entspricht sizeof(struct person**) entspricht sizeof(void*), alle pointer sind gleich gross, aber sizeof(people_b) entspricht sizeof(struct person*[3]) entspricht sizeof(struct person
-
Thread
C arithmetic promotion Fallstricke
auf Lager. Wer hat schon mal > probiert, was bei > > [code] > const char c = 'A'; > printf("sizeof(c) = %d\n", sizeof(c)); > printf("sizeof 'A' = %d\n", sizeof 'A'); > unsigned char c2 = 0xff; > printf("%02x %02x\n", c2, (char) c2); > > > [/code] > > rauskommt (und warum)? > Extrapunkte
Überraschung auf Lager. Wer hat schon mal > probiert, was bei > const char c = 'A'; > printf("sizeof(c) = %d\n", sizeof(c)); > printf("sizeof 'A' = %d\n", sizeof 'A'); > unsigned char c2 = 0xff; > printf("%02x %02x\n", c2, (char) c2); > > rauskommt (und warum)? Der Code hat undefiniertes
-
Thread
Frage zu Datentypen in C++
Bit-System ist das nicht ungewöhnlich. Auf 32 Bit Systemen Ok, aber auf welchem 64 Bit System ist denn sizeof(double) == sizeof(float)?
= Bytes * 8; oder return number - 1; deine Anwendung von *= und -= ist total komisch sizeof float, double sollte 4 und 8 ergeben, oder machst du sizeof pointer?
-
Thread
static char *pointer;
(daten)); jeweils etwas anderes, denn daten + sizeof(daten) == &daten[sizeof(daten)]
= (U8*)(&daten) + sizeof(daten_t); [/c] ist korrekt. sizeof liefert die Länge in Bytes. Pointer Arithmetik ist aber so definiert, dass der Compiler bei einer Addition immer automatisch mit der Datentyplänge des Datentyps
-
Thread
Array/String Länge ermitteln ohne NULL am Ende
hineinkopierst: [c]char string1 [] = "01 02 03"; char string2 [] = " 04 05 06"; char gesamt [sizeof (string1) + sizeof(string2) - 1]; memcpy (gesamt, string1, sizeof(string1)-1); memcpy (gesamt+sizeof(string1)-1, string2, sizeof(string2)); SendObdCommand (gesamt);[/c] Das ist, besonders auf Plattformen
)); neue Daten mit verschiedenen laengen in myData SendObdCommand (mydata, sizeof(myData));[/ neue Daten mit verschiedenen laengen in myData SendObdCommand (mydata, sizeof(myData));[/ neue Daten mit verschiedenen laengen in myData SendObdCommand (mydata, sizeof(myData));[/c]
-
Thread
[C - C++] wohin gehört das #define
Bauform B. schrieb im Beitrag #6134924: > const int bufferSize = sizeof buffer / sizeof buffer[0]; "sizeof buffer[0]" ist relativ sinnlos, denn das ist immer 1, da "sizeof(char)" /immer/ 1 ist. Rolf M. schrieb im Beitrag #6134941: > In der Praxis habe ich damit
Programmierer schrieb im Beitrag #6134957: > Bauform B. schrieb: >> const int bufferSize = sizeof buffer / sizeof buffer[0]; > > "sizeof buffer[0]" ist relativ sinnlos, denn das ist immer 1, da > "sizeof(char)" immer 1 ist. Gilt aber nur, solange der Elementtyp char ist. Wenn man den mal
-
Thread
NULL Pointer als Übergabe in Funktion verursacht sporadische Fehler
Sollte das memset(&Prog[0], 0, sizeof(Prog[0])); nicht eher memset(Prog, 0, sizeof(Prog)); sein?
A. K. schrieb im Beitrag #4837224: > memset(&Prog[0], 0, sizeof(Prog[0])); memset(&Prog[0], 0, sizeof(Prog));
-
Thread
Pointer, die 17324ste
ist sizeof (int) = 2, auf einem 32-Bit-System ist sizeof (int) = 4.
nachbilden will, muss man das ebenfalls berücksichtigen. [C] p_string = ((char*)p_string) + sizeof(*p_string); [/C] der Cast ist genau aus diesem Grunde notwendig, damit nicht der Compiler seinerseits bei der Addition nochmal die sizeof mit einrechnet. Denn sizeof char ist per Definition 1.
-
Thread
Fehlerspeicher speichern in einer txt.Datei
Ganz ehrlich, ich kann doch nicht so dumm sein. if( nrErrorCodes < sizeof(ErrorCode)/sizeof(*ErrorCode) - 2 ) nrErrorCodes++; Wenn ich if auskommentiere // if( nrErrorCodes < sizeof(ErrorCode)/sizeof(*ErrorCode) - 2 ) nrErrorCodes++; was ist dann
Jamie schrieb im Beitrag #2913716: > if( nrErrorCodes < sizeof(ErrorCode)/sizeof(*ErrorCode) - 2 ) Nochmal LANGSAM: sizeof(ErrorCode) liefert die Größe des gesammten Arrays. sizeof(*ErrorCode) liefert die Größte des des ersten Array-Elements. also steht
-
Thread
Frage zum Verständnis in C
da das resultierende Array größer wird als nötig.) Korrrekt wäre: [c]int porta_input_values[sizeof(porta_input_pins)/sizeof(int)][/c] Zur Verifikation: [c]printf("s=%ld vs. s/s=%ld", sizeof(porta_input_pins), sizeof(porta_input_pins)/sizeof(int))[/c]
resultierende Array > größer wird als nötig.) > > Korrrekt wäre: > [c]int porta_input_values[sizeof(porta_input_pins)/sizeof(int)][/c] > > Zur Verifikation: > [c]printf("s=%ld vs. s/s=%ld", > sizeof(porta_input_pins), > sizeof(porta_input_pins)/sizeof(int))[/c] Abgesehen davon finde
-
Thread
Wärmebildkamera mit dem MLX90640 und Arduino Due
{ i2c_eeprom_updateUIntArray(I2C_EEPROM_ADRESSE, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(Zaehler[0])); // Zaehler zuruecksetzen } else { i2c_eeprom_readUIntArray(I2C_EEPROM_ADRESSE, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(
, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(Zaehler[0])); i2c_eeprom_readUIntArray(I2C_EEPROM_ADRESSE, EEPROM_SPEICHER_ADR, Zaehler, sizeof(Zaehler) / sizeof(Zaehler[0])); Serial.println();
-
Thread
Grösse eines Array of pointers
das äußere Array tab hab ich's gefunden [c] sizeof(tab) / sizeof(int *) [/c] Bleiben noch die inneren arrays
Schreibweise voll äquivalent? oder gibt es irgend welche Tücken bei Verwendung von 2.? 1. [c]sizeof(tab)/sizeof(tab[0])[/c] 2. [c]sizeof(tab)/sizeof(*tab)[/c] Ich hab mir so ein define gebastelt. [c]#define LEN_STR_ARR(A) ((sizeof(A)/sizeof(*A))-1)[/c] Läuft zwar, aber hoffentlich
-
Thread
sizeof mit stringliste ?
sizeof) Wie krieg ich die Anzahl der Elemente heraus ? MfG Stefan
strl_actions[] PROGMEM = { str_trinken, str_essen, str_schlafen }; const int count PROGMEM = sizeof(strl_actions)/sizeof(PGM_P);
-
Thread
Array Pointer Problem
hat eine sizeof von 6 (wenn ich mal den sizeof(Uint) als 2 annehmen). Das erste Element hat eine sizeof von 2 (weil es ja ein UInt ist), daher besteht das Array aus 6 / 2 = 3 Elementen
ARRAY_SIZE durch den Makroinhalt, so wie das der Präprozessor macht. [C] Block Per[] = { { Ai, sizeof(AC) / sizeof(*AC), AC }, { Di, sizeof(DC) / sizeof(*DC), DC } }; [/C] sizeof wird vom Compiler ausgewertet, daher kommt der Compiler auf: [C] Block Per[] = { { Ai, 4 / 2, AC },
-
Thread
Code unleserlich schreiben um Zeilen zu sparen.
char* lastName, size_t lastNameLength, ) { const char a [] = "Hallo, "; char* res = malloc (sizeof (a) + firstNameLength + lastNameLength + 2); if (!res) return NULL; memcpy (res, a, sizeof (a)); memcpy (res+sizeof (a), firstName, firstNameLength); res [sizeof (a)+firstNameLength] =
uint8_t a1[2]; uint8_t a2[4]; uint8_t a3[8]; uint8_t a4[16]; int main(){ protocol_A(a1, sizeof(a1), spi1_put); protocol_A(a2, sizeof(a2), spi1_put); protocol_A(a3, sizeof(a3), spi2_put); protocol_A(a4, sizeof(a4), spi2_put); } [/c] so haben wir (mit LTO für C): C: 272
-
Thread
ANSI C - open() als Schleife
13 Chars weniger! char gpio_pin_id[] = { 17, 18, 21, 22, 23, 24 }; //int inputs = sizeof(gpio_pin_id)/3; //int inputs = sizeof(gpio_pin_id)/sizeof(gpio_pin_id[0]); // 11 Chars mehr! int inputs = sizeof(gpio_pin_id)/sizeof(char); [/c]
13 Chars weniger! char gpio_pin_id[] = { 17, 18, 21, 22, 23, 24 }; //int inputs = sizeof(gpio_pin_id)/3; // 21 Chars mehr! int inputs = sizeof(gpio_pin_id)/sizeof(gpio_pin_id[0]); [/c]
-
Thread
msgsnd mit variabler Text-Länge
SendString( const char* text ) { int textLen = strlen( text ) + 1; struct MSGBUF* msg = malloc( sizeof(struct MSGBUF) + textlen ); char* msgText = (char*)msg + sizeof( *msg ); msg->mtyp = STRING_MESSAGE; // oder was auch immer strcpy( msgText, text ); msgsend( msg, sizeof( *msg ) + textlen
pid; char* msg; //!< message field }; PARABUF parabuf; msgrcv(qid, ¶buf, sizeof(PARABUF), 12,IPC_NOWAIT) }
-
Thread
crc-Berechnung Codezeile Erklärung
Matthias S. schrieb im Beitrag #6939311: > crc16((uint8_t *) buff, sizeof(buff), 0x1021, 0, 0, > false, false) uint8_t meineVariable = crc16((uint8_t *) buff, sizeof(buff), 0x1021, 0, 0, false, false)
ob eine solche Plattform überhaupt uint8_t kennt Den kann sie nicht kennen, denn was wäre dann sizeof(uint8_t)? sizeof arbeitet in Vielfachen von char, d.h. es kann keinen kleineren (in Sachen Speicherverbrauch) Datentyp als char geben.
-
Thread
Pointer in STRUCT wollen einfach nicht funktionieren! (AVR-GCC)
De Zordo P. schrieb im Beitrag #3830301: > modbus_frame = malloc(sizeof(*modbus_frame)); Das sollte wohl eher: [c] modbus_frame = malloc(sizeof(modbus_frame_t)); [/c] sein. De Zordo P. schrieb im Beitrag #3830301: > modbus_frame->data = malloc(sizeof(*modbus_frame
Rene H. schrieb im Beitrag #3830316: > De Zordo P. schrieb: >> modbus_frame = malloc(sizeof(*modbus_frame)); > > Das sollte wohl eher: > modbus_frame = malloc(sizeof(modbus_frame_t)); > > sein. Sollte lt. meiner Recherche aber funktionieren..? :/ Ja?
-
Thread
Echte Zufallszahl erzeugen?
); fgets( neu.bed_1, sizeof(neu.bed1), stream ); fgets( neu.bed_2, sizeof(neu.bed2), stream ); fgets( neu.bed_3, sizeof(neu.bed3), stream ); fgets( neu.bed_4, sizeof(neu.bed4), stream ); fgets( neu.bed_5,
= fopen( datei,"r" ); long cntln = 0; while( cntln < zeilennummer && fgets( dummy, sizeof( dummy ), stream ) ) cntln++; fgets( neu.wort, sizeof(neu.wort), stream ); fgets( neu.bed_1, sizeof(neu.bed1), stream ); fgets( neu.bed_2, sizeof(neu.bed2), stream ); fgets
-
Thread
Diverse fragen zu Hash Maps in C
hash2(PCSTR key, SIZE_T len){ // Round up to multiple of the size of UINT unsigned char a[(len+sizeof(UINT)-1)/sizeof(UINT)*sizeof(UINT)]; memset(a, 0, sizeof(a)); memcpy(a, key, len); unsigned char b[sizeof(a)]; hash(len, b, a); return *(UINT*)b+(sizeof(b)-sizeof(UINT)); } [/c]
hash2(PCSTR key, SIZE_T len){ // Round up to multiple of the size of UINT unsigned char a[(len+sizeof(UINT)-1)/sizeof(UINT)*sizeof(UINT)]; memset(a, 0, sizeof(a)); memcpy(a+(sizeof(a)-len), key, len); unsigned char b[sizeof(a)]; hash(len, b, a); return *(UINT*)b; } [/c]
-
Thread
C++ Funktions Template für __flash
<avr/pgmspace.h> template<typename T> static T pgm_read(T const*src ) { static_assert(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4); if constexpr (sizeof(T) == sizeof(uint8_t)) return pgm_read_byte_near(src); else if constexpr (sizeof(T) == sizeof(uint16_t))
size() { return sizeof...(Vals); } static constexpr T vals [] PROGMEM = { Vals... }; }; template<typename T, T... Vals> struct progmem_array { uint8_t constexpr size() { return sizeof...(Vals); } static
-
Thread
Compiler-Error xy-ungelöst
Ich hab an dem Code mal weitergearbeitet und mich dann auch mal zwangsläufg mit dem "sizeof" bechäftigt und bin dann auf folgendes gestoßen: http://www.imb-jena.de/~gmueller/kurse/c_c++/c_sizeof.html Somit habe ich ja beim aufruf meiner Funktion: uart_get_line(string, sizeof(string))
#1845865: > Ich hab an dem Code mal weitergearbeitet und mich dann auch mal > zwangsläufg mit dem "sizeof" bechäftigt und bin dann auf folgendes > gestoßen: > http://www.imb-jena.de/~gmueller/kurse/c_c++/c_sizeof.html > > Somit habe ich ja beim aufruf meiner Funktion: > uart_get_line(string, sizeof
-
Thread
Programmiergrundlagen: array=array?
natürlich optimal %p ist nicht nur optimal - sondern eher zwingend Denn manchmal ist sogar: sizeof(int*) != sizeof(char*)
Hunsbuckel schrieb im Beitrag #5367515: > Denn manchmal ist sogar: > > sizeof(int*) != sizeof(char*) Das leuchtet mir jetzt aber irgendwie nicht ein... Wenn ich ein 32-bit Adressraum habe, in diesem kann ich char sowie int ablegen - Wenn sizeof(char*) nun 2 wäre...
-
Thread
Struct als Argument (C++)
@ A. S. Danke, aber das 'sizeof(myStruct)' ist ungeil. Es muss ohne gehen.
Rahald schrieb im Beitrag #5665832: > Danke, aber das 'sizeof(myStruct)' ist ungeil. Es muss ohne gehen. Dann macht man das in C mit einem Makro: [c] #define myDoUpdate(s) DoUpdate(&s, sizeof(s)) ... myDoUpdate(myStruct); ... [/c] (Hier
-
Thread
Frage zu Pointern
Karl Heinz Buchegger schrieb im Beitrag #2515749: > *(array + m*sizeof(*array) + n) > > wäre korrekt. Anstelle des sizeof könnte man auch einfach 5 schreiben. Das sizeof(*array) würde 1 liefern, da *array vom Typ char ist. Also besser 5 schreiben :)
schrieb im Beitrag #2515771: > Karl Heinz Buchegger schrieb im Beitrag #2515749: >> *(array + m*sizeof(*array) + n) >> >> wäre korrekt. Anstelle des sizeof könnte man auch einfach 5 schreiben. > > Das sizeof(*array) würde 1 liefern, da *array vom Typ char ist. Also > besser 5 schreiben :) No
-
Thread
Verständnissfrage -> C Code
sio_job_tabelle *p = tab_ptr; ; p++) { struct sio_job_tabelle jt; memcpy_P (&jt, p, sizeof (struct sio_job_tabelle)); if (jt.typ == 0) break; uint8_t *pos = (uint8_t*) jt.pos; if (ucSioBuffer[0]) { pos += sizeof (sio_slave_st
Kannst noch weiter kürzen: Den memcpy_P (&jt, p, sizeof (struct sio_job_tabelle)); kann man durch die folgende Zuweisung ersetzen: jt = *p; :-)
-
Thread
C: Dimensionen eines Arrays zur Laufzeit herausbekommen
Hi "Der Andere"! Das meine ich nicht ... Auch, wenn du mit deiner Ergänzung recht hast (sizeof(array)/sizeof(<datatype array>)). Ich rede von den Dimensionen. Wollte nämlich nicht n-1 Dimensionen angeben müssen.
übrigens mit den folgenden Ausdrücken, die alle zur Compilezeit ausgewertet werden: [c] sizeof a / sizeof *a // -> 3 sizeof *a / sizeof **a // -> 6 sizeof **a / sizeof ***a // -> 5 sizeof ***a / sizeof ****a // -> 7 [/c]
-
Thread
sizeof in C und C++
sizeof(char) ist per Definition = 1 egal wie viel bit es hat.
von der Größe eines char zurück. Somit ist sizeof(char) *immer* 1, denn char ist nunmal genau 1 char groß. Mit CHAR_BIT * sizeof(X) erhält man die genaue Größe eines jeden Datentyps in bits.
-
Thread
sizeof eines allocierten Speichers
möchte später mal wieder gerne die Anzahl der "lines" wissen. Ich würde das wie folgt lösen, aber mit sizeof(can_message_struct) werd ich ja nur die Größe des Pointers erhalten. Wie bekomme ich die Größe eines allozierten Speichers heraus? [c] anzlines = sizeof(can_message_struct)/sizeof(can_messageblock_typedef
nein. sizeof liefert dir die größe einer struktur zurück. sizeof(irgend_ein_pointer); gibt dir halt die größe der Pointervariablen zurück. da hilft nur selbst mitzählen. dynamische allozierungen haben nix
-
Thread
Kontinuierlich in eine Datei schreiben
baer schrieb im Beitrag #4688962: > char * data = "test" > > fwrite( data, sizeof(data), 1, pFile ); Was gibt hier der sizeof-Operator zurück?
Vor dem snprintf Buffer Initialisieren mit memset(buffer, 0, sizeof(buffer)) Grüsse, René
-
Thread
Kann keinen String zuweisen wieso ?
elmo schrieb im Beitrag #1941932: > strncpy(mode,"Hallo",sizeof(mode)); schön das andere den gleichen fehler machen wie ich, richtig müsste es so sein: strncpy(mode,"Hallo",sizeof(mode)-1);
)); mode[sizeof(mode)-1] = '\0'; [/c]
-
Thread
Gegen array[Size]
lieber KISS und die Welt bleibt in ordnung ;) [..] > uint8_t array_2[123]; [..] > foo(array_2, sizeof(array_2)); Ersters (KISS) unbedingt. Für array_2 aber nicht sizeof() benutzen (das funktioniert hier nur zufällig wie erwartet), generischer ist sowas [code] #define sizeofarray(x) (sizeof
); > } Und wie gibt man die ganze Matrix aus? n kann ich ja so ermitteln: [c] int col=sizeof(x[0])/sizeof(int); [/c] aber wie ermittele ich die Anzahl der Zeilen (wenn man sie nicht als Parameter mitübergibt)?
-
Thread
Wie vorgehen beim String einlesen?
variable machen und die dann dementsprechenend lang machen und dann übergeben? Das Problem ist das sizeof(uart_string) dann immer 30 ist.
gültig sind! D.h. den darfst du nicht vorzeitig >> verwerfen. bekomme ich nicht die Länge mit: sizeof(uartDataCount) ?
-
Thread
Pointer auf Array in einer for schleife
Code posten, speziell den Teil an dem das Menü initialisiert wird. Und bitte mal schaun, was bei sizeof(MENU)/sizeof(*MENU) herauskommt. Thomas
dann probier doch mal folgendes: [c] int i; for(i=0;i<sizeof(MENU)/sizeof(*MENU);i++) { write_str_p(MENU[i], 5, 10+8*i, WHT, RED); } [/c] By the way: gibt j+=10 überhaupt was zurück? Thomas
-
Thread
memcpy array mit offset auffüllen
#5853935: > Sehr merkwürdig, was Du da vor hast. Wieso nicht memset? [c] > memset(&array[20], 0xFF, sizeof(array) - 20);[/c] Dann aber [c]memset(&array[20], 0xFF, sizeof(array) - 20 * sizeof(int));[/c] Falls array nicht als Array gegeben ist sondern nur als Zeiger, dann liefert sizeof(array) natürlich
Johann L. schrieb im Beitrag #5854951: > Dann aber > memset(&array[20], 0xFF, sizeof(array) - 20 * sizeof(int)); Unfug.
-
Thread
16-Bit-Array in 8-Bit-Array zerlegen
deines 16-Bit Arraya hinaus. > das Array> darf auch zerstört werden. [c]for( size_t i = 0; i<sizeof(var1)/sizeof(*var1); i++ ) { var1[i] = ntohs(var1[i]);[/c]
dividiert man nicht durch die Größe vom Typ, sondern durch die Größe eines Elementes vom Array. sizeof(var1)/sizeof(var1[0]); oder sizeof(var1)/sizeof(*var1); Das kann man dann auch als Makro machen [c]#define SIZEOFARRAY(array) (sizeof(array)/sizeof(*array))[/c] Dann braucht man den Typ
-
Thread
Unterschied zwischen memcmp und strcmp – Wann was nehmen?
Bartosz B. schrieb im Beitrag #6725015: > Beide Ergebnisse werden **-1**, auch mit sizeof(buffer1) Ach ja, die '\0' ist ja noch beim sizeof dabei
Ok, aber verstehe ich dich richtig, dass hier sizeof das Problem ist?