C++ (alle ISO-Standards)

• ?

  Klasse sei Array, welche Operatoren wie?
  • Gast  

  6
  0
  Stimmen
  6
  Beiträge
  690
  Aufrufe

  

  K-Rotte schrieb: Jau, danke. Manche Funktionen erwarten leider nur "array-pointer".. Aber was findest du verkehrt da dran, diese dann so zu benutzen, wie du es mit einem normalen C++-Container aus der STL tun würdest?
• ?

  Verweis auf Element in for-Schleife
  • Gast  

  15
  0
  Stimmen
  15
  Beiträge
  1424
  Aufrufe

  

  NablaSquaredG schrieb: sollte das schon erfolgreich in irgendein register wegoptimiert werden, ganz gleich, wo die Variable definiert wird... Ob Register oder nicht, spielt keine Rolle! Es kostet keine Zeit, eine Variable zu "erstellen", denn es gibt kein Erstellen! Selbst wenn das ganz ohne jede Optimierung übersetzt wird, so dass der Bezeichner 1:1 einer bestimmten Speicheradresse zugeordnet werden kann: Die Speicheradresse existiert sowieso! Die muss nicht erstellt, reserviert oder vorbereitet werden. Stell dir vor, du hast ein Regal. Spielt es eine Rolle, wann du den Entschluss fasst, etwas an einem bestimmten Ort da drin abzustellen? Es mag Zeit brauchen, etwas an den Ort zu stellen und wieder heraus zu nehmen, aber Abstellen und herausnehmen möchtest du ja sowieso. Wie lange das Hineinlegen und Herausnehmen dauert ist aber vollkommen unabhängig davon, ob du den Entschluss dazu spontan fasst, wenn du etwas konkretes zum Ablegen hast (in der for-Schleife); oder den Platz im Voraus für etwas frei hältst, von dem du weißt, dass du es später ablegen musst (vor der for-Schleife). Der wirkliche Unterschied ist, dass bei letzterem der Platz eventuell ungenutzt frei bleibt, weil nichts dort liegt, aber der Platz noch freigehalten wird. Wenn das Regal nicht viele Plätze hat, kann das relevant sein. Das ist es, was hustbaer meinte (siehe sein Beitrag). Bei solchen Mini-Funktionen mag der Optimierer auch von alleine erkennen können, wann genau etwas wo gebraucht wird und wann nicht, und er kann und wird sich dann einfach nicht an die Lebenszeit deiner Deklarationen halten (wie schon so oft gesagt: Variablen, Scopes, usw. sind alles Hilfsmittel für den Programmierer, es gibt sie nicht mehr im eigentlichen Programm). Wenn es wirklich kompliziert wird, kann das aber auch nicht gelingen, und man verhindert durch zu breit gefasste Gültigkeitsbereiche, dass der Optimierer optimal arbeiten kann. Am schlimmsten ist dies, wenn man Variablen global macht, weil der Optimierer sich dann nicht mehr darauf verlassen kann, dass diese Variable nicht von anderswo im Programm aus geändert wird.
• ?

  Print Ausgabe
  • Gast  

  24
  0
  Stimmen
  24
  Beiträge
  3025
  Aufrufe

  ?

  Nein ich bin fertig mit der Schule . Es ist keine Hausaufgabe
• M

  fehler zurueck geben
  • Meep Meep  

  9
  0
  Stimmen
  9
  Beiträge
  752
  Aufrufe

  M

  ich denk ich weiß wie ich es machen werde. ungefaehr so: struct api_error { int system_error_code; int internet_error_code; int http_error_code; int mysql_error_code; auto has_error(void) -> bool { return system_error_code | internet_error_code | http_error_code | mysql_error_code; } auto clear(void) -> void { system_error_code = 0; internet_error_code = 0; http_error_code = 0; mysql_error_code = 0; } }; enum class api_error_mask : int { none = 0, system = 1, internet = 2, http = 4, mysql = 8, all = system | internet | http | mysql }; ADD_OPERATORS_TO_ENUM(api_error_mask) class throw_on_error { public: throw_on_error(api_error &err) noexcept : m_error(&err) { ) ~throw_on_error(void) noexcept(false) { if(m_error->has_error()) { if(m_mask & api_error_mask::system) throw system_error(m_error->system_error_code); if(m_mask & api_error_mask::internet) throw internet_error(m_error->sinternet_error_code); if(m_mask & api_error_mask::http) throw http_error(m_error->http_error_code); if(m_mask & api_error_mask::mysql) throw mysql_error(m_error->mysql_error_code); } } private: api_error *m_error; api_error_mask m_mask; }; dann kann ich folgendes machen: api_error err{api_error_mask::system & api_error_mask::internet}; try { call_api_function(..., throw_on_error(err)); if(err.mysql_error_code != 0) { ... } ... } catch(const system_error &e) { ... } catch(const internet_error &e) { ... }
