C++ (alle ISO-Standards)

• ?

  Zufallsgenerator
  • Gast  

  5
  0
  Stimmen
  5
  Beiträge
  11031
  Aufrufe

  

  Deine Umrechnung auf den Wertebereich 0-6 ist nicht richtig, da passieren Überläufe und Integerdivisionen die du nicht bedacht hast. Mach es so wie ladidalo.
• A

  Kurze Frage zu Threads
  • AlexanderKiebler  

  14
  0
  Stimmen
  14
  Beiträge
  11897
  Aufrufe

  A

  Andere Leute träumen von Eiss bei dem Wetter. Aber mir gehts ähnlich. Mir wären ein paar Software-Erweiterungen auch lieber. Aber nochmal ein weiter Sprung. Kennst Du eine gute Beschreibung wo das Thema Dynamisch gelinkte Bibliotheken gut angeht. In erster Linie wie man die Schnittstelle ordentlich definiert. Also auch die Rückgabewerte. Ich brächt sogar ne Callback.... Kenne mich aber mit DLLs nicht aus. Plattform unabhängig sollte der Code auch noch sein. ... Dann sollte das ganze Ding auch noch Threadsafe sein. Ich frage, weil das Thema neu für mich ist, und der erste Eindruck eienr Sache meißt am besten hängen bleibt und ich möchte nicht mit einer schlechten Beschreibung beginnen... Grüße EDIT: Will damit sagen, ich kann mir selbst was raussuchen, aber ich kann nicht entscheiden ob das dann gut ist.
• *

  Alle Keys einer map aus einer anderen Map entfernen
  • *Q* 1  

  12
  0
  Stimmen
  12
  Beiträge
  12884
  Aufrufe

  K

  Q schrieb: [...] ich hatte eigentlich nur auf einen algorithmus aus <algorithm> gehofft, den es schon gibt und das ganze einfacht macht. Den gibt's doch. Um die Vorzüge von seldons Code (set_difference) und campers Code (value_comp) zu kombinieren: #include <algorithm> #include <iostream> #include <iterator> #include <map> #include <string> int main() { std::map<int, std::string> m1, m2; m1[1] = "foo"; m1[2] = "bar"; m1[3] = "baz"; m2[1] = "qux"; m2[3] = "quux"; m2[5] = "xyzzy"; // "m1 aus m2 entfernen" ... { std::map<int, std::string> mt; std::set_difference(m2.begin(), m2.end(), m1.begin(), m1.end(), std::inserter(mt, mt.begin()), m2.value_comp()); m2.swap(mt); } for(auto i = m2.begin(); i != m2.end(); ++i) { std::cout << i->first << " -> " << i->second << '\n'; } } kk
• ?

  sdt::queue und std::list nicht Thread-Safe?
  • Gast  

  9
  0
  Stimmen
  9
  Beiträge
  15555
  Aufrufe

  X

  cooky451 schrieb: static std::queue<> m_tasks; Weswegen ein statischer queue? cooky451 schrieb: beginthread(my_queue()); // neue Instanz für jeden Thread!, hier darf nur pop() Warum eine Instanz für jeden Thread? Und warum darf nur pop() aufgerufen werden, wenn über den gleichen Mutex geschützt wird. Ich denke eine Implementierung ala template<typename T> class sync_queue{ public: void push(const T& t){ boost::mutex::scoped_lock l(mutex); queue.push(t); } T pop(){ boost::mutex::scoped_lock lock(mutex); T t = queue.front(); queue.pop(); return t; } private: boost::mutex mutex; std::queue<T> queue; }; ist wesentlich eleganter, weil man mehrere queues haben kann... Oder analog eine blockende Variante: template<typename T> class blocking_sync_queue{ public: void push(const T& t){ boost::mutex::scoped_lock l(mutex); queue.push(t); empty_condition.notify_one(); } T pop(){ boost::mutex::scoped_lock lock(mutex); while(queue.empty()) empty_condition.wait(lock); T t = queue.front(); queue.pop(); return t; } private: boost::mutex mutex; std::queue<T> queue; boost::condition_variable empty_condition; }; Gruß, XSpille
