Recently Active Topics

Forum weiterhin ?

Finnegan — Sun, 14 Jun 2026 16:11:05 GMT

@Dravere Auch ein interessanter Nebeneffekt: Habe schon mehr als einmal, als ich der KI erklärt habe, warum der als fehlerhaft angekreidete Code dennoch korrekt ist, selbst nochmal richtig darüber nachgedacht und ein ganz anderes Problem entdeckt, das wir beide nicht gesehen haben. Auch wenn das etwas ist, das auch ein Kollege liefern kann: der hat halt auch nicht immer Zeit für die Probleme anderer. Und es zeigt aber auch, wie nützlich ein Review selbst dann ist, wenn der Reviewer nicht den besten Durchblick hat.

GCC 16.1.0 und Modules

*john 0 — Sat, 13 Jun 2026 08:04:43 GMT

Ah, das war es. Vielen Dank für den Hinweis!

Buchempfehlung "Expedition Chaos: Vom Fixpunkt zur Feigenbaum-Konstante - Experimente mit dem Chaos Labor in C#"

SeppJ — Fri, 12 Jun 2026 14:36:46 GMT

Cool! Ein Buch zur Chaostheorie im Bücherschrank meiner Eltern hat mich mit zu einem meiner ersten ernsthaften, guten Computerprogramme inspiriert, als ich eben genau das Bifurkationsdiagramm von deinem Titelbild nachprogrammiert habe. Hat mir sicher nicht geschadet Leider hat die Mandelbrotmenge im Anschluss nicht funktioniert, weil ich als 13-jähriger nicht so recht wusste, wie man mit komplexen Zahlen rechnet (QBasic hatte auch keinen eingebauten Typ dafür), und meine Versuche das anhand von Lexikonartikeln zu lernen (Damals gab es noch nicht wirklich Internet für Normalleute zuhause) waren nicht so erfolgreich.

SDL2 Input Handling

zeropage — Thu, 11 Jun 2026 13:49:45 GMT

