C++ (alle ISO-Standards)

• C

  Iteratur Liste
  • C++Sepp  

  10
  0
  Stimmen
  10
  Beiträge
  400
  Aufrufe

  J

  @C-Sepp sagte in Iteratur Liste: Also empfiehlt es sich so eine Liste über Zeiger zu verwalten? Ja, genauer: über unique_ptr.
• S

  Mit Klassen einen Vektor&Matrix aus Textdatei auslesen
  • Symn3169  

  9
  0
  Stimmen
  9
  Beiträge
  534
  Aufrufe

  W

  @Symn3169 sagte in Mit Klassen einen Vektor&Matrix aus Textdatei auslesen: Das mass und mat sind double*. Das wurde uns alles so von der Uni so vorgegeben auch das mit char[] statt std::string. Diese Vorgaben sind kritisch zu hinterfragen! (brauchst du für deinen Uni-Kurs wohl nicht zu machen, aber solltest du tun, wenn du C++ richtig lernen willst)
• T

  LebensZeit von "static"-Objekt in Funktion?
  • tryn4x  

  7
  0
  Stimmen
  7
  Beiträge
  186
  Aufrufe

  T

  @hustbaer Vielen Dank.
• K

  Deklaration int anzahl = 0 oder int anzahl {0}
  • KogoroMori21  

  4
  0
  Stimmen
  4
  Beiträge
  218
  Aufrufe

  D

  @KogoroMori21 Das ist eine Definition (mit impliziter Deklaration)
• M

  Check einer Konstanten auf Eindeutigkeit zur Compilezeit
  • Miq  

  49
  0
  Stimmen
  49
  Beiträge
  2451
  Aufrufe

  

  Wieso prüfen? Du musst gar nix prüfen. Du machst einfach das was der Aufrufer vorgibt.
• H

  Klassen und Schleifen
  • Hajar Izem  

  8
  0
  Stimmen
  8
  Beiträge
  338
  Aufrufe

  D

  @Hajar-Izem sagte in Klassen und Schleifen: in Zeile 16 wird der Benutzer gefragt, ob er noch weitere Daten eingeben. kommt da das Programm überhaupt hin, wenn der Vector leer ist (die size() Methode liefert 0)?
• H

  Dieses Thema wurde gelöscht!
  • Hajar Izem  

  1
  0
  Stimmen
  1
  Beiträge
  5
  Aufrufe
• J

  Kopier-Konstruktor
  klassen konstruktor • • Johnny01  

  15
  0
  Stimmen
  15
  Beiträge
  936
  Aufrufe

  

  @Johnny01 Die meisten Programme lassen sich grob in 4 Richtungen unterscheiden: 1.) Schulprogramme Schulprogramme sind Programme, welche an der Schule gelehrt werden und welche fast immer hoffnungslos veraltet sind. Da werden Pointer, verkettete Listen,... benutzt. Möchte man hier helfen, so muss man erst einmal schauen was der Lehrer haben möchte und eine entsprechende Lösung zeigen. Egal wie veraltet, fehleranfällig die Lösung sein mag. 2.) Uniprogramme Uniprogramme sind relativ ähnlich zu Schulprogrammen. Jedoch hat man mehr Freiheiten beim programmiern, hauptsache das Ergebnis stimmt. Und an meiner Uni wurde immer gesagt, man lehre keine Programmierung, das darf man schön selbst machen. Also bekam man öfters eine sehr kurze Einführung in Java, C,... und durfte dann direkt ein Problem nachprogrammieren. 3.) Programmiersprache als MIttel zum Zweck Beispiel: "Hmm, der angebotene Kredit hat einen Zinssatz von 2% und eine Laufzeit von 8 Jahren. Der zweite angebotene Kredit hat einen Zinssatz von 4% und eine Laufzeit von 4 Jahren. Welcher Kredit ist günstiger?" In diesem Beispiel schnappt man sich eine Programmiersprache, rotzt den Programmcode herunter und schaut sich das Ergebnis an. Hierunter könnte dein Programm fallen. Du möchtest Koperkonstruktor verstehen, also schreibst du ein Programm und schaust dir das Verhalten an. 4.) Produktiver/professionieller EInsatz Im produktiven Einsatz versucht man Programme zu schreiben, welche möglichst wenig fehleranfällig, robust gegenüber Fehler (Eingabefehler), schnell, einfach, sauber, lesbar, dokumentiert, leicht erweiterbar, einfach zu bedienen,... ist. Und genau das ist der Unterschied zu den 3 vorherigen Richtungen. Auf einmal spielen Dinge wie fehleranfälligkeit eine Rolle. Betrachtet man dein Programm nun aus Sicht des produktiven Einsatzes, so stellt man sich halt die Frage warum du Pointer und Allokationen (new) nutzt. Beide Sachen erweisen sich nämlich als fehleranfällig. Wer gibt beispielsweise den allokierten Speicher in int* coordinates; frei? Warum erzwingt man hier ein new(), wenn man die Koordinaten doch direkt definieren kann ("int coordinates[2];")? Das macht das Programm doch unnötig langsamer. Deine Funktion make_pair hat eine gewisse Ähnlichkeit zu std::make_pair. Deine Funktion kann aber im Gegensatz zu der std::make_pair Variante ein Speicherloch erzeugen. Nicht gut. usw.
