"Neudefinition des Standardparameters" bei Template-Spezialisierung

[energyzer]

Und was kann ich nun tun?

Es muss doch für so ein einfaches Problem auch eine Lösung geben, oder?

// Edit: Wenn ich dich richtig verstehe Hume ist es ganz egal, ob die
Spezialisierung Default-Argumente hat, weil die schon vorher bearbeitet wurden?
d.h. ich kann diese weglassen und der Compiler würde sich auch in der string
Version meines Templates verwenden?

[HumeSikkins]

EnERgYzEr schrieb:

Es muss doch für so ein einfaches Problem auch eine Lösung geben, oder?

ALso deinem Code nach zu Urteilen hast du sowieso kein Problem, da du *exakt* den selben Standardparameter verwendest. Wozu also die Redefinition?

Wenn du wirklich einen anderen Default-Wert brauchst, dann kannst du dies z.B.
erreichen in dem zu statt Template-Funktionen auf Template-Klassen umsteigst:

template <class T>
struct AttributeValue
{
static string get(string attribute, string tag, string parent="", T stdValue = T())
{
    return "";
}
};

template <>
struct AttributeValue<string>
{
static string get(string attribute, string tag, string parent="Foo", string stdValue = "Bar")
{
    return "";
}
};

Dazu kannst du jetzt z.B. noch ein generisches Template-Funktions-Interface basteln:

template <class T>
T GetAttributeValue(string attribute, string tag)
{
    return AttributeValue<T>::get(attribute, tag);
}

template <class T>
T GetAttributeValue(string attribute, string tag, string parent)
{
    return AttributeValue<T>::get(attribute, tag, parent);
}

template <class T>
T GetAttributeValue(string attribute, string tag, string parent, T stdValue)
{
    return AttributeValue<T>::get(attribute, tag, parent, stdValue);
}

Und schwupps:

int main()
{
    GetAttributeValue<int>("a", "b");     // parent ist "" und stdValue ist 0
    GetAttributeValue<string>("a", "b");  // parent ist "foo" und stdValue ist "bar"
}

[otze]

man könnte es aber auch so machen:

template <class T>
T GetAttributeValue(string attribute, string tag, string parent, T stdValue)
{
[...]
}

template <>
string GetAttributeValue<string>(string attribute, string tag, string parent, string stdValue)
{
[...]
}

template <class T>
T GetAttributeValue(string attribute, string tag)
{
    return GetAttributeValue<T>(attribute,tag,"",T());
}
template <class T>
T GetAttributeValue(string attribute, string tag,string parent)
{
    return GetAttributeValue<T>(attribute,tag,parent,T());
}

da muss man nicht mehr soviel dran ändern...

[HumeSikkins]

otze schrieb:

man könnte es aber auch so machen:

[...]
man hat zwar nicht ganz soviele freiheiten, aber es funktioniert...

Was erreichst du mit deiner Lösung? Du hast auch hier nur einen Satz Def-Werte also keinen Vorteil gegenüber der Originalversion.

[otze]

die templates kann man ja auch überladen...
besides kann deine version probleme bereiten, wenn sich das ganze in einer Klasse abspielt, dh dein workaround eine nested class ist, woher will die die infos über das bekommen, was sich in der Mutterklasse abspielt?

[energyzer]

Da mein Edit glaube ich untergegangen ist, poste ich es hier noch mal

// Edit: Wenn ich dich richtig verstehe Hume ist es ganz egal, ob die
Spezialisierung Default-Argumente hat, weil die schon vorher bearbeitet wurden?
d.h. ich kann diese weglassen und der Compiler würde sich auch in der string
Version meines Templates verwenden?

[HumeSikkins]

otze schrieb:

die templates kann man ja auch überladen...

Verstehe ich nicht. Ich dachte hier geht es um das Problem "unterschiedliche Def-Werte" wobei *du* gleichzeitig gefordert hast, dass alle Funktionen Templates sein müssen. Inwiefern hilft dir da jetzt Überladung? Hast du da vielleicht mal ein konkretes Beispiel?

besides kann deine version probleme bereiten, wenn sich das ganze in einer Klasse abspielt, dh dein workaround eine nested class ist, woher will die die infos über das bekommen, was sich in der Mutterklasse abspielt?

Verstehe ich nicht. Ich sehe hier weder Mütter noch Klassen. Meine Lösung kann z.B. auch Probleme bereiten, wenn das Programm gar nicht in C++ sondern in Brainfuck geschrieben ist

[energyzer]

HumeSikkins schrieb:

Verstehe ich nicht. Ich dachte hier geht es um das Problem "unterschiedliche Def-Werte" wobei *du* gleichzeitig gefordert hast, dass alle Funktionen Templates sein müssen. Inwiefern hilft dir da jetzt Überladung? Hast du da vielleicht mal ein konkretes Beispiel?

Ich glaube wir reden aneinander vorbei... Die Default-Werte sollen
gleich sein! Nur er will halt nicht, wegen diesen Fehlermeldungen

[HumeSikkins]

EnERgYzEr schrieb:

Ich glaube wir reden aneinander vorbei... Die Default-Werte sollen
gleich sein! Nur er will halt nicht, wegen diesen Fehlermeldungen

Ist das hier sowas ähnliches wie "Versteckte Kamera" oder "Verstehen Sie Spaß"?

Wenn die Default-Werte gleich sein sollen, dann hast du wie gesagt doch überhaupt kein Problem.
Lass sie bei der Spezialisierung schlicht und einfach weg. Sie gelten ja, wie ich in meinem ersten Beitrag bereits geschrieben habe, implizit auch für die Spezialisierung.

template <class T>
void func(T a = T());
template<>
void func(int a);

int main()
{
    func<string>(); // Ok. Primary-Template mit a = string()
    func<int>(); // Ok. Spezialisierung mit a = 0
}

[energyzer]

Genau das war meine Frage Ich hatte das genauso verstanden - nur kamen dann
eure ganzen neuen Postings, wo ihr über verschiedene Default-Werte geredet habt,
weswegen ich etwas verwirrt war...

Aber nochmal danke euch beiden!!