1// Literatur: Vorlesungsunterlagen SEN (FH Hagenberg, HSSE Semester 2)
2// C++ Referenz (http://www.cplusplus.com)
3
4// Strings
5 #include <string>
6 string s("test");
7 s.size();
8 s.clear();
9 bool isEmpty = s.empty();
10 s[0] = 'f';
11 s.at(0) = 'f';
12
13 s += "next";
14 s += str2;
15 s += 'c';
16
17 s.append(str2);
18 s.append(str2, 2, 3); // ab Zeichen 2, 3 Zeichen lang
19 s.append("asdf");
20 s.append("asdfasdf", 4); // 4 Zeichen vom String
21 s.append(10,'.'); // 10 x '.'
22 s.append(firstIter, secondIter);
23
24 s.push_back('c');
25
26 s.assign(str2);
27 s.assign(str2, 2, 3); // ab Zeichen 2, 3 Zeichen lang
28 s.assign("asdf");
29 s.assign("asdfasdf", ); // 4 Zeichen vom String
30 s.assign(10, '.'); // 10 x '.'
31 s.assign(firstIter, secondIter);
32
33 s.insert(2, str2); // String an Position 2 einfuegen
34 s.insert(2, str2, 3, 4); // String an Position 2 einfuegen,
35 // ab Zeichen 3, 4 Zeichen lang
36 s.insert(2, "asdf"); // String an Position 2 einfuegen
37 s.insert(2, "asdfasdf", 4); // String an Position 2 einfuegen,
38 // 4 Zeichen vom String
39 s.insert(2, 10, '.'); // an Position 2, 10 x '.' einfuegen
40 s.insert(iter, '.');
41 s.insert(iter, 10, '.');
42 s.insert (iter, str2.begin(), str2.end);
43
44 s.erase(iter);
45 s.erase(firstIter, secondIter);
46
47 s.replace(2, 3, str2); // String an Position 2,
48 // 3 Zeichen lang ersetzen mit str2
49 s.replace(2, 3, str2, 4, 5); // String an Position 2,
50 // 3 Zeichen lang ersetzen mit str2
51 // (ab Position 4, 5 Zeichen lang)
52 s.replace(2, 3, "asdf"); // String an Position 2,
53 // 3 Zeichen lang ersetzen mit String
54 s.replace(2, 3, "asdfasdf", 4); // String an Position 2,
55 // 3 Zeichen lang ersetzen mit str2
56 // (4 Zeichen vom String)
57 s.replace(2, 3, 10, '.'); // String an Position 2,
58 // 3 Zeichen lang ersetzen mit 10 x '.'
59 s.replace(firstIter, secondIter, str2);
60 s.replace(firstIter, secondIter, "asdf");
61 s.replace(firstIter, secondIter, "asdfasdf", 4);
62 s.replace(firstIter, secondIter, 10, '.');
63 s.replace(firstIter, secondIter, str2.begin(), str2.end());
64
65 s.copy(charArr, 2, 3); // String ab Position 2,
66 // 3 Zeichen lang in charArr kopieren
67 s.swap(str2);
68 s.c_str();
69
70 size_t position = s.find(str2);
71 if (position != string::npos)
72 ...
73 s.find(str2, 2); // Suche ab Position 2
74 s.find("asdf");
75 s.find("asdf", 2); // Suche ab Position 2
76 s.find("asdf", 2, 3); // Suche ab Position 2, 3 Zeichen lang
77 s.find('a');
78 s.find('a', 2); // Suche ab Position 2
79 s.rfind(...); // von hinten Suchen
80
81 string s("alle Selbstlaute durch Punkt ersetzen");
82 size_t position;
83 position = s.find_first_of("aeiou");
84 while (position != string::npos)
85 {
86 s[position] = '.';
87 position = s.find_first_of("aeiou", position + 1);
88 } // s = ".ll. S.lbstl..t. d.rch P.nkt .rs.tz.n."
89 s.find_last_of(...);
90 s.find_first_not_of(...);
91 s.find_last_not_of(...);
92
93 str2 = s.substr(); // str2 == s
94 str2 = s.substr(2); // von Position 2 bis zum Ende
95 str2 = s.substr(2, 3); // von Position 2, 3 Zeichen lang
96
97 s.compare(str2) == 0 // Strings gleich
98 s.compare("asdf")
99 s.compare(2, 3, str2) // s ab Position 2,
100 // 3 Zeichen lang vergleichen
101 s.compare(2, 3, str2, 4, 5) // s ab Position 2,
102 // 3 Zeichen lang mit str2 ab Position 4,
103 // 5 Zeichen lang vergleichen
104 s.compare(2, 3, "asdf") // s ab Position 2,
105 // 3 Zeichen lang vergleichen
106 s.compare(2, 3, "asdf", 4) // s ab Position 2, 3 Zeichen lang mit
107 // ".." 4 Zeichen lang vergleichen
108
109
110// Streams
111 #include <iostream>
112 cout << "text" << var << endl; // standard Ausgabe
113 cin >> intVal; // standard Eingabe
114
115 #include <fstream>
116 ofstream out("file.txt");
117 out << "text";
118 out.close();
119 .is_open()
120 .put(char c)
121 .write(const char* c, streamsize maxc)
122 .flush
123 .eof()
124 .fail()
125
126 ifstream in("file.txt");
127 in >> intVal;
128 in.close();
129 .is_open()
130 .get(char &c)
131 .getline(char *c, streamsize maxc)
132 .read(char *c, streamsize maxc)
133 .eof()
134 .fail()
135
136// String Streams
137 #include <sstream>
138 ostringstream oss;
139 oss << "text";
140 oss.str();
141
142 istringstream iss(string);
143 iss >> intVal;
144
145
146// Stream-Manipulatoren
147 hex // Hexadezimalausgabe (bis auf Widerruf)
148 oct // Oktalausgabe
149 dec // Dezimalausgabe
150
151 scientific // Exponenten Darstellung
152 fixed // normale Darstellung
153
154 setprecision(4) // Nachkommastellen fuer naechste Ausgabe
155 setw(3) // Weite der Zahl
156 setfill('0') // Fuellzeichen setzen
157
158 left // Ausrichtung
159 right
160
161 upercase // Grossschreibung
162 nouppercase
163
164 boolalpha // Ausgabe von true/false
165 noboolalpha
166
167 ostream &hr (ostream &os) // eigener Manipulator
168 {
169 os << endl;
170 os << "-------------";
171 os << endl;
172 return os;
173 }
174
175
176// Container
177// Queue - FIFO Datenstruktur
178 queue<int> q;
179 q.push(1); // fuegt Element am Ende ein
180 ivalue = q.front(); // liefert Element am Anfang
181 q.pop(); // loescht Element am Anfang
182
183// Stack - LIFO Datenstruktur
184 stack<int> s;
185 s.push(1); // fuegt Element oben ein
186 ivalue = s.top(); // liefert oberstes Element
187 s.pop(); // loescht oberstes Element
188
189// Vektor - automatisch wachsendes Array
190// + schnelles Einfuegen/Loeschen am Ende
191// + Direktzugriff mit Indexoperator
192 #include <vector>
193 vector<int> v;
194 v.push_back(0); // fuegt Element am Ende ein
195 v[0] // Zugriff auf Element an Stelle 0
196 v.erase(iter); // Element loeschen
197 v.erase(v.begin(), iter); // Bereich loeschen
198 v.empty() // Ueberpruefung ob leer
199 v.size() // Ausgabe der Groesse
200 v.pop_back(); // Element am Ende loeschen
201 v.clear(); // Container loeschen
202
203// Liste - doppelt verkettete Liste
204// + schnelles Einfuegen/Loeschen an jeder Position
205// - nur sequentiellen Zugriff (beide Richtungen)
206 #include <list>
207 list<int> l;
208 l.insert(iter, 0); // Einfuegen eines Elements an
209 // bestimmten Iterator-Position
210 l.push_front(0); // fuegt Element am Anfang ein
211 l.push_back(0); // fuegt Element am Ende ein
212 l.pop_front(); // Element am Anfang loeschen
213 l.pop_back(); // Element am Ende loeschen
214 l.front(); // liefert Element vom Anfang
215 l.back(); // liefert Element vom Ende
216 l.sort(); // Elemente sortieren
217 l.reverse(); // Ordnung der Elemente vertauschen
218 l.clear(); // Container loeschen
219 l.removeif(praedikat); // Loescht Elemente,
220 // welche Bedingung erfuellen
221 l.remove(0); // Loescht alle Elemente mit gleichen Wert
222
223// Map - assoziativer Container mit Schluessel/Werte Paar
224// (eindeutige Schluessel)
225// + Einfuegen und Suchen von Schluesseln in logarithmischer Zeit
226// + Loeschen von Schluesseln in konstanter Zeit
227// + aufsteigend geordnet nach Schluessel
228 #include <map>
229 map<string, int> m;
230 m.insert(pair<string, int>("test", 100));
231
232 pair<map<string, int>::iterator, bool> ret;
233 ret = m.insert(pair<string, int>("test", 100));
234 if (ret.second == false)
235 {
236 cout << "Element existiert bereits: " << ret.first->second << endl;
237 }
238
239 m.erase(iter);
240 m.erase("test");
241 m.erase(firstIter, secondIter);
242 m.clear();
243 m.find("test")->second;
244 m.count("test");
245 m.size();
246 m.empty();
247 m["test2"] = 50;
248
249// Set - assoziativer Container mit Schluesseln (eindeutige Schluessel)
250// + Einfuegen und Suchen von Schluesseln in logarithmischer Zeit
251// + Loeschen von Schluesseln in konstanter Zeit
252// + aufsteigend geordnet nach Schluessel
253 #include <set>
254 set<string> s;
255 s.insert("test");
256 s.erase(iter);
257 s.erase("test");
258 s.erase(firstIter, secondIter);
259 s.clear();
260 iter = s.find("test");
261 s.count("test");
262 s.size();
263 s.empty();
264
265// Bitset
266 #include<bitset>
267 bitset<4> b;
268 b.set(); // alle Bits setzen
269 b.set(2); // Bit an Position 2 setzen
270 b.set(2, true); // Bit an Position 2 setzen
271 b.set(2, false); // Bit an Position 2 loeschen
272
273 b.reset(); // alle Bits loeschen
274 b.reset(2); // Bit an Position 2 loeschen
275
276 b.flip(); // alle Bits negieren
277 b.flip(2); // Bit an Position 2 negieren
278
279 int size = b.size(); // Anzahl der Bits
280 int cnt = b.count(); // Anzahl an gesetzten Bits
281 bool erg = b.any(); // true, wenn irgend ein Bit gesetzt
282 bool erg = b.none(); // true, wenn kein Bit gesetzt
283 bool erg = b.test(2); // true, wenn Bit an Position 2 gesetzt
284
285
286 dequeue // ... double ended queue
287 // + schnelles Einfuegen/Loeschen am Anfang und am Ende
288 slist // ... einfach verkettete Liste
289 // + benoetigt weniger Speicher
290 // - Durchlauf nur in eine Richtung
291 multimap // ... Schluessel/Werte Paare
292 // (mehrfache Verwendung von Schluessel erlaubt)
293 multiset // ... Schluessel (mehrfache Verwendung von Schluessel erlaubt)
294
295
296// Iteratoren
297 vector<int>::iterator iter = vec.begin();
298 vector<int>::const_iterator citer = vec.end();
299 vector<int>::reverse_iterator riter = vec.rbegin();
300 vector<int>::reverse_const_iterator rciter = vec.rend();
301
302 back_inserter(Container)
303 forward_inserter(Container)
304 inserter(Container, Container.end())
305
306 distance(firstIter, secondIter) // Abstand der Iteratoren
307 advance(Iter, distance) // Iterator weiter setzen
308
309// Stream Iteratoren
310 istream_iterator<int> in(cin);
311 istream_iterator<int> eos;
312 copy(in, eos, back_inserter(vec));
313
314 ostream_iterator<int> out(cout, " ");
315 copy(vec.begin(), vec.end(), out);
316
317
318// Praedikate
319 bool Pred(int x, int y) // true ... Aktion wird ausgefuehrt
320 { // false ... Aktion wird nicht ausgefuehrt
321 return x > y;
322 }
323
324 bool Pred(int x)
325 {
326 return x >= 0;
327 }
328
329 plus<>
330 minus<>
331 multiplies<>
332 divides<>
333 modulus<>
334 negate<>
335
336 logical_and<>
337 logical_not<>
338 logical_or<>
339
340 equal_to<>
341 not_equal_to<>
342 greater<>
343 greater_equal<>
344 less<>
345 less_equal<>
346
347
348// Algorithmen
349 #include <algorithm>
350 fill(v.begin(), v.end(), 0);
351 fill_n(v.begin(), 3, 0);
352 fill_n(back_inserter(v), 10, 0);
353
354 generate(v.begin(), v.end(), Func);
355 generate(v.begin(), 3, Func);
356
357 copy(c1.begin(), c1.end(), back_inserter(c2));
358 copy(c1.begin(), c1.end(), ostream_iterator<int>(cout, " "));
359 copy_backward(c1.begin(), c1.end(), ...);
360
361 iter = find(v.begin(), v.end(), 5);
362 iter = find_if(v.begin(), v.end(), Pred);
363
364 count(v.begin(), v.end(), Elem);
365 count_if(v.begin(), v.end(), Pred);
366 for_each(v.begin(), v.end(), Func);
367 bool vorhanden = binary_search(v.begin(), v.end(), 5);
368
369 bool gleich = equal(v.begin(), v.end(), v2.begin());
370 bool gleich = equal(v.begin(), v.end(), v2.begin(), Pred);
371 bool kleiner = lexicographical_compare(v.begin(), v.end(),
372 v2.begin(), v2.end());
373 bool kleiner = lexicographical_compare(v.begin(), v.end(),
374 v2.begin(), v2.end(), Pred);
375
376 elemC = max(elemA, elemB);
377 elemC = max(elemA, elemB, Pred);
378 iterC = max_element(v.begin(), v.end());
379 iterC = max_element(v.begin(), v.end(), Pred);
380 min
381 min_element
382
383 transform(v.begin(), v.end(), v.begin(), negate<int>());
384 transform(str.begin(), str.end(), str.begin(), toupper);
385 transform(v1.begin(), v1.begin()+5, v2.begin(),
386 vres.begin(), plus<int>());
387
388 sum = accumulate(v.begin(), v.end(), 0);
389 prod = accumulate(v.begin(), v.end(), 1, multiplies<int>());
390
391 sort(v.begin(), v.end());
392 sort(v.begin(), v.end(), Pred);
393 stable_sort(v.begin(), v.end());
394 stable_sort(v.begin(), v.end(), Pred);
395
396 merge(v.begin(), v.end(), v2.begin(), v2.end(), vres.begin());
397 merge(v.begin(), v.end(), v2.begin(), v2.end(), vres.begin(), Pred);
398
399
400// Operationen fuer nicht initialisierte Container
401 uninitialized_copy
402 uninitialized_fill
403 uninitialized_fill_n
404
405
406// Funktions Adaptoren
407 bind1st(divide<int>(), 10)
408 bind2nd(divide<int>(), 10)
409
410 bind2nd(not2(less<int>()), 10) = not1(bind2nd(less<int>(), 10))
411
412 char* chNrs[] = {"10","20","30"};
413 int intNrs[3];
414 transform(chNrs, chNrs+3, intNrs, ptr_fun(atoi));
415
416 vector<string*> v;
417 v.push_back(new string("asdf"));
418 v.push_back(new string("asdfasdf"));
419 vector<int> lengths(v.size());
420 transform(v.begin(), v.end(), lengths.begin(), mem_fun(&string::length));
421
422 vector<string> v;
423 v.push_back("asdf");
424 v.push_back("asdfasdf");
425 vector<int> lengths(v.size());
426 transform(v.begin(), v.end(), lengths.begin(),
427 mem_fun_ref(&string::length));
428
429
430
431
432// generische Algorithm
433 template <typename TIter, typename T>
434 TIter find(TIter first, TIter second, T const &val)
435 {
436 while ((first != second) && (*first != val))
437 {
438 first++;
439 }
440 return first;
441 }
442
443 template <typename TIter, typename TPred>
444 TIter find_if(TIter first, TIter second, TPred p)
445 {
446 while((first != second) && !p(*first))
447 {
448 first++;
449 }
450 return first;
451 }
452
453 template <typename TInItor, typename TOutIter>
454 TOutIter copy(TInIter first, TInIter second, TOutIter result)
455 {
456 for(; first!=second; first++)
457 {
458 *result = *first;
459 }
460 return result;
461 }
462
463
464// Funktoren
465 template <typename T>
466 class multiplies: public binary_function<T,T,T>
467 {
468 public:
469 T operator() (T const &x, T const &y) const
470 {
471 return x*y;
472 }
473 };
474
475 class startsWith: public unary_function<string,bool>
476 {
477 public:
478 startsWith(char ch): startCh(ch){}
479 bool operator() (string const &str) const
480 {
481 return ((str.length() > 0) && (str[0] == startCh));
482 }
483 private:
484 char startCh;
485 };
486 startsWith('A')
487
488 class startsWithChar: public binary_function<string,char,bool>
489 {
490 public:
491 bool operator() (string const &str, char ch) const
492 {
493 return ((str.length() > 0) && (str[0] == ch));
494 }
495 };
496 bind2nd(startsWithChar(), 'A')