• J

  Dieses Thema wurde gelöscht!
  • Johnny01  

  1
  0
  Stimmen
  1
  Beiträge
  5
  Aufrufe
• R

  VC++ 2022 Zu viele Affen im System !
  • ralfsobe  

  2
  0
  Stimmen
  2
  Beiträge
  155
  Aufrufe

  R

  Hier meine Klasse: //_____________________________________________________________________________ class VisualC16 //::::C16__VISUALISIERUNGSKLASSE::::_________ { public: //-------------// Ausgabeinterface, mitlaufende Variablen -------------- int VAL; // Code gelesenen Quadrantens. 0-15 Pixelwert, 16 geteilt. int X; // X-Koordinate mitlaufend geht von links nach rechts. int Y; // Y-Koordinate mitlaufend geht von oben nach unten. int Depth; // Verschachtelungstiefe 0 positiv. int Offset; // Eine Zweierpotenz von 1 !! Ist die Bildgröße. int Qx; // Fortschreitender Qudrantensektionen-Abzählindex. //-------------//-------------------------------------------------------- bool* InP; // Dateninput, mitlaufender Lesezeiger. int* Stack; // Stapelzeiger der rekursiven Abarbeitung. // Enthält Auftragscodes. // 0: Abbruch, Lesung zuende. // 1: Lese einen neuen Quadranten. // 2: Lese zwei neue Quadranten. // 3: Lese drei neue Quadranten. // 4: Lese vier neue Quadranten. // // Konstruktor startet eine serielle Durchlesung vom Hauptanfang.............. VisualC16(bool* inp, int* stack, int offset, int x, int y)// Vom Hauptanfang. { InP = inp; Stack = stack; Offset = offset; X = x; Y = y; VAL = 17; Qx = 0; Depth = 0; *Stack = 0; // Ausstiegscode einschreiben. Stack++; *Stack = 1; // Schreibe den Befehlscode ein: Ein Quadrat lesen. X += Offset; // Einsprung-Medizin in rekursive Routine. }; //_________//____________________________________________________________ //_________// Initialisieren und einmal treiben für eine serielle Durchlesung //_________// der Codematrix, die abfragbare Pixelkoordinaten X, Y mitzieht. //_________// Und den VAL Quadrantencode abrufbar macht, den der //_________// schnelle Treiberprogrammierer auf leichsteste Weise mit //_________// einer 17-Farben-Tabelle und eine Funktion zur Zeichnung //_________// bunter Quadrate auf jede Graphikoberfläche zaubern kann. //_______________________// Triggert die Rechenschritte, die wird getrieben. bool Progress(); // Rückgabe wahr: Die Lesung läuft. //-----------------------// Rückgabe falsch: Die Lesung ist zuende. // Treiben geht wirklich einfach : // // VisualC16 Reader( Datenfutter ); // while ( Reader.Progress() ) // { // // VAL, X, Y, etc. lesen und buntes Quadrat zeichnen lassen. // }; }; //===================================================================// bool VisualC16::Progress() // { //================================================================// int Command = *Stack; switch ( Command ) { case 0: default: return false; //------------------------------------// Koordinaten linksoben. case 4: X += Offset; // Vier Teilungsquadrate zeichnen. Y += Offset; // rechte untere Ecke. *Stack = 3; break; // //-------------------------------------// case 3: X -= Offset; // linke untere Ecke. *Stack = 2; break; // //-------------------------------------// case 2: Y -= Offset; // X += Offset; // rechte obere Ecke. *Stack = 1; break; // //-------------------------------------// case 1: X -= Offset; // Zurück zum Ursprung. //////////////////////////////////////// Links oben. bool TB0 = *InP; InP++; // TB0 = Erstes Entscheidungsbit. if (TB0) // ------------- Unterteilt oder Adresse ? { bool TB1 = *InP; InP++; if (TB1) // ---- Jetzt kommt die lange Binärzahl. { return false; // Nicht implementiert, Prozessabbruch. } else // ------------- Es folgen vier Quadranten. { Depth++; // Jetzt geht die Verschachtelung tiefer runter. Stack++; // Und der Stack naturgemäß rauf ! *Stack = 4; // Befehl zum Zeichnen von vier Subquadranten. Offset = Offset / 2; VAL = 16; // Code für unterteilten Quadranten. return true; }; } else //-----------------------------// Elementarer Quadrant. { VAL = 0; // if (*InP) { VAL |= 1; }; InP++; // Immittiert ein bischen das serielle if (*InP) { VAL |= 2; }; InP++; // Bitschlangeninterface. if (*InP) { VAL |= 4; }; InP++; // Eingabedaten raus saugen. if (*InP) { VAL |= 8; }; InP++; // 4 Bits Pixelfarbcode. if (Depth == 0) // Raus hier, Job erledigt, { *Stack = 0; // extra Für ein einzelnes Pixel. } else // Das kleinere Pixel befindet sich in tieferer Verschachtelung. { if (Command == 1) { Depth--; Stack--; Offset = Offset * 2; } }; return true; }; };
