C++ (alle ISO-Standards)

• _

  malloc oder new
  • _ro_ro  

  41
  0
  Stimmen
  41
  Beiträge
  901
  Aufrufe

  _

  @nameName ja, danke Dir. Und ja, ich bin ein Anfänger Betrf. Smartpointer habe ich heute was gelesen. Mit einer neueren MinGW Version könnte das was werden, aber vorerst sind noch ein paar Andere Dinge offen die ich mit der alten STL hinkriegen müsste. Was new/delete betrifft, da habe ich mittlerweile den Code soweit eingedampft daß dazwischen nur noch wenige Zeilen liegen, ist also überschaubar. Immerhin habe ich mittlerweile meine CGI class und die TemplateEngine class von new befreit Viele Grüße!!
• N

  Wofür sind die Underscores_?
  • nameName  

  5
  -2
  Stimmen
  5
  Beiträge
  205
  Aufrufe

  

  Die ASCII-Werte für Buchstaben Ligen glaube ich von 65 für A bis 90 für Z. Wenn es wirklich der ASCII-Werte ist, dann ist das richtig, denn dann muss, wenn der Wert über 90 ist, immer 26 (einmal das ABC) abgezogen werden, damit keine Verschiebung im ABC erfolgt. Doch das ist nur eine Logik, die ich mir im Kopf zusammen gesponnen habe, ich kann kein C++ Programmieren und verstehe den Code auch kein Stück weit. (schau dir mal meinen anderen Beitrag an, damit du ein Gespür bekommst, was ich von C++ weis.
• G

  C++ Array Frage - Anfänger
  • georgz  

  5
  0
  Stimmen
  5
  Beiträge
  169
  Aufrufe

  G

  @Finnegan Vielen Dank, das hat mir sehr weitergeholfen. Gruß, Georg
• _

  Exception: throw string
  • _ro_ro  

  5
  0
  Stimmen
  5
  Beiträge
  159
  Aufrufe

  W

  Außerdem solltest du aufhören (oder dir gar nicht erst angewöhnen), new zu verwenden. Verwende stattdessen Stackvariablen oder Smartpointer. In deinem Code hier hast du ein Speicherleck, wenn die Exception fliegt. Auch im nicht-Exception-Fall leakst du.
• N

  Argumentloser Konstruktor
  • NPC  

  43
  0
  Stimmen
  43
  Beiträge
  1811
  Aufrufe

  N

  @Quiche-Lorraine sagte in Argumentloser Konstruktor: Leute: Don' t feed the trolls! A "troll" is a person who intentionally attempts to disrupt, cause controversy, incite an argument, and/or receive negative attention by deliberately posting provocative content. The term may also refer to the act of posting such content, or the content itself. Trolls are generally deceitful and often use ambivalence as a method of covertly insulting, intimidating, or inciting a person or persons for their own sadistic pleasure. They often pick their words very carefully and are therefore able to defend their masked attempts at creating unrest, frequently redirecting the blame onto the community and its supposed failure to understand them properly. Trolling is strictly prohibited. Quelle: https://wiki.manjaro.org/index.php?title=Forum_Rules Zu tief ins Glas geschaut?
• K

  Forward Declaration bei inneren privaten Klassen/Strukturen
  • KK27  

  8
  0
  Stimmen
  8
  Beiträge
  212
  Aufrufe

  

  @KK27 Richtig, eine forward-declaration einer nested class ist nur möglich, während die äussere Klasse definiert wird. Also nur so wie in deinem Beispiel. Das ist auch ein mMn. wichtiger Nachteil von nested classes. Daher mache ich oft gerne Foo und FooParams statt Foo und Foo::Params.
• L

  Kompilierung von Hello-World in C++ über VS-Code
  • Lysandros  

  2
  0
  Stimmen
  2
  Beiträge
  74
  Aufrufe

  N

  Brauchst das C++ Plugin und clang... vermute ich https://code.visualstudio.com/docs/cpp/config-clang-mac
• H

  Zimmer buchen - falscher Preis wird ausgegeben
  • helpinfo  

  2
  0
  Stimmen
  2
  Beiträge
  99
  Aufrufe

  

  Bedenke die Operatorpriorität bei bool Wochenende = (kalender[i].Wochentag[0] == 'S' && kalender[i].Wochentag[1] == 'a' || kalender[i].Wochentag[1] == 'o'); PS: Packe deinen Code in Code-Tags (Button "</>"), dann schaue ich mir auch noch mehr an...
• M

  Zuweisung an Referenz auf Basisklasse
  • Max3000  

  12
  0
  Stimmen
  12
  Beiträge
  360
  Aufrufe

  

  Oder aber du macht es einfach so: struct Data { Vector v; Matrix m; Tensor t; }; Und dann mit der forward_propagate so wie du sie schon hast. Ein Vorteil davon wäre dass du in den Klassen wo sich der Typ ändert nicht mehr dynamisch Speicher anfordern musst. Wobei das eigentlich nur von Bedeutung ist wenn der ganze Prozess mehrfach wiederholt wird.
• X

  Preis Berechnung if-Verweigungen
  • xTheUhu  

  19
  0
  Stimmen
  19
  Beiträge
  263
  Aufrufe

  P

  @xTheUhu sagte in Preis Berechnung if-Verweigungen: Beim Debuggen stimmt alles soweit außer wenn ich für Kaffee und Milch 'j' eintippe. da solltest du aber dringend nochmal den umgang mit dem debugger üben, das kommt normalerweise gleich nach cout << "Hello World!" << endl;
• B

  Kann ich mit der typeid einer Klasse eine Instanz erzeugen
  • booster  

  14
  0
  Stimmen
  14
  Beiträge
  340
  Aufrufe

  

  @booster sagte in Kann ich mit der typeid einer Klasse eine Instanz erzeugen: Es geht halt darum dass der Enum und die Klassen später erweitert werden müssen. Da ist das mit dem switch case immer etwas unschön. Es muss immer irgendwo irgendwas erweitert werden. So lange der Code sich im selben Modul befindet wie der enum, ist es mMn. mehr oder weniger egal ob man nen switch oder ne map verwendet. Bzw. switch hat sogar nen Vorteil: mit den passenden Compiler-Switches bekommst du eine Warnung wenn du den enum erweiterst, aber vergisst den case beim switch dazuzumachen. Bei GCC ist das z.B. -Wswitch (enthalten in -Wall). Bei MSVC musst du die extra aufdrehen, z.B. mit /W4 /w44061 /w44062. Beispiel: enum class Foo { A, B, C, }; int ok(Foo f) { switch (f) { case Foo::A: return 1; case Foo::B: return 2; case Foo::C: return 3; } return 0; } int warn(Foo f) { switch (f) { case Foo::A: return 1; case Foo::B: return 2; } return 0; } https://godbolt.org/z/cd49vxrhz Wichtig dabei ist dass es kein default Label gibt -- denn sonst kommt bei GCC keine Warnung. Aber ja kann schon schneller sein. Aber ist der Fall wirklich so ungewöhnlich? Das ist doch das Factory Pattern. Ungewöhnlich nicht. Die Frage ist für mich aber ob du diese Komplexität brauchst. Also ob sie einen Vorteil bringt. Es gibt natürlich Fälle wo das Sinn macht bzw. sogar notwendig ist. Stell dir z.B. ein GUI Framework vor, welches zur Laufzeit anhand von "Beschreibungen" (XML Files, ...) GUI Elemente zusammenbaut. Sowas sollte natürlich von ausserhalb des Frameworks erweiterbar sein, damit man seine eigenen Control-Klassen implementieren und verwenden kann. Da funktioniert natürlich ein einfaches switch-case im Framework-Code nicht. Denn das Framework kann ja die Control-Klassen die man selbst dazubastelt nicht kennen. Bzw. auch bei Anwendungen kann es Sinn machen. Ab einer bestimmten Grösse ist es u.U. nicht mehr wünschenswert wenn alle abgeleiteten Klassen an einem zentralen Punkt bekannt sein müssen. Aber so lange alles halbwegs übersichtlich bleibt, gibt es mMn. keinen echten Vorteil durch die Verwendung einer map. Echte Nachteile aber schon (z.B. komplexer, keine Warnings wenn man was vergisst).
• S

  C++ Interface Abstrakte Methoden
  • Sebi1412  

  10
  0
  Stimmen
  10
  Beiträge
  411
  Aufrufe

  *

  Um es nun einmal konkrete zu machen übersetzbarer Code, der trotzdem faktisch nichts macht. Die notwendigen Destruktoren etc. sind weggelassen es geht nur um die Member Functions. Wenn Du wie hier schon besprochen in ConcreteClass2 nicht die zweite Methode überschreibst, dann wird der C++ Compiler das Programm nicht übersetzen. Ein Workaround (das ist der Teil der durch die Präprozessor Variable WORKAROUND nur bedingt übersetz wird) ist es die Methode leer zu implementieren/eine Exception zu werfen was hier im Code einfach durch donothing signalisiert wird. Die Alternative ist es, sofern das Sinn ergibt, zwei abstrakte Interface-Klassen zu definieren. #include <iostream> #include <cstdlib> class Interface1 { public: virtual void seek() = 0; virtual void add(int i) = 0; }; class ConcreteClass1 : public virtual Interface1 { public: void seek() override; void add(int i) override; }; void ConcreteClass1::seek() { std::cout << "ConcreteClass1::seek\n"; } void ConcreteClass1::add(const int i) { std::cout << "ConcreteClass1::add\n"; } class ConcreteClass2 : public virtual Interface1 { public: void seek() override; #ifdef WORKAROUND void add(int i) override; #endif }; void ConcreteClass2::seek() { std::cout << "ConcreteClass2::seek\n"; } #ifdef WORKAROUND void ConcreteClass2::add(int i) { std::cout << "ConcreteClass2::add -- do nothing\n"; } #endif class PartialInterface1 { public: virtual void seek() = 0; }; class PartialInterface2 { public: virtual void add(int i) = 0; }; class ConcreteClass3 : public virtual PartialInterface1, PartialInterface2 { public: void seek() override; void add(int i) override; }; void ConcreteClass3::seek() { std::cout << "ConcreteClass3::seek\n"; } void ConcreteClass3::add(int i) { std::cout << "ConcreteClass3::add\n"; } int main () { ConcreteClass1 cc1; cc1.seek(); cc1.add(1); ConcreteClass2 cc2; cc2.seek(); cc2.add(1); ConcreteClass3 cc3; cc3.seek(); cc3.add(1); return EXIT_SUCCESS; }
• 

  CodeCoverage mit Threads und Sockets
  • It0101  

  17
  0
  Stimmen
  17
  Beiträge
  438
  Aufrufe

  T

  @It0101 Ob 100% oder nicht hängt auch vom Einsatzgebiet ab. Bei sicherheitsrelevanter Software (im Sinne von Menschenleben hängen dran) würde ich schon die 100% anstreben und wurde auch so gemacht in dem Projekt an dem ich mitgearbeitet habe. Für nen Word braucht man das natürlich nicht zwingend.
• 

  Codeteile auslagern. Bekomme cpplint Warnung
  • MegaV0lt  

  48
  0
  Stimmen
  48
  Beiträge
  1872
  Aufrufe

  

  Generell gilt: Die Konstruktion eines Objekts erfordert immer einen passender Konstruktoraufruf. Die Parameter, die du bei der Konstruktion mit new übergibst, musst du auch bei der Konstruktion auf dem Stack angeben: // aus cIndexFile* index = new cIndexFile(Recording->FileName(), false, Recording->IsPesRecording()); // wird cIndexFile index(Recording->FileName(), false, Recording->IsPesRecording()); Ansonsten muss ich Schlangenmensch zustimmen, du solltest dir einen Kenntnisstand erarbeiten, mit dem du zumindest einfache Probleme selbst lösen kannst. Für jeden Compilerfehler einen Beitrag zu schreiben dauert ewig und vergrault Regs, die anfangs noch hilfsbereit sind.
• ?

  Gleichungen lösen
  • Ein ehemaliger Benutzer  

  11
  0
  Stimmen
  11
  Beiträge
  453
  Aufrufe

  ?

  Ihr könnt ja noch einmal schauen... Es können jetzt auch Koeffizienten =/= +-1 gelöst werden* (hoffe ich), und ich bin erst einmal damit zufrieden: *: Also auch Matrizen, die nicht nur aus 1 oder -1 bestehen... #include <string> #include <vector> #include <sstream> #include <iostream> #include <iomanip> #include <variant> #include <cmath> struct Value { double value = 0.0; bool is_unknown = false; }; using Row = std::vector<Value>; using Matrix = std::vector<std::vector<Value>>; struct System { Matrix coefficients; Row constant_terms; }; double round_to(double value, double precision = 0.01) { return std::round(value / precision) * precision; } std::ostream &operator<<(std::ostream &out, const Value &v) { if (!v.is_unknown) { out << std::setw(6) << std::setfill(' ') << round_to(v.value); } else { out << " --"; } return out; } std::ostream &operator<<(std::ostream &out, const Matrix &matrix) { out << "Matrix: (" << matrix.size() << " x " << matrix[0].size() << ")\n"; for (auto &row : matrix) { for (auto &value : row) { out << value; } out << '\n'; } return out << '\n'; } std::ostream &operator<<(std::ostream &out, const Row &row) { out << "Matrix: (1 x " << row.size() << ")\n"; for (size_t i = 0; i < row.size(); i++) { out << " " << (char)('a' + i); } out << '\n'; for (auto &value : row) { out << value; } out << '\n'; return out << '\n'; } void printSystem(const System &system) { std::cout << system.coefficients; std::cout << system.constant_terms; } System solveAndPrint(const System &input) { System result = input; bool changed = true; while (changed) { changed = false; printSystem(result); for (size_t i = 0; i < result.coefficients.size(); i++) { size_t magic_n = 0; size_t magic_i = 0; for (size_t j = 0; j < result.coefficients[i].size(); j++) { if (result.coefficients[i][j].value != 0 && result.constant_terms[j].is_unknown) { magic_n++; magic_i = j; } } if (magic_n == 1) { double sum = 0; for (size_t j = 0; j < result.coefficients[i].size(); j++) { if (j != magic_i && result.coefficients[i][j].value != 0) { sum -= result.coefficients[i][j].value * result.constant_terms[j].value; } } result.constant_terms[magic_i].value = sum / result.coefficients[i][magic_i].value; result.constant_terms[magic_i].is_unknown = false; changed = true; break; } } } return result; } int main(int argc, char const *argv[]) { std::vector<std::string> args({"2 6 -8", "1 0 -1", "0", "2 - -"}); System input; for (int i = 1;; i++) { std::cout << "Koeffizienten " << i << ". Zeile oder einfach 0, um die Eingabe abzuschließen:\n"; std::string l; // getline(std::cin, l); l = args[i - 1]; std::cout << l << '\n'; if (l == "0") { break; } std::stringstream ss; ss << l; std::string segment; Row r; while (getline(ss, segment, ' ')) { r.push_back(Value()); r.back().value = stod(segment); } input.coefficients.push_back(r); } { std::cout << "Bekannte, oder nur -, wenn unbekannt:\n"; std::string l; // getline(std::cin, l); l = args[args.size() - 1]; std::cout << l << '\n'; std::stringstream ss; ss << l; std::string segment; while (getline(ss, segment, ' ')) { input.constant_terms.push_back(Value()); if (segment == "-") { input.constant_terms.back().is_unknown = true; } else { input.constant_terms.back().value = stod(segment); } } } System result = solveAndPrint(input); return 0; } Ich hab nun noch keine Fehlerbehandlung umgesetzt... Und Kommentare fehlen auch, wo etwas nicht selbsterklärend wäre.
• ?

  Zeichen rekursiv verdoppeln und "zählen"
  • Ein ehemaliger Benutzer  

  19
  0
  Stimmen
  19
  Beiträge
  593
  Aufrufe

  ?

  @admin und @Mod kann dieses Thema nicht gelöscht werden, bitte? Es stellt doch offenbar für viele ein Ärgernis dar. Edit: Also, nicht nicht... Bitte löschen.
• S

  C++ DIP (Dependency Inversion Principle) ?
  c++ klassen interface dpi solid • • Sebi1412  

  10
  0
  Stimmen
  10
  Beiträge
  494
  Aufrufe

  

  @Sebi1412 p.s.: Dependency Injection muss natürlich nicht mit einer abstrakten Basisklasse kombiniert werden. Man könnte in dem Beispiel von oben auch direkt eine FooTransport übergeben. Das kann auch manchmal Sinn machen - wobei mir jetzt aus dem Stegreif kein Beispiel einfällt. Am flexibelsten ist es allerding mit der abstrakten Basisklasse. Auch wenn man es im eigentlichen Programm nicht braucht, ist es in Tests oft sehr praktisch. z.B. kann man so die Messenger Klasse testen, ohne dass man einen echten Server braucht mit dem man die Messenger Objekte kommunizieren lassen kann. Statt dessen macht man für den Test eine spezielle TestTransport Klasse, die ebenfalls von AbstractTransport abgeleitet ist, und bloss so tut als ob sie mit einem Server kommunizieren würde.
• M

  Statische Memberfunktionen überschreiben
  • Max3000  

  11
  0
  Stimmen
  11
  Beiträge
  409
  Aufrufe

  M

  Hallo. @DocShoe sagte in Statische Memberfunktionen überschreiben: Nochmal im Ernst, was genau möchtest du erreichen? Was sind Base/Derived konkret, und wie viele verschiedene "Derived" wird's geben? Konkret soll es die Implementierung eines neuronalen Netzes werden. Mein Basis-Typ ist heißt "Layer" und definiert virtuelle Methoden (forward_propagate, backward_propagate, save_to_file, und alles was man sich so vorstellen kann). Abgeleitet davon gibt es VectorInputLayer (keine zusätzlichen Attribute), FullyConnectedLayer (speichert zusätzlich eine Gewichtsmatrix und einen Biasvektor), ConvolutionalLayer (speichert Kernelmatrix und Biaskonstante), FlatteningLayer (keine zusätzlichen Attribute), ... . Die Methoden der Basisklasse sollen dabei überschrieben werden, die Attribute der abgeleiteten Klassen sind aber sehr unterschiedlich. Die zeros_like-Funktion brauche ich um für jede dieser abgeleiteten Klassen einen Layer des selben Typs zu initialisieren bei denen alle Attribute (Gewichte, Bias, Kernel, ...) mit der passenden Größe, aber mit 0-Werten initialisiert werden. Die Vererbung erlaubt es mir dann im Hauptprogramm alle Layer unabhängig vom Typ durchzugehen und das Netz auszuwerten: std::vector<std::unique_ptr<Layer>> layers; // Create Layer list and set weights, biases, activation function... //... // Evaluate network DataArray* data = layers.front()->eval(x); for(auto layer_it = layers.begin()+1; layer_it != layers.end(); ++layer_it) (*layer_it)->forward_propagate(*data) Layer ist im oberen Beispiel Base und Derived1 ist zum Beispiel VectorInputLayer. Irgendwann muss ich mal einen Gradienten anlegen (ist selbst ein neuronales Netz mit gleicher Dimension), aber zunächst mit 0 initialisiert, also: NeuralNetwork grad; for(auto layer = net.layers.begin(); layer != net.layers.end(); ++layer) grad.layers.push_back((*layer)->zeros_like()); Ich habe zeros_like jetzt wie von anderen schon vorgeschlagen als normale Methode implementiert, die virtual in Layer und override in jeder abgeleiteten Klasse ist. Das funktioniert, ist aber nicht unbedingt die schönste Lösung. @Quiche-Lorraine sagte in Statische Memberfunktionen überschreiben: Wie wäre es mit Templates ? Danke für den Hinweis. Leider werden Templates bei mir nicht funktionieren, da die Klassen, für die ich zero_like brauche doch zu unterschiedlich sind und auch keinen Konstruktor mit gleicher Signatur haben. Ich danke allen nochmal für die Hilfe, ich denke ich habe jetzt die Lösung, die irgendwie funktioniert. Viele Grüße.
• ?

  Wie oft passt ein Quader in einen größeren Quader?
  • Ein ehemaliger Benutzer  

  32
  -1
  Stimmen
  32
  Beiträge
  1397
  Aufrufe

  ?

  Ok, ich habe den Beitrag wiederhergestellt, damit der Kontext nicht verlorengeht. @Quiche-Lorraine hat ja schon zugegeben, wer hier ein Problem mit sachlicher Kommunikation hat. Und an dem Verhalten anderer bin ich nicht schuld. @ admins Das Thema gerne schließen, etwas Konstruktives wird nicht mehr zu erwarten sein.
• 

  std::function best practice?
  • It0101  

  11
  0
  Stimmen
  11
  Beiträge
  330
  Aufrufe

  

  @hustbaer Insbesondere der letzte Punkt in deiner Aufzählung hat mich bereits zuvor stark beschäftigt. Wer stellt den Functor/das Callback bereit? Das ist die eigentlich essentielle Frage, die dieses Konstrukt kompliziert macht, weshalb ich es mittlerweise verworfen habe. Der Hintergrund ist: Ich bekomme ein vollständiges Konfigurationsobjekt geliefert, welches gewissermaßen für meine Applikation eine Liste von Datenquellen enthält, also eine Art Verbindungsstruktur. Eine Liste von Services ( Service 'A', Service 'B', etc. ). Jeder Service enthält eine Liste von Partitionen von denen jede unterschiedliche Daten enthält. Jede Partition wiederum hat 1 bis N Connections ( Stichwort Failover ), die aber jeweils identische Daten liefern. D.h. ich muss im Grunde einen Baum abbilden, der aber dynamisch sein kann, was bedeutet, dass ich jederzeit für jeden Service ein Update bekommen kann, das mich dazu zwingt, die exisiterenden Connections zu trennen und neue aufzubauen. Diese Veränderungen wollte ich einem allgemeinen Container abbilden. Die Services wären dann in so einem Container und in jedem Service bestünde ein weiterer Container, der wiederum die Partitionen enthält. Jedes neue Konfigurationsobjekt würde dann durchgereicht in den Baum bis ganz hinten und die Änderungen in den Daten würden einen Aufruf des Callbacks erzeugen, mit dem Hintergrund, dass auch eine Änderung im hinteren Teil des Baums ( z.B. auf Connectionebene ) einen Callback nach ganz außen zur Folge hätte. Ich habe aber den Gedanken eines allgemeinen Templates für Speicherung und Abgleich der Configs verworfen, weil gerade die innern Callbacks irgendwo gespeichert werden müssten, oder ich eben stets in jedem Aufruf von "update" eine gewissen Anzahl an Callbacks mitschleppen müsste.