ich möchte eine Map erstellen, allerdings nicht, dass der Key ein String ist und der Valuewert ein Integer, sondern dies mischen.
So würde ich ja eine Map anlegen

map<string, int> map_

Ich möchte aber, dass Keys zahlen und Zeichen sein können, ebenso bei den Values.

Jemand eine Idee?

Danke

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.

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

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

#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;
}

Ich erzeuge eine mit

MapDictionary<int, string> maptest;

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

using namespace std;

benutze..

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 **.

#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

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.

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.

this-> ist völlig unnötig.

Geschmackssacke.

Hacker schrieb:

this-> ist völlig unnötig.

Geschmackssacke.

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

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.

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

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.

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!

.. und das es ziemlich langsamer pfusch ist..

Na wenn du das gleich so sagst... machs besser ( :Herausforderung: )

Ich bin soweit fertig (unimplementierte Funktionen sind ja durch das Set verfügbar, und da das nur ein Wrapper um ein Set ist...).

template<typename leftKeyT, typename rightKeyT>
class bimap
{
public:

        typedef std::pair<leftKeyT, rightKeyT> value_type;
        typedef std::set<value_type> array_type;

        array_type mSet;///Internal array (set)

        typedef leftKeyT left_key_type;
        typedef rightKeyT right_key_type;

        typedef typename array_type::iterator iterator;
        typedef typename array_type::const_iterator const_iterator;
        typedef typename array_type::size_type size_type; //Hier können theoretisch noch andere typedefs hin, aber die sind durch das Set verfügbar

        iterator find(rightKeyT const& tof)
        {
                return find(tof);
        }

        iterator find(leftKeyT const& tof)
        {
                return find(tof);
        }

        const_iterator find(rightKeyT const& tof) const
        {
                return std::find_if(mSet.begin(), mSet.end(), [&](value_type const& a){return a.second == tof;});
        }

        const_iterator find(leftKeyT const& tof) const
        {
                return std::find_if(mSet.begin(), mSet.end(), [&](value_type const& a){return a.first == tof;});
        }

        leftKeyT& operator[](rightKeyT const& a)
        {
                return const_cast<leftKeyT&>(insert(a).first->first);
        }

        rightKeyT& operator[](leftKeyT const& a)
        {
                return const_cast<rightKeyT&>(insert(a).first->second);
        }

        void clear()
        {
                mSet.clear();
        }

        size_type count(leftKeyT const& lK) const
        {
                return std::count_if(mSet.mSet.begin(), mSet.end(), [&](std::pair<leftKeyT, rightKeyT> const& p)
                                                                   {
                                                                        return p.first == lK;
                                                                   });
        }
        size_type count(rightKeyT const& rK) const
        {
                return std::count_if(mSet.mSet.begin(), mSet.end(), [&](std::pair<leftKeyT, rightKeyT> const& p)
                                                                   {
                                                                        return p.second == rK;
                                                                   });
        }

        size_type erase(rightkeyT const& lK)
        {
                size_type rval = count(lK);
                std::remove_if(mSet.begin(), mSet.end(), [&](value_type const& p){return p.second == lK;});
                return rval;
        }

        size_type erase(leftkeyT const& lK)
        {
                size_type rval = count(lK);
                std::remove_if(mSet.begin(), mSet.end(), [&](value_type const& p){return p.first == lK;});
                return rval;
        }

        template<typename keyT>
        std::pair<iterator, bool> insert(keyT const& t)
        {
                std::pair<iterator, bool> rval(find(t), false);

                if(rval.first != mSet.end())
                        return rval;

                return mSet.insert(std::make_pair(leftKeyT(), t));;
        }
};