• R

  Endlich Pixelkontrolle Visual Studio 22
  c++ graphik • • ralfsobe  

  17
  0
  Stimmen
  17
  Beiträge
  715
  Aufrufe

  C

  ... Womit man sich SFML-Gefummel einhandelt, keine Ahnung, was weniger schlimm ist. Momentan will ich SendMessage( ... WM_PRINT ... ) probieren, der muß irgendwie meine Eingabe verdauen, nur leider kommt die Nachricht nicht an. ich hab nicht alles gelesen aber dein Versuch SendMessage mit WM_PRINT, was soll das bringen? Oder sollte das WM-PAINT heißen was genau so sinnlos ist, denn zum neuzeichnen kannst du nicht einfach WM_PAINT aufrufen, das macht die GDI du kannst nur deinen Zeichenbereich für ungültig erklären (Repaint) und dann wird WM_PAINT vom System angeschoben.
• C

  virtueller Destruktor
  • C++Sepp  

  6
  0
  Stimmen
  6
  Beiträge
  249
  Aufrufe

  C

  Super...vielen Dank!
• W

  Primzahl finden
  • Wusel1991  

  22
  0
  Stimmen
  22
  Beiträge
  891
  Aufrufe

  

  Hat schon jemand die 5er gezeigt, die alle Varianten vereinigt? https://ideone.com/e2TgRM edit: Ja, das ist ja die von Columbo.
