template Problem



  • hi

    Habe mehrere gleichnamige Methoden die nur etwas in eine std::map abspeichern.

    class Properties
    {
    public:
     void addProperty(std::string name, std::string value);
     void addProperty(std::string name, int value);
     void addProperty(std::string name, bool value);
    
     std::string getProperty(std::string name);
     int getProperty(std::string name);
     bool getProperty(std::string name);
    
    private:
     std::map<std::string, std::string> string_properties;
     std::map<std::string, int> int_properties;
     std::map<std::string, bool> bool_properties;
    };
    

    Hab das ganze per template versucht das ganze zu vereinfachen. Das Problem ist das ich nicht weiss wie ich das in der Implemention schreiben soll das er in den einzelnen maps die werte abspeichert? Wie schaff ich das ich die add und get Methoden als template realisiert bekomme?
    Zweites viel grösseres Problem ist das ich die get Methoden mit unterschiedlichen Rückgabewerte anscheinend nicht überschreiben kann.
    Dabei sollten die Parameter der Methoden möglichst unverändert bleiben.

    MFG
    xmarvel



  • template<class T>
    T getProperty(std::string name);
    
    template<class T>
    T getProperty(std::string name)
    {
        T obj;
        // Tu dies, tu das
        return obj;
    }
    


  • #include <map>
    #include <string>
    
    class Properties 
    { 
    public: 
    	template<typename T>
    	void addProperty(const std::string &name, T t)
    	{
    		getMap(t)[name] = t;
    	}
    
    	template<typename T>
    	T getProperty(const std::string &name)
    	{
    		return getMap(T())[name];
    	}
    
    private: 
    	std::map<std::string, int> ints; 
    	std::map<std::string, std::string> strings; 
    	std::map<std::string, bool> bools; 
    
    private:
    	std::map<std::string, int> &getMap(int){return ints;}
    	std::map<std::string, std::string> &getMap(std::string){return strings;}
    	std::map<std::string, bool> &getMap(bool){return bools;}	
    
    }; 
    
    int main() 
    { 	
    	Properties props;
    
    	props.addProperty("p1", 12);
    	props.addProperty("p2", std::string("1212"));
    	props.addProperty("p3", true);
    
    	int i = props.getProperty<int>("p1");
    	std::string str = props.getProperty<std::string>("p2");
    	bool b = props.getProperty<bool>("p3");
    
    }
    


  • thx für die Antwort mit dem getMap ist wirklich tricky währe ich jetzt nicht raufgekommen. 😉

    Hab aber diesbezüglich noch drei Fragen.

    1. Wieso muss ich bei addProperty("p2", std::string("1212"); noch angeben das es ein string ist? Ok bei 1212 als String kann ich das noch verstehen aber wenn der String "Hello World" ist dann müsste er das doch erkennen das es ein string ist oder versucht er das automatisch immer in ein int umzuwandeln?
      (Dachte wenn was zwischen zwei " steht bedeutet das es ein string ist.)

    2. Was ist der Unterschied von T und T() ?

    3. und die template Methoden müssen inline geschrieben werden so wie ich das gelesen habe stimmt das?

    MFG
    xmarvel



  • xmarvel schrieb:

    1. Wieso muss ich bei addProperty("p2", std::string("1212"); noch angeben das es ein string ist? Ok bei 1212 als String kann ich das noch verstehen aber wenn der String "Hello World" ist dann müsste er das doch erkennen das es ein string ist oder versucht er das automatisch immer in ein int umzuwandeln?
      (Dachte wenn was zwischen zwei " steht bedeutet das es ein string ist.)

    wenn was zwischen zwei " steht, bedeutet das **const char ***
    füg noch folgende Methode ein:

    void addProperty(const std::string &name, const char *str)
    {
      addProperty(name, std::string(str));
    }
    

    xmarvel schrieb:

    1. Was ist der Unterschied von T und T() ?

    T - type
    T() - default value of type T

    xmarvel schrieb:

    1. und die template Methoden müssen inline geschrieben werden so wie ich das gelesen habe stimmt das?

    nein

    class Properties 
    { 
    //...	
    	template<typename T> 
    	void addProperty(const std::string &name, T t); 
    
    	template<typename T> 
    	T getProperty(const std::string &name);
    //...	
    };
    
    template<typename T> 
    void Properties::addProperty(const std::string &name, T t)
    { 
    	getMap(t)[name] = t; 
    } 
    
    template<typename T> 
    T Properties::getProperty(const std::string &name)
    { 
    	return getMap(T())[name]; 
    }
    

Anmelden zum Antworten