C++ (alle ISO-Standards)

• G

  Suche nach Buch oder Tutorial!!
  • goto55  

  3
  0
  Stimmen
  3
  Beiträge
  379
  Aufrufe

  A

  goto55 schrieb: Vllt kennt ihr auch ein paar gute Bücher mit denen ich c++ lernen kann, am besten für grafikprogammierung Wenn du wirklich C++ lernen willst, schlag dir erst einmal Grafikprogrammierung aus dem Kopf. Dieses Thema kannst du noch immer angehen, wenn du dich wirklich mit C++ vertraut gemacht hast (Und bis dahin wirst du mindestens ein Jahr älter sein ;p). Falls du mit Englisch klarkommst: http://mindview.net/Books/TICPP/ThinkingInCPP2e.html cu André
• ?

  Sinn von pair und tuple
  • Gast  

  6
  0
  Stimmen
  6
  Beiträge
  554
  Aufrufe

  W

  Artchi schrieb: (D)Evil schrieb: Wie gibst du sonst bitte 2 Rückgabewerte ohne Probleme zurück? (und ohne eine extra struct anzulegen!) ? Genau das nennt man "wenn man zu fauel ist". Das ist nicht der einzige Grund. Der Vorteil von std::pair<> ist u.a. das std:: vor dem pair, damit ist z.B. im C++-Standard definiert wie man an die Member rankommt und ein Objekt dieser Klasse anlegt. Es passt auch eher zu anderen Dingen, die schon da sind. Gruß Werner
• B

  Bekommt struct keine Daten ??
  • Brusko  

  21
  0
  Stimmen
  21
  Beiträge
  1413
  Aufrufe

  B

  ich glaub ich geh eine runde lesen *hmmm*
• ?

  container ineinander umwandeln
  • Gast  

  2
  0
  Stimmen
  2
  Beiträge
  425
  Aufrufe

  T

  http://www.cppreference.com/cppdeque/container_constructors2.html The last constructor creates a dequeue that is initialized to contain the elements between start and end. std::vector<int> v; ... //füllen std::deque<int> d(v.begin(), v.end());
• ?

  Konstruktoraufruf bei new
  • Gast  

  2
  0
  Stimmen
  2
  Beiträge
  446
  Aufrufe

  C

  mhm schrieb: Hallo bedeuten new bla; und new bla(); das selbe, oder gibts da einen feinen Unterschied(Bei C++ weiß man ja nie)? Das hängt von bla ab. new bla() initialisert das allokierte Objekt/Array in jedem Falle. new bla tut das nur, wenn bla kein POD ist.
• ?

  Was ist an folgendem Programm falsch?
  • Gast  

  5
  0
  Stimmen
  5
  Beiträge
  522
  Aufrufe

  L

  Da: Der Standard schrieb: A return statement in main has the effect of leaving the main function (destroying any objects with automatic storage duration) and calling exit with the return value as the argument. If control reaches the end of main without encountering a return statement, the effect is that of executing return 0; (unter: 3.6.1 Main function [basic.start.main])
• S

  Klasse mit fester Elementvariable oder nicht
  • Stromberg  

  2
  0
  Stimmen
  2
  Beiträge
  303
  Aufrufe

  .

  Das erste selbstverständlich. Öffnen braucht Zeit. Allerdings hast du bei einer solchen Implementierung das Problem, dass du auf das Kopieren der Objekte verzichten musst.
• -

  Funktion um Ordnerstruktur zu erstellen?
  • -Allan-  

  2
  0
  Stimmen
  2
  Beiträge
  579
  Aufrufe

  B

  Hallo, Im Standard gibt es da nichts. Du könntest z.Bsp. boost::filesystem::create_directories nehmen oder eine Funktion deines Betriebssystems.