• R

  Initialisierung von Variablen
  • redrew99  

  17
  0
  Stimmen
  17
  Beiträge
  14296
  Aufrufe

  R

  krümelkacker schrieb: Zu kritisieren wäre in diesem Fall, dass Du es nicht so geschrieben hast: int main() { int i = 0; cout << i << " = Wert von i\n"; int erg = addiere_5(i); cout << erg << " = Ergebnis von addiere_5\n"; cout << i << " = i unverändert!\n"; } Gewöhne Dir an, die Variablen erst dann zu definieren, wenn du sie brauchst und nach Möglichkeit auch gleichzeitig richtig initialisierst. Bei anderen Typen (wie zB std::string) gibt es durchaus Performanz-Unterschiede; denn der Compiler darf in einer Situation wie dieser: [cpp] Außerdem kannst Du so auch Programmierfehler vermeiden, weil Du dann einfach weniger "uninitialisierte" Variablen hast. Danke für den Tip. Der Code ist nicht von mir, sondern aus einem Lehrbuch. Da ich an verschiedenen Stellen bislang nur gelesen habe, daß man Variablen bei Definition auch initialisieren sollte, wollte ich mal wissen, wie die Abweichung von der Regel in diesem Programmbeispiel einzuordnen ist.
• A

  Thread problem
  • AlexanderKiebler  

  41
  0
  Stimmen
  41
  Beiträge
  14431
  Aufrufe

  A

  *ggg*
• ?

  Problem beim kopieren eines Vektors; wie bekomme ich das Ding typisiert
  • Gast  

  5
  0
  Stimmen
  5
  Beiträge
  10919
  Aufrufe

  ?

  Ehrlich gesagt habe ich mir über Sinn- bzw Unsinnigkeit von Pointern/ Referenzen keine Gedanken gemacht. Und ja, ich hab auch gesehen, dass die beiden Vectoren unterschiedliche Längen haben - wußte nicht, dass das zu Probs führt... Dann bleib ich erstmal bei assign, sofern das beim debuggen gut aussieht und das sonst gleichwertig ist... Danke
• P

  OOP in C++ Buchvorschlag???
  • Pasha  

  3
  0
  Stimmen
  3
  Beiträge
  10744
  Aufrufe

  P

  heee was ist denn das also ich bin mir ziemlich sicher dass es mit c++ weiter gehen wird
• ?

  Uint16 steh auf dem Schlauch
  • Gast  

  9
  0
  Stimmen
  9
  Beiträge
  12211
  Aufrufe

  W

  314159265358979 schrieb: wxSkip schrieb: 314159265358979 schrieb: Und mit C++ hast du dann auch <cstdint> Du hast 0x vergessen. Nein, ich hab 11 vergessen Hab' schon überlegt, ob ich es dazuschreiben soll.
• C

  Include Problem mit typedefs
  • C0de4Fun  

  6
  0
  Stimmen
  6
  Beiträge
  953
  Aufrufe

  ?

  Naja, zb class B; typedef B C; typedef std::vector<B> BVec; class B { }; int main() { C c; BVec vec; } Funzt bei mir. vielleicht kannst du den zentralen header ähnlich aufbauen(natürlich ohne deklaration der klasse). Tut mir leid wenn ich mich grade vertue, ich brauch eventuell doch mehr schlaf als 1-2 stunden pro nacht.(Da programmiert es sich doch nicht ganz so gut) namespace datastore { class CVarStore; typedef boost::shared_ptr<CVarStore> CVarStorePtr; } Und sowas.
