-
Thread
Arduino: Größe eines Pointers
; testPtr(); testPtr = [](){Serial.println("Lambda");}; testPtr(); Serial.print("sizeof(testPtr) : "); Serial.println(sizeof(testPtr)); } void loop() { } [/c]
avr schrieb im Beitrag #5604706: > Mit sizeof findest du die Größe heraus. [c] return sizeof(void*); c0: 82 e0 ldi r24, 0x02 ; 2 c2: 08 95 ret [/c]
-
Thread
Denkfehler / Menü-Programmierung - bitte helft mir :)
denn mein blöder Denkfehler? Viele Grüße! pete [c]//defines.h #define ARRAY_SIZE(x) (sizeof(x)/sizeof(*x)) typedef void (*FunktionPointer) (void); //Zeiger auf Funktionen deklarieren struct MenueAufbau { uint8_t ProgrammEbene;//Ebene des ProgrammEintrages im Menü
-
Thread
Komandozeilenparameter/CMD Pfad Angabe
include <windows.h> int main() { char fullpath[100]; GetModuleFileName(NULL,fullpath,sizeof(fullpath)-1); printf("%s",fullpath); } [/c]
-
Thread
Mega328p und RFM69 - Problem mit PCINT
digitalWrite(RADIO_STATUSLED, HIGH); delay(100); //Radio.sendWithRetry(RADIO_RECEIVERID, Buffer, sizeof(Buffer)); Radio.sleep(); digitalWrite(RADIO_STATUSLED, LOW); delay(100); // zzzz set_sleep_mode(SLEEP_MODE_PWR_DOWN); sleep_mode(); } /*/////// // ISR // ///////*/ ISR
-
Thread
CCS8 -- unsigned int zählt nicht über >32767
]sprintf(vers,"%s","0050-CCS-TS5435");[/c] geht besser so: [c]strncpy(vers, "0050-CCS-TS5435", sizeof (vers));[/c] Oder gleich viel einfacher: [c]const char vers [] = "0050-CCS-TS5435";[/c] Und [c]for (z=0; z<26;z++) { c=vers[z]; lcd_write_command(LCD_CMD_WRITE_DATA, c); }[/c] Geht einfacher so: [c]for (size_t i = 0; i < sizeof(vers)-1; ++i) lcd_write_command(LCD_CMD_WRITE_DATA, vers [i]);[/c] Generell sollte man Variablen nicht (mehr) am Anfang der Funktion definieren, sondern erst dann wenn man tatsächlich einen Wert
-
Thread
Programm zur Datenanalyse schreiben (C)
anzahl)) { cc ++; } } jg = (char **) malloc(MAX_LAENGE_ARR*sizeof(char *));; for (int j = 0; j < len; j++) { jg[j] = (char*)malloc(MAX_LAENGE_STR*sizeof(char)); } for(int i = 0; i < len; i++) { if((strcmp(bundesland, laender
-
Thread
Arduino: Ist boolean intern als Bit oder byte (char) organisiert?
Boolean type bool - type, capable of holding one of the two values: true or false. The value of sizeof(bool) is implementation defined and might differ from 1. [/pre]
> bool - type, capable of holding one of the two values: true or > false. The value of sizeof(bool) is implementation defined and > might differ from 1. > boolean is a non-standard type alias for bool defined by Arduino. > It’s recommended to instead use the standard type bool, >
-
Thread
DCF77 von Peter Danegger
static uint8_t parity = 0; uint8_t i; uint8_t *d; i = newtime.second - 21; if( i >= sizeof( BITNO )) // only bit 21 ... 58 return; parity ^= pulse; // calculate parity i = __LPM_classic__(&BITNO[i]); if( i == 0xFF ){ // test parity if( parity )
-
Thread
Array mit Kommas getrennt ausgeben in C
[c]int array[] = {9, 4, 7, 8, 10, 5, 1, 6, 3, 2}; printf ("Array: "); for (size_t i = 0; i < sizeof(array)/sizeof(array[0]); ++i) { if (i) printf (", "); printf ("%d", array [i]); }[/c]
int array[] = {9, 4, 7, 8, 10, 5, 1, 6, 3, 2}; > printf ("Array: "); > for (size_t i = 0; i < sizeof(array)/sizeof(array[0]); ++i) { > if (i) printf (", "); > printf ("%d", array [i]); > } Warum so kompliziert? Und ineffizient (doppelter printf-Aufruf, Division...)?
-
Thread
struct und Array (Arduino)
for(i=0; i<sizeof(HeaderUnion); i++) { UDP_Header.Byte[i] = *UDP_Paket++; } [..] //Pruefsumme des Header okay? if (UDP_Header.Header.crc8 != CRC8(UDP_Header.Byte, sizeof(HeaderUnion) -1 ) ) return ( UDP_HEADER_\ CRC); Das funktioniert, sieht elegant aus, setzt aber voraus das du verstehst was du machst weil es abhaengig von Compiler und Wordbreite im Controller
-
Thread
C - ByVal, ByRef
zu tun, sondern damit, dass das für das Verständnis wichtig ist. Die typische Frage "warum gibt sizeof für mein Array immer eine Größe von 4 zurück?", die ich schon bestimmt 100 mal in Foren und Newsgroups gelesen habe (und die gerade wieder in einem Nachbarthread diskutiert wird), resultiert gerade
-
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
C sizeof Funktion in main vs in Funktion
min); printf("Maximum: %d ", max); return (float)summe/(float)sizeof(zahlen); return 0; } int main() { int zahlen[] = {3,7,5,10,122}; int bla = sizeof(zahlen)/sizeof(int); MinMaxDurch(zahlen); return 0; }
Array ermittel willst, dann schreib beim Divisor die ein Element aus dem Array hin size_t bla = sizeof(zahlen)/sizeof(zahlen]0]); oder size_t bla = sizeof(zahlen)/sizeof(*zahlen); Dann ist da auch noch korrekt, wenn sich der Typ von zahlen ändert. Bei Übergabe von Arrays an Funktionen solltest
-
Thread
Softwareschutz
to find the absolute value of v unsigned int r; // the result goes here int const mask = v >> sizeof(int) * CHAR_BIT - 1; r = (v ^ mask) - mask;[/c]
Tom schrieb im Beitrag #5580412: > v >> sizeof(int) * CHAR_BIT Rechts Shift von vorzeichenbehafteten Zahl ist undefined behaviour. Shift um eine Zahl die >= die Anzahl Bits ist, ebenfalls. Also keine besonders gute Idee, zumal es abs() gibt,
-
Thread
c/c++ array in bereits reserviertem Speicher anlegen
struct titel titelData[128]; } [/c] Ein "union u_buf" ist exakt 80000 Bytes groß, oder 128 * sizeof(struct titel), je nachdem was größer ist. :-)
S. R. schrieb im Beitrag #5569016: > Ein "union u_buf" ist exakt 80000 Bytes groß, oder 128 * sizeof(struct > titel), je nachdem was größer ist. :-) Klingt erstmal gut, werde ich mal testen. Gruß aus Berlin Michael
-
Thread
F_Mount /FATFS / STM32F401RE
Test."; f_open(&myFILE,MyPath,FA_WRITE|FA_CREATE_ALWAYS); f_write(&myFILE,MyData,sizeof(MyData),&testByte); f_close(&myFILE); f_mount(&myFATAFS,SDPath,0); } } [/c] -> Funktioniert, Datei und Inhalt können z.B. am PC gelesen werden. [c] { if(received) {
Test."; f_open(&myFILE,MyPath,FA_WRITE|FA_CREATE_ALWAYS); f_write(&myFILE,MyData,sizeof(MyData),&testByte); f_close(&myFILE); f_mount(&myFATAFS,SDPath,0); } received=0; }[/c] -> funktioniert nicht. Der Code bleibt bei f_mount stehen. Nichts geht mehr.
-
Thread
Arduino 1602 LCD Keypad Umlauttabelle
489",480}, {"\490\491\492\493\494\495\496\497\498\499",490} }; const byte RecordCount = sizeof Aufnahme / sizeof Aufnahme[0]; char schreibe[30]; void setup() { Serial.begin(2000000); lcd.begin(16, 2); lcd.clear(); for (int i = 0; i < RecordCount; i++) { Serial.print
-
Thread
C Anfängerfrage zu Pointern in Funktionen
Pointer definiert wurde. In Ausdrücken Unterschiedlich behandelt werden Arrays und Pointer m.W. nur in sizeof. Weshalb C in Parameter-Deklarationen sowas wie f(int a[]) überhaupt zugelassen hat, habe ich nie verstanden.
Man braucht dafür keine Philosophie, nur Abstraktion. > Diese Struct ist jedenfalls > gemäss sizeof 8 Bytes gross (x64): > struct S { > int& y; > }; Und wie groß ist die Referenz gemäß sizeof? Welches Alginment hat eine Referenz? Auf diese Fragen gibt es auf der abstrakten Ebene von
-
Thread
Lookup Tablegenerator für NTC-Widerstände (Linux)
constexpr(sizeof(value_type) == 1) { return value_type{pgm_read_byte(&data[i])}; } if constexpr(sizeof(value_type) == 2) { return value_type
assert(i < size()); if constexpr(sizeof(value_type) == 1) { return value_type{pgm_read_byte(&data[i + 1])}; } if constexpr(sizeof(value_type) == 2) { return value_type
-
Thread
Berechnung innerhalb atof() bzw. atoi()
Das hat einerseits die Konsequenz, daß die Funktion nichts weiter über das Array weiß (und damit /sizeof/ nicht die Größe des Arrays bestimmen kann), und andererseits, daß sich dieser Parameter eben /genauso wie ein Pointer/ verhält. Wenn Du zu einem char-Array (das Du übrigens auch gleich mit einem
int uiSTAB_Status; unsigned int uiSTAT_Status; strcpy(cCmdBuf, "STAB?"); iStrLen = sizeof(cCheckBuf); if ((iRtn = TatsBUS_QueryDevice(iDevID, cCmdBuf, cCheckBuf, /* NR-Chars*/ &iStrLen, /* RepeatCnt */ 1, /* Delay */ 0)) == NOT_OK) { PCM_Error(iDevID, __FILE__, __FUNCTION
-
Thread
Wert einer Speicheradresse auslesen
Shared Memory printf("erstelle shared memory...\n"); shared_memory1_id = shmget((key_t)213151587, sizeof(struct shared_memory1_struct), 0666 | IPC_CREAT); ///0666 everyone can read and write //shared memory für programm zugänglich machen shared_memory1_pointer = shmat(shared_memory1_id, (void *)0,
-
Thread
SDCC und ASM
clang-format on } int main() { unsigned int i = 0; unsigned int a = 0; for (i = 0; i < sizeof(dat); i++) { wert = dat[i]; crc16(); } ... [/c] "__data" sorgt dafür, daß die in Inline Assembler genutzten Variablen im direkt adressierbaren RAM liegen. BTW, - neue
-
Thread
I2C Display-Weis-I2C-SDD1306-128x64-Modul
im Prinzip auch nicht. [c] char[] meinArray={'A','B','C'}; for (int i=0; i<3; i++) // oder sizeof(meinArray) anstelle der 3 { draw_character(i*5,0,meinArray[i]); } char[] meinString="ABC"; draw_string(0,0,meinString); [/c] Der Unterschied ist, dass Strings automatisch mit einem Null-Zeichen
-
Thread
Wert im Array zugreifen
wollte ich eine schleife machen und auf jedes einzelne Element zugreifen. [code] int moveLength = sizeof(moves)/sizeof(moves[0]); [/code] Allerdings bekomme ich die Fehlermeldung: file.c on line 16:48: error: subscripted value is neither array nor pointer nor vector int moveLength = sizeof(moves
Felix schrieb im Beitrag #5540669: > int moveLength = sizeof(moves)/sizeof(moves[0]); Das ist korrekt. Der von Dir gepostete Rest aber hat mit C nur wenig zu tun. > typedef struct arr_##name ## ist in Bezeichnern nicht zulässig. > // arr_#
-
Thread
SPI Komunikation
} ISR(SPI_STC_vect) { byte c = SPDR; //kopieren der Daten von SPI Buffer if (pos < sizeof buf) { buf [pos++] = c; //hinzufuegen des naechsten Zeichens if (c == '\n') senden = true; } } void Paket_Text() { if (pos1 < sizeof buf1) for (const char * p =
Hallo, ich habe da so mein Problem mit der Schreibweise von sizeof(<type>) in deinem Code. Ich kenne die Anwendung nur als Funktionsaufruf: https://www.geeksforgeeks.org/sizeof-operator-c/
-
Thread
C - Casting Verständniss Problem
entwickelst du? 32 oder 64 bit? Kannst du mal ausgeben was die Größe des void Pointers ist? [c]sizeof(void*)[/c] Evtl. liegt da der Hund begraben.
entwickelst du? 32 oder 64 bit? > > Kannst du mal ausgeben was die Größe des void Pointers ist? > sizeof(void*) > Evtl. liegt da der Hund begraben. Das ist für nen XMEGA, schreibe den Source in C. Kann die Größe jetzt leider nicht ausgeben. Mein Rechner ist jedoch ein 64 Bit. Aber das sollte damit
-
Thread
SPI mit SPIDEV
long)(data + i); SPI[i].rx_buf = (unsigned long)(data + i); SPI[i].len = sizeof(*(data + i)) ; SPI[i].delay_usecs = 0 ; SPI[i].speed_hz = this->Frequenz ; SPI[i].bits_per_word = this->BitsPerWord ; SPI[i].cs_change = 0; } cout << endl;
i].rx_buf = (unsigned long)(data + i); // receive nach "data" SPI[i].len = sizeof(*(data + i)) ; SPI[i].delay_usecs = 0 ; SPI[i].speed_hz = this->Frequenz ; SPI[i].bits_per_word = this->BitsPerWord ; SPI[i].cs_change = 0; */ } cout << endl
-
Thread
SAM4S und MAX31865
Register,Data}; pio_clear(pinlocation,pin);// Clear CS Pin spi_write_packet(SPI0, command, sizeof(command)); while(!(SPI0->SPI_SR & SPI_SR_TXEMPTY)); pio_set(pinlocation,pin);// Set CS Pin } uint16_t receive_data_16bit(uint8_t address, Pio *pinlocation, uint32_t pin) { uint8_t rx[2] = {0,0}; pio_clear(pinlocation,pin);// Clear CS Pin spi_write_packet(SPI0, &address, sizeof(address)); while(!(SPI0->SPI_SR & SPI_SR_TXEMPTY));// Wait till transfer is done spi_read_packet(SPI0,rx,sizeof(rx)); pio_set(pinlocation,pin);// Set CS Pin return ((uint16_t)rx[0]<<8)
-
Thread
char Array für ultoa()
bevor das Programm überhaupt gestartet wurde. Sagen wir mal: So gut wie immer. Für den Operator sizeof ist garantiert, dass er bis auf VLAs den übergebenen Operanden nicht evaluiert und damit auch im Falle eines Zeiger nicht dereferenziert. Für [C] char* p = 0; sizeof *p; [/C] ist also garantiert
und sizeof nicht dereferenziert, obwohl man's hinschreibt). ;-) Deinen restlichen Ausführungen kann ich folgen. Danke dafür.
-
Thread
Spannungsteiler funktioniert nicht, was mache ich falsch?
} // Assign value if in bounds if (index >= 0 && index <= sizeof(message)) { message[index - 1] = buffer; } else { // TODO for now just complain Serial.print(F("Index is out of bounds: ")); Serial.println(index - 1); } // Message fully read, now print if (buffer == 0xAB && index - 1 == sizeof(message) - 1) { // Message length may either be 10 or 19, depending on the message int messageLength = index; Serial.print(F("Message received: ")); for
-
Thread
cast to pointer from integer of different size.
char *string, uint8_t CRC) { char VT[50] = "\v"; VT [1] = CRC; strncpy (VT+2, string, sizeof(VT)-2); size_t commandLen = strlen(VT); if (commandLen > sizeof(VT)) commandLen=sizeof(VT); // Kann passieren wenn string zu lang RS232_flushTX(ComPort); for (size_t i = 0; i <= commandLen
uint8_t > CRC) > { > char VT[50] = "\v"; > > VT [1] = CRC; > strncpy (VT+2, string, sizeof(VT)-2); > size_t commandLen = strlen(VT); > if (commandLen > sizeof(VT)) commandLen=sizeof(VT); // Kann passieren > wenn string zu lang > > RS232_flushTX(ComPort); > > for (size_t
-
Thread
C - Einer Funktion, eine Adresse eines Struktur Members übergeben?!
wäre [C] &x + offset [/C] äquvivalent zu [C] (struct X*) ((unsigned long) &x)+offset*sizeof(struct X)) [/C] berechnet also die Adresse einer Struktur mit gegebenen Offset in einem Array von Strukturen. Vollständig sieht das dann so aus: [C] #include <stdio.h> struct X {
-
Thread
[C++] Template in der Template Spezialisierung
val; matvar_t* var = Mat_VarRead(matfp, name.toStdString().c_str()); if (var->data_size == sizeof(T) && var != NULL) memcpy(&val, var->data, var->data_size); Mat_VarFree(var); return val; } [/c] Für das Lesen anderer Datentypen habe ich mir eine Spezialisierung erstellt, wie
Segmentation Violation abbrechen. So wäre es richtig: [C] if ( var != NULL && var->data_size == sizeof(T) ) ... [/C] oder auch: [C] if ( var && var->data_size == sizeof(T) ) ... [/C]
-
Thread
WS2812B mit Lib von Martin Hubáček auf F103
dieser natürlich regelmäßig upgedatet werden: [c] memcpy(display_buffer_show, display_buffer_dim, sizeof(display_buffer)); [/c] Die Konfiguration ist dabei wie folgt (Insbesondere die für den Timer und Timer-Clock ist wichtig): MCU STM32F407VGTx HCLK = 160 MHz APB1 Timer Clock = 80 MHz APB2 Timer
-
Thread
verschiedene Kommandoslänge per Rs232 senden
strcpy(in_command, in_buff); // strcpy(in_buff,""); memset(&in_buff[0], 0, sizeof(in_buff)); chr_cnt = 0; if(0 == strcmp((const char*)in_command, "SerialNumber") { Command = SerialNumber; }
-
Thread
24 Einzelne Bits zu 3 Byte zusammen fügen in c++?
uint8_t mix[] = { 1, 12, 18, 0, 24, 11 }; uint32_t ret = 0; for (int i = 0; i < sizeof(mix); i++) ret |= ((raw >> mix[i]) & 1) << i; return ret; } [/c]
0,7>, HWPin<0, 3>, HWPin<1, 4> > {}); std::cout << "0x" << std::hex << std::setw(CHAR_BIT * sizeof(packed) / 4) << std::setfill('0') << packed << std::endl; }[/c]
-
Thread
ESP8266 - SPIFFS streamFile will nicht richtig auf Android aber auf PC
file.size(); char buf[1024]; while(size > 0) { size_t len = std::min((int)(sizeof(buf) - 1), size); file.read((uint8_t *)buf, len); server.client().write((const char*)buf, len); size -= len; } [/c] bei mir nicht.
-
Thread
Keil Hardfault STM32 Jlink
das kann man in C auch haben, normalerweise schreibt man ja [c]char str[MAX]; snprintf (str, sizeof str, "%s\n", blafasel);[/c]