• ?

  Anfängerfrage::Addresse
  • Gast  

  12
  0
  Stimmen
  12
  Beiträge
  838
  Aufrufe

  F

  Vor einer Variable: "Adresse von" Vor einem Funktions-Parameter (oder Deklaration einer Membervariable): "Referenz auf".
• S

  Funkionsreferenzen statt Funktionszeigern?
  • StarCraftFeuerteufel  

  13
  0
  Stimmen
  13
  Beiträge
  1168
  Aufrufe

  

  LordJaxom schrieb: Simon2 schrieb: Trotzdem stimme ich Dir zu: Ich verstehe nicht, was das mit "Referenz auf eine Memberfunktion" zu tun hat. Ich schätze Swordfish wollte auf den Aufruf dieser "Memberfunktionsreferenz" hinaus. Die Operatoren dafür sind .* und ->*, beide implizieren eine Dereferenzierung, und die funktioniert nunmal nur bei Zeigern, nicht bei Referenzen. Cool, es gibt Leute, die mich verstehen Mich würd' aber interessieren, ob es noch einen anderen Grund gibt, warum es keine "Methodenreferenzen" geben kann. Von einem ungültigem ::& konstrukt einmal abgesehen. greetz, Swordfish
• A

  error: invalid use of undefined type `struct...
  • Allroad  

  15
  0
  Stimmen
  15
  Beiträge
  2359
  Aufrufe

  A

  Geschafft...! Hab statt Objekte, Pointer benutzt und es funkt! Danke. QList<ClassCB*> myList
• D

  zweidimensionales struct - inneres dyn. erstellen?
  • Dave_R  

  6
  0
  Stimmen
  6
  Beiträge
  596
  Aufrufe

  D

  gut danke, hab mir das auch schon irgendwie so überlegt. werds mal versuchen
• L

  Programmabbruch funktioniert nicht
  • LadyM  

  11
  0
  Stimmen
  11
  Beiträge
  1189
  Aufrufe

  B

  Ich habe die Problematik auch einmal aufgefasst und die Aussagen oben so gut es geht in einem lauffähigen Programm zusammen gefasst. Folgende Anforderungen habe ich an das Programm gestellt: * Die Abfrage des Schlüssel erfolgt nicht während des Einlesens * Die Abfragefunktion beendet nicht das Programm, wenn kein Schlüssel gefunden wurde. In meinem Beispiel bricht das Programm nicht ab, sondern gibt eine Mitteilung aus, dass der Schlüssel nicht gefunden wurde. #include <iostream> #include <fstream> #include <map> #include <sstream> #include <string> typedef std::pair<size_t, double> Result; typedef std::map<std::string, double> Database; void insertFromFile(const std::string& filename, Database&); Result selectFromDB(const std::string& key, const Database&); int main() { Database db; // ** Einlesen der Datenbank ** try { insertFromFile("test.txt", db); } catch(std::string e) { std::cerr << "Fehler!\n " << e << std::endl; return EXIT_FAILURE; } // ** Arbeiten mit der Datenbank ** Result r1 = selectFromDB("pi", db); if(r1.first > 0) { // Erwartetes Ergebnis: std::cout << "Pi ist " << r1.second << std::endl; } Result r2 = selectFromDB("a03", db); if(r2.first == 0) { // Erwartetes Ergebnis: std::cout << "a03 konnte nicht gefunden werden" << std::endl; } return EXIT_SUCCESS; } // ---------------------------------------------------------------------------- void insertFromFile(const std::string& filename, Database& d) { std::ifstream in(filename.c_str()); if(!in.is_open()) throw std::string("Datei konnte nicht geoeffnet werden!"); // std::string sollte eigentlich NICHT geworfen werden! std::string line; while(getline(in, line)) { std::stringstream ss(line); std::string key; char pipe; float value; ss >> key >> pipe >> value; // Der Rest der Zeile wird ohnehin verworfen d[key] = value; } } // ---------------------------------------------------------------------------- Result selectFromDB(const std::string& key, const Database& d) { size_t count = d.count(key); double value = 0.0; if(count > 0) value = d.find(key)->second; return std::make_pair(count, value); } Die Datenbasis: a01 | 0.1234 | Kommentar beliebier Länge a02 | 1.3345 | - pi | 3.14157 | - Ich hoffe, dass Beispiel ist einigermaßen verständlich, auch wenn es nicht sonderlich gut kommentiert ist. Grüße... Heiko
• ?

  ofstream in %windir%
  • Gast  

  5
  0
  Stimmen
  5
  Beiträge
  758
  Aufrufe

  ?

  danke hat mir sehr weiter geholfen
• D

  Fehler bei Template-Spezialisierung
  • Diogenes77  

  6
  0
  Stimmen
  6
  Beiträge
  726
  Aufrufe

  C

  pumuckl schrieb: So kannst du den header trotzdem ueberall einbinden, musst aber darauf achten, dass die template_spezi.o mitgelinkt wird, da sonst die nicht-spezialisierte Version instantiiert wird wenn jemand clone<int> aufruft. (eventuell kann man das durch static_assert verhindern) Es genügt nicht, diese Übersetzungseinheit mit der Definition mitzulinken. Die Spezialisierung muss auch in jeder anderen Übersetzungseinheit deklariert werden (sonst würde diese Spezialisierung ja in den anderen Übersetzungseinheiten aus dem Primärtemplate instantiiert werden - wie üblich keine Diagnose erforderlich). //// template_header.h #ifndef BESP_template_header_h #define BESP_template_header_h template <class T> T* clone(T* tp) { /*mach was*/ return tp; } template <> int* clone (int* sp); // wichtig #endif /// template_spezi.cpp #include template_header.h template <> int* clone (int* sp) { //mach was anderes return sp; };
• ?

  Klassenattribut nach einlesen überschreiben
  • Gast  

  7
  0
  Stimmen
  7
  Beiträge
  735
  Aufrufe

  P

  NiBurhe schrieb: Das mit dem Namespace std stammt so eins zu eins aus der Vorlesung Dann hau deinen Prof Das muss nicht schön sein, es muss erstmal nur funktionieren, dumme unbenotete Testate. Das mag sein, trotzdem wirst du hier immer wieder Schoenheitstipps bekommen, denn schoen bedeutet lesbar, leicht wartbar und vor allem schnell verstaendlich. Und wer gleich von Anfang an schoenen (= lesbaren, wartbaren,...) Stil praktiziert, quaelt spaeter sich (und uns) nicht mit grausamem hack&slay-Code Das Speichern und auslesen an sich funktioniert, das Objekt sieht im Debugger richtig aus. Nur die Liste _studenten macht Probleme, sie scheint zwar im Debugger eine leere Liste zu sein, sobald man aber auf die Liste zugreifen will, schiesst er sich ab. Daher wollte ich die Liste _studenten, die mit ausgelesen wurde, mit einer neuen Liste überschreiben, da ich ja nur eine leere Liste brauche. Er scheint halt eine Speicheradresse für die Liste zu speichern, aber wenn es wieder ausliest ist diese Speicheradresse nicht mehr gültig, deswegen wollte ich ne neue Liste anlegen und die Liste _student dann auf die neue Liste verbiegen, ohne direkt mit einem Zeiger auf eine Liste zu arbeiten, da ich sonst wieder alle Methoden ändern muss, also ein Workarround, nicht schön, aber soll nur funktionieren. Das Listenobjekt das du in deinem Kurs-Objekt hast, verwaltet intern seine Insassen mit Pointern. Die werden natuerlich ungueltig, sobald du das Objekt abspeicherst. Auch deshalb int das bitweise kopieren von Objekten aus dem Speicher in Dateien wirklich sehr, sehr, sehr, sehr unschoen. Mich wundert eh, dass das bisher bei dir funktioniert hat, schliesslich scheinen die Studenten-Objekte auch entweder const char* oder std::string-Member zu besitzen, die auch intern pointer besitzen, weshalb das bitweise Abspeichern und Auslesen in der Datei schiefegehn sollte (es sei denn du benutzt in student char-Arrays fester Laenge, was wiederum auch ein no-go in C++ ist). Zeig uns doch mal den restlichen Code, also die Methoden von Kurs. Denn irgendwie scheinst du ja auf die Innereien von Kurs-Objekten Einfluss nehmen zu koennen. Noch zwei Anmerkugnen: Die Liste die du beim Auslesen der Datei benutzt und die Liste _studenten in deiner Kurs-Klasse haben verschiedenen Typ. Die eine speichert studenten, die andere pointer auf studenten! vermeide fuehrende Unterstriche bei Variablennamen (z.B. _studenten, _Dozent etc.) einige Bezeichner mit fuehrenden Unterstrichen (und auch mit doppelten Untestrichen innerhalb des Namens) sind fuer die Compiler reserviert. Daher ist es besser, sich fuehrende Unterstriche von vornherein grundsaetzlich abzugewoehnen, bevor man irgendwann Stunden damit verbringt, einen subtilen Bug zu finden, der entstehen kann, wenn z.B. ein Compiler ein Makro definiert hat das man unbewusst benutzt hat.
• B

  Listbox mit kleinen Bildern
  • Bench_XProjects  

  6
  0
  Stimmen
  6
  Beiträge
  449
  Aufrufe

  A

  Hallo Hier gehts weiter. bis bald akari
• M

  was genau bedeutet das argument (int C::*)
  • muffmolch  

  8
  0
  Stimmen
  8
  Beiträge
  524
  Aufrufe

  P

  Es geht dabei darum, dass eine Klasse C Member haben kann, unter anderem einen int (muss aber nicht sein) Damit ist das Konstrukt int C::* genau dann erlaubt, wenn C eine Klasse ist. Du hast natuerlich recht, das es fuer Klassen, die kein int-Member haben, so einen Pointer nicht geben kann - abgesehen vom Nullpointer, der gerade hier zum Einsatz kommt sizeof(IsClassT<T>::test<T>(0)) == 1 Der Nullpointer kann also auch dann ein Pointer-auf-int-Mebmer-von-C sein, wenn C keine int-Member hat. Damit ist der Match besser als mit der Ellipse und der Test positiv.
• P

  template in namespace
  • pospiech  

  24
  0
  Stimmen
  24
  Beiträge
  2075
  Aufrufe

  P

  unter dem Wikipedia-Artikel zur ODR steht Some violations of the ODR must be diagnosed by the compiler. Other violations, particularly those that span translation units, are not required to be diagnosed. also genau das "no diagnostics required" - ich evrmute dann wirds auch im standard so stehn
• S

  anfänger
  • stoeoe  

  6
  0
  Stimmen
  6
  Beiträge
  508
  Aufrufe

  F

  Nur noch einmal vorweg, was da eigentlich geändert wurde: std::printf("Die Zahl lautet: %i\n",x); Der erste Parameter ist der Formatstring, der einfach so ausgegeben wird. Ausgenommen sind hier die Argumente die mit einem % anfangen. Dahinter kommt dann der Bezeichner der der Funktion mitteilt, was für ein Argument er hier erwartet darf bzw. wie er es ausgeben soll. Da gibt es so einige Funktionen. %i steht zB für eine Ganzzahl, %s für einen String, %c für ein Zeichen usw. Die restlichen Parameter (beliebig viele) sind dann eben jene Argumente mit denen die Bezeichner im Formatstring ersetzt werden. Das ist aber ziemlich unsicher, daher sollte man die Funktion nicht verwenden, wenn es sich nicht vermeiden läßt. Die zweite von mir genannte Alternative ist sowohl in C++ als auch sicher.