• N

  Aufgabe Verwaltung eines dynamischen Arrays
  • nobrainer  

  34
  0
  Stimmen
  34
  Beiträge
  1517
  Aufrufe

  

  @nobrainer , in der main so wie in den meisten Funktionen brauchst Du eine Abfrage: //----------------------------------------------------------------------------- int askUser( std::string output, int min, int max ) { int retVal = -1; if ( min >= max ) { std::cout << "min muss kleiner max sein" << "\n"; } else { do { std::cout << output << "\n"; std::cout << "Eingabe:"; std::cin >> retVal; if ( retVal < min || retVal > max ) { std::cout << "Eingabe nicht im Eingabebereich" << "\n"; } } while ( retVal < min || retVal > max ); } return retVal; } Die kann schon mal in der main in einer do-while-schleife genutzt werden: int input = 0; std::size_t mainArraySize = 0; int * mainArray = nullptr; do { input = askUser( "1 Array anlegen\n2 Array-Groesse aendern\n3 Wert eingeben\n4 Feld ausgeben\n0 Programm beenden\n", 0, 4 ); switch ( input ) { case 1: mainArray = arrayAnlegen( mainArray, mainArraySize ); break; case 2: mainArray = arrayGroesseAendern( mainArray, mainArraySize ); break; case 4: arrayAusgeben( mainArray, mainArraySize ); break; default: break; } } while ( input != 0 ); if ( mainArray ) delete[] mainArray; // nur der Ordnung halber return 0; jetzt noch eine Funktion: int * arrayAnlegen( int * mainArray, std::size_t & mainArraySize ) { int * localArray = mainArray; if ( ! localArray ) { mainArraySize = askUser( "Groesse des Arrays?", 2, 1000 ); if ( mainArraySize > 0 ) { localArray = new int[mainArraySize]; for ( std::size_t i = 0; i < mainArraySize; ++i ) { localArray[i] = -1; } } } else { std::cout << "Fehler: Array schon vorhanden" << "\n"; } return localArray; } u.s.w. Ungetestet und geht wahrscheinlich noch eleganter
• S

  Aliasing-Optimierung?
  • Steffo  

  16
  0
  Stimmen
  16
  Beiträge
  687
  Aufrufe

  *

  Die AVX Befehle sind zum Teil etwas sonderbar. Die folgende Abfolge kommt mit AVX und SSE aus, und liefert das Ergebnis. #include <iostream> #include <immintrin.h> class vec3 { public: __m256d e; vec3() : e (_mm256_setzero_pd ()) {} vec3(const double e0, const double e1, const double e2) : e (_mm256_set_pd (0.0, e2, e1, e0)) {} // ... double length_squared() const; }; double vec3::length_squared () const { double ret[2] = {0.0, 0.0}; __m256d t = _mm256_mul_pd (e, e); __m256d r = _mm256_hadd_pd (t, t); __m128d lo = _mm256_extractf128_pd (r, 0); __m128d hi = _mm256_extractf128_pd (t, 1); __m128d tt = _mm_blend_pd (lo, hi, 1); __m128d rr = _mm_hadd_pd(tt, tt); _mm_store_pd (ret, rr); return ret[0]; } double dot(const vec3 &u, const vec3 &v) { return u.e[0] * v.e[0] + u.e[1] * v.e[1] + u.e[2] * v.e[2]; } int main () { vec3 a(1.0, 1.0, 1.0), b(2.0, 2.0, 2.0); std::cout << dot (a, a) << "\n"; std::cout << dot (b, b) << "\n"; std::cout << b.length_squared() << "\n"; }