• ?

  Code Bitte Erklären!
  • Gast  

  22
  0
  Stimmen
  22
  Beiträge
  2960
  Aufrufe

  L

  camper schrieb: fdfdg schrieb: this->that schrieb: Gute Compiler werden doch den Funktionsaufruf aus der Schleife rausziehen? Zumindest könnten sie es, bei Funktionen aus der Std-Lib ist ja klar, welche pure sind und welche nicht. Selbst der beste Compiler kann nicht wissen (ohne dass man es ihm auf irgendweine andere Weise mitteilt), dass die Sequenz kein 0xC3 enthält und folglich das Ergebnis von strlen nicht beeinflusst wird.
• P

  [C++0x] decltype + überladene Funktionstemplates
  • pumuckl  

  3
  0
  Stimmen
  3
  Beiträge
  735
  Aufrufe

  P

  KasF schrieb: auto vor den Funktionsnamen machen. gnarf. Danke.
• ?

  Fehler tief im System
  • Gast  

  5
  0
  Stimmen
  5
  Beiträge
  712
  Aufrufe

  W

  Wenn du keine Exceptions verwenden willst, kannst du ja auch setjmp() und longjmp() verwenden.
• *

  Protected Attribute - ja/nein?
  • *Q* 1  

  11
  0
  Stimmen
  11
  Beiträge
  1236
  Aufrufe

  E

  Da muss man sich ja direkt nach sprachlichen Zusammenhängen zwischen den beiden Wörtern in die Kammer zurückziehen und in der Dunkelheit viele Nächte und Tage meditieren, bis der Mond die Erde mehrfach umkreist hat, um dann zu der Erkenntnis zu kommen, dass...
• A

  VS C++ DLL in VB einfügen
  • asdfghjkl1234  

  12
  0
  Stimmen
  12
  Beiträge
  1436
  Aufrufe

  ?

  Excel - DLL - VB oder VBA? Je nach Version sind die Limits anders. Hier mal ein Beispiel aus 2006: http://www.xlam.ch/xlimits/visualbasic.htm Keine Ahnung ob du damit in Konflikt kommst? Hier noch so was: http://www.xlam.ch/xlimits/arrays.htm MfG f.-th.
• M

  Boost Safe bool Idiom
  • Mythli  

  3
  0
  Stimmen
  3
  Beiträge
  966
  Aufrufe

  M

  bool_testable<> in Boost.Operators looks promising. The reference mentions that: bool_testable provides the antithesis of operator bool, such that the expression if (!p) is valid, whilst also making operator bool safer by preventing accidental conversions to integer types. ... bool_testable<> prevents these accidental conversions by declaring a private conversion operator to signed char, and not defining the body.
• S

  Verschiedene Daten aus Textfile auslesen
  • sebleb  

  4
  0
  Stimmen
  4
  Beiträge
  986
  Aufrufe

  E

  sebleb schrieb: in Class Lesenschreiben schreibe ich Daten in einer Datei mit Method schreiben() und zwar x ,y ,xmin, xmax und funname und jetzt versuche ich dans ganze wieder zulesen Und was bringt das im Gegensatz zu der üblichen Variante?
• 1

  String aus Char Array extrahieren
  • 1quiroauieo  

  3
  0
  Stimmen
  3
  Beiträge
  853
  Aufrufe

  ?

  Ich persönlich hätte es so geregelt: Statt in einzelne char-arrays zu kopieren, würde ich allerdings einen std::vector empfehlen. #include <vector> #include <string> #include <cstring> void Lese(const char* cArray, std::vector<std::string>& strings) { if(!strings.empty()) strings.clear(); if(cArray == NULL) return; const char *first = cArray, *last; for(;;++first) { first = std::strchr(first, '>'); if(first == NULL) return; last = std::strchr(first+1, '\n'); if(last == NULL) return; strings.push_back(std::string(first+1, last)); } } std::strchr sucht zunachst nach dem buchstaben, danach kann man den string kopieren, wobei die Endlosschleife so lang läuft, bis strchr einmal NULL liefert, also keinen buchstaben mehr findet. Ausgegeben habe ich es so: char str[] = { ">String1\n" ">String2\n" ">String3\n" ">String4\n" ">String5\n" ">String6\n" }; int main() { std::vector<std::string> vec; Lese(str, vec); for(std::vector<std::string>::iterator it=vec.begin();it!=vec.end();++it) cout << '-' << *it << endl; } Ich würde aber zum auslesen der datei auch empfehlen,in einen String zu lesen, statt in ein char-array. Lese() sähe dabei auch kaum anders aus: void Lese(const std::string& str, std::vector<std::string>& strings) { if(!strings.empty()) strings.clear(); if(str.empty()) return; std::size_t first = 0, last; for(;;) { first = str.find('>', first); if(first==std::string::npos) return; last = str.find('\n', first); if(last==std::string::npos) return; ++first; strings.push_back(str.substr(first, last-first)); } } Oder man kann wie schon erwähnt zeilenweise lesen und einfach den ersten buchstaben abschneiden.
