Lokale Variable ist initialisiert aber nicht referenziert

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Lokale Variable ist initialisiert aber nicht referenziert

    Hallo,

    ich habe ein kleines Problem... ich sollte zu einer Vorgegeben funktion void f ein template schreiben, welches beliebige Typen umwandeln kann.. jedoch werden die Typen (X, Y, answer) in meiner Funktion nicht referenziert... heißt dass, das meine Templates falsch sind? Ich was vergessen habe? Oder kommt dass nur, weil sie nicht benutzt werden?

    das ist meine Klassen.. erste die Templates.. dann die Spezialisierungen und unten die Funktion void f, in der die Warnungen auftreten:

    Quellcode

    1. #include <exception>
    2. #include <sstream>
    3. #include "y.h"
    4. #include "x.h"
    7. //gibt To explizit an
    8. template <typename To, typename From> To stream_cast(From input)
    9. {
    10. std::stringstream str;
    11. str << input;
    12. To output;
    13. str >> output;
    14. if(str == false)
    15. throw std::bad_cast("bad stream_cast");
    16. return output;
    17. }
    19. //Spezialisierung für gleiche Typen
    20. template<typename To> To stream_cast(const To &input)
    21. {
    22. return input;
    23. }
    25. //Spezialisierung string in char* -> wird nicht umgewandelt, input wird zurückgegeben
    26. template<> std::string stream_cast(const char* input)
    27. {
    28. return input;
    29. }
    31. //Spezialisierung char* in string -> wird nicht umgewandelt, input wird zurückgegeben
    32. template<> const char* const stream_cast(std::string input)
    33. {
    34. //c_str() gibt den string als const char * zurück
    35. return input.c_str();
    36. }
    38. //X und Y sind gegeben
    39. class X;
    40. std::ostream& operator<<(std::ostream&,const X&);
    41. std::istream& operator>>(std::istream&,X&);
    43. class Y;
    44. std::ostream& operator<<(std::ostream&,const Y&);
    45. std::istream& operator>>(std::istream&,Y&);
    47. //Funktion f ist gegeben
    48. void f( const std::string& intstr, const X& x , const Y& y )
    49. {
    50. int answer = stream_cast<int>(intstr);//<int> da cast zu int - 12
    51. const std::string& str = stream_cast<std::string>(x);//5 cast zu string
    52. const X& xx = stream_cast<X>(str);//string 5 cast zu X 5
    53. const std::string& str2 = stream_cast<std::string>(y); //4 und 5.0 zu string
    54. const Y& yy = stream_cast<Y>(str2);//str2 zurück in Y 4 und Y 5.0
    55. }
    Alles anzeigen


    Warnungen für die void f:

    warning C4189: 'xx': Lokale Variable ist initialisiert aber nicht referenziert
    warning C4189: 'answer': Lokale Variable ist initialisiert aber nicht referenziert
    warning C4189: 'yy': Lokale Variable ist initialisiert aber nicht referenziert

    Soo.. hier nochmal die Klassen X und Y.. sie sind auch schon vorgegeben gewesen:

    Quellcode

    1. #include <istream>
    2. #include <ostream>
    4. class X {
    5. public:
    6. X() : i_() {}
    7. X(int i) : i_(i) {}
    9. int get_int() const {return i_;}
    10. int & get_int() {return i_;}
    12. private:
    13. int i_;
    14. };
    16. inline std::ostream& operator<<(std::ostream& os, const X& x)
    17. {
    18. os << x.get_int();
    19. return os;
    20. }
    22. inline std::istream& operator>>(std::istream& is, X& x)
    23. {
    24. is >> x.get_int();
    25. return is;
    26. }
    Alles anzeigen


    Quellcode

    1. #include <istream>
    2. #include <ostream>
    4. class Y {
    5. public:
    6. Y() : i_(), d_() {}
    7. Y(int i, double d) : i_(i), d_(d) {}
    9. int get_int () const {return i_;}
    10. double get_double() const {return d_;}
    12. int & get_int () {return i_;}
    13. double& get_double() {return d_;}
    15. private:
    16. int i_;
    17. double d_;
    18. };
    20. inline std::ostream& operator<<(std::ostream& os, const Y& y)
    21. {
    22. os << y.get_int() << ' ' << y.get_double();
    23. return os;
    24. }
    26. inline std::istream& operator>>(std::istream& is, Y& y)
    27. {
    28. is >> y.get_int() >> y.get_double();
    29. return is;
    30. }
    Alles anzeigen


    Danke schonmal, für jeden Hinsweis ;)

    LG.July
    Forza Italia!!!!!!