-
Thread
Verständnis Struct mit Zeigern
p = (mytype *) daten; printf("a = %d, b = %d, Text '%s'\n", p->a, p->b, p->text); printf("sizeof mytype = %d, sizeof daten = %d\n", sizeof mytype, sizeof daten); [/c] Was geschieht hier? Die Struktur belegt nur den Speicher, der für die Speicherung der Elemente a und b erforderlich ist.
, b = %d, Text '%s'\n", p->a, p->b, p->text); [c] a = 12, b=34, Text 8NHalo [/c] > printf("sizeof mytype = %d, sizeof daten = %d\n", sizeof mytype, sizeof > daten); [c] sizeof mytype = 2, sizeof daten = 2+2+1+1+1+1+1+1+1 (bytes)[/c]
-
Thread
Null im Array bricht Array ab
nicht. So sollte es gehen: void SendCommand(unsigned char buf[], int len) {...} ... len = sizeof(buf) / sizeof(buf[0]); SendCommand(buf[], len); ...
len = sizeof(buf) / sizeof(buf[0]); Hmm. Wiki schreibt: In the programming languages C and C++, the unary operator sizeof is used to calculate the sizes of datatypes, in number of bytes. ...und buf ist ja
-
Thread
Wie Objekte in einem Array aktuell halten und umgekehrt?
[/c] Gespeichert wird alles mit: [c] eeprom_write_block ((void*)&Eepdata, (void*)EEP_START, sizeof(Eepdata)); [/c]
include <Wire.h> #include "MyFRAM_I2C.h" namespace MY_FRAMCONTROL { consteval uint32_t sizeofObject (const auto &data) { return sizeof(data); } consteval uint32_t lengthStructure (const auto &data, const size_t N) { return sizeofObject(data)/N; } constinit uint8_t TWI_BUFFER_SIZE
-
Thread
malloc Frage
) { FILE *stream_in; int n; stream_in = fopen(inputfile, "rb"); fread(&n, sizeof(int), 1, stream_in); ibuf = (int *)malloc(n*sizeof(int)); fread(ibuf, sizeof(int), n, stream_in); fclose(stream_in); return(n); } int main() { int i, n, *ibuf;
FILE *stream_in; int i, nx, ny1; stream_in = fopen(inputfile, "rb"); fread(&nx, sizeof(int), 1, stream_in); fread(&ny1, sizeof(int), 1, stream_in); *ny = ny1; ?ibuf = malloc(nx * sizeof(int*)); for (i=0; i<nx; i++){ ?ibuf[i] = malloc(ny1 * sizeof(int)
-
Thread
Übertragungsgeschwindigkeit SPI Bus Arduino Mega
-15, -0.320207200030E-18, 0.971511471520E-22, -0.121047212750E-25}; int cLength = sizeof(c) / sizeof(c[0]); double a0 = 0.118597600000E+00; double a1 = -0.118343200000E-03; double a2 = 0.126968600000E+03; for (i = 0; i < cLength
-15, -0.320207200030E-18, 0.971511471520E-22, -0.121047212750E-25}; int cLength = sizeof(c) / sizeof(c[0]); double a0 = 0.118597600000E+00; double a1 = -0.118343200000E-03; double a2 = 0.126968600000E+03; for (i = 0; i < cLength
-
Thread
Größe eines Arrays im Flash zur Compilezeit bestimmen
also wenn die Länge bekannt ist wird sizeof rausoptimiert bei einem guten Compiler
gibt einfach nur die Größe des verwendeten Typs zurück, also eine Konstante. Auf dem AVR ist zB sizeof(int)=2, sizeof(char)=1, sizeof(char[5]=5) (die letzten beiden sogar überall). Wenn du sizeof(variablenname) schreibst wird daraus sizeof(typ) wobei typ der Typ der Variable ist. Der /Inhalt/ der Variablen
-
Thread
C Text teilen
counter > 1) > { > (*single_words) = realloc(*single_words, ++array_size * > sizeof(*single_words)); Hast du mal überlegt, was passiert, wenn realloc fehlschlägt? Außerdem müßte es eigentlich sizeof **single_words heißen. > (*single_words)[array_size -1] = (char *)malloc((counter * > sizeof(char)) + 1); Den Cast nach char* solltest du bleiben lassen. Der ist eher schädlich als nützlich. Und sizeof(char) ist per Definition immer 1. > copyMemory((*single_words)[array_size -
-
Thread
Probleme mit malloc()
etwas mehr Leerzeichen wäre das wahrscheinlich nicht passiert) Du erwartest zu viel von sizeof. sizeof kannst du nur bei Dingen verwenden die zur Compilezeit schon ihre Größe haben. zb [C] memcpy(HTTPRxBuffer, buf0, sizeof(buf0)); //copy old content to new HTTPRxBuffer [/C] das kopiert nicht den ganzen Bufferinhalt um, sondern nur sizeof(buf[0]) Bytes. buf[0] ist vom Datentyp her ein unsigned char, hat also die Länge 1. Daher wird auch nur 1 byte umkopiert. Selbiges hier [C] HTTPRxBuffer = (unsigned char *)malloc(sizeof(buf0
-
Thread
Wert wird nicht übernommen in Struktur
ich nämlich noch nicht! Naja, malloc allokiert Speicher mit der angegebenen Größe in Bytes. sizeof(vtss_state) würde jetzt hier die Größe einer Adresse nehmen, weil vtss_state ein pointer zu einem pointer ist. sizeof(*vtss_state) würde jetzt hier die Größe einer Adresse nehmen, weil *vtss_state
vtss_inst_create(const vtss_inst_create_t *const create, vtss_inst_t *const inst) { vtss_state = malloc(sizeof(*vtss_state)); memset(vtss_state, 0, sizeof(*vtss_state)); vtss_state->cookie = 123; vtss_state->create = *create; (*inst) -> create = *create; // beispielsweise...
-
Thread
C++17, alignment-check template Interface reduzierbar?
Z T::*MPtr> struct offset_helper { using TV = declval_helper<T>; char for_sizeof[(char *)&(TV::value.*MPtr) - (char *)&TV::value]; }; } template<typename T, typename Z, Z T::*MPtr> constexpr int offset_of() { return sizeof(detail::offset_helper<T, Z, MPtr>::for_sizeof
auch mit > "std::optional". du hast recht - weniger code, und dann muss ich nur alignof und sizeof prüfen - dachte ich kann das auch mit nackten char-arrays machen Danke für die Hilfe
-
Thread
Struct extern deklarieren?
t.h [c] struct Timer { uint8_t zahl }; extern struct Timer AlleTimer[]; extern uint8_t sizeof_AlleTimer(void); #define NrTimer (sizeof_AlleTimer()/sizeof(struct Timer)); [/c] t.c [c] #include "t.h" struct Timer AlleTimer[] = { {0,}, {1,}, #if NEED_TWO {2,}, #endif {3,}
Fallen beeinhalten können, ist es gut, wenn man sie sofort erkennen kann. [C] #define NR_TIMER (sizeof(AllTimer) / (sizeof(*AllTimer))) [/C]
-
Thread
Rheinturm Uhr Startzeit Problem
;} unsigned long TIMEREAD(void){return millis()-t0;} void setup() {int i; for(i=0; i<sizeof(oneSecond);i++)pinMode(oneSecond[i],OUTPUT); for(i=0; i<sizeof(tenSecond);i++)pinMode(tenSecond[i],OUTPUT); for(i=0; i<sizeof(theSwitch);i++)pinMode(theSwitch[i],OUTPUT); digitalWrite(A0, HIGH);
HIGH); digitalWrite(A2, HIGH); } void loop() {int i; t=TIMEREAD(); do {for(i=0;i<sizeof(oneSecond);i++)digitalWrite(oneSecond[i],s1<=i?LOW:HIGH); //EINERBAND SEKUNDEN for(i=0;i<sizeof(tenSecond);i++)digitalWrite(tenSecond[i],s10<=i?LOW:HIGH); //ZEHNERBAND SEKUNDEN digitalWrite
-
Thread
Interessante Entdeckung im GCC Compiler
Prüfe mal mit sizeof, wie gross deine Datenstrukturen sind. Auf einem PC mit sizeof(int) == 4 tippe ich auf folgende Werte: [c]sizeof(_struct_B) == 4 sizeof(_struct_A) == 9 sizeof(_array) == 9[/c] Nochwas: Identifier
aber sauber hintereinander auslesen kann? be s. schrieb im Beitrag #4324230: > Prüfe mal mit sizeof, wie gross deine Datenstrukturen sind. folgende Werte sind entstanden: sizeof(_struct_A)=12 sizeof(_struct_B)=4 sizeof(_array)=12 da sind wieder die 3 zusätzlichen bytes
-
Thread
Int Array Wert zuweisen
{ { 1,2,3 }, { 4,5,6 }, { 7,8,9 } } } ; for (int x=0 ; x<sizeof(Foo::bar)/sizeof(Foo::bar[0]) ; ++x) { for (int y=0 ; y<sizeof(Foo::bar[0])/sizeof(int) ; ++y) { printf("%d ",myArray.bar[x][y]) ; } printf("\n") ; } return 0 ; } [/
{ 1,2,3 }, { 4,5,6 }, { 7,8,9 } } ; myArray = &tmp ; for (int x=0 ; x<sizeof(*myArray)/sizeof(*myArray[0]) ; ++x) { for (int y=0 ; y<sizeof(*myArray[0])/sizeof(int) ; ++y) { printf("%d ",(*myArray)[x][y]) ; } printf("\n") ; } return 0 ; } [/c
-
Thread
uIP+httpd+Daten zum Webserver senden
pname=http_get_parameter_name(s->param,i,sizeof(s->param)); pval =http_get_parameter_value(s->param,i,sizeof(s->param)); if(!strcmp(pname,("mac")) ) { result = result && ( decode_mac(pval,_eth_addr) == 6
Und somit die if nicht war wird if(s->param[0] && pcount=http_get_parameters_parse(s->param,sizeof(s->param)))>0)
-
Thread
LPC1788 - startup / .ld-script
)); LONG(LOADADDR(.data_RAM4)); LONG( ADDR(.data_RAM4)) ; LONG( SIZEOF(.data_RAM4)); __data_section_table_end = .; __bss_section_table = .; LONG( ADDR(.bss)); LONG( SIZEOF(.bss)); LONG( ADDR(.bss_RAM2)); LONG( SIZEOF(.bss_RAM2));
)); LONG(LOADADDR(.data_RAM4)); LONG( ADDR(.data_RAM4)) ; LONG( SIZEOF(.data_RAM4)); __data_section_table_end = .; __bss_section_table = .; LONG( ADDR(.bss)); LONG( SIZEOF(.bss)); LONG( ADDR(.bss_RAM2)); LONG( SIZEOF(.bss_RAM2));
-
Thread
Problem mit Schleifenabbruch
::hex << (int)buchstabe << std::endl; stelle++; } while( buchstabe != 13 && stelle < sizeof(kommando)-1 ); } std::cout << kommando << std::endl; return 0; } [/c]
CRLF_Out(wo); DoCommand (Kommandozeile, wo); foo_clear(Kommandozeile, sizeof(Kommandozeile)); kzi = 0; return; } if (kzi >= (sizeof(Kommandozeile)-1) ) // buffer full => ignore input return; if (c == '\b') // delete last
-
Thread
memcpy Zweidimensionales Array -> Eindimensionales Array
die Größe einer int liefert (die Speichergröße der Zahl 8, sizeof(42) wäre gleichwertig). Stattdessen willstu doch 8*(ein Feldelement) kopieren - deshalb 8*sizeof(setup.tSensorsIDs[i][0]). Ebensogut würde 8*sizeof(unsigned char) funktionieren.
um die Größe eines Objekts im Speichers, also um seinen Typ. Wirklich darauf zugegriffen wird bei sizeof nicht. Also: sizeof(tempID[8]) ist hier 1, sizeof(tempID) und 8*sizeof(tempID[8]) wären 8.
-
Thread
Struct mit Schleife durch zählen
[C] ... struct heizung MyHeizung; ... eeprom_read_block( &MyHeizung, eeMyHeizung, sizeof( MyHeizung ) ); ... eeprom_write_block( &MyHeizung, eeMyHeizung, sizeof( MyHeizung ) ); [/C] Im gcc-Tutorial gibt es da einen schönen Abschnitt darüber. Padding ist natürlich grundsätzlich
beinhaltet: [c] > uint8_t *writepointer = (uint8_t *) &ZIMMER[z]; [/c] Die ist 16 Bit. Dass sizeof(ZIMMER[z]) nie größer als 256 werden kann, hast Du schon abgeklopft, nehme ich an. Hast Du auch abgeklopft, ob die Gesamtlänge ins EEProm passt?
-
Thread
c code Unterschied uint8 buffer [8] und char buffer[8]
arrays und pointer absolut das selbe >> sind. > > so pauschal stimmt das aber nicht. > > sizeof() liefert bei pointer etwas anders als bei einem Array. sizeof ist aber ein compile time operator, zur laufzeit ist es das selbe. der compiler zählt halt und etzt für sizeof diese zahl ein. und
so), bei dem gilt: char = 24 Bit short int = 24 Bit int = 24 Bit long int = 48 Bit und damit sizeof(char) = sizeof(short int) = sizeof(int) = 1 und sizeof(long int) = 2. Spätestens bei solchen exotischen Prozessoren fällt man auf die Schnauze wenn man davon ausgeht, dass ein char immer 8 Bit
-
Thread
Dynamisches Array im embedded System
string.h> void test(int n) { int test_array[n]; int ende; printf("sizeof int: %d, sizeof test_array: %d, &test_array: %d, &ende: %d\r\n", sizeof(int),sizeof(test_array),&test_array[0],&ende); } int main(int argc, char* argv[]) { test(atoi(argv[1])
{ struct { int test_array[n]; int ende; } s; printf("sizeof int: %ld, sizeof test_array: %ld, test_array: %p, ende: %p, diff: %ld\r\n", sizeof(int), sizeof(s.test_array), &s.test_array[0], &s.ende, (void*)&s.ende - (void*)&s.test_array[0]); }
-
Thread
C-Aufgabe: bedingtes Inkrementieren
, 1, 65 }; do_something(block[i]+j); if ( ++j < 16 ) return; j=0; if ( ++i < sizeof(block)/sizeof(*block) ) return; i=0; } [/C]
block[] = { 1, 17, 1, 33, 1, 49, 1, 65 }; do_something(block[i]+j); ++j < 16 || (j=0, ++i < sizeof(block)/sizeof(*block) || i=0); } [/c]
-
Thread
Teilstring mit Konstante vergleichen
von BT_Receive_Data_Buffer: char *Datastream = NULL; memcpy(Datastream,BT_Receive_Data_Buffer,sizeof(BT_Receive_Data_Buffer)); //danach Teile ich die Kopie: char const delimiter[] = "#"; char *data_substr = NULL; data_substr = strtok(Datastream, delimiter); Datastream = data_substr; [/C]
nur 4 Zeichen. Deshalb die 5. Du kannst aber hier memcpy(Datastream,BT_Receive_Data_Buffer,sizeof(BT_Receive_Data_Buffer)); dann nicht einfach sizeof( BT_Receive_Data_Buffer ) Bytes drüberbügeln! Das muss alles zusammenpassen. Wenn du 15 Bytes von BT_Receive_Data_Buffer nach Datastream kopierst
-
Thread
Problem mit STRUCT, UNION & CO
sizeof(x) ist einfach eine Zahl die der Compiler erzeugt. sizeof(U8) ist äquivalent zu 1. Da gibts null Unterschied.
Yagan z. Dongobar wrote: > Ach ja, da fehlt noch eine Klammer: > > send_buffer( (U8 *)buf, sizeof(puffer_t) ); > > So müsste es gehen. Nein! buf ist noch kein Zeiger. send_buffer( (U8*)&buf, sizeof(puffer_t) );
-
Thread
Funktionsaufruf mit Zeiger
Rufus T. Firefly wrote: > sizeof ist keine Funktion, sondern wird bereits während des Compilierens > durch den resultierenden Wert ersetzt. Wie ist das eigentlich bei C99? Da müsste sizeof ja sowohl zur Compiletime als auch
@Karl Heinz: In dem von dir angesprochenen Fall wird in C99 sizeof tatsächlich erst zur Laufzeit ausgewertet. Die Norm selbst formuliert das so: 6.5.3.4 The sizeof operator Constraints [...] 2 The sizeof operator yields the size (in bytes) of its operand
-
Thread
int Array abschneiden
zitter_ned_aso schrieb im Beitrag #5716401: > uint16_t* my_array = malloc(sizeof(uint16_t)); Korrektur: uint16_t* my_array = malloc(sizeof(uint16_t)*NEUE_ARRAY_GROESSE);
int value=array[i]; printf("wert=%i\n",value); } } [/c] Die Verwerndung von sizeof(), strlen() und strcat() könnte hier nützlich sein.
-
Thread
Verkettete Liste für Mikrocontroller Gesperrt
nicht so wie es sein sollte. Was mache ich hier falsch? [c] node pnode; pnode = (node)malloc(sizeof(struct list_node)); insert_right(pnode, 123); insert_right(pnode, 345); [/c]
[c] void main(void) { node pnode; pnode = (node)malloc(sizeof(struct list_node)); [/c] Normalerweise nimmt man einen Nullzeiger, um eine leere Liste anzuzeigen. Keinen leeren Knoten. Wie willst Du den denn schnell erkennen ? Also : [c] void main(void
-
Thread
[C] Struktur ist zu groß
was dich an dem > padding stört ? Ja, ich würde gerne einen Fileheader mit [c]F G; fread(&G, sizeof(F), 1, file);[/c] auslesen.
Verhalten besteht darin, Bytes in ein char Array > zu lesen Was wäre damit? [c] F G; fread(&G.A, sizeof(G.A), 1, file); fread(&G.B, sizeof(G.B), 1, file); fread(&G.C, sizeof(G.C), 1, file); // usw. [/c] Konrad S. schrieb im Beitrag #4269369: > Typischer Anfängerfehler beim Design der Struktur
-
Thread
GNUARM: Problem mit einer Warnung
pDst = (unsigned char *) &(uc_RxBuf[0]); memcpy( pDst, &mRxCAN[mRxOUT].MsgID, sizeof( unsigned int ) ); pDst += sizeof( unsigend int ); memcpy( pDst, &mRxCAN[mRxOUT].DatA, sizeof( unsigned int ) ); pDst += sizeof( unsigend int ); memcpy( pDst, &mRxCAN[mRxOUT].DatB, sizeof( unsigned int ) ); pDst += sizeof( unsigend int ); memcpy( pDst, &mRxCAN[mRxOUT].Frame, sizeof( unsigned int ) ); ... [/C] (pDest ist hier wieder ein unsigned char Pointer) > "assignment makes integer from pointer without
-
Thread
C Einführung: strncpy
= %d\n",strlen(myString),sizeof(myString)); printf("tempName: strlen= %d, sizeof= %d\n", strlen(tempName),sizeof(tempName)); printf("tempName2: strlen= %d, sizeof= %d\n", strlen(tempName2),sizeof(tempName2)); return
die Ziele auch nach strncpy() sicherheitshalber terminieren: [c] strncpy(tempName,myString,sizeof(tempName)-1); strncpy(tempName2,myString,sizeof(tempName2)-1); tempName[sizeof(tempName)-1] = '\0'; tempName2[sizeof(tempName2)-1] = '\0'; [/c] Vorteil: Es muss nur noch jeweils
-
Thread
char array Größenbestimmung
Merke: Man kann Arrays nicht direkt an Funktionen übergeben. und was kommt dann bei den beiden sizeof () raus: [c] void Display(char text []){ int max= sizeof(text); ... // und void Display(char text [128]){ int max= sizeof(text); ... [/c]
big size schrieb im Beitrag #2665869: > und was kommt dann bei den beiden sizeof () raus: beides mal sizeof(void*)
-
Thread
Probleme mit Call by Reference
GEKU schrieb im Beitrag #5915645: > Das hieße doch, dass es keine Plattform gibt, bei der sizeof (char) != 1 > ist oder? Richtig. sizeof liefert die Größe in Vielfachen von char. char ist genau 1 char groß, daher sizeof(char)=1. char ist aber eben nicht unbedingt 8 bit groß. Die Anzahl an Bits in einem Datentyp bestimmt man mit sizeof (X)*CHAR_BIT.
-
Thread
Compiler überschreibt Speicherbereich von Malloc
spwert = (unsigned int) &i; } ... hier kann spwert betrachtet werden [/c] (setzt voraus, daß sizeof (unsigned int) == sizeof (pointer) ist, ist auf den meisten Architekturen der Fall)
Holger Krähenbühl schrieb im Beitrag #4101076: > class->object_text = malloc((( strlen(Text) + 1) * sizeof(char))); Kleiner Tip: sizeof(char) ist *immer* 1. Daher reicht hier malloc (strlen (Text) + 1). Rufus Τ. Firefly schrieb im Beitrag #4101146: > (setzt voraus, daß sizeof (unsigned int) == sizeof
-
Thread
Schleifenproblem
uint8_t nZeichen = 0; uint8_t nLine = 0; uint8_t nColumn = 0; while(nZeichen <= (sizeof(arrLcdString)/sizeof(uint8_t))) { while(nLine <= 3) { if(arrZeichensatz[nLine][nColumn] == arrLcdString[nZeichen]) { nColumn++;
lcdString(char *strLcdString) So erwartet die Funktion einen String, wie du ihn übergibst. 2. (sizeof(arrLcdString)/sizeof(uint8_t)) Das ergibt bei einer 8 Bit Maschine immer 1, egal wie lang der String ist, da du hier ein sizeof auf den Pointer machst. Die Länge von einem String bekommst du mit
-
Thread
Verkette Liste
Eben und sizeof() braucht ne Variable und keinen Typ...
@ A. K. (prx) @ Stefan Ernst (sternst) Stimmt, geht beides bei sizeof. Ist ja ganz schön schlau das sizeof...
-
Thread
Diese "ollen" Pointer...
>if(bufhead > (sizeof(buf)/sizeof(unsigned char)) bufhead = 0; Kann man auch so machen: bufhead &= (sizeof(buf)/sizeof(unsigned char)-1); Aus dem rechten Teil sollte der Compiler einen konstanten Ausdruck machen.
[C] bufhead &= (sizeof(buf)/sizeof(unsigned char)-1); [/C] funktioniert nur wenn (sizeof(buf)/sizeof(unsigned char) eine Zweierpotenz ist (2^1=2,2^2=4,2^3=8,2^4=16,2^5=32,2^6=64,...).
-
Thread
C++ Kurve darstellen
data wird als Zeiger übergeben. Deshalb wird die Größe sizeof(data)/sizeof(data[0]) als weiterer Parameter übergeben. Ich empfehle erst einmal http://www.uni-trier.de/urt/user/baltes/docs/vcpp/vcpp6/vcpp6.pdf
0,1,2,3,4,5,6,7,8,7,6,5,4,3,2,1,0,4,6,7,8,7}; GraphOut Graph1; Graph1.Graph_Background(pDC); Graph1.d2Graph(pDC,data,(sizeof(data)/sizeof(data[0]))); }
-
Thread
char* an Funktionübergeben
= sizeof(test); }[/c]
sizeof ist nicht wirklich eine funktion. Es ist vielmehr eine Art Makro, die den compiler veranlasst, mal nachzuschauen, wie gross deine Variablen sind und der Wert wird dann an der Stelle des sizeof eingesetzt
-
Thread
SIZEOF array ARM GCC
uint8_t size = (sizeof(dataBuff)/sizeof(dataBuff[0])); printf("DB:%s",dataBuff); writeData(id,CMD_TX_TEST1,size,dataBuff); } [/c]
sizeof(dataBuff) = 32 Bit = 4 Byte sizeof(dataBuff[0]) = 1 Byte = 1 Byte
-
Thread
sizeof offsetof verschachtelte structs
int k; } foo; typedef struct _bar { int j; foo f; } bar; int main() { int g1=sizeof(bar::j); // ok in c++ int g2=sizeof(bar::f.i); // ok in c++ int o1= offsetof(bar,j ); // ok in c++ int o2= offsetof(bar,f.i ); // ok in c++ ... [/code] Mir fehlt leider gerade die Idee
wegoptimiert, wenn sie eh nur für's sizeof verwendet wird.
-
Thread
sizeof Operator verrechnet sich?
Hallo, ich will mit sizeof feststellen, wie groß ein Array ist. Das Array besteht aus struct: typedef struct { uint8_t id, next, prev, parent, child; char name[MENU_STRING_LENGTH]; uint8
uint32_t max_int; void ( *fkt_pointer )( void ); } menu_t; menu_t test[5]; ... sizeof(test); Ich würde ja nun das Ergebnis "145" ertwarten. Bis zur Arraygröße 2 (also 2 Einträge) klappt es auch; danach stimmt das ERgebnis nicht mehr. So kommt schon bei menu_t test[3] als sizeof-Ergebnis
-
Thread
double Binärisieren und zurück
Jay schrieb im Beitrag #4363516: > for(i = 0; i <= sizeof(double); i++) { [c] for(i = 0; i < sizeof(double); i++) { [/c]
nur) er. Diese Ansamlung von Fehlern! Zumindest etwas besser wäre: [c] double a; char buffer[sizeof(a)]; // Semikolon am schluss nicht vergessen memcpy (buffer, &a, sizeof(a)); // Schluessende Klammern, Semikolon und Referenzieren von a nicht vergessen [/c] Wobei das aber das ursprungliche
-
Thread
Struktur kopieren
int i; channel_t *newp; for(i = 0; i < SIZEOF(*pchn);i++) { *(newp+1) = *(pchn+i); }
// So war es eigentlich gemein int i; channel_t *newp; for(i = 0; i < SIZEOF(channel_t);i++) { *(newp+1) = *(pchn+i); }
-
Thread
Statische 2D Char Arrays mit verschiedenen Größen
jeweils 10 Chars. Kann ich jetzt die ersten 2 Char Arrays mit 100 Bytes deklarieren ? So daß sizeof(a[0]) = 100 sizeof(a[1]) = 100 sizeof(a[2]) = 10 sizeof(a[3]) = 10 sizeof(a[4]) = 10 Ich möchte keine dyn. Arrays auf dem Heap haben. Viele Grüße Werner
> sizeof(a[0]) = 100 > sizeof(a[1]) = 100 > sizeof(a[2]) = 10 > sizeof(a[3]) = 10 > sizeof(a[4]) = 10
-
Thread
Zufallsgenerator für Manschaft Turnier
int main(void) { srand((unsigned int)time(NULL)); printf("Zufall Team:\n%s\n", team[rand()%(sizeof team/sizeof team[0])]); return 0; } ********************* jetzt soll ich alle in 4 Teams in Gruppen verteilen: GruppeA: Team1,Team4,Team7,Team10 GruppeA:................ ..................
for(j=0; j<4; j++) { while(teams[i][j] == -1) { if(numbers[rand()%(sizeof numbers/sizeof numbers[i])] == numbers[0]) { numbers[rand()%(sizeof numbers/sizeof numbers[i])] = numbers[1]; teams[i] = (rand()%(sizeof numbers/sizeof numbers[i]))+1
-
Thread
buffer[res]=0;
schreibst du in der nächsten Zeile über das Array hinaus. besser wäre: res = read(fd, buffer, sizeof(buffer) - 1);
erzeugt diese Endemarke. Grüße Stefan PS: Du solltest in jedem Fall auch prüfen, ob res >= sizeof(buffer) ist. buffer[sizeof(buffer)] ist die erste Speicherstelle *hinter* buffer, da liegt mit Sicherheit was anderes...
-
Thread
Debug ANSI C Programm, RaspberryPI.
{ fgets( temp_buffer, sizeof(temp_buffer), fp ); fgets( temp_buffer, sizeof(temp_buffer), fp ); char *t; t = strndup ( temp_buffer +29, 5 ) ; temp = atof(t)/1000; return(temp); }
{ fgets( temp_buffer, sizeof(temp_buffer), fp ); fgets( temp_buffer, sizeof(temp_buffer), fp ); char *t; t = strndup ( temp_buffer +29, 5 ) ; temp = atof(t)/1000; fclose ( fp ); return(temp
-
Thread
Zu blöd ein struct zu sortieren
} } int main( int nargs, char **args ) { puts( "vorher:" ); dumpServos( servos, sizeof(servos)/sizeof(servos[0]) ); qsort( servos, sizeof(servos)/sizeof(servos[0]), sizeof(servos[0]), cmp_serv_t_by_position ); puts( "nachher:" ); dumpServos( servos, sizeof(servos)/sizeof(servos[0]) ); return 0; } [/c]
-
Thread
Problem mit malloc() und free()
[c] char* recbuf = (char*)malloc(sizeof(RECBUFFER_SIZE)); [/c] Das macht sehr sicher nicht das, was beabsichtigt ist. Was mag "sizeof (RECBUFFER_SIZE)" liefern? Na?
das gleiche wie sizeof RECVBUFFER_SIZE ist.
-
Thread
sizeof(Buffer) geht nicht warum in C
[c]for(v=0;sizeof(Buffer);v++)[/c] Und wo ist da die Abbruchbedingung? sizeof(Buffer) ist immer "wahr". Würde mal [c]for(v=0;v<sizeof(Buffer);v++)[/c] probieren. Gruß Markus
char a[10]; sizeof(a); // liefert 10 sizeof(a[3]); // liefert 1 aus http://de.wikibooks.org/wiki/C-Programmierung:_Ausdr%C3%BCcke_und_Operatoren#Speichergr.C3.B6.C3.9Fe_sizeof und a[0] ? Nach meiner