• L

  Eigene standardbibliothek implementieren ?
  • lk  

  15
  0
  Stimmen
  15
  Beiträge
  1752
  Aufrufe

  E

  EOutOfResources schrieb: Ethon schrieb: Typsicher [...] klare Warnungen Passt meiner Meinung nach nicht zusammen... Wenn dasteht: "Hey, du sagst int, ich seh da aber nen const char*" ist das in meinen Augen nicht wirklich unsicherer als ein direkter Compilerfehler. Ich find's schlechter lesbar. Links steht ein %bla und %blub und rechts kommen erst die Eintragungen. Bei den Streams ist die Reihenfolge hingegen richtig, das ist deutlich besser. Aber die Diskussion ist müßig und sinnlos. Hängt imo vom Einsatzzweck ab. "Name: (Hans Peter) Age: 20" würde man per Formatstring mit nem einfachen "Name: (%s) Age: %d" String parsen können, mit Streams wäre das etwas unübersichtliches und hässliches geworden. Meistens lohnt es sich da direkt Boost.Spirit auszupacken. Natürlich gibts andere Fälle, in denen Streams schneller & besser sind, man muss halt je nach Situation entscheiden. (Finde ich zumindestens)
• ?

  Suche strcpy, strcmp, memcpy, memcmp Implementation
  • Gast  

  12
  0
  Stimmen
  12
  Beiträge
  3211
  Aufrufe

  Y

  Ganz interessant finde ich in dem Zusammenhang auch, dass der Compiler (MSVC) statt in einer Schleife direkt kopiert und dabei die Registerbreite ausnutzen kann (nur bis zu einer bestimmten Größe, und auch nur, wenn die Größe % Registerbreite == 0). 24 Byte kopieren auf einem 32 Bit-System: mov edx, DWORD PTR [eax] mov DWORD PTR [ecx], edx mov edx, DWORD PTR [eax+4] mov DWORD PTR [ecx+4], edx mov edx, DWORD PTR [eax+8] mov DWORD PTR [ecx+8], edx mov edx, DWORD PTR [eax+12] mov DWORD PTR [ecx+12], edx mov edx, DWORD PTR [eax+16] mov DWORD PTR [ecx+16], edx mov eax, DWORD PTR [eax+20] mov DWORD PTR [ecx+20], eax Mit SSE-Optimierungen werden stattdessen die XMM Register bemüht: movq xmm0, QWORD PTR [eax] movq QWORD PTR [ecx], xmm0 movq xmm0, QWORD PTR [eax+8] movq QWORD PTR [ecx+8], xmm0 movq xmm0, QWORD PTR [eax+16] movq QWORD PTR [ecx+16], xmm0 Bei anderen (geraden) Längen zieht der Compiler mit den Optimierungen die XMM- und für das letzte Wort das ax-Register heran. Ähnliche Optimierungen kommen auch bei strcmp und Konsorten zum Zuge*. Nur die naivsten Implementierungen (gibt es soetwas überhaupt noch?) vergleichen byteweise. Edit: Bzw. diese Funktionen werden gleich so programmiert. seldon hat dies afair einmal im C-Forum demonstriert.