Hallo, Sorry, das ich so lange weg war, aber ich hatte Schwierigkeiten mich anzumelden, bis ich mitbekommen hatte, das ich hier ne andere Mail Adresse hatte.Aber nun gut. Ich beschäftige micht gerade mit SDL2 und fand das Input Handling etwas irritierend. Einerseits scheint es nach meinen rudimentären Recherchen unterschiedliche Vorgehensweisen für gedrückte und gehaltene Tasten zu geben, andererseits will ich keine EventLoop für Tastendrücke haben. So kam ich zu einer für mich zufriedenstellenden Lösung, die ich hier gerne vorstellen möchte. Diese ist natürlich nur in meinem Horizont, es mag bestimmt besserere Lösungen geben, die ich nur noch nicht gesehen habe. Ich finde meine Lösung aber recht intuitiv, weil es nur zwei Bedingungen gibt. Man muss eine 'Mouse Update' Methode vor einem Frame setzen und eine "Key Update" nach jedem Frame. Außerdem werden drei Tastenzustände registriert; Pressed, Held, Released. Das Ganze sieht dann so aus: #pragma once #include namespace zp { struct KeyState { bool Pressed = false; bool Released = false; bool Held = false; }; } namespace zp { class SDLInput { public: SDLInput(); void updateKeyInput(); void updateMouseInput(); private: const Uint8* m_CurrentKeyStates; Uint8 m_PreviousKeyStates[SDL_NUM_SCANCODES]; KeyState m_KeyState; static constexpr Uint32 MOUSE_KEY_BUFFER = 5; Uint32 m_CurrentMouseStates[MOUSE_KEY_BUFFER]; Uint32 m_PreviousMouseStates[MOUSE_KEY_BUFFER]; KeyState m_MouseState[MOUSE_KEY_BUFFER]; ivec2 m_MousePos; public: const KeyState& getKey(const SDL_Scancode key); const KeyState& getKey(const KeyCode key); const KeyState& getMouse(const MouseButton button) const; const ivec2& getMousePos() const; private: void updateKeyState(const SDL_Scancode key); void updateMouseState(); }; } Hier die cpp: #include zp::SDLInput::SDLInput() : m_CurrentKeyStates(SDL_GetKeyboardState(nullptr)) { updateKeyInput(); } void zp::SDLInput::updateKeyInput() // set after frame { // Update previous states memcpy(m_PreviousKeyStates, m_CurrentKeyStates, SDL_NUM_SCANCODES); } void zp::SDLInput::updateMouseInput() // set before frame { updateMouseState(); } const zp::KeyState& zp::SDLInput::getKey(const SDL_Scancode key) { updateKeyState(key); return m_KeyState; } const zp::KeyState& zp::SDLInput::getKey(const KeyCode key) { updateKeyState(static_cast(key)); return m_KeyState; } const zp::KeyState& zp::SDLInput::getMouse(const MouseButton button) const { return m_MouseState[static_cast(button)]; } const zp::ivec2& zp::SDLInput::getMousePos() const { return m_MousePos; } /* private */ void zp::SDLInput::updateKeyState(const SDL_Scancode key) { if (m_CurrentKeyStates[key]) { if (!m_PreviousKeyStates[key]) { m_KeyState.Pressed = true; m_KeyState.Held = true; m_KeyState.Released = false; } else { m_KeyState.Pressed = false; m_KeyState.Held = true; m_KeyState.Released = false; } } else { if (m_PreviousKeyStates[key]) { m_KeyState.Pressed = false; m_KeyState.Held = false; m_KeyState.Released = true; } else { m_KeyState.Pressed = false; m_KeyState.Held = false; m_KeyState.Released = false; } } } void zp::SDLInput::updateMouseState() { int x, y; auto mouseState = SDL_GetMouseState(&x, &y); m_MousePos = ivec2(x, y); for (auto i = 0; i < MOUSE_KEY_BUFFER; ++i) { m_CurrentMouseStates[i] = mouseState & SDL_BUTTON(i); m_MouseState[i].Pressed = false; m_MouseState[i].Released = false; if (m_CurrentMouseStates[i] != m_PreviousMouseStates[i]) { if (m_CurrentMouseStates[i]) { m_MouseState[i].Pressed = true; m_MouseState[i].Held = true; } else { m_MouseState[i].Released = true; m_MouseState[i].Held = false; } } m_PreviousMouseStates[i] = m_CurrentMouseStates[i]; } } Ich habe dann auch eigene enums, die ich auch intuitiver finde. Die KeysCodes habe ich einfach von der sdl2 wiki kopiert. enum class MouseButton : Uint32 { LEFT = SDL_BUTTON_LEFT, MIDDLE = SDL_BUTTON_MIDDLE, RIGHT = SDL_BUTTON_RIGHT, X1 = SDL_BUTTON_X1, X2 = SDL_BUTTON_X2 }; enum class KeyCode : Uint32 { A = 4, B = 5, C = 6, D = 7, E = 8, F = 9, G = 10, H = 11, I = 12, J = 13, K = 14, L = 15, M = 16, N = 17, O = 18, P = 19, Q = 20, R = 21, S = 22, T = 23, U = 24, V = 25, W = 26, X = 27, Y = 28, Z = 29, D1 = 30, D2 = 31, D3 = 32, D4 = 33, D5 = 34, D6 = 35, D7 = 36, D8 = 37, D9 = 38, D0 = 39, RETURN = 40, ESCAPE = 41, BACKSPACE = 42, TAB = 43, SPACE = 44, F1 = 58, F2 = 59, F3 = 60, F4 = 61, F5 = 62, F6 = 63, F7 = 64, F8 = 65, F9 = 66, F10 = 67, F11 = 68, F12 = 69, HOME = 74, PAGEUP = 75, DELETE = 76, END = 77, PAGEDOWN = 78, RIGHT = 79, LEFT = 80, DOWN = 81, UP = 82 }; Sorry, das ich wieder kaum kommentiert habe, aber da habe ich echt noch Schwierigkeiten. Zwar bin ich nicht besonders kritikreselient aber wer mag, kann gerne seine Gedanken dazu schreiben. LG

RayLib für Einsteiger

LuckyStriker — Sun, 07 Jun 2026 21:52:35 GMT

