Maps

KeinNameMehrFrei schrieb:

Ah, ich muss also für jeden Fall eine Map anlegen, dachte man kann es irgendwie "einfacher" gestalten.

Danke

Das ist nur eine Idee von mir. Glaube, dass es da von Boost was gibt, aber da du meintest, dass du es für int/string brauchst, dachte ich, dass diese Lösung genügt.

Brauch es auch nur für int und String.

Ich hab 4 Fälle:
<int, string>
<string, int>
<string, string>
<int, int>

Mit Boost möchte ich (noch) nicht arbeiten.

Du kannst natürlich auch Templates verwenden, sodass du es für beliebige Typen-Kombinationen verwenden kannst:

#include <iostream>
#include <string>
#include <map>

using namespace std;

template <typename T, typename U>
class SuperMap
{
    private:
        map<T, U> mapT;
        map<U, T> mapU;

    public:
        U &operator[](const T &key)
        {
            return this->mapT[key];
        }

        T &operator[](U key)
        {
            return this->mapU[key];
        }
};

using namespace std;

int main()
{
    SuperMap<int, string> foo;

    foo["test"] = 0;
    foo[0] = "test";

    SuperMap<float, int> foo2;

    foo2[0.111f] = 1234;
    foo2[0] = 12.34f;

    return 0;
}

Ah, das ist eine viel schönere Lösung, als 4 verschiedene Maps anzulegen,
allerdings habe ich ein Problem beim anlegen einer neuen Map in der Main.

Ich erzeuge eine mit

MapDictionary<int, string> maptest;

Dann sagt der Compiler aber, dass int und String unzulässige Typnamen sind?!

Allerdings findet er angeblich auch kein cin und cout.. Obwohl ich

using namespace std;

benutze..

Für std::cin/std::cout brauchst du den Header iostream. Für std::string brauchst du den Header string. Zeig doch mal deinen Code...

Sone

Mapper schrieb:

Ups, hab das ein bisschen zu flüchtig gemacht. Merk ich z. B. daran, dass ein mal this-> fehlt und der int unnötigerweise per Referenz übergeben wird. Das Prinzip sollte aber klar sein.

Da fehlt kein this-> (eins zuviel).
Was der TE sucht, ist** boost::bimap **.

//header
#ifndef Uebung9.3_h
#define Uebung9.3_h

#include <string>
#include <map> 

using namespace std;
template <typname T, typname U>

class MapDictionary {

private:
        map<T, U> mapT;
        map<U, T> mapU;

public:
        U &operator[](const T &key)
        {
            return this->mapT[key];
        }

        T &operator[](U key)
        {
            return this->mapU[key];
        }
}

#endif

#include "Uebung9.3.h"

using std::map;
using std::cout;
using std::string;
using std::cin;
using std::endl;
//using namespace std;

int main()
{
	MapDictionary<int, string> maptest;

	maptest["eydu"] = 15487;
	maptest[815] = "geheim";
	maptest[10105588799] = 8234;
	maptest["visa"] = "hallo";

	string key;
	/*cout << "Key = ";
	cin >> key;

	map <int, string>::iterator it;
	it = maptest.find(key);

	if (it != maptest.end())
	{
		cout << "Key: " << it->first << " Vaule: " << it->second << endl;
	}*/
}

Hab den Rest extra auskommentiert, weil anscheinend die std::map Sachen auch nicht erkannt werden

Hacker schrieb:

Mapper schrieb:

Ups, hab das ein bisschen zu flüchtig gemacht. Merk ich z. B. daran, dass ein mal this-> fehlt und der int unnötigerweise per Referenz übergeben wird. Das Prinzip sollte aber klar sein.

Da fehlt kein this-> (eins zuviel).

Wo is da eins zu viel?

Hacker schrieb:

Was der TE sucht, ist** boost::bimap **.

Nein, er will ja vorerst kein Boost:

KeinNameMehrFrei schrieb:

Mit Boost möchte ich (noch) nicht arbeiten.

Sone

booster schrieb:

Nein, er will ja vorerst kein Boost:

KeinNameMehrFrei schrieb:

Mit Boost möchte ich (noch) nicht arbeiten.

Glatt übersehen
this-> ist völlig unnötig, außer lokale Variablen haben den gleichen Identifier wie eine deiner Member.

Hacker schrieb:

this-> ist völlig unnötig.

Geschmackssacke.

Sone

feinschmecker schrieb:

Hacker schrieb:

this-> ist völlig unnötig.

Geschmackssacke.

Aber kein Muss. Deswegen ist die Aussage "da muss noch ein this-> hin" falsch.

Ob this oder nicht, das ist ja hier jetzt nicht das Problem

Hacker schrieb:

feinschmecker schrieb:

Hacker schrieb:

this-> ist völlig unnötig.

Geschmackssacke.

Aber kein Muss. Deswegen ist die Aussage "da muss noch ein this-> hin" falsch.

Gegenteiliges hab ich auch nie behauptet. Ich hab nur gesagt, dass da ein "this->" fehlt, was ich auf meinen Beitrag bezogen hab, weil ich es ein mal hin geschrieben und beim anderen aus Versehen vergessen hab.

Sone

Gut gut, schon verstanden. Zurück zum Thema - oder besser gesagt zu seinem Code.

Schön
Der, falls es nicht bemerkt wurde, bereits gepostet wurde

Sone

Jo, du inkludierst natürlich nicht <iostream> .
Vergiss übrigens nicht, dass beide Maps in MapDictionary unabhängig von einander existieren.

Ja, hatte es mit Map schon bemerkt..

Danke, natürlich war es (mal wieder) iostream.

KeinNameMehrFrei schrieb:

Brauch es auch nur für int und String.

Ich hab 4 Fälle:
<int, string>
<string, int>
<string, string>
<int, int>

Jetzt würde mich dochmal die Aufgabenstellung interessieren.

Sone

Theoretisch würde ich sowas nehmen:

template<typename key1T, typename key2T>
struct bimap
{
        typedef std::vector<std::pair<key1T, key2T>> array_type;
        array_type array;

        typename array_type::iterator find(key2T tof)
        {
                typename array_type::iterator iter = array.begin();
                for(;iter != array.end();++iter)
                        if(iter->second == tof)
                                break;

                return iter;
        }

        typename array_type::iterator find(key1T tof)
        {
                typename array_type::iterator iter = array.begin();
                for(;iter != array.end();++iter)
                        if(iter->first == tof)
                                break;

                return iter;
        }

        key1T& operator[](key2T a)
        {
                typename array_type::iterator iter;
                if((iter = find(a)) != array.end())
                        return iter->first;

                array.push_back(std::make_pair(key1T(), a));
                return array.back().first;
        }
        key2T& operator[](key1T a)
        {
                typename array_type::iterator iter;
                if((iter = find(a)) != array.end())
                        return iter->second;

                array.push_back(std::make_pair(a, key2T()));
                return array.back().second;
        }
};

Nur ist halt das Problem, dass es nicht reguläre Memberfunktionen wie in einer std::map gibt...

Aufgabe für heute gefunden!