-
Thread
Double to String C
Marcel Ofitsch schrieb im Beitrag #2116554: > Na ich wusste schon, dass es sich dabei um strings und dergleichen > handelt! > Verwirrt hat mich nur der Stern bzw. Malpunkt * Das widerspricht sich. Bevor Du weiterstoppelst: Kauf Dir ein C-Buch. Und lies es durch. Empfehlung: Brian Kernighan & Dennis Ritchie, "Programmieren in C", 2. Ausgabe, Hanser-Verlag. Ist zwar schon 20 Jahre alt, aber immer noch /das/ Buch, das einem alles relevante über C vermittelt.
-
Thread
Stringverknüpfung C/C++
Mikro 7. schrieb im Beitrag #5660638: > Serial.println(std::string("Boa") + "Constructor"); [c]'string' is not a member of 'std'[/c]
[c] Serial.println("Boa" "Constructor"); [/c] ------------- [c] Serial.println(String("Boa")+String("Constructor")); [/c] ----------- [c] Serial.println(String("Boa")+"Constructor");
-
Thread
C String in 2 Strings
willst du aber hier vermutlich nicht. Wenn ich es richtig verstanden habe willst du aus einem String 0x71;0x11 2 Chars mit einer Hex to int umwandlung machen. char c1 = (string[2]-'0') << 8 + (string[3]-'0'); char c2 = (string[7]-'0') << 8 + (string[8]-'0'); (ist jetzt aber nicht getestet,
schrieb: > wenn ich also sende(der code sieht immer gleich aus!!) > 0xFA;0x4F > soll 0xFA in i2c_start geschrieben werden und > 0x4F in i2c_write geschrieben werden. Du empfängst diesen String in einer String Variable char Command[20]; <- da baut die die Empfangsroutine den String
-
Thread
Gibt es listen in C wie in C++
() { lcd_clear(); set_cursor(0, 1); lcd_string("Einstellungen:"); set_cursor(0, 2); lcd_string("1/3 Spannung"); set_cursor(0, 3); lcd_string("2/3 Helligkeit"); set_cursor(0, 4); lcd_string("zurück"); } char (*menuestruktur
p_current_Menu = p_current_Menu->p_Naechstes_Menue; [/c] den Titel erhaelst du so: [c] p_current_Menu->p_MenueEintragTitel; [/c] MFG PS: Wie weit bist du denn mit deinem Projekt?
-
Thread
C sorgt oft für Verwirrungen
W.S. schrieb im Beitrag #3531738: > Aber die Realität sieht ganz anders aus. Augenkrebs... Ach ja, C++ ist schön: [c]std::string myString = "Cheese!"; for (char c : myString) { tuwas(c); }[/c] W.S. schrieb im Beitrag #3531738: > Mit immer mächtigerer Hardware > immer komplexere Software weiter
Kindergärtner schrieb im Beitrag #3531778: > Ach ja, C++ ist schön: > std::string myString = "Cheese!"; > for (char c : myString) { > tuwas(c); > } Aber auch noch nicht so lange. Davor sah das alles andere als schön aus: [C] for (std::string
-
Thread
Umstieg auf C
was soll das?" oder so ähnlich. Da will man lieber selber im Speicher rum-pock-en, statt std::string verwenden. Denn da weiß man ja gar nicht was das macht (heul). Statt froh zu sein, das knifflige nur einmal machen (lassen) zu müssen. Gut, Moby will auch kein C, solange es auch ASM gibt ;-)
was soll das?" oder so ähnlich. > Da will man lieber selber im Speicher rum-pock-en, statt std::string > verwenden. Denn da weiß man ja gar nicht was das macht (heul). > Statt froh zu sein, das knifflige nur einmal machen (lassen) zu müssen. > Gut, Moby will auch kein C, solange es auch ASM gibt
-
Thread
die gemeinsten Fallstricke in C
[c] char* generateConfigString() { //std::string result; char result[100]; //... //return result.c_str(); return result; } [/c] Edit: Pardon hier ist ja reines C gefragt ;-)
verwendete Compiler die Meldung auch dann aus, wenn in meinen Beispiel statt char[100] dort std::string steht, also: [c] char* generateConfigString() { std::string result; //... return result.c_str(); } [/c]
-
Thread
Pointer in C
so unendlich viele verschiedene Strings miteinander vergleichen. Sie bekommt halt nur die beiden Pointer (Addressen) wo die beiden Strings sich befinden mit geteilt. Am besten du holst dir mal ein Buch ueber die Grundlagen von 'C'
bringt. Bsp: Was ist der grundlegende Unterschied zwischen diesen beiden Funktions-Variationen [C] void lcd_string( char * pString ) { while( *pString != '\0' ) lcd_char( *pString++ ); } [/C] [C] void lcd_string( char String[] ) { uint8_t i; for( i = 0; i < strlen( String
-
Thread
C/C++ Objektmethoden
richtige Strings hat. Nackte Pointer sollte man in einem C++ Programm auch nicht verwenden (oder brauchen). Dynamische Allozierungen verpackt man besser in Objekten, dann kann man das Aufräumen auch gleich in den
Einfall dazu, schließlich wird der auch bei > std::cout "missbraucht". Und auch in Qt-Containern: [c] QVector<QString> v; v << "String 1"; v << "String 2"; v << "String 3" << "String 4" << "String 5"; // v[0] == "String 1", v[1] == "String 2" usw. [/c] MfG, Andreas
-
Thread
C++ Arduino Grundlagen
Die Arduino-String-Klasse ist für Mikrocontroller optimiert. Auf dem PC verwendet man std::string. uC und PC Programme lassen sich nicht 1:1 übertragen, besonders wenn es um AVR mit den diversen Sonderlocken (PROGMEM
();[/c] Tier.cpp [c]#include "Tier.h" Tier::Tier (std::string name) : m_name (name) { zoo.push_back (this); } void Tier::show () { std::cout << m_name; } void showAll () { for (auto& t :
-
Thread
AVR-C Pin lesen und in LCD schreiben
void lcd_data( uint8_t data ); [/c] und BEACHTEN Georg G. schrieb im Beitrag #3425904: > lcd_string erwartet als Argument einen String. Das sind ein oder mehr > druckbare Zeichen, die mit einer 0x00 beendet werden. > > digitalRead
Wolfgang schrieb im Beitrag #3426185: > Indem du, gesteuert durch den Wert des Pins, einen String erzeugst, den > du auf dem LCD ausgeben kannst. Dafür musst du erstmal wissen, was ein > String in C überhaupt ist und was ASCII-Zeichen sind. Guck dir mal den > Inhalt von deinem Character Generator
-
Thread
Uhr des µC stellen über c# keine funktion
... while(1) { if( uart_hasc() ) { // Hoppla, da will wer was von uns c = uart_getc(); oder text = uart_gets(); oder ..... } [/C] ... [C] uart_puts( dtostrf( stunden, 1,0,string ) ); //Senden an USART (VERSUCH) [/C] dtostrf? Bist du des Wahsinns fette Beute? Wozu den Umweg über float? Beschäftigungstherapie für den µC? [C] sprintf( string, "%02d:%02d:%02d;" stunden, minuten, sekunden ); uart_puts( string ); [/C]
-
Thread
Befehl strcmp wie bei ANSI C?
Ansonsten: Tante Google findet normalerweise mit dem Funktionsnamen auch sofort eine Referenzsseite. "C strcmp" sollte eigentlich weiter helfen Als Minimalkurzversion des Allernotwendigsten kann man auch da mal reinschauen [[String-Verarbeitung_in_C]]
if(strcmp(uart_str, "OK\r\n") == 0) > [/c] > ^^^ stehen? uart_str ist die Ausgabefunktion. Der String selber steht in uart_answer.
-
Thread
AVR Programmierung C++
// max string length: 255 int SendString(char* data); }; cSerialComm::cSerialComm() { //UCSR0A = UCSR0B = (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0)|(1<<TXCIE0); UCSR0C = (1<<UMSEL00)|(1<<UPM01)|(1<<UCSZ00
cRingBuffer TxBuffer; // constructor -> setup cSerialComm(); // write string in tx buffer // returns -1 if buffer overflow // max string length: 255 int SendString(char* data
-
Thread
Strings verbinden Gesperrt
i++; } return 0x01 //da der PC Programm Counter es bis hier hin geschafft hat, sind die beiden Strings gleich } int main(){ //.. dein Code char[200] c; if(compareStrings(a, b) == 0x01){ //.. verknüpfen int i =0 while(a[i] != '\0'){ i++;} for(int y=0; y< i; y++){ c[y] += a[y]; } c[i] =
(falsche) Rolle nur wenn "lim < strlen(str)" (der String wird abgeschnitten). D.h. ich kann lim auf 100.000 setzen - es ist egal. Hauptsache der destination-String kann alle Teilstrings aufnehmen. Wozu brauch ich diesen Wert dann? [c] #define
-
Thread
Am besten C lernen
gemeint. [1] C++ schleppt eine Menge Merkwürdigkeiten mit sich herum, die es nur wegen der Kompatibilität zu C braucht. *Ich* hätte mir z.B. gewünscht, daß C++ nur noch /richtige/ Strings erlaubt und die Krücke mit
bist Du der unersetztliche > Guru. Wers braucht... An einem anderen Beispiel wird es deutlicher: C++: [c]std::string x = "Hallo, " + name + "! Du hast " + std::to_string(mem) + " MB Speicher verbraucht.";[/c] C: [c]#define FORMAT "Hallo, %s! Du hast %zu MB Speicher verbraucht." char* buf = malloc
-
Thread
Stringende in C bei µC
hi gibt es ausser dem \0 noch irgendwelche Ascii zeichen die dazu führen dass in C das ende eines strings makiert wird? weil bei mir sendet der µC nie alle zeichen die in dem String stehen, und ich schreibe random ascii zeichen rein danke und mfg alex
Datentypen für terminierte > und nichtterminierte Strings in C. das ist ja klar, weil es ja in C überhaupt keine strings gibt - es gibt nur zeiger.
-
Thread
C-Problem Funktionsaufruf
C kann keinen String als Rückgabewert! Gruß jonas
Besser: C will keinen String als Rückgabewert ;) Gruß Jonas
-
Thread
verhalten von defines in C
Hallo, ich habe eine Verständinsfrage zu defines in C. [c] #define TYPE "ABC" #define VARIATION "_2" #define MAJOR_VERSION "00" #define MINOR_VERSION "900" #define SUB_REVISION "00" #define VERSION_STRING
erhoehe um Probleme, die > du kriegst, weil in einen char nur ein Zeichen passt und kein ganzer > String. Das ist richtig. Sollte [c] char version[20] = VERSION_STRING;[/c] Arduino F. schrieb im Beitrag #8027012: > Nicht das Define, aber der String wird sich in irgendeinem Speicher > befinden
-
Thread
uC Programmiertechniken - Gibt es da Bücher?
GPS_GetStamp()->tm_sec); ssd1306_WriteString(oledbuf,Font_11x18,White); [/c]
* GPS_NmeaString = (char*)&GPS.nmeastring; /* Aktueller NMEA String */ const struct tm* GPS_Time = (struct tm*)&GPS.time; /* Aktuelle GPS Zeit */ [/c]
-
Thread
Konstanten-Datei in C
Anscheinend versucht der gcc ab -O1 automatisch einen "String Merge" über Translation Units hinweg. Wichtig ist wohl nur das man die Strings so [c] const char *string = "bla"; [/c] und nicht so [c] const char string[] = "bla"; [/c] definiert. Es gäbe
.h-Datei, die alle Konstanten ..... > dem Projekt zur Verfügung stellt. Daten in *.h? z.B. Strings, oder Variablen? C kann das nicht wirklich. C++ allerdings schon. Ein Grund mehr C++ statt C zu verwenden.......
-
Thread
string bei C und PICs
Hallo habe eine Frage zu Strings bei PIC µC, gibt es da keine? Ich will zB das Bitmuster 100000001 als string darstellen, hat jemand ne Idee?
string Variable speichern. C unterstützt aber wohl keinen string? Naja aber jetzt habe ich es verstanden, man kann auch ein Array anlegen :-) Kann man mal sehen, das ich ein echter Anfänger bin.
-
Thread
C String-Problem
Daten für den Grafikmodus zu übertragen. Das ganze soll zunächst mal ganz billig und simpel mit einem C-String funktionieren. Wird jetzt aber etwa ein 'newline character' in diesem Array übergeben, dann beschwert sich mein Compiler. Eine mögliche Abhilfe sehe ich in dem kompletten Umrechnen der Daten
------------------------------------------------------------ // lcd_write_image // @param *fmap: c_string formated image //----------------------------------------------------------------------------- // Write a 320x240 (9600 bytes) sized image into graphic RAM. // void lcd_write_image(char
-
Thread
Frage zu 'End of String' in C
[c] if (a == 3) [/c] besser [c] if (3 == a) [/c] zu benutzen, weil der Fehlerfall, daß Du ein "=" vergessen hast [c] if (3 = a) [/c] auf jeden Fall einen Compiler-Abbruch erzwingt.
eingehalten habe und somit die > formalen Kriterien erfüllt habe. Aber analysieren wir doch mal [C] void lcd_string( const char* str ) { uint8_t i; for( i = 0; str[i] != '\0'; i++ ) lcd_char( str[i] ); } [/C] versus [C] void lcd_string( const char* str ) { while( *str )
-
Thread
[C++] Nur Probleme jetzt mit getline()
zusammen knobeln). [c] void copyw(String ^in, char* out) { for(int i=0;i<in->Length;i++) { out[i] = (char)in[i]; } out[in->Length]='\0'; } [/c]
der Klasse und kann Strings in C-Arrays einlesen. Das andere getline ist eine freistehende Funktion, also keiner Klasse zugehörig und liest in einen std::string ein. Nicht alle Funktionen in C++ sind Member einer Klasse.
-
Thread
Welchen Controller für C++ Programmierung? Gesperrt
in Teilen zustimmen. Als Beispiel seien mal Operationen mit Strings genannt. In C hat man dort toll strcpy, strcat, sprintf und Konsorten welche sicherlich für einen Großteil von Buffer Overflows und Sicherheitslücken in C Programmen zuständig sind. In C++ nimmt man einfach std::string (ja ist für µC vielleicht nicht unbedingt zu empfehlen) und damit kann man eigentlich keinen Buffer Overflow erzeugen. Eingefleischte C Programmierer werden aber kaum von sowas wie std::string zu überzeugen
-
Thread
Unterschied zwischen bei Compiler MPLAB® C und MPLAB® XC
Input" fields, since nothing new/different was specified to the parser since the "Input" item. 0xC0} // End Collection }; //Array of configuration descriptors ROM BYTE *ROM USB_CD_Ptr[]= { (ROM BYTE *ROM)&configDescriptor1 }; //Array of string descriptors
dann wird das Standard-Script genommen ;-) Im Descriptor-File kannst du das mal so probieren: [c]//#pragma romdata SERIAL #ifndef __DEBUG #pragma romdata serilanumber = 0x7FC0 #endif const struct{uint8_t bLength;uint8_t bDscType;uint16_t string[8];}sd003={ sizeof(sd003),USB_DESCRIPTOR_STRING
-
Thread
Mengendeklaration in C
Das ist nicht provokant sondern wahr. Obwohl ich in C/C++ 'zu Hause' bin habe ich aufgegeben einen ATMega in C zu programmieren.
zeigen, wie > ausweglos das Unterfangen ist: > char* p = "bla"; Hm, da sieht man mal wieder wie "C++-geprägt" ich bin. ;-) In C++ wäre diese Anweisung nicht gut, zumindest deprecated (afaik). p ist nämlich ein Zeiger auf einen nicht-konstanten Wert, "bla" aber eine String-Konstante. Ich meinte
-
Thread
Atmega8 und I2C-Display startet nicht
void Uart_init(); void Port_init(); void I2C_init(); void uart_send_string(const char *s); void main() { Uart_init(); Port_init(); I2C_init(); uart_send_string("Programmstart..."); uart_send_string(CR); while(1) { //START
void Uart_init(); void Port_init(); void I2C_init(); void uart_send_string(const char *s); void main() { Uart_init(); Port_init(); I2C_init(); uart_send_string("Programmstart..."); uart_send_string(CR); while(1) { //START
-
Thread
Taschenrechner in C Gesperrt
was C angeht ;-).
Hier alle Datein; C-Files zusammen kompilieren und ausprobieren :-)
-
Thread
Übergeben eines Textstrings in C
Abfrage die Funktion zum String-ausgeben aufrufen, oder ich schreibe den entsprechenden String in eine Variable und gebe am Ende der Abfragen eben nur diesen Puffer aus, also ungefähr so: [c] char buffer [5]; if (Option 1)
du \n und \0 durcheinanderschmeisst? \n Zeilenvorschub \0 0-Zeichen mit dem jeder gültige String in C abgeschlossen wird.
-
Thread
strings übergeben
// Nach Stringende send_XPort = 0; ready = 1; // beendet String-Sende-Fkt. } }[/c]
kleckern, klotzen! > 4) andere Fehler? nichts erkennbares aber lass dir doch einfach mal den String, den du empfangen hast ausgeben [C] uart_gets(command, 10); uputs( "\r\nEmpfangen: >" ); uputs( command ); uputs( "<\r\n" ); [/C] dann weißt du ganz genau, was deine Leseroutine
-
Thread
Code unleserlich schreiben um Zeilen zu sparen.
, wobei ein Zeichen char, wchar, char32_t usw sein kann. Wenn man unvorsichtigerweise c_str () aufruft und die Länge nicht mit verarbeitet, nutzt man es halt falsch. C-Strings funktionieren in C++ noch genauso, aber std::string ist eben kein Wrapper für C-Strings.
") > == std::string("foo") falsch? Auch nicht sehr schön. Der Ctor von std::string interpretiert den C-String auch richtig. Also std::string("foo\0bar") hat die Länge 3, denn "foo\0bar" ist ein C-String der Länge
-
Thread
AVR, Datentypumwandlung in C
Dezimalstring lcdstring = lcd_wert; return lcdstring; //Rückgabe int als string } [/c] MfG
return lcd_wert; //rückgabe int als string [/c] Bekomme dabei nun folgende Fehlermeldungen: ../int_to_string.c:14: warning: implicit declaration of function 'lese' Diese Problem habe ich leider noch nicht so ganz duchschaut. Ich Rufe
-
Thread
I2C Display-Weis-I2C-SDD1306-128x64-Modul
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 terminiert sind, während Arrays von Zeichen es nicht sind. Die draw_string Funktion
Arrays an diesem Zeichen. Wenn es fehlt, passiert irgend etwas blödes. Das gilt allgemein für alle String-Funktionen in c.
-
Thread
Arduino C# Serielle Kommunikation
eingelesen! Serielle Kommunikation SerialEvent https://www.arduino.cc/en/Tutorial/SerialEvent [c] void auswertung(inputString) { if(!strcmp(inputString, "help") Serial.println("do something"); } void loop() { // print the string when a newline arrives: if (stringComplete) { Serial.println(inputString); // hier fehlt die Auswertung, und Aegtschen auswertung(inputString); // clear the string: inputString = ""; stringComplete = false; } } [/c]
-
Thread
strings mit i einem anderen string zuweisen?
Hi, hab ein kleines C++ Problem; vielleicht könnt ihr mir ja weiterhelfen :-) [c] string Sel1; string Sel2; string Sel3; for(int i=1; i<=3; i++) { string test = Sel[i]; } [/c] Ich möchte, dass
zu vereinfachen [c] std::string test = (std::string &[]){ Sel1, Sel2, Sel3 } )[i]; [/c]
-
Thread
C Frage: auslesen eines *arrays[]
C-Compiler als C-Code verstanden zu werden, dessen Compilat die ASCII-Zeichen in einem String als Hex-Zahl auffasst und diese in eine Zahl umwandelt. Und gut muss er aussehen. Meine Güte.
genau das was ich will, danke für den Tipp!! jetzt muss ich noch irgendwie zusehen das ich den string zerlegt bekomme und er mir quasi erkennt wenn er ein "#" sieht. [c] int main(void) { char c; scanf("%x", &c) != 1); printf("character = %c\n", c); } [/c]
-
Thread
Variablenübergabe in C
Compiler: "ssid ist losing const qualifier". dann muss halt noch die Funktion angepasst werden. [c] static void sendStrXY( const char *string, int X, int Y) [/c] wobei das doch gar kein c mehr ist oder?
nicht-konstante Zeichenkette erwartet, und die Funktion so richtig ist, dann stimmt eben die Deklaration des Strings nicht. Mit [c] char* ssid = "MeinNetz"; [/c] sollte es gehen (nicht getestet).
-
Thread
ASCII-Zeichen nach 128 in C auf DOGXL darstellen nicht möglich
darauf auf. Du hast das ganze bloß nicht verstanden. Also hier noch mal zum Nachlesen für dich: [c] /*************************************************************** Zeichnet einen String im aktuellen Font an der angegebenen Stelle und liefert die Breite des Strings *************************
int z; while (*P) { z = CgCh_at(x,y,*P++, FontMode); x = x + z; } return (x); } [/c] So sieht sauberes Programmieren aus: Die String-Funktion setzt auf die Char-Funktion auf. Das schafft Klarheit in der Hierarchie und es vermeidet zwei parallele Funktionalitäten, die ohnehin dasselbe
-
Thread
C/C++: Alle Funktionen auflisten
Kaj G. schrieb im Beitrag #7104493: > alle Funktionen einer C/C++ Datei (also die dort implementierten) > automatisiert (Python) aufzulisten. in meiner ide habe ich das so gelöst: [c] private void sub_functiond_find(string searchtext1, string searchtext2
PadLeft(4, '_') + "_" + stufe.ToString() + "_*/"); sb.Append("\t"); sb.Append(s); sb.Append(Environment.NewLine); lineCounter++; } } [/c] Es werden jeweils die Ebenen geschweifter Klammern
-
Thread
Array aus chars in C
, die in keinem Lehrbuch wirklich schlüssig beantwortet werden. Das Initialisieren/Kopieren von Strings bzw. Arrays in C gehört aber definitiv nicht zu dieser Kategorie. Dass C keine "echten" String- Datentypen besitzt, steht ja nun wirklich in jedem Buch schon fast im Vorwort, ebenso der Hinweis
man bei sowas glaub ich String-Funktionen nutzen. > Guck mal nach strcpy. Antwortender 4: > [...] einfach in einer Schleife Zeichen für Zeichen kopieren. Fragesteller: Boah sind C-Kenner eingebildet.
-
Thread
Strings in C die zweite
Deine Servierschleife ist auch Unsinn. In C wird mit 0 zu zählen angefangen! D.h. die erste '1' wir überhaupt nicht ausgegeben. Dafür greifst du auf das Zeichen mit der Indexnummer 68 im String zu. Das ist aber immer das abschliessende '\0
, es direkt in den Compiler mit aufzunehmen (0b11111111). Dann sind pro String nur noch 9 Bytes nötig und die kann man auch im Flash ablegen. Wie genau müssen denn die 6µs und 94µs sein ? Mit irgendwelchen C-Loops ist das ne ziemlich unsichere Sache. Ich würds entweder
-
Thread
Strings- der blanke Hass in 'C'
target type Es muss doch möglich sein unter C einen String auswerten zu können, ohne hunderte von Intergervariablen zur Zeichenzählung mitschleppen zu müssen und jeden String Zeichenweise zu fuss auswerten zu müssen. ... also als ganz einfaches
ist es wahrscheinlich volatile. Du hast dann zwei Möglichkeiten: a) Die Daten des Strings nicht mehr als volatile deklarieren b) Ein eigenes strlen schreiben, dass "const volatile char*" übernimmt. c) Die Warnung mit (const char*)(p) unterdrücken bzw. const_cast<const char*>(p) in C+
-
Thread
AVR und C++ - ein Versuch
++ -c -mmcu=atmega16 -I. -gstabs -DF_CPU=16000000UL -Os -Wall -Wextra -Wwrite-strings -std=c++11 -save-temps -funsigned-char -funsigned-bitfields -fshort-enums -ffunction-sections ../UI.C -o UI.o avr-g++ -c -mmcu=atmega16 -I. -gstabs -DF_CPU=16000000UL -Os -Wall -Wextra -Wwrite-strings -std=c++11 -save-temps -funsigned-char -funsigned-bitfields -fshort-enums -ffunction-sections ../main.C -o main.o .
-
Thread
Datenaustausch von µC und PC
Array voll ist while( NextChar != 'A' && StringLen < MaxLen - 1 ) { *Buffer++ = NextChar; StringLen++; NextChar = uart_getc(); } // Noch ein '\0' anhängen um einen Standard // C-String daraus zu machen *Buffer = '\
in string schreiben Buffer++; StringLen++; NextChar = uart_waitforc(); //nächstes zeichen lesen } *Buffer = '\0'; //string terminieren }[/c]
-
Thread
[C & µC] Verwendet ihr printf/scanf?
Standard-IO-Funktionen mit nullterminierten Strings und nicht mit festen Längen. Man wird auch keinen Sensor, der per SPI angesteuert wird, plötzlich per I2C oder UART ansteuern. Daher machts imo keinen Sinn, solche Dinge in das Standard-IO-Schema
der Aufwand ist so gross, dass er sich einfach nicht lohnt. Benutzereingaben werden mit Standard-C so gemacht: erst mal mit einem fgets eine komplette Eingabezeile als String einlesen. Die dann weiter zerlegen, zb auch mit sscanf, strtok bzw. den anderen String-Funktionen. Aber mal ehrlich:
-
Thread
Stringvergleich mit C
irgendwo anders her spielt für die Funktion str[n]cmp _überhaupt_ _keine_ Rolle! Mach Doch mal ein C-Programm auf einem PC, welches einfach nur die zu erwartenden Strings vergleicht...
Testet!" da geb ich Dir aber sowas von recht. Jeder kennt die Plattformunabhängigkeit von C, aber gerade C-Anfänger wollen sie einfach nicht nutzen. Selbst die speziellen Speicherbereiche des Keil C51 kriegt man mit ein paar Defines wunderschön auskommentiert. Und wenn man ein altes DOS-Borland-C
-
Thread
if (c >= 'A') zulässig?
Terra schrieb im Beitrag #3031360: > if (strcmp(&string, "VER") == 0) strcmp erwartet 2 C-Strings. Dein char-Array "string" ist aber kein C-String (Nullterminierung fehlt).
Ich dachte dabei auch eher an die Zeile: [c] memset(string, 0, sizeof(string)); [/c] ...