Hallo zusammen! Ich bin Quer.- bzw. Neueinsteiger. Ich wollt e mich mal an der "ralib.h" versuchen und scheitere schon beim ersten Anlauf. #include int main() { const int Window_Width = 750; const int Window_Height = 750; const int FPS = 12; InitWindow(Window_Width, Window_Height, "RayLib Test"); SetTargetFPS(FPS); // Simulation Loop while (WindowShouldClose()==false) { // 1. Event Handling // 2. Updating State // 3. Drawing BeginDrawing(); EndDrawing(); } CloseWindow(); } schließen bzw. beenden. Stattdessen dreht sich der Maus-Cursor (früher war das 'ne Sanduhr). Danke im voraus Micha

Blogi simples Blogsystem

SeppJ — Wed, 03 Jun 2026 18:32:57 GMT

@Tuxist1 sagte in Blogi simples Blogsystem: @SeppJ Deutsche Glasfaser der Anschluss zickt manchmal .... Tatsache. Nach ein paar Minuten Warten bekommt man tatsächlich eine Antwort. Manchmal. Da war ich vor meinem letzten Kommentar wohl zu ungeduldig. Aber ich glaube nicht, dass ich die Geduld habe, mir das unter diesen Umständen anzugucken.

Anzahl der Permutationen verringern?

Helena76 — Tue, 02 Jun 2026 12:18:45 GMT

@Lennox sagte in Anzahl der Permutationen verringern?: Das Kuriose ist auch, dass die freien Stellen für einen Menschen ganz leicht zu erkennen sind - aber für den Backtracking-Algo eben nicht... Also, welche Approximationen (oder Schätzungen) gibt es für dieses Problem? Ich hatte diese Frage zunächst auch in einem anderen Forum gestellt (Computerbase), dort aber ein lebenslanges Hausverbot bekommen, weil dort überwiegend in Berlin angesiedelt Journalisten sind, die nur links-grüne Meinungen zulassen. Andere Positionen sind dort nicht erwünscht... Ich weiß gar nicht, ob ein grundloser Bann rechtens ist, aber andererseits ist das auch eigentlich ein Hardwareforum - und Fragen zur Programmierung sind dort eher nur eine Nischen-Erscheinung. Vermutlich wird sich auch erst dann mal daran etwas ändern, sobald die AfD regiert... denn dann werden sehr viele auch mal um ihre sicher geglaubte Position fürchten müssen. Jedenfalls wüsste ich sonst nicht, wo ich diese Frage noch stellen könnte (von der KI oder Stack Overflow mal abgesehen). Das Problem mit dem Backtracking ist, dass es stur jeden Pfad testet, während unser Gehirn Muster sofort erkennt. Probier mal die „Minimum Remaining Values“ (MRV) Heuristik: Wähle immer zuerst den Bereich mit den wenigsten Möglichkeiten aus. Das beschneidet den Suchbaum extrem effektiv. Auch Constraint Propagation (wie AC-3) hilft, den Suchraum vorab durch Ausschluss zu verkleinern. Lass dich von Foren nicht ärgern, in der Programmierung zählt am Ende nur der effiziente Code.

Läuft VS 2026 unter Windows 10 ?

biter — Sat, 23 May 2026 05:49:54 GMT

Hallo Ihr, eine Frage: Läuft VS 2026 Community unter Windows 10 ? Im Internet habe ich gelesen, dass man wenn man Anwendungen für Windows 10 erstellen will, die Konstanten WINVER und _WIN32_WINNT auf 0x0A00 setzen soll. Wo kann man das machen ? Unter targetver.h/SDKDDKVer.h, habe ich diese Definitionen nicht gefunden. Weiss jemand Rat ?

Zahlen mit Anzahl Nachkommastellen

SeppJ — Fri, 22 May 2026 13:14:59 GMT

