Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!
Werbeanzeige
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
#include "WrappedList.h" #include "WrappedMap.h" #include <iostream> //#include <map> class U16String { private: WrappedList<char> *mBaseString; static WrappedMap<unsigned int, WrappedList<char>> mBaseTable; //static std::map<unsigned int, WrappedList<char>> mBaseTable; int mBaseId = 0; public: U16String(const char* text); }; |
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
#include <list> template<typename T> class WrappedList { public: void add(T item); unsigned int count(); private: std::list<T> mList; unsigned int mCount = 0; }; template<class T> void WrappedList<T>::add(T item) { mList.push_back(item); mCount++; } template <class T> unsigned int WrappedList<T>::count() { return mCount; } |
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
#include <map> template<class TKey, class TValue> class WrappedMap { public: void add(TKey key, TValue); bool containsKey(TKey key); TValue at(TKey key); private: std::map<TKey, TValue> mMap; }; template<class TKey, class TValue> void WrappedMap<TKey, TValue>::add(TKey key, TValue value) { this->mMap.insert(std::pair<TKey, TValue>(key, value)); } template<class TKey, class TValue> bool WrappedMap<TKey, TValue>::containsKey(TKey key) { bool containsKey = false; std::map<TKey, TValue>::iterator it; for (it = mMap.begin(); it != mMap.end(); ++it) { if (it->first == key) { containsKey = true; break; } } return containsKey; } template<class TKey, class TValue> TValue WrappedMap<TKey, TValue>::at(TKey key) { TValue value; std::map<TKey, TValue>::iterator it; for (it = mMap.begin(); it != mMap.end(); ++it) { if (it->first == key) { value = it->second; break; } } return value; } |
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
#include "U16String.h" using namespace std; // WARNING // DO NOT CHANGE mBaseString // ADD NEW STRING ON mBasteTable and give the address to mBaseString // WARNING WrappedMap<unsigned int, WrappedList<char>> U16String::mBaseTable; //std::map<unsigned int, WrappedList<char>> U16String::mBaseTable; U16String::U16String(const char* text) { WrappedList<char> tempBaseString; for (unsigned int i = 0; i < strlen(text); i++) { tempBaseString.add(text[i]); } mBaseId = unsigned int(text); bool isInTable = mBaseTable.containsKey(mBaseId); if (!isInTable) { mBaseTable.add(mBaseId, tempBaseString); } mBaseString = &mBaseTable.at(mBaseId); } |
C-/C++-Quelltext |
|
1 2 3 4 5 6 |
#include "U16String.h" int main() { U16String test1 = "Hallo Welt"; } |
Community-Fossil
Zitat von »Legend«
Was die Auswechselbarkeit angeht, bin ich aber selber am überlegen ob man das mit der STL in dem selben Stile wie z.B. in C# hinbekommen könnte.
Zitat von »Legend«
Ich danke dir aufjedenfall schonmal, mir ist halt wichtig das diese Unabhängig sind, sodass ich später mal wie gesagt zum Beispiel meine eigene List Klasse machen kann.
Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »Spiele Programmierer« (27.12.2014, 18:16)
Trotzdem: Ich würde eher überlegen von den STL Klassen zu erben, anstatt einen Wrapper zu bauen. Auf diese Weise müsste ich nicht jede einzelne Methode wrappen. Stattdessen könnte ich Methoden, die ich vermisse, zusätzlich implementieren. Probleme erwarte ich eigentlich keine, aber wissen tu ich das jetzt nicht.
Werbeanzeige