-
Thread
Mehrdimensionale, dynamische Arrays
Mach ein sizeof(int*), das ist schöner. Grüsse, R.
Rene schrieb im Beitrag #3137138: > Mach ein sizeof(int*), das ist schöner. Nein richtiger! Es gibt durchaus Systeme auf denen sizeof(int) und sizeof(int *) unterschiedliche Größe bringen. Ich sage mal AS400 :-)
-
Thread
Wahrheit von Zeigerarithmetik
nach Möglichkeit auf die Angabe von Datentypen im sizeof beim malloc-Argument komplett zu verzichten und nach Möglichkeit immer alles über die Variable abzuwickeln. [C] p = malloc( sizeof( *p ) ); [/C] bedeutet: Allokiere ein Objekt, so dass
. Aber der Code compiliert in diesem Fall durch und kann fehlerhaftes Verhalten hervorrufen wenn sizeof(int) != sizeof(void*).
-
Thread
gleitkommazahl Wert eingeben durch einzelne Bytes
eeprom_busy_wait(); m = 0x000042e8; //m= 116.0; eeprom_write_block(&m, &e_m ,sizeof(double)); eeprom_busy_wait(); eeprom_write_byte(&e_sal, 0x46); #endif // Werte aus EEPROM lesen eeprom_busy_wait(); eeprom_read_block(&m,&e_m, sizeof(double)); eeprom_busy_wait
weil er eine union Lösung anbietet und dann im Gegenzug ein [C] float f; unsigned char b[sizeof(float)]; memcpy( &f, b, sizeof(float); [/C] oder ein [C] float f; unsigned char b[sizeof(float)]; f = *(float*)b; [/C] anbieten. Alle 3 Lösungen haben exakt die gleichen
-
Thread
Frage zu Struct
. // die 3 verbleibenden Bits bleiben ungenutzt } y; int main(void) { int sizofx = sizeof(x); int sizofy = sizeof(y); while(1) { } }[/c]
Jo Danke, habs jetzt so gemacht. [c]int main(void) { while(1) { int sizofx = sizeof(x); int sizofy = sizeof(y); } }[/c]
-
Thread
Code optimieren ?
Bruno V. schrieb im Beitrag #7432371: > Rolf M. schrieb: >> Du meinst wahrscheinlich sizeof > > Dann aber zweimal :-)! Uups, sorry: ich meinte natürlich countof. Also sizeof(a)/sizeof(a[0])
{ 929, 6 },{ 907, 7 }, { 886, 10 }, { 864, 12 }, //... }; #define ARRAY_SIZE(X) (sizeof (X) / sizeof (*X)) #define kennfeld_len ARRAY_SIZE(kennfeld) uint16_t Lenght = kennfeld_len; int main() { printf("Arraylaenge:%i", Lenght); printf("\nGesamtbytes:%ld", sizeof
-
Thread
nRF51 TWI-Sensor auslesen
2]), 0), APP_TWI_WRITE(SENSOR_ALPHA_ADDRESS, REGISTER_SETUP[3], sizeof(REGISTER_SETUP[3]), 0), APP_TWI_WRITE(SENSOR_ALPHA_ADDRESS, REGISTER_SETUP[4], sizeof(REGISTER_SETUP[4]), 0), APP_TWI_WRITE(SENSOR_ALPHA_ADDRESS, REGISTER_SETUP[5], sizeof(REGISTER_SETUP[5]), 0), APP_TWI_WRITE(SENSOR_ALPHA_ADDRESS, REGISTER_SETUP[6], sizeof(REGISTER_SETUP[6]), 0), APP_TWI_WRITE(SENSOR_ALPHA_ADDRESS, REGISTER_SETUP[7], sizeof(REGISTER_SETUP[7]), 0), APP_TWI_WRITE(SENSOR_ALPHA_ADDRESS, REGISTER_SETUP[8], sizeof(REGISTER_SETUP[
-
Thread
Ansi-C 4d Array
memset( relais , 255, (sizeof(Switchpoint)*NOF_SWITCHPOINTS)*NOF_RELAIS );
einträge mit 0xff for( i = 0; i< NOF_SWITCHPOINTS ; i++ ){ memset( &relais[0][i].on , 0xff , sizeof( Timestamp )) ; memset( &relais[1][i].on , 0xff , sizeof( Timestamp )) ; } // alle OFF einträge mit 0 for( i = 0; i< NOF_SWITCHPOINTS ; i++ ){ memset( &relais[0][i].off , 0 , sizeof(
-
Thread
Feldgrösse eines Array
die gewünschte "Feldgröße"... Damit könnte die Größe eines Elements gemeint sein. Simpel: sizeof float Umständlich: sizeof array[0][0] Nur wozu?
Hmpf... [pre] (6 * 4 * sizeof(float)) [/pre]
-
Thread
warum werden bei uart immer char gesendet/empfangen?
mit Zeichen und Zeichensätzen zu tun: ein char ist immer ein Byte ist immer von der Größe 1. sizeof(char) = 1.
; uint8_t cmd; int32_t data; uint16_t crc; }; const static uint8_t length = sizeof(toAddr) + sizeof(fromAddr) + sizeof(cmd) + sizeof(data) + sizeof(crc); uint8_t asArray[length]; // für Zugriff über Index } empfDaten, sendDaten; // zwei gleiche Buffer anlegen [/c]
-
Thread
Wie FSM mit Events in Tabelle umsetzen (C)?
state= stateNr, .eventTable= &(struct eventTransTab_s []){ ##__VA_ARGS__ }, \ .eventTableSize = sizeof((struct eventTransTab_s []){ ##__VA_ARGS__ }) / sizeof( struct eventTransTab_s )} #define CREATE_FSM_TABLE( ... ) .stateTableSize= sizeof((struct fsm_state_data_s []){ ##__VA_ARGS__ }) / sizeof
= sizeof((struct eventTransTab_s []){{ . eventId= (event_id_t)EV_TWO, . nextState = (uint16_t)STATE_ZERO, . transFunc = 0 }, }) / sizeof( struct eventTransTab_s )}, }) / sizeof( struct fsm_state_data_s ),
-
Thread
union mit Struktur und Array gleicher Größe?
} int main() { struct eeprom src = { 1,2,0xffffffff,-42 } ; unsigned char buffer[sizeof(struct eeprom)] ; unsigned char *p = buffer ; serialize(src.ui8, sizeof(src.ui8 ),&p) ; serialize(src.ui16,sizeof(src.ui16),&p) ; serialize(src.ui32,sizeof(src.ui32),&p) ; serialize(src.i16 ,sizeof(src.i16 ),&p) ; struct eeprom dst ; unsigned char const *q = p ; dst.i16 = (int16_t )deserialize(&q,sizeof(dst.i16 )) ; dst.ui32 = (uint32_t)deserialize(&q,sizeof(dst.ui32
-
Thread
Warum haben manche Programmiersprachen Nullen und andere Einsen?
include <stdio.h> #include <stdint.h> int main () { int i; uint8_t * p; printf ("sizeof(int) = %lu\n", sizeof (i)); printf ("sizeof(ptr) = %lu\n", sizeof (p)); printf ("sizeof(ul) = %lu\n", sizeof (unsigned long)); p = (uint8_t *) 0x123456789abcdef0; i = 256;
unsigned long) (p - i)); return 0; } [/c] [code] # cc -O2 -Wall -Werror a.c && ./a.out sizeof(int) = 4 sizeof(ptr) = 8 sizeof(ul) = 8 0x123456789ABCDDF0 0x123456789ABCDDF0 [/code] Für mich gibts da keinen Unterschied, aber vielleicht habe ich ja falsche Werte benutzt und Du hast ein
-
Thread
Datentyp mit 2bytes beim STM32
mystruct_t 4 mal rein passt mystruct_t buffer[4]; oder mystruct_t * buffer; buffer = malloc(sizeof(mystruct_t)*4)
willst, der genau die richtige Grröße für deine Struct hat, mach halt: [C] unsigned char buffer[sizeof(deine_struct)]; [/C]
-
Thread
An die C-Profis: Datei einlesen und String teilen
auszulagern. Aktuell bin ich froh dass es läuft :) Carsten schrieb im Beitrag #3115972: >> owbwohl mir sizeof(data) 3143 ausgibt > Denn sizeof(data) sollte die Anzahl der Bytes und nicht der Elemente > zurückgeben (3144 * 5 Bytes = 15720 Bytes). Mir ist bewusst dass sizeof() die größe des gesamten Arrays
Bernhard W. schrieb im Beitrag #3116135: > Mir ist bewusst dass sizeof() die größe des gesamten Arrays in Bytes > ausgibt, deshalb teile ich auch wieder durch die größe des 1. Eintrages > im Array. Das ist alles in Ordnung. > > [c] > size = (sizeof(Data)/sizeof
-
Thread
Array von Zeigern und Doppelzeiger
Strings, jedoch haut das noch nicht so ganz hin: [c] int main(){ int **array_2D = calloc(10, sizeof(int*)); int i = 0; while(i < 10){ *array_2D = calloc(10, sizeof(int)); array_2D++; i++; } *(*(array_2D)) = 12; *(*(array_2D) + 1) = 33; *(
i < 10; ++i ){ array_2D[i] = calloc(10, sizeof(int)); } [/c] ist doch einfach lesbarer.
-
Thread
länge eines arrays wird ein element mehr als für mich erwartet
summe, const char* sum1, const char* sum2) { const uint32_t length_1 = sizeof(sum1)/sizeof(sum1[0]); const uint32_t length_2 = sizeof(sum2)/sizeof(sum2[0]); printf("length1: %d\r\n", length_1); printf("length2: %d\r\n", length_2); for(uint8_t x=0; x<length_1; x
static void add(char* summe, const char* sum1, const char* sum2) > { > const uint32_t length_1 = sizeof(sum1)/sizeof(sum1[0]); > const uint32_t length_2 = sizeof(sum2)/sizeof(sum2[0]); Das funktioniert nicht. Innerhalb der Funktion ist nicht bekannt, wie groß die Arrays sind. Das ist eine elementare
-
Thread
array als parameter / sizeof()
[] = {{"status1", &status1}, \ {"status2", &status2}}; printf("%d\n", sizeof (intParam)); GetIntParam(intParam); void GetIntParam(intTypePrm intParam[]){ printf("%d\n", sizeof (intParam)); }
Ansonsten such hier im Forum nach 'sizeof', das Thema gibts alle Nase lang: http://www.mikrocontroller.net/search?query=sizeof
-
Thread
wie finde ich das Speicherleak?
*ctb(unsigned short usocfe) // *usocfe = Zeiger "unsigned short of cfe" { char *bin = malloc(sizeof(char)* (9+1)); char *temp = malloc(sizeof(char)* (9+1)); int a; for (a=7; a>=0; --a) { switch (usocfe%2) { case 0: usocfe=usocfe/2; strcpy(temp, "0")
(unsigned short usocfe) // *usocfe = Zeiger "unsigned short of cfe" > { > char *bin = malloc(sizeof(char)* (9+1)); > return(bin); > } Maik Geßner schrieb im Beitrag #2142202: > printf("Wert?! %s \n\n", ctb((unsigned short) _cfe[a])); du allozierst in einer Funktion, speicher, den du
-
Thread
String splitten (Programmiersprache: C)
strtok_r(NULL,",",&tmp); // die Einzelteile in Sicherheit bringen strncpy( part1, links, sizeof( part1 ) ); part1[ sizeof( part1 ) - 1 ] = '\0'; strncpy( part2, rechts, sizeof( part2 ) ); part2[ sizeof( part2 ) - 1 ] = '\0'; // mach was damit uart_puts( part1 ); uart_puts
und mit strncpy( part1, links, sizeof( part1 ) ); kopiere ich von links in part1 soviel rein, wie in part1 überhaupt rein passt, also sizeof( part 1) um somit ein Überlauf zu vermeiden... das klingt sehr gut.
-
Thread
typedef union
immer noch nicht. denn es ergibt sizeof(memberA) ist = sizeof(memberB) trotzdem gibts inder Zeile memset( &memberA, 0, sizeof(memberA)); Müll
printf("Init\n"); printf("%p %p %p\n", this, &memberA, &memberB); printf("%ld %ld %ld\n", sizeof(*this), sizeof(memberA), sizeof(memberB)); memberA.elementA = 1; memberB.elementA = 2; nochwas[0] = 3; printf("%d %d %d\n", memberA.elementA, memberB.elementB, nochwas[0])
-
Thread
Verwendung von Serial.readStringUntil
test[56]; template<typename T> void zeigeArrayGroesse(T &array) { cout << F("zellengr: ") << sizeof(*array) << endl; cout << F("anzzellen: ") << (sizeof(array)/sizeof(*array)) << endl; } void setup() { Serial.begin(9600); cout << F("Start: ") << F(__FILE__) << endl; zeigeArrayGroesse
typename T, size_t anzzellen> void zeigeArrayGroesse(T (&)[anzzellen]) { cout << F("zellengr: ") << sizeof(T) << endl;//*array cout << F("anzzellen: ") << anzzellen << endl; } [/c] Hier ist die Referenz dann gar anonym.
-
Thread
Datentyp Formatierung
du kannst es einfach als int lesen so wie du es einfach als int sendest. senden: fwrite(&c, sizeof(uint16_t), 1, f); lesen: fread(&c, sizeof(uint16_t), 1, f);
wenn ich dies ändere: int rx_header_buffer; read(uart0_filestream, &rx_header_buffer, sizeof(int)); stützt das Programm ab...
-
Thread
String-Array und malloc
dann mit str=realloc(str,strlen(str)+1) auf den wirklich benötigten Speicher kürzen. Das malloc(sizeof(char*)*laenge)ist übrigens Unsinn, da du nicht Länge mal Zeiger auf Char brauchst, sondern Länge+1. sizeof(char) ist 1, deshalb kannst du es weglassen, und 1 Byte brauchst du noch für das Nullbyte
str=realloc(str,strlen(str)+1) auf den > wirklich benötigten Speicher kürzen. > > Das malloc(sizeof(char*)*laenge)ist übrigens Unsinn, da du nicht Länge > mal Zeiger auf Char brauchst, sondern Länge+1. sizeof(char) ist 1, > deshalb kannst du es weglassen, und 1 Byte brauchst du noch für das
-
Thread
Basic und/bzw. vs - C Erfahrungsumfrage
in der sizeof sein Ergebnis liefert, ist Byte: |6.5.3.4 (2): |The sizeof operator yields the size (in bytes) of its operand So, können jetzt bitte all diejenigen, die den Standard noch nie von nahem gesehen
> sizeof (int) == 1 (not 2). C55x bytes and words are equivalent (16 > bits). Hier verstehe ich das so, dass das Byte als 16bit definiert ist und da ein char als ein Byte definiert ist (weshalb sizeof(char
-
Thread
C Programmierung ppm Ausgabe Hilfe
); printf("note 2:...."); fgets(adressen.note2, sizeof(adressen.note2), stdin); printf("note 3:...."); fgets(adressen.note3, sizeof(adressen.note3), stdin); printf("Vorname Schueler2...."); fgets(adressen.vorname, sizeof(adressen.vorname
printf("note 3:...."); fgets(adressen.note3, sizeof(adressen.note3), stdin); printf("Vorname Schueler3...."); fgets(adressen.vorname, sizeof(adressen.vorname), stdin); printf("Nachname:...."); fgets(adressen.nachname, sizeof(adressen.nachname
-
Thread
Overflow unsigned char
besser geeignet. ösi schrieb im Beitrag #2703797: > Beachte aber wie bereits oben erwähnt, dass sizeof(char) nicht zwingend > 1 ist. Doch, sizeof(char) ist per Definition immer 1. > Die Kardinalität von char ist 2^(sizeof(char)*8). Wieso 8? Das ist nirgends so festgelegt. Die Zahl an Bits
ösi schrieb im Beitrag #2703797: > Beachte aber wie bereits oben erwähnt, dass sizeof(char) nicht zwingend > 1 ist. In C schon. C99 zum sizeof() Operator: "When applied to an operand that has type char, unsigned char, or signed char, (or a qualified version thereof) the result is
-
Thread
c code: Priorität & Lebensdauer Variable im Funktionsaufruf
nicht gleich 'daten' und habe die kopiererei in der Funktion angefangen, und das klappte dann sizeof(_Localdaten) lieferte ja dann genügend zeichen . Ich habe anstatt sizeof(daten) jetzt strlen(daten) in der Funktion, jetzt liefert es auch anstatt 4 [c] for (i=0; i<sizeof(daten); i++) printf
sizeof - strlen Eine andere Möglichkeit, da noch etwas Klarheit reinzubringen, ist es, sich zu verinnerlichen, dass sizeof eine Compile-Time Sache ist. D.h. hier wertet der Compiler bereits den Ausdruck
-
Thread
Zugriff auf struct über Pointer unter Visual Studio macht Probleme.
BMP_DateiKopf_p_type; #pragma pack(pop) int main(array<System::String ^> ^args) { printf("sizeof unpacked: %d\n", sizeof(BMP_DateiKopf_type)); //sizeof packed: 16 printf("sizeof packed: %d\n", sizeof(BMP_DateiKopf_p_type)); // sizeof packed: 14 Boolean b; return 0;
Wo trennst Du das? Schon das da [c] int main(array<System::String ^> ^args) { printf("sizeof unpacked: %d\n", sizeof(BMP_DateiKopf_type)); //sizeof packed: 16 printf("sizeof packed: %d\n", sizeof(BMP_DateiKopf_p_type)); // sizeof packed: 14 Boolean b; return 0; } [/c
-
Thread
AVR - float in einzelne Bytes
char * ptrToTest = (char *)&test; //habe nicht getestet, daher ohne garantie :) int bytecnt = sizeof(float) / sizeof(char); oder int bytecnt = sizeof(test) / sizeof(char); for (i = 0; i < bytecnt; i++) { sendCharOnUsart(ptrToTest[i]); }
nur mit "char". Daher ist memcpy besser. kyrk.5 schrieb im Beitrag #5580571: > int bytecnt = sizeof(float) / sizeof(char); sizeof(char) ist /immer/ 1. Daher ist das hier überflüssig.
-
Thread
2d array in c erste spalte string, zweite spalte uint8
> CARDS* cards[5]; Das sind nicht 5 CARDS sondern ein Zeiger auf 5 Cards. Kannst mal mit sizeof(CARDS) überprüfen.
> Ist es denn schon die richtige Richtung? Wird besser Mit sizeof(Cards)/sizeof(Cards[0]) Bekommst du die groesse des Arrays Und ich wuerde bei der init cards eher Card* (anstatt Cards[]) und int Count uebergeben
-
Thread
RS485 vermute Störsignale, wie entfernen
Treffend E. schrieb im Beitrag #7108424: > SerialWriteBuf(Anemometer_request, sizeof(Anemometer_request)); Ich frage mich: Wofür ist diese Funktion? Tut nicht ... [c] Serial1.write(Anemometer_request, sizeof(Anemometer_request)); [/c] ... genau das gleiche? Ok, ich kenne
leider nicht. Die Hardware fehlt mir. Ein Test Serial.print(Serial1.write(Anemometer_request,sizeof(Anemometer_request))); Würde dir auch beweisen, das genau dir richtige Anzahl Byte geschrieben werden.
-
Thread
CAN Bus fifo
, char* bytes); CANObj data; //schreiben: Länge=DLC + CAN_ID + RTR ringBufferWrite(data.dlc+sizeof(uint32)+sizeof(char), (char*)&data);
Guido schrieb im Beitrag #4733624: > ringBufferWrite(data.dlc+sizeof(uint32)+sizeof(char), (char*)&data); Korrektur bzw besser: ringBufferWrite(data.dlc+sizeof(data.CanId)+sizeof(data.rtr),(char*)&data); Der macht dann nichts weiter, als ab Adresse &data eine
-
Thread
pointer in struct / initialisierung / zugriff
UCHAR ucKey; UCHAR ucCnt; T_TEST *pTest; } T_TEST_TBL; T_TEST_TBL xTestTbl[] = { {1, sizeof(xTestA)/sizeof(T_TEST), (T_TEST *)&xTestA}, {2, sizeof(xTestB)/sizeof(T_TEST), (T_TEST *)&xTestB} [/c]
ja geht auch ohne typecast [c] T_TEST_TBL xTestTbl[] = { {1, sizeof(xTestA)/sizeof(T_TEST), xTestA}, {2, sizeof(xTestB)/sizeof(T_TEST), xTestB} }; [/c]
-
Thread
Wie bekommt man eine double Variable in ein char Array?
#2872759: > Ist der maximal zu erwartende spi transfer. > > > Steffen memcpy(spi_buf+pos*sizeof(double), &n, sizeof(double)); Wobei pos 0 ... sizeof(spi_buf) / sizeof(double). Vergiss das Shiften, ist so einfacher, natürlich musst du pos entsprechend hochzählen bei jedem Senden. mfg
+pos*sizeof(double), &n, sizeof(double)); } [/c] Sollte es so gehen? Gruß Steffen
-
Thread
C -> Struktur initalisieren
)/sizeof(*table), [/c] Müsste das nicht so lauten? [c] .table_length = sizeof(table)/sizeof(table[0]), [/c]
Jan, C Grundlagen, ist das selben. Jan H. schrieb im Beitrag #5504603: >> .table_length = sizeof(table)/sizeof(*table), > Müsste das nicht so lauten?.table_length = > sizeof(table)/sizeof(table[0]),
-
Thread
Datentypen wie "uint8_t"
eine gute Annahme für die reale Welt ist, es aber nicht so verbindlich *standardisiert* ist. sizeof(char) == 1 und sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long) ist dort die einzige Wahrheit. Beachte die "=". Gruß – Peter
Doch, ist es. Siehe dazu z.B. C99-Standard 5.2.4.2.1 Peter schrieb im Beitrag #2561441: > sizeof(char) == 1 und sizeof(char) <= sizeof(short) <= sizeof(int) <= > sizeof(long) <= sizeof(long long) ist dort die einzige Wahrheit. > Beachte die "=". Und? Die "=" eröffnen lediglich die Option,
-
Thread
Pointerfehler, warum nur?
Im ersten Ansatz: pointer = (int *)(SECTOR11_STARTADRESS + i * (sizeof ( int ) )); Besser: pointer = (int *)SECTOR11_STARTADRESS + i;
Du musst einen expliziten Typecast machen: [c] pointer = (int *)(SECTOR11_STARTADRESS + i * (sizeof ( int ))); [/c]
-
Thread
Arduino Serielle Schnittstelle PC --> Arduino
"ledpower" off(); memset(&serial_in_command[0], 0, sizeof(serial_in_command)); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); } // if( !strcmp(serial_in_command, "ledpower") ) if( !strcmp(serial_in_command, "ledhell?") )
[0], 0, sizeof(serial_in_command)); memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); } // --------------- serial in --------------- [/c]
-
Thread
Array fixer Länge an Funktion übergeben
Naja, sizeof funkt zwar, aber ist eigentlich unnötig da ja die Arraygröße eh im Prototyp (und damit im aktuellen Objekt irgendwo) bekannt ist :-)
PS: So funktioniert sogar sizeof(arr) und arr.size() "sinnvoll".
-
Thread
GCC - Länge eines Const Array in ein anderes bringen
1000.0} }; //Länge des dynamischen Array herausfinden const unsigned elements_anzeigeelemente = sizeof(anzeigeelemente)/sizeof(struct dispwert); [/c]
unterstuetzt) 0x01, //bNumDescriptors = 1 0x22, //bDescriptorType = 0x22, //sizeof(rep_desc), low(sizeof(rep_desc)),high(sizeof(rep_desc)), /*** EP1 Descriptor ***/ 0x07, //bLength = 0x07, Groesse Deskriptor in Byte 0x05, //bDescriptorType = 0x05,
-
Thread
LCD-Adresse im C-Programm
GCC-AVR (gekürzt): [code] $ touch blah.c $ avr-gcc -mmcu=atmega1284p -dM -E blah.c | grep __SIZEOF | sort #define __SIZEOF_DOUBLE__ 4 #define __SIZEOF_FLOAT__ 4 #define __SIZEOF_INT__ 2 #define __SIZEOF_INT24__ 3 #define __SIZEOF_LONG__ 4 #define __SIZEOF_LONG_DOUBLE__ 8 #define __SIZEOF_LONG_LONG__ 8 #define __SIZEOF_POINTER__ 2 #define __SIZEOF_PTRDIFF_T__ 2 #define __SIZEOF_SHORT__ 2 #define __SIZEOF_SIZE_T__ 2 #define __SIZEOF_WCHAR_T__ 2 #define __SIZEOF_WINT_T__ 2 [/code] Ist jetzt also sinnlos laut
-
Thread
Entprellen mit Sam µC
um alle Eingangs- bzw Ausgangspins über eine Schleife zu definieren: [c] for(uint8_t i=0; i<sizeof(inputs); i++) { ioport_set_pin_dir(inputs[i], IOPORT_DIR_INPUT); //ioport_set_pin_mode(inputs[i], IOPORT_MODE_PULLUP); } for(uint8_t i=0; i<sizeof(outputs); i++) ioport_set_pin_dir
; i<sizeof(inputs); i++) { ioport_set_pin_dir(inputs[i], IOPORT_DIR_INPUT); //ioport_set_pin_mode(inputs[i], IOPORT_MODE_PULLUP); } for(uint8_t i=0; i<sizeof(outputs); i++) ioport_set_pin_dir
-
Thread
Pointer Größe nur 4 Byte bei 64 Bit Betriebssystem
steht folgendes: [code]Ein Zeiger ist eine Variable, die eine Adresse speichert. Wird der Operator sizeof auf ein Feld angewendet (sizeof(feld)), erhält man den Speicherverbrauch des Feldes in Bytes. Wird der Operator sizeof auf einen Zeiger angewendet, erhält man die Anzahl der Bytes, die zur Spei-
Simon schrieb im Beitrag #6261519: > printf("Groesse von ptr = %d", sizeof(ptr)); probiere mal mit [c] printf("Groesse von ptr = %zu", sizeof(ptr)); [/c]
-
Thread
Array größe berechnen
Stichwort: sizeof()
S. R. schrieb im Beitrag #6124792: > Oder du machst einfach ein printf("%d\n", sizeof(Array)) sizeof gibt ein size_t zurück. Darum: [c] printf("%zu\n", sizeof(Array)); [/c]
-
Thread
Serielle Schnittstelle ansprechen unter win95 mit Visual C++
frame sollte da die Anzahl der zu schreibenden Bytes stehen. Hier also der Wert vier. Besser noch: sizeof (frame).
zumindest dcb_alt.DCBLength stimmt nicht => SetCommState fehlerhaft) mach mal memset(&dcb,0,sizeof(DCB)); dcb.DCBLengthz = sizeof(DCB); memset(&dcb_alt,0,sizeof(DCB)); dcb_alt.DCBLengthz = sizeof(DCB); bevor du den DCB per Get/SetCommState verwendest. Versuch mal "\\\\.\\COM2" oder "
-
Thread
dynamische Speicherverwaltung/sizeof-Operator
nachdem ich eine struct mit einer int- und einer char-Variablen erstellt habe, habe ich mit Hilfe des sizeof-Operators die Größe von dem erstellten struct ermittelt. Diese beträgt 8 Byte, obwohl die darin enthaltenen Datentypen nur 5 Byte aufweisen. Ist das "Gerüst" einer struct immer 3 Byte groß? Vielen
-
Thread
Posix Thread Fehler bei Übergabe mehrerer Parameter?
char * TMP = NULL; volatile char * TMP2 = NULL; volatile char * tok_buf; TMP = malloc (sizeof(char) * MAX); while (TMP == NULL) { printf ("No Space left in RAM!"); TMP = malloc (sizeof(char) * MAX); } /*tok_buf = malloc(sizeof(char) * MAX); while (tok_buf == NULL) { printf("No Space left in RAM!"); tok_buf = malloc(sizeof(char) * MAX); }*/ /* TMP2 = malloc (sizeof(char) * MAX); while(TMP"" == NULL) { printf("No Space left in RAM!"); TMP2 = malloc (sizeof(char) * MAX); }*/ while (!OPTOK)
-
Thread
Definition von Structs
null-checker schrieb im Beitrag #1998865: > struct kugel pk = (struct kugel*) malloc(sizeof(struct kugel)); ich schlage vor : [c] struct kugel *pk = (struct kugel*) malloc(sizeof(struct kugel)); [/c] damit du denn Unterschied siehst. Wenn du das verstanden hast sehe dir diesen zweiten
ist also überflüssig, vielleicht sogar gefährlich. Das sizeof(*pk) ist ein Trick aus der Praxis, wenn du denn Datentyp von pk änderst allociert malloc dennoch die richtige Größe an Speicher. was bei sizeof(struct kugel); nicht mehr geht. Das kann bei großen
-
Thread
Messwerteglätung
an und nutzen, } //Ausgabe for (int j = 0; j < sizeof(Data) / sizeof(double); j++) { printf("Summe: %.3f\n", Data[j]); } return 0; }
----------------------------------\\ for (int j = 0; j < sizeof(Data) / sizeof(float); j++) { //Ausgabe (kann weggespart werden) printf("Summe: %.3f\n", Data[j]); } return 0; }
-
Thread
Lebensdauer von lokalen Variablen
Frank M. schrieb im Beitrag #5667993: > if (strlen(text) + strlen(MsgToSend) >= sizeof(MsgToSend)) { Danke für den Hinweis auf den Fehler!
angeblich auch einfach so gehen: [c]serialSIM800.print(F(atc));[/c] Erspart die Kopie komplett. sizeof(char) ist übrigens /immer/ 1, denn die Einheit, in welcher sizeof die Größe angibt, ist in Vielfachen von char. Und da char immer genau 1 char groß ist, ist sizeof(char)=1. Gilt analog auf für signed