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.


  • Mod

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

    du versucht eine referenz an ein literal zu binden.



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



  • Oder füge ein const hinzu 😉



  • Vielen dank, mit dem const tuts...


Log in to reply