-
Thread
Typenproblem
in der Funktion und gibt die Zahl aber mit einer einfachen Genauigkeit zurück. [c] printf("sizeof(%f)=%zd\n", 10.5, sizeof(10.5)); printf("sizeof(%ff)=%zd\n", 10.5f, sizeof(10.5f)); [/c] Ausgabe: [code] sizeof(10.500000)=8 byte sizeof(10.500000f)=4 byte [/code]
-
Thread
Problem bei Pointer-/Parameterübergabe und malloc
double Zeiger) ausgewertet. Zur Verdeutlichung: [c] double* array1 = (double *)malloc(sizeof(double) * 4); double* array2 = (double *)malloc(sizeof(double) * 4); double array3[4] = { 1.0, 2.0, 3.0, 4.0 }; double* ptr = array1; double* ptr2[3] = { array1, array2, array3
> double* array1 = (double *)malloc(sizeof(double) * 4); Den Rückgabewert von malloc sollte man nicht casten. Der Cast ist unnötig und verdeckt potentielle Fehler.
-
Thread
Zufallstexte
bisschen vom Thema abzuschweifen: Wieso kann man hier malloc eine feste Größe übergeben, ohne sizeof(char)? So wie im Post von kbuchegg: [code]malloc( rmdnum + 1 );[/code] Ist ein char immer ein byte? Ist folgendes richtiger, oder nur überflüssig? [code]malloc( sizeof(char) * (rmdnum + 1) );[
> Wieso kann man hier malloc eine feste Größe übergeben, ohne > sizeof(char)? So wie im Post von kbuchegg: Weil sizeof(char) per Definition 1 ist. Sprich überall, wo eine Größe einer Datenmenge verwendet wird (Parameter von malloc, Ergebnis von sizeof) ist die Größe
-
Thread
Struktur mit Zeigern anlegen
NumberOfDevices]; PNIO_init_struct.deviceInputLength = (PNIO_UINT32*)malloc( NumberOfDevices * sizeof( PNIO_UINT32 ) ); PNIO_init_struct.deviceInputLength[NumberOfDevices]; PNIO_init_struct.deviceInputData = (PNIO_UINT8**)malloc( NumberOfDevices * sizeof( PNIO_UINT8 ) * MaxLen * sizeof( PNIO_UINT8
NumberOfDevices]; PNIO_init_struct.deviceOutputLength = (PNIO_UINT32*)malloc( NumberOfDevices * sizeof( PNIO_UINT32 ) ); PNIO_init_struct.deviceOutputLength[NumberOfDevices]; PNIO_init_struct.deviceOutputData = (PNIO_UINT8**)malloc( NumberOfDevices * sizeof( PNIO_UINT8 ) * MaxLen * sizeof( PNIO_UINT8
-
Thread
malloc verständnisproblem
[10]; // max 10 udp verbindungen void foo(void){ udp_table[i] = (udp_stuct*)malloc( sizeof(udp_stuct) ); if( udp_table[i] == NULL ) return 0; memset( udp_table[i] ,0, sizeof(udp_stuct) ); udp_table[i]->port = ... udp_table[i]->time = ... } [/c] irgendwann
( sizeof( struct ) ); [/c] hilft hier ungemein #defines sind gut .. aber gerade hierbei nicht hilfreich ... ergebniss ist : das #define sagte 50 bytes sizeof sagt 68 bytes damit zerschießt
-
Thread
uint64_t direkt im EEprom eines AVRs möglich?
Karl Heinz Buchegger schrieb im Beitrag #3053178: > eeprom_read_block( &value, addr, sizeof(uint64_t) ); Was ist mit "addr" (Adresse) gemeint?
uint64_t eezahl EEMEM = 123456; //zahl frei gewählt schreiben: eeprom_read_block( &value, &eezahl, sizeof(uint64_t) ); lesen: eeprom_read_block( &value, &eezahl, sizeof(uint64_t) ); Nach dem Lesen ist value = 0 (Verwirrung)
-
Thread
Structs in eeprom minimalcode durchschauen
habe ich gelesen: size_t corresponds to the integral data type returned by the language operator sizeof damit weiß ich nun,dass sizeof keine funktion ist, sondern ein Operator, der daten im format size_t zurückgibt. also ich füttere die Funktionen ja mit dem argument sizeof(...) dann werde ich
gelesen: > > size_t corresponds to the integral data type returned by the language > operator sizeof > > damit weiß ich nun,dass sizeof keine funktion ist, sondern ein Operator, > der daten im format size_t zurückgibt. > > also ich füttere die Funktionen ja mit dem argument sizeof(...) dann
-
Thread
Wie bekomm ich die Daten in den Speicher?
[c] FILE *fp; fp=fopen("c:\\ausgabe", "wb"); char x[4]= {0xAA, 0xBB, 0xCC, 0xDD}; fwrite(x, sizeof(x[0]), sizeof(x)/sizeof(x[0]), fp); fclose( fp ); [/c] Das ist es was Du ursprünglich machen wolltest.... und wenn du die datei ausgabe jetzt in galep öffnest wirst du auch die Bytes 0xAA, 0xBB
FILE *fp; > fp=fopen("c:\\ausgabe", "wb"); > char x[4]= {0xAA, 0xBB, 0xCC, 0xDD}; > fwrite(x, sizeof(x[0]), sizeof(x)/sizeof(x[0]), fp); > fclose( fp ); > > Das ist es was Du ursprünglich machen wolltest.... und wenn du die datei > ausgabe jetzt in galep öffnest wirst du auch die Bytes 0xAA,
-
Thread
Array wird nicht kleiner, obwohl in Funktion definiert
tut nicht. Nix wird genullt. Bekomme aber eine Warnmeldung vom Compiler: warning: argument to ‘sizeof’ in ‘memset’ call is the same expression as the destination; did you mean to dereference it? [-Wsizeof-pointer-memaccess] memset(addresses, 0, sizeof( addresses) ); @Peter II & @(easylife)
Johannes A. schrieb im Beitrag #4750528: > memset(addresses, 0, sizeof( addresses) ); mache mal memset( &addresses, 0, sizeof( addresses) );
-
Thread
attiny85 EEPROM schreiben/lesen
char getByte, eeData[250+1]; uint8_t i=0; while (getByte = EEPROM.read(eeAddr+i) && i!=sizeof(eeData)) { eeData[i++] = getByte; } data[i] = getByte; return String(eeData); }
Schreiben um 1x öfter laufen als der String lang ist. Was ist data[Länge+1]? Beim Lesen: Wie weiss sizeof(eeData) wie lang der String ist?
-
Thread
Listeneintrag beschreiben in C
functionName) { struct function *zeiger; if(firstFct == NULL) { if((firstFct = malloc(sizeof(struct function))) == NULL) { fprintf(stderr, "Kein Speicherplatz vorhanden " "fuer anfang\n"); return; } firstFct->inter=3; //ich brauch
Der andere Punkt > > [C] > firstFct->functionName = malloc(sizeof(*functionName/*string aufgelöst? */))) > [/C] Im Prinzip: ja. Aber nicht mit sizeof. Der String, den du hier bekommst [C] void addFunction(char *functionName) { ... [/c] hat eine Länge
-
Thread
Pfiffiges Makro gesucht für Variablen-Deklaration / - Initialisierung
nicht? struct { const uint8_t len; const uint8_t cmd; const uint8_t data[sizeof({0,1,2,3})]; } telegramm_name;
Joachim wrote: > Warum kann der Comiler sowas denn auch nicht? > const uint8_t data[sizeof({0,1,2,3})]; Weil {0,1,2,3} weder ein C-regelgerechter Ausdruck noch ein regelgerechter Datentyp ist. Diese beiden sind aber die einzigen zulässigen Argumente für den sizeof-Operator. Dein
-
Thread
Zeiger auf array-Element: Inkrement WTF?
enthalten, was sich auch in sizeof() niederschlägt.
ist cursorBitmap ein Zeiger auf uint8_t, entsprechend wird bei der Adressberechnung die 10 mit sizeof(uint8_t)=1 multipliziert. In &cursorBitmap+10 ist cursorBitmap ein Zeiger auf uint8_t[20] (das Array hat auf Grund der Initialisierung 20 Werte). Die 10 wird nun nicht mit 1, sondern mit sizeof
-
Thread
Stacknutzung bei Ellipsen erzwingen (PowerPC)
] typedef unsigned char * va_list; #define va_start(marker, last) { marker = (va_list)&last + sizeof(last); } #define va_arg(marker, type) *((type *)((marker += sizeof(type)) - sizeof(type))) #define va_copy(dest, src) { dest = src; } #define va_end(marker) { marker = (va_list)
typedef unsigned char * va_list; > #define va_start(marker, last) { marker = (va_list)&last + > sizeof(last); } > #define va_arg(marker, type) *((type *)((marker += sizeof(type)) - > sizeof(type)))[/c] Mit Verlaub, das ist Hack mit Soße... wie wär's z.B. mit[c]#define va_start(v,l) __builtin_va_start
-
Thread
Kapazität messen, 400-700pF
TODO:: Please write your application code static int i; for (i = 0 ; i < sizeof(captures); i++) captures[i] = startCapture(); result = 0; for (i = 0 ; i < sizeof(captures); i++) result += captures[i]; result /= sizeof(captures); sprintf(buff, "%05u", (uint16_t)result); buff[sizeof(buff) - 1] = '\n'; for (i = 0; i < sizeof(buff); i++) uart_putc(buff[i]); } }[/c]
-
Thread
struct in file
Alibaba schrieb: > if(-1 == write(fdStatus,&icsStat,sizeof(ICS554_STATUS))) > {putchar('a');} so ist es natürlich richtig: > if(-1 == write(fdStatus,&Stat,sizeof(STATUS))) > {putchar('a');}
int fh if((fh = open("Status",O_CREAT, O_RDWR)) == -1) putchar('s'); if(-1 == write(fh,&Stat,sizeof(ICS554_STATUS))){putchar('a');} trotzdem kein schreiben auf File möglich
-
Thread
Cast Problem bei memcpy und memset
Hi [c] memcpy((void *)capture, capture_fft, sizeof(capture) ); memset((void *)capture, 0, sizeof(capture) ); [/c] Matthias
Frank Link schrieb im Beitrag #2435831: > das Problem: > memcpy( capture, capture_fft, sizeof(capture) ); > memset( capture, 0, sizeof(capture) ); Du kopierst den inhalt von capture_fft nach capture, und überschreibst dann capture mit 0en? Klingt irgendwie sinnlos
-
Thread
übergabe von var addresse an pointer
send_beyte(*DATA); DATA++; beyts--; } } long testvar = 5143; senden(&testvar,sizeof(long)/sizeof(char)); int testvar2 = 143; senden(&testvar2,sizeof(int)/sizeof(char)); [/c] das problem ist das der compieler nicht mitspielt [code] argument of type "int *" is incompatible
joachim j. schrieb im Beitrag #3601749: > senden(&testvar,sizeof(long)/sizeof(char)); fehlt hier nicht noch ein Parameter?
-
Thread
2 Arrays auf Gleichheit prüfen
>> for (i=0;i<=sizeof(array-1);i++) >Ich vermute, du meinst >for (i=0;i<=sizeof(array)-1;i++) Einfach wird das Konstrukt so: [c] i=0; do { ... } while ( ++i != sizeof(array) ); [/c]
. for( i = 0; i < sizeof(array); ++i ) mach was mit array[i]
-
Thread
Speicher wird überschrieben?!
korrigier den mal. Und damit dir das nicht nochmal passiert [C] if(sbufferpos > sizeof(buffer) - 1) { [/C] oder [C] if(sbufferpos >= sizeof(buffer)) { [/C] Und wer weiß, wie oft die die um 1 zu große bufferpos in deinem restlichen Programm noch verwendest.
> if(sbufferpos > sizeof(buffer) - 1) { > sbufferpos = 0; > spi_enableInterrupt(false); > } else{ > spi_enableInterrupt(false); //GENAU HIER >
-
Thread
Array dynamisch vergrößern
%d\n", size, bufferlaenge); decData = (int *) realloc(decData, (bufferlaenge * sizeof(int)) + (size * sizeof(int))); if(decData == NULL) { printf("\nRealloc() failled!"); decData = backup;
"\n%d, %d\n", size, *bufferlaenge); *decData = (int*) realloc(*decData, *bufferlaenge * sizeof(int) + (size * sizeof(int))); if(*decData == NULL) { printf("\nRealloc() failled!"); *decData = backup; } } [\C] Da hängt
-
Thread
Structure Array ins EEPROM
Railway RailPointer[Rx][Ry]) { eeprom_write_block(&RailPointer[Rx][Ry],&eeRailPointer[Rx][Ry],sizeof(struct Railway)); } void EEPROM_RP_read (struct Railway RailPointer[Rx][Ry]) { eeprom_read_block(&RailPointer[Rx][Ry],&eeRailPointer[Rx][Ry],sizeof(struct Railway)); } -----------------
Array Feld für Feld ansprechen ? Ja, denn das ist der Zweck eines Arrays. > Stimmt dann die sizeof Abfrage ? Ein "sizeof(Typname)" gibt die Größe des Typs zurück. Wenn die Funktion das an dieser Stelle erwartet: ja. > Sind die EEPROM function calls richtig ? Keine Ahnung. Kommt auf die Signatur
-
Thread
Com-Schnittstellen auflisten ?
devinfo_data; PSP_DEVICE_INTERFACE_DETAIL_DATA pdevinfo_detail; ZeroMemory( &devinfo_data, sizeof( SP_DEVICE_INTERFACE_DATA ) ); devinfo_data.cbSize = sizeof( SP_DEVICE_INTERFACE_DATA ); while ( SetupDiEnumDeviceInterfaces( devinfo, NULL, &GUID_DEVINTERFACE_COMPORT, mem_index, &devinfo_data
res, pdevinfo_detail->DevicePath ); delete pdevinfo_detail; ZeroMemory( &devinfo_data, sizeof( SP_DEVICE_INTERFACE_DATA ) ); devinfo_data.cbSize = sizeof( SP_DEVICE_INTERFACE_DATA ); mem_index++; } SetupDiDestroyDeviceInfoList( devinfo ); [/c] Die Frage, die jetzt noch bleibt
-
Thread
Mit C mehrstufige Verzeichnisstruktur durchsuchen;
Mit "next = (set*) calloc(1, sizeof(set));" statt "next=calloc(1,sizeof(set));" in Zeile 45 klappt das Compilieren.
interrupt schrieb im Beitrag #6979086: > Mit > "next = (set*) calloc(1, sizeof(set));" > statt "next=calloc(1,sizeof(set));" > > in Zeile 45 klappt das Compilieren. Das deutet darauf hin, dass du den Code als C++ statt als C kompiliert hast. In C++ geht es nicht ohne den
-
Thread
float zu 4x8Bit und zurück
mm_data[4] = {0}; uint8_t *mm_data_ptr; mm_data_ptr = mm_data; memcpy((void*)&mm_data, &vm, sizeof(float)); for(uint8_t i=0;i<4;i++) { msg.data[i] = *mm_data_ptr; mm_data_ptr++; } can_send_message(&msg); [/C] Empfangen: [C] float data; memcpy(&data, can_dump_frame->data, sizeof(
Ringpuffer geschrieben und später verschickt: In Puffer: [C] memcpy((void*)&mm_buf[mm_buf_h], &vm, sizeof(uint32_t)); ... [/C] Senden: [C] for(tt; tt != th; tt = (tt + sizeof(uint32_t)) & (MM_BUFSIZE -1)) { msg.id=ID; mm_buff_ptr = mm_buff + tt; for(i=0;i<4;i++) { msg.data
-
Thread
dynamische struct im C
uint16_t test4=1; struct person eins[test4]; while(1) { test4++; sizeof(eins); } }[/c]
main(void) { int i; for(i = 5; i < 10; i++) { struct Struct s[i]; int size = sizeof(s); printf("sizeof = %d\n", size); } } [/c] gibt die werte 40, 48, 56, 64, 72 aus. - jgdo -
-
Thread
Probleme mit der Zifferausgabe bei Verkettete Listen
element *akt_el1, *akt_el2; if(first==NULL) { first=(struct element*) malloc(sizeof(struct element)); first->nummer=i; first->next=NULL; return first; } else { akt_el1=first; while(akt_el1!=NULL && akt_el1->nummer<
*) malloc(sizeof(struct element)); first->nummer=i; first->next=akt_el1; return first; } else { akt_el2=first; while(akt_el2
-
Thread
memcpy auf ARM Cortex A9 & Linaro
irgendwie auch viel zu einfach). Bloß noch: [c] int i; const int c = 4711; memcpy(&i, &c, sizeof(int)); [/c] Ist ja auch viel lesbarer. Wenn's hilft...
unsigned *p) { return *(float *)p; } [/c] Dieser dagegen tut was er soll. (voraussgesetzt sizeof(float) == sizeof(unsigned)) In den meisten Fällen wird das memcpy wegoptimiert. [c] float f(unsigned *p) { float fl; memcpy(&fl, p, sizeof(fl)) return fl; } [/c]
-
Thread
Socketprogrammierung Win32
[0], &myname.sin_addr.s_addr,hp -> h_length ); if((connect ( moh, (struct sockaddr *) &myname, sizeof(myname) ) ) < 0 ) { printf("network client connect failure \n"); close (moh); return -1; } sprintf(buf,"HELO irgendwas.at\r\n"); write (moh,buf, strlen(buf)); bzero (buf, sizeof(buf)); read(moh,buf,sizeof(buf)); sprintf(buf,"MAIL FROM: <%s>\r\n",from); write (moh,buf, strlen(buf)); bzero (buf, sizeof(buf)); read(moh,buf,sizeof(buf)); if (strncmp(buf,"250",3) != 0) return -1;
-
Thread
Exponentialrechnung
nur float und nicht wie > standardmäßig double. Huh? Ist aber egal, da bei AVR-GCC bislang sizeof(float) = sizeof(double) gilt. (Johann arbeitet gerade daran, dass es auch 64-bit double geben kann.) > Aber ich würde es an deiner Stelle trotzdem so schreiben: Das wird nicht besser. Solange
Jörg W. schrieb im Beitrag #6061684: > Ist aber egal, da bei AVR-GCC bislang sizeof(float) = sizeof(double) > gilt. Hängt jetzt an der Konfiguration von avr-gcc: 64-bit double erhält man z.B.mit --with-double=64 oder --with-double=64,32. Oder mit --with-double=32,64 und -
-
Thread
Probleme mit Pointerstruktur
>> schreiben könnte? > > ist nicht genaugenommen > > ppkt[offset] := (*(ppkt + (offset * sizeof(ppkt))) sizeof(*ppkt) Nein. Das sizeof ist in der Pointerarithmetik automatisch drinnen. Die Äquivalenz *( pointer + offset ) <==> pointer[offset
T * ptr; hat, gilt wiederrum automatisch ptr + offset <==> ((char*)ptr) + offset*sizeof(T) (d.h. der Offset wird implizit automatisch mit der sizeof des Basis-Datentyp des Pointers multipliziert)
-
Thread
128KB-ATMegas: Adressierung anders?
Dietmar schrieb im Beitrag #1684863: > Jetzt frage ich micht: Was ist hier sizeof(uint8_t *)? Kann ich mir das > vom Compiler irgendwie ausgeben lassen? Indirekt: [c] #include <stdint.h> int main(void) { static int a1[1-2*(sizeof(uint8_t *) <= 1)]; static int a2[1-2*(sizeof(uint8_t *) <= 2)]; static int a3[1-2*(sizeof(uint8_t *) <= 3)]; static int a4[1-2*(sizeof(uint8_t *) <= 4)]; } [/c] Kompilieren und schauen, bei welcher Zeile er sich als erstes
-
Thread
Fehler bei snprintf_P(.) Arduino ESP8266
zusätzliche Debug Meldungen generieren: [c] void setRelay(uint8_t power) { snprintf_P(log, sizeof(log), PSTR("Test")); addLog(LOG_LEVEL_INFO, log); snprintf_P(log, sizeof(log), PSTR("Power: %d"), power); addLog(LOG_LEVEL_INFO, log); . . . [/c] Obwohl die Syntax vielfach, auch unter
sonoff.ino: In function 'void setRelay(uint8_t)': sonoff:751: error: ISO C++ forbids applying 'sizeof' to an expression of function type [-fpermissive] snprintf_P(log, sizeof(log), PSTR("Test")); ^ sonoff:751: error: cannot convert 'double (*)(double)' to 'char
-
Thread
struct / jedes einzelne bit lesen
ist, dass die Daten des > struct wirklich lückenlos im Speicher hintereinanderliegen. > > Wenn sizeof (SensorFrame) * 8 == Anszal Bits ist, dann müssen sie > lückenlos im Speicher stehen. sizeof liefert die Größe in Byte, was soll da raus kommen? Bei Keil gibt es "packed" um das alignment selber
SensorFrame; void Send( uint8_t* data, size_t size ) { } Send( (uint8_t*)&SensorFrame, sizeof( SensorFrame ) ); [/c]
-
Thread
Elemente eines Zeiger Arrays ermitteln?
Die Größe des ganzen Arrays im Speicher ist : [c]sizeof(Array)[/c] Die Anzahl der Elemente im Array ist : [c]sizeof(Array)/sizeof(Array[0])[/c]
geht sizeof da nicht?
-
Thread
C Ende eines Arrays wenn nicht vom Typ Char?
Wenn das Array immer ganz gefüllt wird, kann man sich die Übergabe derLänge auch sparen und sizeof verwenden. Für das obige Beispiel: sizeof(x) Man muss da aber wissen was man tut; je nach Datentyp kann auch was falsches rauskommen. ;-)
> Wenn das Array immer ganz gefüllt wird, kann man sich die Übergabe > derLänge auch sparen und sizeof verwenden. > Für das obige Beispiel: sizeof(x) Nein kannst du nicht. Eine Funktion kann grundsätzlich nicht die Länge eines übergebenen Arrays bestimmen. Die ganze Arraysyntax in der Argumentliste
-
Thread
Unterschiedliche "static const struct Größe beim compilieren auf ARM/x86
verwende und mit dem gcc compiliere, ist das Struct 1 Byte größer, als mit dem ARM-compiler. Also sizeof(struct) gibt mir auf der x86 Platform ein byte mehr aus, als auf der ARM Platform. Ich habe mir schon die Größe jedes einzelne Element des structs ausgeben lassen mit sizeof(struct.element) und verglichen
kompiliere [c] struct st { int i; char c; }; std::printf( "%u\n", (unsigned)sizeof(struct st) ); [/c] , dann bekomme ich 8 als Größe raus. Das heißt, es wird auch am Ende noch gepadded. Ist auch logisch, weil man ja mit z.B. malloc(5*sizeof(struct st)) ein Feld allokieren
-
Thread
Compiler Optimization Level (-O1) ändert Ablauflogik?
for( i = 0; i < 4; i++ ) oder wenn man ein wenig mehr Erfahrung hat for( i = 0; i < sizeof( Array ) / sizeof( *Array ); i++ ) (vergiss die letzte Form momentan wieder) Die entscheidenden Punkte sind die Laufvariable wird mit 0 initialisiert der Vergleich lautet auf 'kleiner
dritte Parameter sagt, wie viele Bytes kopiert werden. So viele, wie die Struktur groß ist: [c]sizeof(segmente_t)[/c] Das wären in diesem Fall zwei Bytes.
-
Thread
Länge von short und int
. printf("int ist %d Bits groß, short ist %d Bits groß\n", sizeof (int) * 8, sizeof (short) * 8);
Wie er was verstehen soll? sizeof ist Standard-C und dient genau dazu, Dir Deine Frage zu beantworten.
-
Thread
STM32 F103 - I2C Probleme
habe ich erfolglos schon folgende Befehle: [c] HAL_I2C_Master_Transmit(&hi2c1, 0x3C, outbuffer, sizeof(outbuffer), 1); HAL_I2C_Mem_Write(&hi2c1, 0xA0, 0x1AAA, I2C_MEMADD_SIZE_16BIT, (uint8_t*)wmsg,strlen(wmsg)+1, HAL_MAX_DELAY);[/c] I2C Port ist in CubeMX auf Standard und auf Pin PB6 und PB7 eingestellt
So in etwa. [c] HAL_I2C_Master_Transmit(&hi2c1, 0x3C, outbuffer, sizeof(outbuffer), 1); [/c] wird zu: [c] HAL_I2C_Master_Transmit(&hi2c1,(uint16_t)0x3C,(uint8_t*)outbuffer,sizeof(outbuffer),1); [/c]
-
Thread
Fehler beim generieren eines Arrays
dein x=y=z=(double*)malloc(n*sizeof(double*)); sizeof(double*) im malloc verkneife dir mal. Ein Pointer (Adresse) auf double ist auf einem 32Bit-System 4 Bytes groß, dagegen double selbst 8 Bytes. double *x=(double*)malloc(3*n*sizeof(double)),*y=x+n,*z=x+n+n; wäre möglich.
-
Thread
kleine Frage
sizeof liefert die grösse des datentyps zurück. in diesem fall ist es double welcher 4 byte gross ist
Der sizeof-Operator liefert die Größe eines Datentyps in Vielfachen von sizeof(char) zurück. In deinem Fall sind das 4, was den 4 Byte = 32 Bit des Typs double entspricht. sizeof liefert dir nicht die Länge
-
Thread
Wie weit kann man den Malloc-Speicher treiben 1x 5x beim 8086?
#include <stdio.h> #include <stdlib.h> int main(void) { unsigned char *p = malloc(64000 * sizeof(unsigned char)); unsigned char *z = malloc(64000 * sizeof(unsigned char)); if(p != NULL) { *p=99; /* alternativ auch p[0] = 99 */ *(p+63999) = 255; /* alternativ
Die Prüfung von z != NULL fehlt. Außerdem ist per Sprachdefinition sizeof(unsigned char) = sizeof(signed char) = sizeof(char) = 1 Grüße
-
Thread
Durchschnitt von 16-bit Farbwerten berechnen
; float hitDistance = 1e20f; struct Sphere hitObject = {}; for(int i = 0; i < (sizeof(spheres) / sizeof(spheres[0])); i++) { float dist = intersectSphere(spheres[i], ry); if(dist != -1.0 && dist < hitDistance) { hitDistance = dist; hitObject
{ return a * b; } int main (void) { uint16_t a = 300, b = 400; printf ("// sizeof (int) = %d\n", (int) sizeof (int)); printf ("// Ausgabe: %" PRIu16 " * %" PRIu16 " = %" PRIu32 "\n", a, b, mul (a, b)); } // sizeof (int) = 2 // Ausgabe: 300 * 400 = 54464
-
Thread
Speicher reservieren mit malloc
pTest; uint32_t Var1; uint16_t Var2; }; test *ptr_test; ptr_test = (test*)malloc(sizeof(test)); [/c]
[/c] Ansonsten passt das. Bei [c] ptr_test = (test*)malloc(sizeof(test)); [/c] scheiden sich die Geister, ob man den Rueckgabewert von malloc nun casten sollte oder nicht. In C++ musst du casten, in C kannst du casten, musst du aber nicht. Beachte, dass bei
-
Thread
FT232 String senden/empfangen
(); i++) { cmd[i] = TEXT[i]; } */ ftStatus=FT_Write(ftHandle,cmd,sizeof(cmd),&Written); if (ftStatus == FT_OK) { printf("\nText: \"%s\" written\n",cmd); } else { printf("\nText write failed\n"); } return 0; } [/c
String senden" } [/C] Ja. Wie gehts jetzt weiter? Stringlänge feststellen (Hinweis: dein sizeof da oben ist schon mal nicht dafür geeignet), entsprechenden Pointer auf die Bytes in FT_wruite reinstecken, die ermittelte Stringlänge reinstecken und ... fertig. Ich seh immer noch kein Problem
-
Thread
Feststellen der Größe einer Variablen bei Übergabe eines void pointers
...... } template <typename T> void test (T& par1) { test (static_cast<void*> (&par1), sizeof (T)); } int main() { test(g_val1); }[/c] Das template bestimmt automatisch die korrekte Größe.
Du kannst ja ein Makro schreiben. Etwa [c] #define TEST(g_val1) test((void*)&g_val1, sizeof (g_val1)) [/c]
-
Thread
Font in SPI Flash schreiben
for(count=0;count<sizeof(Arial_8x13_Table)/255;count++) { df_write((uint8_t*)&Arial_8x13_Table[count*255],255); df_write_close(); } df_write( (uint8_t*)&Arial_8x13_Table[count*255],sizeof(Arial_8x13_Table
for(count=0;count<sizeof(Arial_8x13_Table)/255;count++) { df_write((uint8_t*)&Arial_8x13_Table[count*255],255); df_write_close(); } df_write( (uint8_t*)&Arial_8x13_Table[count*255],sizeof(Arial_8x13_Table
-
Thread
Modularisierung in C (spezialfall)
im Beitrag #3388930: > drinnen geschieht wahrscheinlich noch eine Grössenüberprüfung > length = sizeof(Buffer) sizeof(array) mein ich natürlich
Beitrag #3388930: >> drinnen geschieht wahrscheinlich noch eine Grössenüberprüfung >> length = sizeof(Buffer) > > sizeof(array) mein ich natürlich Ist egal. Denn die Funktion kann die Größe sowieso nicht aus eigener Kraft feststellen, sondern ist darauf angewiesen, dass du korrekte Werte übergibst
-
Thread
Linux Uart Konfiguration
int n = read(fd,data,(int) strlen(data)); Sollte es nicht sizeof(data) sein?
du nur 5 Bytes lesen können, nicht mehr. Ich bin ziemlich sicher du meinst die Größe des Buffers (sizeof wäre in dem Fall auch falsch).