-
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 oder Pascal
warum du glaubst deswegen anderer Leute Zeit verschwenden zu müssen, wenn es eine simple Suche nach "C Anführungszeichen in Strings" auch getan hätte. C hat daran _keine_ Schuld.
erwarten, daß eine so tolle Sprache mehr Entwickler von ihren Vorzügen überzeugen kann. > wie Strings JETZT in z.B. XE7 funktionierten getraust dich > wohl nicht mit C/C++ zu vergleichen ;-) Warum sollte ich die Stringfunktionen von Object-Pascal nicht mit denen von C++ vergleichen? C++-Strings
-
Thread
c++ Code langsam
> In einfachem C Untested: [c] #include <stdio.h> #include <string.h> int main(int argc, char **argv) { char buf[32768]; char *field[64], *p; int c, i; field[i = 0] = p = buf; while
mh schrieb im Beitrag #6686306: > Ich hab noch etwas mit C++ getestet: Compiliert leider nicht (VS 2019): [c] test_mh.cpp(23): error C2664: "std::basic_string_view<char,std::char_traits<char>>::basic_string_view(const char *const ,const std::basic_string_view
-
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
Verkette Listen in C und C++
Sicherheit gewinnt (im Gegensatz du den ganzen beliebten Buffer Overflows bei C String Verarbeitung mit char*)...
einzelnen mit der C-String-Verarbeitung rumzubasteln und ständig auf Overflows zu achten. Und selbst wenn es Performance-Kritisch wird (sehr viele/große Strings) ist keineswegs gesetzt dass std::string langsamer sei - das
-
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
von C nach C++
die Werte aufzudröseln und in Variablen abzulegen. (also so strtok- und atoi-Geschichten). Unter C++ sollte das ja wohl einfacher gehen, also mal nach "C++ string tokenizer" gegoogelt. Auf http://stackoverflow.com/questions/53849/how-do-i-tokenize-a-string-in-c werden sehr viele Lösungsvorschläge
sind ja da. Wenn es dir aber eben nicht reicht, das Parsen quasi 'in place' im String zu machen, sondern wenn du die Strings dann tatsächlich einzeln benötigst, dann bietet dir C++ auch dann Möglichkeiten, welche du in C so erst mal nicht hast. Gerade dann, wenn es eben darum geht
-
Thread
C++ Implementierungsproblem
secsSinceMidnight) { m_secsSinceMidnight = secsSinceMidnight; } CTimeOfDay::CTimeOfDay(std::string timeOfDay) { unsigned int hours; unsigned int minutes; unsigned int seconds; sscanf(timeOfDay.c_str(), "%02u:%02u:%02u", &hours, &minutes, &seconds); m_secsSinceMidnight = hours * 3600
du die ungewissen Integer-Typen nutzt. Kevin L. schrieb im Beitrag #5443752: > sscanf(timeOfDay.c_str(), "%02u:%02u:%02u", &hours, &minutes, > &seconds); Waurm scanf und nicht std::cin ? Kevin L. schrieb im Beitrag #5443752: > std::string CTimeOfDay::intToString(unsigned int value) { Warum
-
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
wrapper in c (quellcode ist C++ und QT)
float *a, long size, float * avg); DLLIMPORT unsigned int NumInteger(Wrapper LV_ref, char * inputString); #ifdef __cplusplus } #endif [/code] C_Wrapper.cpp [code] // DLL_Test_Labview.cpp : Defines the exported functions for the DLL application. // #include "stdafx.h" #include "MyClass.h
.strgets1().toStdString().c_str(); bhelpWrapper.s2 = bclass .strgets2().toStdString().c_str(); ...... // hier ist eingetlich mein Problem // Rückgabeparameter muss eine Struct (laut Deklaration) //
-
Thread
C/C++ Funktionspointer
, float); Invoker<decltype(&FooFun), &FooFun> i1; std::map<std::string, InvokerBase*> commands { {"Foo", &i1 } };[/c] Der spannende Teil kommt dann in der noch fehlenden deserialize Funktion :-)
dem if constexpr ist das glaube ich sogar sehr einfach. Müsste irgendwie so gehen (Pseudocode) [c] template<typename First, typename ... Args> std::tuple<typename std::decay<First>::type, typename std::decay<Args>::type...> deserialize(std::vector<string> remainArgs) { auto first = fromString
-
Thread
C Programmierung ohne Pointer?
Bei Strings lassen sich Pointer in C nur schwer vermeiden.
| [/c] Das sollte einen schon stutzig machen! Richtig ist es so: [c] const char *test1 = "ein x"; [/c] Ein Zeiger auf einen konstanten String Oder gar so: [c] const char *const test1 = "ein
-
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
ist C++ langsamer als C?
oder Liste produziert. Stringverarbeitung stösst ins gleiche Horn. Die wenigsten C-Programme, die ich bisher gesehen habe, sind auf einem ähnlichen 'Sicherheitsniveau', die ein C++ Programm mit std::string aus dem Stand heraus erreicht. Ein simples [C] std::string input;
dieser Idealfall nirgends wirklich vor. Aber wenn C#, VB oder Java Leute mit String Klassen wahre Erfolgsorgien feiern, gibt es keinen Grund warum C++ Leute das nicht auch tun könnten. Zumindest ist das Argument: Weil mir dann die Laufzeit in die Knie
-
Thread
Wie baut man in C Strings zusammen?
. */ values[0] = 65; // A values[1] = 66; // B values[2] = 67; // C ret = insert_values(string, values, 3); printf("%d values / new string: [%s]\n", ret, string); return 0; } [/c]
, wenn man sowas wie "char x[]={"A = ", 'A', 0};" schreiben könnte, aber leider kann das C noch nicht... Oder man nimmt halt snprintf: [c] char testString[17]; snprintf(testString, sizeof(testString), "A = %02X, B = %02X.\n", byte1, byte2); [/c]
-
Thread
C# oder C++ für Win?
Der C++ String Klasse fehlen mir auch Funktionen. Z.B. toLower(). Wer Java kennt, muss sich fragen, was das soll. https://docs.oracle.com/javase/7/docs/api/java/lang/String.html vs http://www.cplusplus.com
Chris F. schrieb im Beitrag #5059990: >> Der C++ String Klasse fehlen mir auch Funktionen > > Dann nimm die passenden Algorithmen und bau sie selber. genau das ist das Problem mit C++, es sind nur rudimentäre Funktionen vorhanden und man muss
-
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
Konvertierung c#
PadLeft(8, '0') > > Das Bsp. funktioniert natürlich nicht Dann wird versucht die Bytes als String/Text zu übertragen oder irgend etwas läuft völlig anders als auf normalen Computern. Beispiel: [c] // Ein Text, woher auch immer, wird umgewandelt in einen Integer. // Einmal ist der Text die
[/c]
-
Thread
C++ Codeoptimierung Tastatureingabe
Realisiert habe ich das auf diese Weise, nun würde mich interessieren ob man das eleganter lösen kann: [c] #include <iostream> #include <string> using namespace std; const string punctuation {".,;-_!?"}; const char EXIT {'~'}; const char NEWLINE {'\n'}; void is_punctuation(string& s) { for(
: [c] #include <iostream> #include <string> using namespace std; const string punct {".,;?!_-'"}; bool is_punct(char ch) { for(char w : punct) // macht wirklich nur Sinn wenn man mit strings
-
Thread
Welche C++ Entwicklungsumgebung?
Na, wenn du das sagst... ich habe die C-Strings jedenfalls nie gebraucht, und vor allem nicht deren schreckliche API.
Sven B. schrieb im Beitrag #3082717: > Das erste, was ich mit C++ gemacht habe, war auch mit Qt und ich hab's > auch gelernt. Man muss nun wirklich nicht unbedingt erstmal die C > strings und diese schrecklichen C++-Arrays und den Factory Pattern > verstehen
-
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
Laufzeiten und GNU/Watcom C
Was passiert, wenn du mal [c]#define GetSysVar(foo) "42"[/c] davor setzt? Dieses sich wiederholende [c]atoi(GetSysVar("timeout"))[/c] stößt mir irgendwie auf. Solch eine String->Int-Konvertierung macht man doch am besten
furchtbar. Da blickt ja keiner durch. diese unsägliche scword( p) / sscanf orgien. es gibt eine C-Funktion, die Zerlegt dir einen String in Token: [c] char *token; const char s[] = " "; /* get the first token */ token = strtok(str, s); /* walk through other tokens */
-
Thread
MMC SD library FAT16 FAT32 read write
aus diesem c File aufrufen will ich dann nochmals strings.h includen muss.
willst. Dann noch: [c] ffwrites(dat); [/c] Das funktioniert nur problemlos, wenn auf dat jetzt wirklich ein String steht. In C ist ein String immer mit '\0' terminiert, dafür musst Du sorgen. Ist das nicht so, schreibt
-
Thread
Typsichere und permutierte Parameterlisten in C++
// mmh? bar(d2); // ok bar("bla"); // not_ok [/c] Ein C-String ist eine unspezifische Zeichenkette, kein Typ für ein Datum.
[c] namespace { std::tuple strings{"abc"_pgm, "def"_pgm, "abc"_pgm}; } [/c] und alles ist gut.
-
Thread
String-Konstanten in C++
[c] #include <string> const string foo = "Hallo Welt!"; const string bar = "Hello World!"; [/c] main.cpp [c] #include "msg.hpp" [/c] Mir gefällt es nicht Header in Header zu inkludieren. Außerdem
größer wird. Ansonsten: msg.hpp [c] #ifndef MSG_H #define MSG_H #include <string> extern const std::string foo; extern const std::string bar; #endif [/c] msg.cpp [c] #include "msg.h" const std::string foo = "Hallo Welt
-
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
with.do bei C/c++?
In Pascal/Freepascal/Delphi/Lazaurs gibt es with...do gibt es vergleichbares in C/C++? [code] type name_rec = record first : string; middle : string; last : string; end; (* ... *) var name : name_rec; (*
Menge von Werten und entscheidet dann zwischen zwei Ausgaben. Oder sehe ich das falsch? Ich habe con C++ so absolut keine Ahnung, bin da eher auf Krabbelkind Niveau, bewege mich da eher bei Pascal oder sogar Basic als C/C++ Müsste es nicht eher so sein [code] { std::string today = "Dienstag
-
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
C++ und this
einem op= muss man das ganze richtig machen. Die falsche (vermeintlich richtige) Version ist [C] String& String::operator=( const String & rhs ) { if( &rhs != this ) { delete [] pointer; pointer = new char [ strlen( rhs.pointer ) + 1 ]; strcpy( pointer, rhs.pointer ); } return *this; } [/C] die korrekte Version ist [C] String& String::operator=( const String & rhs ) { char * tmp = new char [ strlen( rhs.pointer ) + 1 ]; strcpy( tmp, rhs.pointer ); delete [] pointer; pointer
-
Thread
C - Char array löschen
es geht weiter: [c] if(sizeof(string1) <= 1 || sizeof(string2) <= 1) return 0; [/c] ein Zeiger ist immer gleich groß, die abfrage macht überhaupt keinen sinn. viel zu kompliziert und falsch (length-1 warum
else { continue; } } if(breakflag) return 0; [/c] geht auch einfacher: [c] for(i = 0; i<length-1; i++) { if((isdigit(string[i]) || isalpha(string[i])) && !isspace(string[i])) { return 0; }; } [/c]
-
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 String einlesen, wieso geht das?!
Parameter bekommen. Um eine Funktion zu definieren, welche gar keine Parameter bekommt, muss man in C schreiben: [c]void Abfrage (void) {[/c] In C++ kann man sich die Fummelei mit der maximalen String-Länge sparen und eine "echte" String-Verarbeitung nutzen: [c]#include <string> #include <iostream
. [c] string[strlen(string) - 2)] = '\0'; [/c] So könnte man es machen, aber es wird unappetitlich, sofern der String bereits leer ist, strlen also 0 zurückgibt. Diese Bedingung muss man noch abfangen
-
Thread
C-Problem Funktionsaufruf
C kann keinen String als Rückgabewert! Gruß jonas
Besser: C will keinen String als Rückgabewert ;) Gruß Jonas
-
Thread
for(;;) bedeutung?
Strings vonn C oder die ShortStrings von Pascal besser sind. Ebenso können die C++-Strings mit den AnsiStrings von Object-Pascal verglichen werden. Der Vergleich von nullterminierten mit AnsiStrings
Ich bin grad nicht bei C++, sondern bei C und D. Dass C++ Strings anders arbeiten als C Strings ist mir bewusst.
-
Thread
Objektorientierte Programmierung in C
basierend auf Micky Mouse Beispielprogrammen, die nur zeigen, dass der Basisunterbau bei C++ nun mal ein wenig fetter ist. Logisch - kann ja auch mehr. Bis ein C-Programmierer seine String-Funktionen hat, dass sie genauso zuverlässig und fehlersicher laufen wie std::string ist es nun mal ein
verlinkten nicht gegangen wird. Wer nicht versteh, wo der prinzipielle Unterschied zwischen [C] char test1[10] = "Juhu"; char test2[10]; strcpy( test2, test1 ); [/C] und [C] std::string test1 = "Juhu"; std::string test2; test2 = test1; [/C] liegt, besser
-
Thread
C++ Dll in C# nutzen
static extern void ncStatusToString(uint Status, uint SizeofString, [In, Out]char[] String); [/c] (Alle Beispiele sind aus meiner Wrapperklasse für die National Instruments CAN Karten DLL für Visual C Anwendungen.)
die ca.dll an die gleiche Stelle kopieren wie die exe die du erstellst, dann findet er die DLL. [c] public static extern long PutParameter(string s, double val); [/c] Ist wahrscheinlich auch falsch. Du kannst keinen String übergeben, stattdessen übergibst du einen Pointer auf das erste Zeichen.
-
Thread
C String in Hexstring umwandeln
) { *Result = Digit(*HexString) + 16*Digit(*(HexString+1)); Result++; HexString += 2; } } int main() { char Buffer[80]; ToString( "7265767679", Buffer ); } [/C] [/C]
Karl hein, danke für deine Version, dachte es geht einfacher :-) Hier ist meine Version: string hexStr ("48616C6C6F"); string asciiStr; int tmpHexNr=0; int i=0; while (i<hexStr.length()) { string tmpStr (hexStr, i, 2); sscanf (tmpStr.c_str(), "%X", &tmpHexNr); char tmp
-
Thread
C: string auswerten
in einen Puffer zu speichern. Zeile: [c] 1:23.10.2021:08:16:09;A;B;12 23 34 45 55 66 77;0.0 % [/c] Was ich brauche ist der Dateninhalt [c] 12 23 34 45 55 66 77 [/c]
Ausgangsstring. viel zu modern :) die Fehlersuche macht mit dem originalen strtok viel mehr Spaß [c] #include <stdio.h> #include <string.h> int main() { char input[] ="1;23.10.2021;08:16:09;A;B;12 23 34 45 55 66 77;0.0 %"; strtok(input,";"); strtok(0,";"); strtok(0,";"); strtok(
-
Thread
C-struct Array effektiv nach C++ konvertieren
Oliver S. schrieb im Beitrag #7907737: > Die Structs sind in C++ genauso groß wie in C, und das bisschen > Verwaltung für den Vektor spielt kaum eine Rolle. Nein, sie sind grösser. Er braucht ja zwei std::vector (etwa 32 Bytes pro vector) und einen std::string
Ich habe das mit emplace_back ausprobiert: [c] #include <stdio.h> #include <vector> #include <string> #include <cstdint> struct Note { uint16_t time; uint8_t note, vel; uint8_t flags, stick; }; struct DrumPat {
-
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
[C] String abfragen
wir > C programmieren sitzen geblieben bin Traurig genug, dass du nach 2 Anläufen dann immer noch nicht gelernt hast, wie String-Verarbeitung in C tatsächlich funktioniert. Das ist zwar die erste gröbere Hürde für C-Programmierer, aber so schwer ist es auch wieder nicht. Von dort (sicheres Beherrschen der String-Behandlung), bis zur File-Behandlung ist dann noch ein weiterer Weg. Aber solange String-Behandlung
-
Thread
C# Wie auf einen String zugreifen
s ) { if ( char.IsDigit(c) ) { i = i * 10 + int.Parse( c.ToString() ); } } [\c]
(c)) { sb.Append(c); } } return Int32.Parse(sb.ToString()); } [/code]
-
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]