Probleme mit Aufruf von Methoden einer Template Klasse

Hallo,

Ich möchte einen generischen Cache schreiben.

Dieser soll die Möglichkeit haben, über die Methode

void set(KEY& key, T& elem)

Elemente hineinzu schieben und sie dann später wieder mit

bool get(KEY& key, T& elem)

heraus zu holen.

Wenn ich das ganze jetzt Compilieren will, dann erhalte ich folgende Fehlermeldung:

U8A3_GenericCache_test.C: In function `int main()':
U8A3_GenericCache_test.C:31: Fehler: keine passende Funktion f"ur Aufruf von >>GenericCache<int, std::string, 3>::set(int, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)<<
U8A3_GenericCache.h:59: Anmerkung: Kandidaten sind: void GenericCache<KEY, T, N>::set(KEY&, T&) [with KEY = int, T = std::string, int N = 3]
U8A3_GenericCache_test.C:33: Fehler: keine passende Funktion f"ur Aufruf von >>GenericCache<int, std::string, 3>::set(int, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)<<
U8A3_GenericCache.h:59: Anmerkung: Kandidaten sind: void GenericCache<KEY, T, N>::set(KEY&, T&) [with KEY = int, T = std::string, int N = 3]
U8A3_GenericCache_test.C:35: Fehler: keine passende Funktion f"ur Aufruf von >>GenericCache<int, std::string, 3>::set(int, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)<<
U8A3_GenericCache.h:59: Anmerkung: Kandidaten sind: void GenericCache<KEY, T, N>::set(KEY&, T&) [with KEY = int, T = std::string, int N = 3]
U8A3_GenericCache_test.C:39: Fehler: keine passende Funktion f"ur Aufruf von >>GenericCache<int, std::string, 3>::set(int, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)<<
U8A3_GenericCache.h:59: Anmerkung: Kandidaten sind: void GenericCache<KEY, T, N>::set(KEY&, T&) [with KEY = int, T = std::string, int N = 3]
U8A3_GenericCache_test.C:43: Fehler: keine passende Funktion f"ur Aufruf von >>GenericCache<int, std::string, 3>::set(int, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)<<
U8A3_GenericCache.h:59: Anmerkung: Kandidaten sind: void GenericCache<KEY, T, N>::set(KEY&, T&) [with KEY = int, T = std::string, int N = 3]
U8A3_GenericCache_test.C:45: Fehler: keine passende Funktion f"ur Aufruf von >>GenericCache<int, std::string, 3>::set(int, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)<<
U8A3_GenericCache.h:59: Anmerkung: Kandidaten sind: void GenericCache<KEY, T, N>::set(KEY&, T&) [with KEY = int, T = std::string, int N = 3]
U8A3_GenericCache_test.C:47: Fehler: keine passende Funktion f"ur Aufruf von >>GenericCache<int, std::string, 3>::set(int, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)<<
U8A3_GenericCache.h:59: Anmerkung: Kandidaten sind: void GenericCache<KEY, T, N>::set(KEY&, T&) [with KEY = int, T = std::string, int N = 3]
make: *** [U8A3_GenericCache_test.o] Fehler 1

Die Datei, in der das Template steht, sieht so aus:

#ifndef GENERICCACHE_H
#define GENERICCACHE_H

#include <iostream>
#include <map>

template <typename KEY, 
          typename T, 
					int N = 10>

class GenericCache
{
	public:

	GenericCache()
		: data_(), size_(N), current_(0)
	{
	}

	GenericCache(const GenericCache& c)
		: data_(c.data_), size_(c.size_), current_(c.current_)
	{
		current_ = c.current_;
	}

	~GenericCache()
	{
	}

	bool get(KEY& key, T& elem)
	{
		std::pair<KEY, T> result;

		for (int i = 0; i < size_; i++)
		{
			result = data_.find(i)->second;
			if (result.first == key)
			{
				elem = result.second;
				return true;
			}
		}

		return false;

	}

	void set(KEY& key, T& elem)
	{
		std::pair<KEY, T> thing = std::make_pair(key, elem);
		std::pair<int, std::pair<KEY, T> > input = std::make_pair(current_, thing);
		std::pair<KEY, T> result;

		bool schondrin = false;

		for (int i = 0; i < size_; i++)
		{
			result = data_.find(i)->second;
			if (result.first == key)
			{
				schondrin = true;
				break;
			}
			else
			{
				schondrin = false;
			}
		}

		if ( !schondrin)
		{
			data_.insert(input)	;
			current_++;
		}

		if (current_ == (size_ - 1))
		{
			data_.erase(0);

			current_--;

			for (int i = 1; i < size_; i++)
			{
				thing = data_.find(i)->second;
				input = std::make_pair( (i-1), thing);
				data_.insert(input);
				data_.erase(i);
			}
		}

	}

	protected:

	std::map< int, std::pair<KEY, T> > data_;
	int size_;
	int current_;

};

#endif

Ob das so der gute Code ist, lass ich mal dahin gestellt
Aber mich interessierts jetzt hauptsächlich mal, warum das ganze nicht kompliert.
Der vollständigkeitshalber noch die Datei, die das ganze aufruft:

#include "U8A3_GenericCache.h"
#include <iostream>
#include <vector>
using namespace std;

GenericCache <int, string, 3> cache;

void checkAll()
{
  string s;
  cout << "check" << endl;
  for (int i = 0; i < 6; ++i)
  {
    if (cache.get(i, s)) 
    {
      cout << "hat " << i << endl;
    }
  }
}

int main()
{
  vector<string> data(6);
  data[0] = "null";
  data[1] = "eins";
  data[2] = "zwei";
  data[3] = "drei";
  data[4] = "vier";
  data[5] = "fuenf";

  cache.set(0, data[0]);
  cout << "-> 0" << endl;
  cache.set(1, data[1]);
  cout << "-> 1" << endl;
  cache.set(2, data[2]);
  cout << "-> 2" << endl;

  cache.set(3, data[3]);
  cout << "-> 3" << endl;
  checkAll();

  cache.set(4, data[4]);
  cout << "-> 4" << endl;
  cache.set(0, data[0]);
  cout << "-> 0" << endl;
  cache.set(0, data[0]);
  cout << "-> 0" << endl;

  checkAll();

  return 0;
}

Vielen Dank für eure Hilfe!

MfG Xargo

Warum speicherst du Informationen doppelt? Dass dein Cache generisch ist sieht doch jeder daran, dass es ein Template ist.

camper

Aber mich interessierts jetzt hauptsächlich mal, warum das ganze nicht kompliert.

du versucht eine referenz an ein literal zu binden.

Michael E.

Kleiner Tipp: Wenn dir eine Fehlermeldung unklar ist, lass mal nen anderen Compiler drüberlaufen. VC 2003 Standard (gibts kostenlos) sagt z. B.:

error C2664: 'GenericCache<KEY,T,N>::set' : cannot convert parameter 1 from 'int' to 'int &'

Die Lösung: Lass bei KEY &key das & weg.

LordJaxom

Oder füge ein const hinzu

Vielen dank, mit dem const tuts...