@Mika69 sagte in Zahlen mit Anzahl Nachkommastellen: Hi! Dieser Kommentar trifft den Nagel auf den Kopf, wenn es um die klassischen Tücken von Fließkommazahlen (float und double) geht. Computer rechnen intern im Binärsystem (Basis 2), weshalb viele alltägliche Dezimalbrüche wie 0,10,10,1 oder 123,12123,12123,12 nicht exakt dargestellt werden können.Deshalb ist der mathematische Weg über Math.Truncate (mit 10n10^n10n multiplizieren, abschneiden, durch 10n10^n10n teilen) meistens die sauberere Wahl für Berechnungen, auch wenn das binäre Restrisiko minimal bleibt. Wenn es dir rein um die Optik geht, ist das Umwandeln in einen String und das anschließende Abschneiden tatsächlich der einzige Weg, um die exakte Dezimaldarstellung zu erzwingen. Dein vorgeschlagener mathematische Weg geht eben gerade nicht! Da 0.1 nicht als float dargestellt werden kann, nützt es auch nichts, trunc(0.1 * 10) / 10 zu berechnen, denn das Ergebnis passt dann ja immer noch nicht in einen float! 0.1 als float ist ca. 0.10000000149. Mal 10 ist 1.0000000149, abgeschnitten 1. Aber 1 / 10 ist dann was als float? Eben wieder 0.10000000149! Und nun? die exakte Dezimaldarstellung Was ist diese exakte Dezimaldarstellung? Wenn ich (vor oder nach deiner Rechnung) den float 0.10000000149 habe, ist dann die exakte Dezimaldarstellung davon 0.1 oder 0.10000000149, etwas dazwischen, oder ganz was anderes? Wäre die Antwort eine andere, wenn die nächstmögliche Binärdarstellung stattdessen so etwas wie 0.0999999975 wäre? Apropos, die genaueste float-Darstellung von 0.7 ist 0.699999988. Aber trunc(0.699999988 * 10) / 10 ist 0.6000000238. Ist es das, was du von deiner mathematischen Methode willst? PS: Ich habe die Dezimaldarstellungen in den Zahlenbeispielen nach einer Weile abgeschnitten. Die Zahlen sind zwar alle Dezimal exakt darstellbar (darum geht es ja gerade), aber es bringt ja keinen Mehrwert, wenn ich 0.60000002384185791015625 schreibe statt auf 0.6000000238 zu runden, außer dass es unleserlich wird. Bloß dass niemand denkt, ich könne keine Kommarechnung

Betriebssystem-Auswahl und -Optimierung für spezifischen Server-RAM (DDR5-5600MHz)

Noah20 — Thu, 14 May 2026 09:01:33 GMT

Ehrlich gesagt, beim Kompilieren von großen Projekten würde ich mich nicht zu sehr in den Details verlieren, aber nimm was Aktuelles. Mir ist aufgefallen, dass ältere Systeme bei DDR5 oft nicht richtig hinterherkommen. Für meinen Dev-Server bin ich auf Fedora umgestiegen, und der Unterschied bei den Build-Zeiten mit ninja war im Vergleich zu meinem alten Debian echt krass. Aber ein Tipp aus der Praxis: Wenn du später mal 8 Riegel drin hast, wird das ordentlich warm im Gehäuse. Achte also auf einen guten Airflow! Diese Hitzeentwicklung liegt übrigens an den PMICs (Power Management ICs), die bei DDR5 direkt auf den Riegeln sitzen. Wenn die zu heiß werden, drosselt das System die Spannung, was zu abgebrochenen Compiles führt. Um den Airflow nicht zu blockieren, muss das Kabelmanagement perfekt sein. Früher habe ich meine Kabel mit billigem Tape markiert, das durch die Hitze weggeschmolzen ist. Letzte Woche habe ich beim Basteln einfach einen gravierten Schlüsselanhänger als persönliches Geschenk mit Erinnerungswert zweckentfremdet, um den Hauptkabelstrang stabil und hitzefest am Gehäuseboden zu fixieren. Klingt verrückt, aber so bleibt der Luftstrom frei. Achte echt darauf, dass die Luft sauber zwischen den Riegeln durchziehen kann!

Round-Trip-Cast als Prüfung für verlustfreien Cast?

Quiche Lorraine — Thu, 23 Apr 2026 05:44:21 GMT

@DNKpp Danke!

Substrings innerhalb eines Strings sortieren

SeppJ — Fri, 17 Apr 2026 13:49:37 GMT

