C++ Probleme mit std::to_string

[Life Sucks]

beim Debuggen kommt folgen Fehlermeldung:

Fehler C2665 "std::to_string": Durch keine der 9 Überladungen konnten alle Argumenttypen konvertiert werden. 09-03 c:\...\my_templlist.cpp 32

Die Variante ohne Templates funktioniert super. Sitze seit stunden daran und finde keine Lösung.
Zur Info: Ich müsste eine einfache verkettete Liste in Benutzung von Templates erstellen.

my_templist.cpp:

#include "my_templlist.h"

template <typename T>
void hinten_anfuegen(TListenKnoten<T>* &anker, const T wert)
{
    TListenKnoten<T> *neuer_eintrag = new TListenKnoten<T>;
    neuer_eintrag->data = wert;
    neuer_eintrag->next = nullptr;
    if (anker == nullptr)
        anker = neuer_eintrag;
    else
    {
        TListenKnoten<T> *ptr = anker;
        while (ptr->next != nullptr)
            ptr = ptr->next;
        ptr->next = neuer_eintrag;
    }
}

template <typename T>
std::string liste_als_string(TListenKnoten<T>* anker)
{
    std::string resultat = "";
    if (anker == nullptr)
        return "Leere Liste."; // Zeile geändert !!!!!!!!!!!!!!
    else
    {
        resultat += "[ ";
        TListenKnoten<T> *ptr = anker;
        do
        {
            resultat += std::to_string(ptr->data);
            if (ptr->next != nullptr) resultat += " , ";
            else resultat += " ";
            ptr = ptr->next;
        } while (ptr != nullptr);
        resultat += "]";
    }
    return resultat;
}

template <typename T>
void liste_ausgeben(TListenKnoten<T>* anker)
{
    std::cout << liste_als_string(anker) << std::endl;
}

template <typename T>
void vorne_anfuegen(TListenKnoten<T>* &anker, const T wert)
{
    TListenKnoten<T> *neuer_eintrag = new TListenKnoten<T>;
    neuer_eintrag->data = wert;
    neuer_eintrag->next = nullptr;
    int x = 0;
    if (anker == nullptr)
        anker = neuer_eintrag;
    else
    {
        neuer_eintrag->next = anker;
        anker = neuer_eintrag;
    }
}

template <typename T>
void liste_loeschen(TListenKnoten<T>* &anker)
{
    TListenKnoten<T>* ptr = anker, *ptr2 = nullptr;
    while (ptr != nullptr)
    {
        ptr2 = ptr->next;
        delete ptr;
        ptr = ptr2;
    }
    anker = nullptr;

}

template <typename T>
T liste_aufaddieren(const T var_a, const T var_b)
{
    return var_a + var_b;
}


// Expliziete Instanziierungen
template struct TListenKnoten<int>;
template void hinten_anfuegen<int>(TListenKnoten<int> *&anker, const int wert);
template std::string liste_als_string<int>(TListenKnoten<int> * anker);
template void liste_ausgeben<std::string>(TListenKnoten<std::string> * anker);
template void vorne_anfuegen<int>(TListenKnoten<int> *&anker, const int wert);
template void liste_loeschen<int>(TListenKnoten<int>* &anker);

my_templlist.h:

#pragma once
#include <iostream>
#include <string>

template <typename T> struct TListenKnoten
{
    T data;
    TListenKnoten<T> *next;
};
template <typename T>
void hinten_anfuegen(TListenKnoten<T>* &anker, const T wert);

template <typename T>
std::string liste_als_string(TListenKnoten<T>* anker);

template <typename T>
void liste_ausgeben(TListenKnoten<T>* anker);

template <typename T>
void vorne_anfuegen(TListenKnoten<T>* &anker, const T wert);

template <typename T>
void liste_loeschen(TListenKnoten<T>* &anker);

template <typename T>
T liste_aufaddieren(const T var_a, const T var_b);

main.cpp:

#include <iostream>
#include <string>
using namespace std;

#include "my_templlist.h";

int main()
{
    int laenge = 3;
    TListenKnoten<int> *anker = nullptr;
    liste_ausgeben(anker);


    /*for (int i = 0; i < laenge; i++)
        hinten_anfuegen<int>(anker, i*i);
    liste_ausgeben(anker);

    for (int i = 0; i < laenge; i++)
        vorne_anfuegen<int>(anker, i*i);
    liste_ausgeben(anker);

    liste_loeschen<int>(anker);

    for (int i = 0; i < laenge; i++)
        vorne_anfuegen<int>(anker, i*i);
    liste_ausgeben(anker);

    for (int i = 0; i < laenge; i++)
        vorne_anfuegen<int>(anker, i*i);
    liste_ausgeben(anker);*/



    system("PAUSE");
    return 0;
}

 

[F.b]

Du versuchst in der my_templist.cpp liste_ausgeben<std::string> zu kompilieren, welche wiederunm liste_als_string<std::string> benutzt. Da std::to_string keine Überladung für std::string hat (warum auch immer), funktioniert das nicht. Du bräuchtest im Prinzip eine Spezialisierung für den Fall, dass du eine Liste hast, die schon strings speichert.

Unabhängig davon hast du in der main.cpp nen extra Semikolon hinter dem include, welches da nicht hingehört. Ich bin mir auch nicht sicher, warum deine Funktionen Referenzen auf Pointer übergeben bekommen anstatt einfach nur Referenzen, hat aber mit dem Problem nichts zu tun.

EDIT: so wie deine main-Funktion aufgebaut ist, wirst du spätestens zur Laufzeit Probleme bekommen, denn dein List-Pointer "anker" ist ein nullptr und zeigt nicht auf ein valides Objekt.

 

[Life Sucks]

Erstmal einen großen Dank für deine Hilfe. Nach mehrmals durchlesen habe ich nun endlich verstanden was du meintest. Meine main.cpp ich noch nicht vollständig. Ich wollte erstmal das to_string Fehler lösen.
Mein fehler war:

template void liste_ausgeben<std::string>(TListenKnoten<std::string> * anker);

die<std::string> sollten <int> sein. Einen String in einen String muss man nicht umwandeln glaube ich, daher denke ich auch das deine Überladung stattgefunden hat. Korrigier mich wenn ich mit meiner Begründung falsch liege.

 

[F.b]

Ich versteh nicht ganz was du meinst. Die Funktion 'std::to_string' hat ne bestimmte Anzahl an Überladungen (für int, long, float etc). Für std::string ist sie NICHT überladen. Ob das gehen würde oder nicht ist dabei unerheblich. Aber wenn es für strings eh nicht gehen soll/muss, dann kannst du dir den check natürlich sparen.

 

[Life Sucks]

Wenn ich jetzt Inhalt von TListenKnoten von typ String setzte ist das irgendwie falsch. In allen anderen Funktionen ist das von Typ int und auf einmal soll das ein String sein. Macht halt kein Sinn. Der wert in jedem knoten ist ein int wert. Die Funktion soll einen int wert nehmen und in einem String umwandeln.

 

[F.b]

Wieso wäre das falsch? Der Sinn und Zweck von Templatisierung ist doch, dass man die Liste mit verschiedenen Typen Instantiieren kann. D.h. warum soll es denn keine Liste mit strings geben? Oder float, oder unsigned long long etc.