-
Thread
Pointer und new
wird immer implizit reserviert, indem man einfach sowas hinschreibt wie Foo x; Dann kriegst du sizeof(Foo) Bytes an Stack-Speicher für ein Objekt des Typs Foo. &x ist die Adresse von dem Stack-Speicher. Wenn du schreibst Foo* x; dann kriegst du sizeof(Foo*) (das ist eigentlich immer 4 oder 8) Bytes
beides. Es werden sizeof(Foo*) Bytes auf dem Stack reserviert, und sizeof(Foo) Bytes auf dem Heap, und der erste Speicherbereich wird mit der Adresse des zweiten befüllt. In modernem C++ versucht man explizite Verwendung
-
Thread
meine CRC-Funktion ähnlich <util/crc16.h> will nicht.
0xa2 }; int checkcrc(void) { uint8_t crc = 0, i; for (i = 0; i < sizeof serno / sizeof serno[0]; i++) crc = _crc_ibutton_update(crc, serno[i]); return crc; // must be 0 } [/c] Nun komme ich seit einer Stunde nicht dahinter, was ich verkehrt
Contents of serno: %X\n", serno); // Bei mir 8049624 printf ("Size of serno[0] = %d\n", sizeof (serno[0])); // 1 printf ("Size of serno[] = %d\n", sizeof (serno) / sizeof (serno[0])); // 8 return 0; } [/c]
-
Thread
OpenCL mit Code::Blocks einrichten.Probleme
maxDevices = 5; cl_device_id* deviceIDs = (cl_device_id*)malloc(maxDevices*sizeof(cl_device_id)); cl_platform_id* platforms = (cl_platform_id*)malloc(sizeof(cl_platform_id)); cl_int err; cl_uint num_entries = 1; cl_uint available
maxDevices = 5; cl_device_id* deviceIDs = (cl_device_id*)malloc(maxDevices*sizeof(cl_device_id)); cl_platform_id* platforms = (cl_platform_id*)malloc(sizeof(cl_platform_id)); cl_int err; cl_uint num_entries = 1; cl_uint available
-
Thread
Array übergeben
Um wieviel erhoeht er? Nun da RET zuallererst mal ein Pointer auf Pointer ist, erhoeht er um sizeof( uint8_t *). Das moeschtest Du aber nicht, du moechtest um sizeof( uint8_t ) erhoehen, da du ja an das naechste Array Element ran kommen willst. Da aber auf deinem System anscheinend sizeof( uint8_t*) == 2 * sizeof( uint8_t ) ist, beschreibst du nur jedes 2-te Array Element (und hast einen klassischen Fall von: 'hinter ein Array schreiben' und damit undefiniertes Verhalten) Die Frage ist doch: Warum ueberhaupt
-
Thread
Arduono Mega Pin ID 'Programm`
char name[3]; // maximale Textlänge + 1 }; PinDaten pinname; const byte ANZAHL_NAMEN = (sizeof(tableName) / sizeof(tableName[0])); void setup() { Serial.begin(9600); Serial.println(ANZAHL_NAMEN); // Testausgabe for (int i = 0; i < ANZAHL_NAMEN; i++) { strlcpy_P(pinname.name, (char*)pgm_read_word(&(tableName[i])), sizeof(pinname.name)); Serial.println(pinname.name); } pinMode(3, OUTPUT); digitalWriteName(3, LOW); } void loop() { } void digitalWriteName(const byte pin, const bool pegel) {
-
Thread
C++ Objekt mit Array
definieren template<typename Array> constexpr size_t arrayCount(const Array &array) { return sizeof(array)/sizeof(array[0]); } class Symbol { private: static const PROGMEM Character zeichen; public: void schreiben() const; }; const Character PROGMEM Symbol::zeichen
#5622256: > template<typename Array> constexpr size_t arrayCount(const Array &array) > { > return sizeof(array)/sizeof(array[0]); > } Das würde ich dann aber eher so schreiben: [C] template<typename Array, size_t N> constexpr size_t arrayCount(const Array (&array)[N]) { return sizeof(array
-
Thread
union-Frage
&(x), 0, sizeof( x ) ) und damit schreiben: point_t xy; CLEAR( xy );
7,8,9},callback_2}, }; void main(void){ point_t live={7,8,9}; U8 cnt; for(cnt=0; cnt<sizeof(table)/sizeof(table_t); ++cnt) if( strncmp((char*)&table[cnt], (char*)&live, sizeof(point_t))==0) table[cnt].pfkt();//TabellenÜbereinstimmung gefunden } [/C] Würde mich über einen
-
Thread
char initialisierung in C
definieren, da dieser Datentyp gleichgross ist wie ein int, aber nicht negativ sein kann, und mit sizeof prüfen ob etwas an dem Arrayindex steht: [c] int characterType[] = {....}; unsigned c = getchar(); int type = 0; if( c < sizeof(characterType)/sizeof(*characterType) ) type = characterType
auf der sicheren Seite, da kein Array mehr als /size_t/ Elemente enthalten kann (sonst würde der sizeof-Operator nicht mehr funktionieren). Karl H. schrieb im Beitrag #4264812: > Schon richtig. > Aber der Hintergrund ist ein anderer. Auf jeden Fall ist es in obigem Beispiel unsinnig, ein /char
-
Thread
Pointer auf EEPROM als Argument für Funktion
nicht enthalten. Ich habe das Gefühl mich undeutlich auszudrücken. +1 heißt übersetzt eep plus sizeof(datentyp). Was heißt dann wohl +2?
Nachtrag: +1 heißt übersetzt eep plus sizeof(datentyp). Was heißt dann wohl +2? Soll heißen: +1 heißt übersetzt eep plus 1 * sizeof(datentyp). Was heißt dann wohl +2? Ist nicht leicht ohne richtige Tastatur.
-
Thread
Keil µV: Warning - sizeof returns zero
die Tabelle zu, daher habe ich die Tabelle ganz oben deklariert. für den Zugriff benutze ich den sizeof-Operator. Beim Kompilieren warnt mich der Compiler, dass der sizeof-Operator 0 zurückliefert. das ganze sieht etwa so aus (schreibe leider von einem anderen Rechner, daher kein Originalcode):
die Größe der Struktur bestimmen zu lassen. >> } while(Count < sizeof(Tabelle) / sizeof(*Tabelle)); Damit ist man dann in allen Fällen auf der sicheren Seite.
-
Thread
C - linux - raw-socket - recvfrom liefert daten wo keine sein sollten
flags |= O_NONBLOCK; fcntl(rawrsockfd, F_SETFL, flags); memset(&if_ip, 0, sizeof(struct ifreq)); if ((rawrsockfd = socket( PF_PACKET, SOCK_RAW, htons( ETH_P_ALL))) == -1) { perror("non blocking listener: socket"); return(EXIT_FAILURE
socklen_t addr_len = sizeof socket_address; numbytes = recvfrom(rawrsockfd, recbuf, 2048, 0, (struct sockaddr*)&socket_address, &addr_len); if (numbytes<=-1){ printf("wait\b\b\b\b\b"); return 0; } printf("listener: got
-
Thread
Fehlersuche in C Gesperrt
input) fehler("Datenbank zum Lesen öffnen fehlgeschlagen"); size_t size = fread(db, 1, sizeof(db), input); if (size != sizeof(db)) fehler("Datenbank nicht komplett geladen"); fclose(input); } void db_save() { FILE *output = fopen(DBNAME, "wb"); if (!output) fehler("Datenbank zum Schreiben öffnen fehlgelschlagen"); size_t size = fwrite(db, 1, sizeof(db), output); if (size != sizeof(db)) fehler("Datenbank nicht komplett geschrieben"); fclose(output); } void db_clear() { for (int i = 0; i < DBSIZE; i++) { db[i].anzahl
-
Thread
Universelles Diagramobjekt erstellen
return (NULL); /* Reserviere Speicher für Infostruct*/ DiaParam_t* dest = malloc(sizeof(DiaParam_t)); if (dest == NULL) return(NULL); /* Kopiere Infos in neuen Struct */ memcpy(dest,src,sizeof(DiaParam_t)); /* Reserviere Speicher für Wertetabelle */ size_t len; switch (src->DataFormat) { case t_float : len = sizeof(float); break; case t_int8 : len = sizeof(int8_t); break; case t_uint8 : len = sizeof(uint8_t);
-
Thread
Nervenzusammenbruch - Speichertest auf ARM9
unsigned long *)BOARD_SDRAM_END; addr = start; while (addr < end) { for (i = 0; i < sizeof(bitpattern)/sizeof(bitpattern[0]); i++) { value = bitpattern[i]; readback = ~bitpattern[i]; *addr = value; *dummy = ~value; readback = *addr; if(readback
> müsste es nich so heisen: > > addr = addr + sizeof(unsigned long); Nein. /addr/ ist ein Zeiger auf /unsigned long/. Ein Inkrement lässt den Zeiger auf das nächste Element zeigen.
-
Thread
Lesbarer ProgrammCode
uint8_t *mem_1 = malloc(10); /* do fancy stuff */ uint16_t *mem_2 = alloc(23 * sizeof(uint16_t)); /* do fancy stuff */ uint32_t *mem_3 = malloc(47 * sizeof(uint32_t)); /* do fancy stuff */ int ret_val = 0; if ( mem_1 == NULL ) ret_val = -
1 == NULL) { return -1; } /* do fancy stuff */ mem_2 = malloc(23 * sizeof(uint16_t)); if (mem_2 == NULL) { free(mem_1); return -2; } /* do fancy stuff */ mem_3 = malloc(47 * sizeof(uint32_t)); if (mem_3 == NULL) {
-
Thread
Rangordnung C Operatoren
man es schon per Pointerconstruct ausdrücken will, so doch eher so: a[i] entspräche dann *(a + i*sizeof(a)) Immerhin soll a[i] ja das i'te Element von a bezeichnen und hier ist nichts über die Größe bzw. Datenart von a gesagt. Gelle? W.S.
Bytes hochzählt sondern in Strukturgrößen denkt. *(a+i) Kann deshalb nicht ganz passen. *(a + i*sizeof(a)) sieht für mich sinnvoller aus.
-
Thread
int-Array Initialisieren
ersten Falle rufst Du das auch korrekt auf, in dem Du die Anzahl der zu beschreibenden Bytes mit "sizeof (int) * 10" bestimmst. Dein zweiter Versuch schlägt einerseits fehl, weil Du nur die ersten zehn Bytes des Arrays überschreibst, was, je nach sizeof (int) nur die ersten fünf oder gar nur zweieinhalb
schlägt Dein Versuch fehl, weil Du den Arrayelementen nicht den Wert 1, sondern den Wert 0x0101 (bei sizeof (int) == 2) oder 0x01010101 (bei sizeof (int) == 4) zuweist. Das ist 257 oder 16843009. Verständlich? Du wirst Dein Array "von Hand" mit einer Schleife initialisieren müssen: for (i = 0
-
Thread
bool[8] in uint8_t umwandeln
Einsen) enthält Ganz fies kann das das so testen: [c] bool arr[8] =...; if(!memchr(arr, true, sizeof(arr)) { // nur false (Nullen) in arr[] } if(!memchr(arr, false, sizeof(arr)) { // nur true (Einsen) in arr[] } [/c] memchr() benutzt intern eine Schleife die maximal sizeof(arr) pro
Beitrag #5496610: > Ganz fies kann das das so testen:bool arr[8] =...; > > if(!memchr(arr, true, sizeof(arr)) { > // nur false (Nullen) in arr[] > } > > if(!memchr(arr, false, sizeof(arr)) { > // nur true (Einsen) in arr[] > } Und im zweiten Fall fällt man dann je nach Implementierung ganz
-
Thread
Concatenation und anschließende Zuweisung eines Wertes
). Du kannst doch auch die Größe den Macros als Argument übergeben bzw. in den Funktionen mit sizeof() ermitteln.
Konstante? Solange du nicht über irgendwelche (void *) auf die Fifo zugreifts, kannst Du doch über sizeof(entry)/sizeof(entry[0]) die Größe immer ermitteln. Oder packe die Size einfach mit in die struct. Braucht 2 Byte mehr, aber macht das ganze transparenter (Init der Size nicht vergessen...)
-
Thread
einfacher C-Code -> Denkfehler??
Initialisierungen müssen übereinstimmen. [C] int Entries[] = { 10, 80, 100, 40, 80 }; #define NR_ENTRIES (sizeof(Entries) / sizeof(*Entries)) int main() { for( i = 0; i < NR_ENTRIES; ++i ) // mach was mit Entries[i] } [/C] Hier passt sich alles von selbst an. Will ich einen Wert mehr im Array
Compiler erledigt den Rest [C] int Entries[] = { 10, 80, 100, 40, 80, 400 }; #define NR_ENTRIES (sizeof(Entries) / sizeof(*Entries)) int main() { for( i = 0; i < NR_ENTRIES; ++i ) // mach was mit Entries[i] } [/C] (Und nein: Beides ist gleich effizient. Nur um gleich dem Einwand der
-
Thread
gcc array an mehrdimensionales array zuweisen
reg[]" zugreift, nun, wie lang eines der Elemente darin sind? Diese Information geht verloren. sizeof (wr_bat_volt) funktioniert, aber sizeof (reg[0]) liefert /ganz was anderes/. Und .. u8? Wirklich? Spätestens seitdem es stdint.h gibt, ist sowas eine schlechte Idee.
Warum dann indiziert? der naive Ansatz wäre: [c] bat_volt = sub_wr_tx_rx(wr_bat_volt, sizeof(wr_bat_volt)); bat_kw = sub_wr_tx_rx(wr_bat_pow , sizeof(wr_bat_pow )); [/c]
-
Thread
Leere Einträge aus Array löschen
0x30, 0x00, }; unsigned int iAusgabe; unsigned int i; for( i=0; i<sizeof(arr)/sizeof(arr[0]); ++i ) { arr_test[i] = arr[i]; } moveBackDuplicateZero_ui8( arr, sizeof(arr)/sizeof(arr[0]) ); for( iAusgabe=0; iAusgabe<sizeof(arr)/sizeof(arr[0]); ++iAusgabe
-
Thread
Code funktioniert- Verbesserungsvorschlag?
while(*str++==':') { > val=strtol(str,&str,0); // oder 10 fuer dec > if(idx>=0&&idx<sizeof(receive_value)/sizeof(receive_value[0])) > receive_value[idx++]=val,ret++; > } > } while(*str++==';'); > return ret; > } Da muss man erstmal hinterkommen.....
(*str++==':') { >> val=strtol(str,&str,0); // oder 10 fuer dec >> if(idx>=0&&idx<sizeof(receive_value)/sizeof(receive_value[0])) >> receive_value[idx++]=val,ret++; >> } >> } while(*str++==';'); >> return ret; >> } > > Da muss man erstmal hinterkommen.....
-
Thread
2bit array[ ] ?
struct { unsigned char bStatus_1:1; // 1 Bit für bStatus_1 } x;[/C] definiere, ist dann sizeof(x) == 1 ? Sprich 8 Bit groß, nur 7 Bits werden nicht benutzt? Würde das heißen, dass sizeof(x) bei folgendem Fall 2 sein wird? (Sprich 2 Bytes werden reserviert, 7 Bits ungenutzt) [C] struct
nichts dagegen die Bits in einen signed/unsigned int hineinzupfriemeln. > definiere, ist dann sizeof(x) == 1 ? Sprich 8 Bit groß, nur 7 Bits > werden nicht benutzt? Ja. Kleiner als sizeof(x) == 1 geht nicht. (*) > Würde das heißen, dass sizeof(x) bei folgendem Fall 2 sein wird? > (Sprich 2
-
Thread
Array mit einem Befehl löschen?
Grübel schrieb im Beitrag #3498633: > sizeof ( array ) ne, Mist, das geht natürlich nicht bei > 8 Bit
ne, Mist, das geht natürlich nicht bei > 8 Bit Auch dafür gibt es eine Lösung: [c]for(i=0; i<sizeof(array)/sizeof(*array); i++)[/c]
-
Thread
Struct little endian
Gib doch mal ein sizeof(myData) aus. Debugger hilft auch…
len) { memcpy(&myData, data, len); printf("packet laenge: %d\n",len); printf("sizeof(myData): %ld\n",sizeof(myData)); printf("antenna signal:%d\n", myData.radio_tap_header[30]); printf("int:%d\n", myData.b); printf("float:%.3f\n", myData.c); printf("bool:%d\n",
-
Thread
Überlauf von int, char etc.
üblichen Zweierkomplementdarstellungen und IEEE754-Gleitkommazahlen folgendes implizieren: . sizeof(char) >= 8 . sizeof(short) >= 16 . sizeof(int) >= 16 . sizeof(long) >= 32 . sizeof(long long) >= 64 . sizeof(float) >= 32 . sizeof(double) > 32 (Letzteres wird vom AVR-GCC derzeit nicht eingehalten
-
Thread
cpp memory leaks vermeiden
richtig sehe, werden wohl für jedes Object 36 Bytes > > Das kann man übrigens auch super mit sizeof() abfragen. Naturlich nicht. sizeof nennt die deklarierte Grösse der Datenstruktur in bytes, aber weiss weder auf welche Granularität aufgerundet wird noch welche Verwaltungsinformation zusätzlich
erwartenden Speicherverbrauchs im Kontext der hier diskutierten Aufgabenstellung vernachlässigbar. Sizeof ist für eine grobe Abschätzung völlig ausreichend.
-
Thread
Kreuzkorrelation und Signallängen
template for (int i = 0; i < size_h; i++) { image_data[i] = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * size_w ); image_fft[i] = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * size_w ); templ_data[i] = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * size_w ); templ_fft[i] = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * size_w ); corr_data[i] = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * size_w ); ifft_data[i] = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) *
-
Thread
C String an Terminal ausgeben
Sizeof ist die falsche funktion. Was du willst heißt strlen ....
TestX schrieb im Beitrag #4125051: > Sizeof ist die falsche funktion. Was du willst heißt strlen .... und strlen hilft da leider auch nix
-
Thread
Einzelne Bytes in Struktur aufrufen
IMMER eine Lösung suchen, die das Abzählen von irgendwelchen Größen dem Compiler aufbürdet. Sprich: sizeof benutzen!
)&myStructVariable, (uint8_t*)&eemyStructVariable, sizeof( *myStructVariable ) ); [/C] bzw. [C] eeprom_write_block( (uint8_t*)&myStructVariable, (uint8_t*)&eemyStructVariable, sizeof( *myStructVariable
-
Thread
32BIT unsigned int auf 16Bit uP?
Portabilität. Dadurch werden Daten und Rechnungen unnötig aufgeblasen. Wenn auf einer Maschine mit sizeof(long)=4 und sizeof(int)=2 alle Konstanten >int mit L oder UL versehen werden, dann kriegt man in einer Umgebung mit sizeof(long)=8 und sizeof(int)=4 unnötigerweise 64bit-Werte und Berechnungen. Und
-
Thread
Feedback zum Artikel "Plattformunabhängige Programmierung in C"
etwa [c] /* gen-hostconfig.c */ #include <stdio.h> int main (void) { printf ("#define SIZEOF_INT %d\n", (int) sizeof (int)); ... } [/c] [pre] # Makefile gen-hostconfig: gen-hostconfig.c $(CC) $^ -o $@ host-config.h: gen-hostconfig ./$< > $@ programm.c: hostconfig.h [/pre] [c] /* program.c */ #include "hostconfig.h" #if SIZEOF_INT == 2 ... [/c] Sowas hab ich bisher erst einmal gebraucht um Endianess aus einem Programm zu faktorisieren. Ein Test zur Laufzeit war zu aufwändig und je nach Compiler nicht optimiert.
-
Thread
Dumme Frage zum "C" mit AVR's
const unsigned char portPinMap[] = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 }; static_assert(sizeof(ports)/sizeof(*ports)==sizeof(portPinMap)/sizeof(*portPinMap)/8,"error: portPinMap must match number of ports"); #define setPin(x,y) ( x[portPinMap[y]>>3] |= 1 << ( portPinMap[y] & 7 ) ) static const unsigned PIN_COUNT = sizeof(portPinMap)/sizeof(*portPinMap); setPin(ports,3); [/c]
-
Thread
64bit datentypen avr
Der Code sieht so aus: lcd_putchar(sizeof(uintmax_t)+'0'); uint32_t und uint16_t zeigen es richtig. avr-gcc (Gentoo 4.4.3 p1.0) 4.4.3
Jens B. schrieb: > lcd_putchar(sizeof(uintmax_t)+'0'); Öhm. Räusper. Hust. Röchel. Würg. Das ist also der Code der Dir das Ergebnis von sizeof anzeigt? Aha. Interessant. Willst Du noch mal raten? Dreimal darfst Du.
-
Thread
EEPROM Zugriff beim ATMega
L297; }; struct config_t Config; void foo() { eeprom_write_block( &Config, START_ADDR, sizeof Config ); } int main() { Config.Steps = 15; Config.Freq = 18; Config.VRef = 19; Config.L297 = 20; foo(); while( 1 ) ; } [/C] Aber das Prinzip ist immer das gleiche
L297; void foo( uint8_t* Addr ) { eeprom_write_word( (uint16_t*)Addr, Steps ); Addr += sizeof Steps; eeprom_write_byte( Addr, Freq ); Addr += sizeof Freq; eeprom_write_byte( Addr, VRef ); Addr += sizeof VRef; eeprom_write_byte( Addr, L297 ); } int main() { uint8_t Command
-
Thread
Ringpuffer mit ADC Werten füllen und versetzt ausgeben
unsigned short buffersize = 20; int putring( int uin ) { //if ( buffersize >= sizeof ringbuffer ) // return -1; uin = read_ADC(5); uin=uin; ringbuffer[ putindex ] = uin; putindex++; if ( putindex >= sizeof ringbuffer
Vermutlich scheitert das schon daran, dass der Compiler deinen Quellcode nicht schluckt, oder? Tip: "sizeof" ist eine Funktion
-
Thread
qsort haut nicht hin
Michael schrieb: > qsort(entry, count, sizeof(char *), Compare); Ein "Element" deines Arrays hat nicht die Größe sizeof(char*) Mach dir das am besten so klar Du hast einen 'Spezialstring' der 19 (20 mit \0) Zeichen aufnehmen kann
bündelt nameString entry[40]; Der qsort Aufruf muss dann so aussehen qsort( entry, count, sizeof( nameString ), Compare ); denn ein Element im entry Array hat ja die Größe eines nameString. sizeof(nameString) ist aber 20 und nicht sizeof(char*) Und deine Compare Funktion kriegt dann Pointer
-
Thread
opendir(), readdir() Sortierung
return 1; int ret = 0; size_t curSize = 32, read = 0; char** files = (char**) malloc (sizeof(char*) * curSize); if (!files) { ret = 1; goto closeDir; } memset (files, 0, sizeof(char*) * curSize); struct dirent* dirEntry; while ((dirEntry = readdir(dirHandle)) !
; } else { ++read; } } ret = 0; qsort (files, read, sizeof (char*), cmp); for (size_t i = 0; i < read; ++i) { puts (files [i]); } freePaths: for (size_t i = 0; i < read; ++i) free (files [i]); free (files); closeDir: closedir
-
Thread
Propleme beim Zeitgesteuerten Dimmen einer LED
SETTING THE CLOCK ONCE. */ // TimeIsSet = 0xffff; // RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); /* Control the clock. Clock will only be set if NV-RAM Address does not contain 0xaa. DS1307 should have a battery backup. */ RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof
DEC); Serial.print(" - Address in NV-RAM is: "); RTC.getRAM(0, (uint8_t *)&lastAddr, sizeof(uint16_t)); Serial.print(lastAddr, HEX); lastAddr = lastAddr + 1; // we want to use it as addresscounter for example RTC.setRAM(0, (uint8_t *)&lastAddr, sizeof(uint16_t));
-
Thread
hilfe zu malloc und free bei verketter liste
; memset( block ,0, sizeof(struct data_struct) ); free( block ); break; } } } } struct data_struct* data_new( void ){ struct data_struct *new_block; new_block = calloc( sizeof(struct data_struct) , sizeof(char) ); if( new_block == NULL ){ return NULL; } if(data_table == NULL) { new_block->next = NULL; }else{ new_block->next = data_table; } data_table = new_block; //
-
Thread
goto-Label an Funktion übergeben?
]int weird_goto (unsigned x) { static void **labels[] = { &&a, &&b, &&c }; if (x >= sizeof (labels) / sizeof (labels[0])) return -1; goto *labels[x]; a: return 1; b: return 2; c: return 0; }[/c] Ob computed goto sinnvoll ist — etwa in auto-generiertem
weird_goto (unsigned x) > { > static void **labels[] = { &&a, &&b, &&c }; > > if (x >= sizeof (labels) / sizeof (labels[0])) > return -1; > > goto *labels[x]; > > a: return 1; > b: return 2; > c: return 0; > }[/c] Nette Sache. Mit anderen Compilern
-
Thread
[C++/Qt] Position in Array aus Pointer?
size_t pos = Zeiger - Data; [/C] > Bin mir nicht sicher ob die arithmetische Verarbeitung mittels sizeof(myStruct) > wie man es auf nem uC machen würde für PC-System so das beste Mittel der > Wahl ist, Wozu brauchst du sizeof? > auch da Qt-Programme auf Windows/Linux/Mac laufen können, und ob
schrieb im Beitrag #2545909: >> Bin mir nicht sicher ob die arithmetische Verarbeitung mittels sizeof(myStruct) >> wie man es auf nem uC machen würde für PC-System so das beste Mittel der >> Wahl ist, > > Wozu brauchst du sizeof? in C auf 8-Bit-uC ist der Zeiger ja die physische Startadresse
-
Thread
Funktionspointer array als parameter übergeben
uint8 fpSize= getArrSize(/* hier soll die übergabe rein*/); } uint8 getArrSize( void){ return sizeof(myStateArray) / sizeof(myStateArray[0]); } [/c] wie ihr seht hab ich es bisher durch eine globale variable gelöst. Das geht doch aber auch mit einer übergabe? In etwa so: [c] uint8 fpSize= getArrSize(stateArray nFct){ return sizeof(nFct) / sizeof(nFct[0]); } [/c] Leider leider mag das aber der compiler nicht :\ Danke und Gruß µCFrage
-
Thread
Keine änderung im Memory Dump bei Array füllung.Weshalb?
Rolf Magnus schrieb im Beitrag #3358101: > Dann würde sizeof(Array) nämlich die Größe eines Zeigers > zurückgeben, was es aber nicht tut. Das ist eine der wenigen Stellen, an denen die Vereinheitlichung nicht ganz klappt. > Außerdem ist &Array eben wie
steht die Arraygröße drin, und ich kann ihn daher ausschließlich für Arrays der Größe 5 benuten. sizeof *pa ergibt 5*sizeof(int). Also mußte man sich was einfallen lassen, wie man einen Zeiger bekommt, über den man auf Arrays zugreifen kann, ohne bei der Definition des Zeigers schon die Array-Größe
-
Thread
Socket UDP Verbindung und mehrere Clients
; } objectUDPPort *UPort[2]; void main(void) { UPort[0] = (objectUDPPort *)malloc(sizeof(objectUDPPort)); UPort[1] = (objectUDPPort *)malloc(sizeof(objectUDPPort)); _objectUDPPort(UPort[0], "192.168.0.1", 1000, 1001); // UDP-Client _objectUDPPort(UPort[1], "192.168.0.2", 1000
name.sin_addr.S_un.S_addr = htonl(INADDR_ANY); if (bind(pInst->Socket, (sockaddr*)&name, sizeof(name)) == SOCKET_ERROR) { closesocket(pInst->Socket); pInst->Socket = INVALID_SOCKET; } else { int result = 0; int Timeout_ms = 1; if (result
-
Thread
STM32 USART2 wie mehrere bytes empfangen?
// Yes, send one USART_SendData(USART2, buffer[bufget++]); if (bufget >= sizeof(buffer)) bufget = 0; cnt--; } } } printf("alle bytes empfangen und zurueckgesendet\r\n"); } [/c]
in our ringRXBUFFER RXBUFFER[bufput++] = USART_ReceiveData(USART2); if (bufput >= sizeof(RXBUFFER)) bufput = 0; } c--; } [/c]
-
Thread
Audio MSP430
1355, 1415, 1477, 1539, 1601, 1664, 1728, 1791, 1855, 1919, 1984}; int laenge_melody = (sizeof(melody) / sizeof(int)); int laenge_array = (sizeof(sin_vector) / sizeof(int)); //------------- Interrupt --------------------- #pragma vector = TIMER0_A0_VECTOR __interrupt void TIMERA0(void) { DAC12_0DAT = sin_vector[z]; if(z<(sizeof(sin_vector) / sizeof(int))) { z++; } else { z=0; dieseNote++; setup(); } TACTL &= ~TAIFG; } //-----------------------------
-
Thread
Ausgabe von Gleitkommazahlen
Wie schon jemand schrieb, derzeit ist bei AVR-GCC + avr-libc sizeof(double) == sizeof(float) [== 4]. Das könnte sich eventuell mal ändern (falls wir es wirklich schaffen, ,,richtige'' doubles zu implementieren), aber sicher nicht heute und morgen und sicher auch
sizeof liefert die Größe des Objekts in Bytes...
-
Thread
C++11 std::array mit struct
{false, "hihie",13} }; void test_c99 (void) { for ( uint i = 0; i < sizeof (c99_lut ) / sizeof ( r_data ); i++ ) { std::cout<<\ i<<") "<<\ c99_lut[i].e_use<<" "<<\ c99_lut[i].e_name<<\ " Double = "<<(c99_lut[i].e_value)<<\
Problem habe ich aber mit den C++11 std::array Bei C99 kann ich schreiben: #define LUT_SIZE sizeof ( C99_lut ) / sizeof ( r_data ) und dann r_data C99_lut[] = {Initialisiererliste...} und LUT_SIZE dann in meine FOR Schleife eintragen Bei C++11 muss ich die Größe bei Definition selbst als zweites