• F

  C++-Standard: ... shall not ....
  • Fytch  

  15
  0
  Stimmen
  15
  Beiträge
  1864
  Aufrufe

  E

  wob schrieb: Thou shalt not follow the null pointer, for chaos and madness await thee at its end. Das ist wenigstens on topic hier, sort of Der war gut. Thread auf jeden Fall successfully hijacked.
• V

  Durch Spalten iterieren und dabei die größte Distanz zwischen zwei Punkten berechnen
  • vickal93  

  12
  0
  Stimmen
  12
  Beiträge
  1437
  Aufrufe

  S

  Hm, beim nochmaligen lesen des ersten Posts ist mir auch das Wort "benachbart" aufgefallen. Bei Distanzberechnung war mir das irgendwie durchgegangen, denn Distanz zwischen zwei benachbarten Punkten ist ja immer 1 Pixel. Also geht es um die Länge der roten Linie in einer Spalte, oder so. Hier müsste man aber auch nicht immer die Distanz berechnen, sondern nur, wenn der nächste Punkt nicht mehr rot ist. Aber wahrscheinlich ist es ratsamer erstmal die triviale Lösung zu implementieren.
• ?

  [Anfänger] Ausgabe dynamischer Speicherobjekte
  • Gast  

  4
  0
  Stimmen
  4
  Beiträge
  733
  Aufrufe

  

  Bitte. Steht übrigens wirklich so im Standard, also das mit *(prt+x) . Wie dir vielleicht auffällt sind ptr und x in *(prt+x) austauschbar. D.h. sie müssten auch in ptr[x] austauschbar sein. Und tatsächlich sind sie es auch. Man kann in C++ ernsthaft statt ptr[123] auch 123[ptr] schreiben. Hat mich recht amüsiert wie ich da draufgekommen bin.
• ?

  Problem mit Klassen und Methoden
  • Gast  

  6
  0
  Stimmen
  6
  Beiträge
  930
  Aufrufe

  W

  Noch ein Tipp. Deine Funktion Setwerte ruft nach Ärger. Warum? Weil sie schwer zu lesen ist. Schaue ich mit den Header an, sehe ich nur void Setwerte(int wert1, int wert2); also dass irgendwelche 2 Werte gesetzt werden. Nur wenn ich in die Implementierung schaue, stelle ich fest, dass wert1 die Stärke und wert2 die Gewandtheit ist. Du kannst das leicht mal vertauschen. Noch schlimmer: dein Spieler hat auch eine Funktion Setwerte . Diese hat sogar 3 Parameter, wie wir an Roli.Setwerte(random_Gewandtheit, random_Staerke, random_Glueck); erkennen können. Die Gewandheit und Stärke sind hier auch noch in umgekehrter Reihenfolge. Ratschläge: 1) Benenne die Variablen vernünftig (nicht "wert1" und "wert2"), sodass man direkt an der Signatur erkennt, was da in welcher Reihenfolge rein muss. Das behebt das Problem allerdings nicht, sondern macht es nur etwas leichter nachvollziehbar, was man macht. 2) Nimm entweder separate Funktionen für alle Eigenschaften (setStaerke, setGewandheit, ...). Oder mach dir eine Klasse oder ein Struct "Kampfwerte", in dem du alle relevanten Kampfwerte drin hast - dann kannst du mit "setKampfwerte" gleich alles setzen. Also auch allgemein: Funktionen mit weniger Parametern sind leichter zu verstehen als welche mit vielen Parametern.
