#include <vector>
#include <map>
// Map of Vectors:
// http://schwehr.org/blog/archives/2006-08.html
// http://www.codeguru.com/cpp/tic/tic0232.shtml	
template <typename T, typename U>	// Map mit Schlüssel vom Typ T und Werten im Vector vom Typ U

class MapVec
{
	private:			
		std::map<T, std::vector<U> > mv;		
	public:
		void Add(T key, U val);
		U &operator [](T key);	// Zeiger auf den zugehörigen Vektor zurückgeben
		U operator =(U &val);
};
////////////////////////////////////////////////////////////////////////////
template <typename T, typename U>
void MapVec<T, U>::Add(T key, U val)
{
	std::pair<T, std::vector<U> > entry;
	if (mv.find(key) == mv.end() )				// Prüfen ob Eintrag schon existiert
	{
		// Nicht vorhanden
		entry.first = key;						// Schlüssel
		entry.second.push_back(val);			// Eintrag im Array anhängen
		mv.insert(entry);						// Paar hinzufügen
	}
	else {		
		mv[ key ].push_back( val );				// Schon vorhanden, dann nur Array erweitern
	}
}
////////////////////////////////////////////////////////////////////////////
template <typename T, typename U>
U &MapVec<T, U>::operator [](T key)		
{
	return &mv[key];
}
////////////////////////////////////////////////////////////////////////////
template <typename T, typename U>
U MapVec<T, U>::&operator =(U &val)	//??	
{
	// ???
}

Nun würde ich gerne den Vektor zu einem Key folgendermaßen auslesen:

MapVec<std::string, int> IntMap;

IntMap.Add("A", 12);
IntMap.Add("A", 34);

std::vector<int> iv;
iv = IntMap["A"];

Allerdings weiß ich in dem Fall nicht wie ich den Zuweisungsoperator überladen muss, damit das zugehörige Array (oder ein Zeiger darauf) zurückgegeben werden kann.

template <typename T, typename U>
std::vector< U > &MapVec<T, U>::operator [](T key)       
{
    return mv[key];
}

Es reicht doch wenn du beim operator[] ein std::vector<U> zurück gibst. Oder hab ich das falsch verstanden?

Danke, funktioniert!
Manchmal sieht man den Wald vor lauter Bäumen nicht.

Also:

for(MapVec::iterator it = IntMap.begin(); it != IntMap.end(); it++)
{
 ...

Ja, das geht. Aber: Was sind die denn gängigen STL Iteratoren?

Na ich meinte damit den Zugriff in meinem Beispiel oben.

Ich habe mal das hier probiert:

public:
		void Add(T key, U val);
		std::vector<U> &operator [](T key);	// Zeiger auf den zugehörigen Vektor zurückgeben		
		typedef std::map<T, std::vector<U> >::iterator 			iterator;
		typedef std::map<T, std::vector<U> >::const_iterator 	const_iterator;		
		iterator begin() 				{ return mv.begin(); }
		iterator end() 					{ return mv.end(); }
		const_iterator begin() const 	{ return mv.begin(); }
		const_iterator end() const 		{ return mv.end(); }

aber da bekomme ich beim übersetzen den Fehler
> expected `;' before "iterator"

typedef typename std::map<T, std::vector<U> >::iterator             iterator;
typedef typename std::map<T, std::vector<U> >::const_iterator     const_iterator;