Ich brauche gerade mal eine entspannte Kaffeepause. Da kann ich auch mal ein bisschen Informatikunterricht spielen und das Schritt für Schritt entwickeln. Fangen wir mit dem Grundgerüst an. Nur die Teilstringdefinition und die Eingabe (Auf ideone.com von stdin): #include #include #include #include // Liste der bekannten Substrings const std::map> mTeilstrings = { {1, {"[8A]", "[UKE]"}}, {2, {"[Dings da]", "[DingsBums]"}}, {3, {"[GF]", "[MOD]", "[MOD3]", "[MOD6]"}}, {4, {"[Weiss]", "[Rot]", "[Orange-Blau]"}} }; int main() { for(std::string line; std::getline(std::cin, line);) { std::cout << line << '\n'; } } https://ideone.com/8xFxh5 Jetzt wollen wir anhand der Teilstrings unsere Eingabezeilen in einen vector> zerlegen. Mir ist bewusst, dass die hier in diesem Beispiel naturgemäß immer schon in der richtigen Reihenfolge rauskommen, und ich an dieser Stelle auch gucken könnte, ob es Doppelungen gibt. Das geht aber nur so gut, weil ich alle Problematik bezüglich Doppelungen, Uneindeutigkeiten, oder fehlender Definitionen vernachlässige. Ich nehme an, dass das Zerlegen in Wahrheit komplizierter ausfallen könnte. Nach jeder Zerlegung gucken wir uns das Ergebnis an, ob es den Erwartungen entspricht! #include #include #include #include // Liste der bekannten Substrings const std::map> mTeilstrings = { {1, {"[8A]", "[UKE]"}}, {2, {"[Dings da]", "[DingsBums]"}}, {3, {"[GF]", "[MOD]", "[MOD3]", "[MOD6]"}}, {4, {"[Weiss]", "[Rot]", "[Orange-Blau]"}} }; auto parse_line(std::string line, const std::map> &substring_groups) { std::vector> result; for (auto const& kv : substring_groups) { for (auto const &substring: kv.second) { if (line.find(substring) != std::string::npos) result.push_back(std::make_pair(substring, kv.first)); } } return result; } int main() { for(std::string line; std::getline(std::cin, line);) { auto substring_pairs = parse_line(line, mTeilstrings); std::cout << "Zeile \"" << line << "\" wird zerlegt in '"; for (auto pair: substring_pairs) std::cout << "{\"" << pair.first << "\", " << pair.second << "}, "; std::cout << '\n'; } } Zeile "[8A][Dings da][Orange-Blau]" wird zerlegt in {("[8A]", 1), ("[Dings da]", 2), ("[Orange-Blau]", 4), } Zeile "[MOD][Weiss][UKE]" wird zerlegt in {("[UKE]", 1), ("[MOD]", 3), ("[Weiss]", 4), } Zeile "[GF][MOD3][Dings da]" wird zerlegt in {("[Dings da]", 2), ("[GF]", 3), ("[MOD3]", 3), } Zeile "[MOD][Black][UKE]" wird zerlegt in {("[UKE]", 1), ("[MOD]", 3), } Zeile "[GF][MOD3][Dings da][GF][MOD3][Dings da]" wird zerlegt in {("[Dings da]", 2), ("[GF]", 3), ("[MOD3]", 3), } https://ideone.com/HsyN2N Ideone kann nur C++14 so richtig, daher Entschuldigung für den altertümlichen Stil. Besonders mit C++17 und neuer gehen die ganzen Schleifen sehr viel schöner, wie du in deiner Lösung schon korrekt vormachst. Hoppla, da haben wir ja auch gleich mehrere Fehler im Ergebnis! Zeile "[MOD][Black][UKE]" wird zerlegt in {("[UKE]", 1), ("[MOD]", 3), } Da fehlt [Black], weil es nicht in der Teilstringdefinition vorkommt. Das ignoriere ich jetzt wie gesagt erst einmal, da es in der Vorgabe nicht definiert ist, was passieren soll. Aber das hier: Zeile "[GF][MOD3][Dings da][GF][MOD3][Dings da]" wird zerlegt in {("[Dings da]", 2), ("[GF]", 3), ("[MOD3]", 3), } Da fehlen die Doppelungen von [MOD3] und [Dings da]. Da müssen wir beim Zerlegen gründlicher sein: #include #include #include #include // Liste der bekannten Substrings const std::map> mTeilstrings = { {1, {"[8A]", "[UKE]"}}, {2, {"[Dings da]", "[DingsBums]"}}, {3, {"[GF]", "[MOD]", "[MOD3]", "[MOD6]"}}, {4, {"[Weiss]", "[Rot]", "[Orange-Blau]"}} }; auto parse_line(std::string line, const std::map> &substring_groups) { std::vector> result; for (auto const& kv : substring_groups) { for (auto const &substring: kv.second) { std::string::size_type pos = 0; while ((pos = line.find(substring, pos)) != std::string::npos) { result.push_back(std::make_pair(substring, kv.first)); pos += substring.length(); } } } return result; } int main() { for(std::string line; std::getline(std::cin, line);) { auto substring_pairs = parse_line(line, mTeilstrings); std::cout << "Zeile \"" << line << "\" wird zerlegt in '"; for (auto pair: substring_pairs) std::cout << "{\"" << pair.first << "\", " << pair.second << "}, "; std::cout << '\n'; } } Zeile "[8A][Dings da][Orange-Blau]" wird zerlegt in '{"[8A]", 1}, {"[Dings da]", 2}, {"[Orange-Blau]", 4}, Zeile "[MOD][Weiss][UKE]" wird zerlegt in '{"[UKE]", 1}, {"[MOD]", 3}, {"[Weiss]", 4}, Zeile "[GF][MOD3][Dings da]" wird zerlegt in '{"[Dings da]", 2}, {"[GF]", 3}, {"[MOD3]", 3}, Zeile "[MOD][Black][UKE]" wird zerlegt in '{"[UKE]", 1}, {"[MOD]", 3}, Zeile "[GF][MOD3][Dings da][GF][MOD3][Dings da]" wird zerlegt in '{"[Dings da]", 2}, {"[Dings da]", 2}, {"[GF]", 3}, {"[GF]", 3}, {"[MOD3]", 3}, {"[MOD3]", 3}, Passt. https://ideone.com/jV4pWL Man könnte an dieser Stelle natürlich trivial prüfen, ob es Doppelungen gibt. Wir müssen bloß Mitzählen beim Suchen der Teilstrings in jeder Gruppe. Aber wie gesagt, nehme ich an, dass das später komplizierter werden kann, also ignoriere ich das jetzt erst einmal und mache das erst später. Nächster Schritt: Sortieren! Hier eigentlich nicht nötig, aber in komplizierteren Fällen schon. Ist sowieso ein Einzeiler. Spaßeshalber kann ich die Reihenfolge ja umdrehen, so dass man sieht, dass auch etwas passiert. #include #include #include #include #include // Liste der bekannten Substrings const std::map> mTeilstrings = { {1, {"[8A]", "[UKE]"}}, {2, {"[Dings da]", "[DingsBums]"}}, {3, {"[GF]", "[MOD]", "[MOD3]", "[MOD6]"}}, {4, {"[Weiss]", "[Rot]", "[Orange-Blau]"}} }; auto parse_line(std::string line, const std::map> &substring_groups) { std::vector> result; for (auto const& kv : substring_groups) { for (auto const &substring: kv.second) { std::string::size_type pos = 0; while ((pos = line.find(substring, pos)) != std::string::npos) { result.push_back(std::make_pair(substring, kv.first)); pos += substring.length(); } } } return result; } int main() { for(std::string line; std::getline(std::cin, line);) { auto substring_pairs = parse_line(line, mTeilstrings); std::sort(substring_pairs.begin(), substring_pairs.end(), [](auto left_pair, auto right_pair){return left_pair.second > right_pair.second;}); std::cout << "Zeile \"" << line << "\" wird zerlegt in '"; for (auto pair: substring_pairs) std::cout << "{\"" << pair.first << "\", " << pair.second << "}, "; std::cout << '\n'; } } Zeile "[8A][Dings da][Orange-Blau]" wird zerlegt in '{"[Orange-Blau]", 4}, {"[Dings da]", 2}, {"[8A]", 1}, Zeile "[MOD][Weiss][UKE]" wird zerlegt in '{"[Weiss]", 4}, {"[MOD]", 3}, {"[UKE]", 1}, Zeile "[GF][MOD3][Dings da]" wird zerlegt in '{"[GF]", 3}, {"[MOD3]", 3}, {"[Dings da]", 2}, Zeile "[MOD][Black][UKE]" wird zerlegt in '{"[MOD]", 3}, {"[UKE]", 1}, Zeile "[GF][MOD3][Dings da][GF][MOD3][Dings da]" wird zerlegt in '{"[GF]", 3}, {"[GF]", 3}, {"[MOD3]", 3}, {"[MOD3]", 3}, {"[Dings da]", 2}, {"[Dings da]", 2}, Passt. https://ideone.com/qOMpob Und jetzt setzen wir die Einzelteile wieder zusammen. Und spätestens jetzt müssen wir prüfen, ob es Doppelungen gibt, also vergleichen wir jeweils mit dem Vorgänger. #include #include #include #include #include // Liste der bekannten Substrings const std::map> mTeilstrings = { {1, {"[8A]", "[UKE]"}}, {2, {"[Dings da]", "[DingsBums]"}}, {3, {"[GF]", "[MOD]", "[MOD3]", "[MOD6]"}}, {4, {"[Weiss]", "[Rot]", "[Orange-Blau]"}} }; auto parse_line(std::string line, const std::map> &substring_groups) { std::vector> result; for (auto const& kv : substring_groups) { for (auto const &substring: kv.second) { std::string::size_type pos = 0; while ((pos = line.find(substring, pos)) != std::string::npos) { result.push_back(std::make_pair(substring, kv.first)); pos += substring.length(); } } } return result; } std::string reconstitute_line(std::vector> const& substring_pairs) { std::string result; int last_group; if (not substring_pairs.empty()) { last_group = substring_pairs[0].second; result = substring_pairs[0].first; } for (std::size_t i = 1; i < substring_pairs.size(); ++i) { int current_group = substring_pairs[i].second; if (current_group == last_group) return "Zeile enthält illegale Doppelungen"; result += substring_pairs[i].first; } return result; } int main() { for(std::string line; std::getline(std::cin, line);) { auto substring_pairs = parse_line(line, mTeilstrings); std::sort(substring_pairs.begin(), substring_pairs.end(), [](auto left_pair, auto right_pair){return left_pair.second > right_pair.second;}); std::string sorted_line = reconstitute_line(substring_pairs); std::cout << "Zeile \"" << line << "\" wird sortiert zu \"" << sorted_line << "\"\n"; } } Zeile "[8A][Dings da][Orange-Blau]" wird sortiert zu "[Orange-Blau][Dings da][8A]" Zeile "[MOD][Weiss][UKE]" wird sortiert zu "[Weiss][MOD][UKE]" Zeile "[GF][MOD3][Dings da]" wird sortiert zu "Zeile enthält illegale Doppelungen" Zeile "[MOD][Black][UKE]" wird sortiert zu "[MOD][UKE]" Zeile "[GF][MOD3][Dings da][GF][MOD3][Dings da]" wird sortiert zu "Zeile enthält illegale Doppelungen" Passt. https://ideone.com/M25huJ Es ist eigentlich falsch, Fehler als Rückgabewert zurück zu geben, aber ich hatte jetzt keine Lust für das Beispiel auch noch eine ausgiebige Fehlerbehandlung zu programmieren. Zumal ich gar nicht weiß, was die Anforderung für den Fehlerfall ist. Das sind noch reichlich Verbesserungen möglich. Wurden ja auch schon genannt, oder du bist selber drauf gekommen. Und auch so triviale Dinge, wie das Vermeiden von unnötigen Kopien, sind noch nicht getan. Aber so hast du erst einmal eine Basis, die funktioniert, und wo die Funktionalitäten aufgetrennt sind. Von da aus ist es leichter, diese Verbesserungen vorzunehmen, anstatt alles auf einmal in einer siebenfach verschachtelten Schleife zu machen.

Neues von MFC ?

biter — Sun, 12 Apr 2026 06:03:10 GMT

Danke Dir Erhard !