• S

  Doppelte Namespace-Definition trotz Include Guard
  • SyntaxError85  

  3
  0
  Stimmen
  3
  Beiträge
  764
  Aufrufe

  W

  Dein Problem hat mit Namespaces nichts zu tun, außer dass sich die Variable i eben darin befindet (ebenso wie du kein Problem mit deinem Haus hast, wenn nur die Armbanduhr, die zufällig im Haus liegt, defekt ist - das Haus ist dann der Space, in dem sich die Uhr befindet, hat aber mit dem Defekt nix zu tun). Hm, ok, sehr weit hergeholt, der Vergleich... Um so eine globale Variable hinzubekommen, darfst du sie nur einmalig definieren, aber beliebig oft nur deklarieren. Ansonsten gibt es Probleme beim Linken des Programms. Du könntest die Definition der Variablen i also in das mylibrary.cpp schieben und in dem Header mylibrary.h diese Variable nur deklarieren (mittels extern int i; ). Andererseits: fang gar nicht erst mit globalen Variablen an! Wenn du mit Namespaces herumspielen möchtest, probiere doch lieber aus, deine Funktion useMyLibrary in den Namespace zu tun. Dann Klassen in Namespaces. usw.
• ?

  omp simd reduction auf eine array element?
  • Gast  

  5
  0
  Stimmen
  5
  Beiträge
  709
  Aufrufe

  ?

  #include <omp.h> #include <vector> int main(){ std::vector<double> var(1234); for(int r=0; r<1234; r++) { double &varr = var[r];//<-reduction(+:varr) geht, var[r] nicht #pragma omp simd reduction(+:var[r]) for(int i=0; i<1234; i++) varr += i; } } g++ 5.4
• M

  Enum: '...' does not name a type
  • marci_du_mont  

  4
  0
  Stimmen
  4
  Beiträge
  1426
  Aufrufe

  

  Namen, die in einer Memberfunktions-Definition vor dem Namen der Memberfunktion ( A::getCmd ) vorkommen, werden nicht innerhalb der Klasse sondern im Kontext der Definition, also im namespace scope, gesucht (cf.[basic.lookup.unqual]). Du kannst also, wie von meinem Vorposter vorgeschlagen, den Namen der Enumeration voll qualifizieren-- A::Cmd --, oder einen trailing return type schreiben: auto A::getCmd() -> Cmd const{...} (Wobei das für gewöhnlich nur bei Membern von Templates gemacht wird, da die template-id langatmig ist).
• S

  Suche Buch zum Design von Programmen
  • Sewing  

  4
  0
  Stimmen
  4
  Beiträge
  585
  Aufrufe

  S

  ich danke euch
• S

  Geschwindigkeit bei Schreiben auf Speicher
  • Sewing  

  28
  0
  Stimmen
  28
  Beiträge
  2438
  Aufrufe

  ?

  und nur so nebenbei: Benchmark-Versuche nur im Release-Mode mit eingeschalteter Optimierung (alles andere ist völlig sinnfrei - da um Faktor 100-beinahe unendlich langsamer) keine trivial-Loop-Tests unter ein paar Mio Durchläufe und IO-Ausgaben am Ende mit rein (irgendwas in der Schleife kumulieren) sonst entfernt der Optimierer zu viel Code und du freust dich über nicht vorhandene Hyper-Geschwindigkeit
• 

  Verschiedene Klassen als Argument?
  • zeropage  

  9
  0
  Stimmen
  9
  Beiträge
  831
  Aufrufe

  

  Sorry, war gestern etwas angetrunken. Wenn ich wieder auf dem Dampfer bin, melde ich mich wieder. Ich glaube nämlich, auch eine Basisklasse ist keine schlechte Idee.
• M

  if abfrage fehlerhaft. bitte um hilfe
  • MrDark7199  

  4
  0
  Stimmen
  4
  Beiträge
  502
  Aufrufe

  M

  vielen dank fürs antworten. da hatte ich doch mal nen blöden fehler^^ naja aus fehler lernt man. danke