• H

  Typisierten Container/ Sammlung anzeigen in XAML (WinUI)
  • Henri689  

  1
  0
  Stimmen
  1
  Beiträge
  93
  Aufrufe

  H

  Moin, bin Anfänger in CPP und würde gerne mit WinUI etwas in einer ListView anzeigen. Ich habe bisher auch noch nie mit Xaml basierten GUIs gearbeitet. Ich habe mir die Photo Beispiel App angesehen und den Bookstore + Bindung an eine Sammlung nach Anleitung ausprobiert. Vergleichen mit C# Beispielen klappt ja leider so nicht. Nun hab' ich das Problem, dass ich da nicht ganz durchsteige. Beispiel: Ich habe einen typisierten Containter. Die Eigenschaften im Struct: Name, Geschlecht, Alter. Ich würde das Ganze jetzt gerne in einer ListView anzeigen, aber dazu müsste das ja public gemacht werden durch die IDL Datei. Ich finde leider überhaupt keine Infos da drüber, wie das nun aussehen müsste. Überseh ich da was und müsste mir das Bookstore Beispiel, dass eigentlich sagen? Ist das richtig, dass dies nur durch Bindung geht und nicht per XBind mit einem Datatemplate, welches mehrere Controls für die einzelnen Eigenschaften hat?
• T

  C++ Coalesced Hashing, Vergleichsoperatoren
  • TufanMahan12  

  4
  -1
  Stimmen
  4
  Beiträge
  239
  Aufrufe

  S

  @TufanMahan12 Wenn du deine Mitmenschen repsektieren würdest, hättest du das schnell hier rein getippt.... so, dass war es jetzt mit Hilfe von meiner Seite
• J

  Array übergeben zu Konstruktor
  konstruktor zeiger • • Johnny01  

  52
  0
  Stimmen
  52
  Beiträge
  3735
  Aufrufe

  *

  Hier sind zwei Varianten die funktionieren. #include <type_traits> template <typename T> concept Addable = requires (T a, T b) {a + b;}; auto double_up (const auto& value) requires Addable<decltype(value)> { return value + value; } // alternativ auto double_up (const Addable auto& value) { return value + value; } int main() { double_up (2.0); }
• C

  Basisinitialisierer Vererbung
  • C++Sepp  

  19
  0
  Stimmen
  19
  Beiträge
  581
  Aufrufe

  

  Nein, da in deinem Code TraceParcel(const Parcel& pc, Address adr): Parcel(1, 2, adr ) adr als Wert übergeben wird (d.h. es wurde eine Kopie erzeugt). Reichst du diese als Referenz an die Basisklasse Parcel weiter (und wie schon geschrieben, würde diese Referenz dann gespeichert werden), so wird adr nach Verlassen des Konstruktor wieder zerstört und die gespeicherte Referenz referenziert ins Nirvana. Und selbst bei Address& adr wäre dies entsprechend so: ... außer - das temporäre Objekt wird in der Initialisierungsliste eines Konstruktors an eine Member-Referenz gebunden. Dann endet die Lebensdauer des Objekts mit dem Ablauf des Konstruktors ...
• P

  std::atomic<bool> hat anderen Wert in anderem Thread
  multithreading atomic async • • PadMad  

  6
  0
  Stimmen
  6
  Beiträge
  664
  Aufrufe

  S

  @PadMad Hi, es ist zwar interessant zu sehen, aus welchem Projekt der Code komnmt. Aber: Ich möchte ,um zu Helfen, den relevanten Code ausführbar möglichst schnell zu sammen haben, also Copy & Paste von hier, ohne das ganze Projekt runter zu laden zu müssen. Ein minimales compilierbares Beispielt hat die Vorteile, dass genau das gegeben ist, außerdem der Code zum nachvollziehen des Problems auf jeden Fall da ist (wenn ich das richtig gesehen habe, hattest du die relevante Stelle im Eingangspost ja gar nicht erwähnt) und wahrscheinlich wärst du beim Erstellen des minimalen Beispiels schon selber über den eigentlichen Fehler gestolpert