• M

  Template forward declaration Problem, einfaches Access-Management
  • MrSpoocy  

  4
  0
  Stimmen
  4
  Beiträge
  655
  Aufrufe

  ?

  Dann versuchs mal mit static_assert , das müsstest hinbekommen.
• ?

  C++ Template-Programmierung: Unterschiedliche Rückgabewerte bei Überladung des &quot;+ Operators&quot;
  • Ein ehemaliger Benutzer  

  5
  0
  Stimmen
  5
  Beiträge
  835
  Aufrufe

  

  hustbaer schrieb: Hat common_type in diesem Beispiel einen Vorteil gegenüber decltype(T() + U()) ? decltype(std::declval<T>() + std::declval<U>()) wäre hier in der Tat besser, da es in Fällen funktionieren kann, in denen common_type eben nicht funktioniert. Insbesondere dann, wenn T und U Typen ohne ein besonderes Verhältnis zueinander sind. Mein Fehler.
• ?

  Bin zu doof den Unterschied in meinem Code zu finden... Leute mit Informatikerblick gesucht! :D
  • Gast  

  19
  0
  Stimmen
  19
  Beiträge
  1723
  Aufrufe

  ?

  SeppJ schrieb: Da hilft dir auch kein String (außer du rechnest in einem System mit mindestens den Primteilern 2 und 3), dafür hilft aber Denken und Mathematik: Rechne mit Brüchen. Oder gleich mit Sechsteln. Doch, String hätte geholfen. Wollte ja eine Zahlenklasse schreiben, mit der man dann beliebig große/kleine Zahlen speichern und verrechnen kann. Also sowas wie “0,1230000000000000000000003141592...“, das halt nichtmal in long double passt. Was meinst Du genau mit 2 und 3 als Primteilern? Klingt interessant Ich habe auch daran gedacht, die Zahlen als großen Bruch zu schreiben, um spätere Ungenauigkeiten einzuschränken. So nach dem Motto: 2x6x3x5x.../6 hoch <Anzahl Faktoren im Nenner> Aber vermeiden lassen sie sich nicht ganz, oder rechnen die Operatoren intern mit beliebiger Genauigkeit? Hab ja zwischendrin wieder falsche Ergebnisse, die ich addiere Die sind so klein, dass sie als 0.0 gezählt werden, aber es sind so viele, dass sie das Ergebnis verfälschen. Hast Du noch Ideen für Mathekniffe?
• T

  Return Werte einer Funktion
  • TauCeti  

  4
  0
  Stimmen
  4
  Beiträge
  570
  Aufrufe

  

  temi schrieb: "Normal" wäre die 2. Möglichkeit, aber in der Praxis gibt es tatsächlich auch die dritte Möglichkeit, siehe std::getline Interessanter Punkt. Es ist tatsächlich so, dass die dritte Variante noch den Vorzug hat, chaining zu ermöglichen. Wäre noch effektiver, wenn die Funktion eine Referenz zurückgeben würde.
• ?

  Schweres c++ Quiz?
  • Gast  

  8
  0
  Stimmen
  8
  Beiträge
  901
  Aufrufe

  F

  Meinem Verständnis nach hängt das damit zusammen, dass Default-Argumente nicht Teil des Rumpfes sind und somit auch nicht vererbt werden können. Default-Argumente sind Teil der Deklaration, daher hängt die Wahl der Default-Argumente davon ab, über welche Deklaration man die Funktion aufruft (nämlich die neuste im aktuellen Scope). Das ist auch der Grund, wieso man z.B. Default-Argumente redefinieren kann, den Funktionsrumpf hingegen nicht. Im Codebeispiel ist x 5, weil foo über A aufgerufen wird, dessen Definition von foo ein Default-Argument von 5 für x vorschreibt. Castet man den Zeiger a nach B* und gibt das dann aus mit static_cast< B* >( a )->foo() , so wird das Default-Argument 10 angenommen und die Ausgabe ist plötzlich 30.