 |
C++Talk.NET
C++ language newsgroups
|
| View previous topic :: View next topic |
| Author |
Message |
Markus Raab
Guest
|
 Posted: Mon Feb 26, 2007 5:58 pm Post subject: Element-Templates |
 |
|
class Key {
public:
template <class T>
T get()
{}
template <class T>
void set(T x)
{}
};
Wie kann ich zu der Element-Template Methode get() und set(T x)
Spezialisierungen schreiben?
std::string s;
set(s);
funktioniert bereits, obwohl kein POD, ohne Spezialisierung, warum?
Der naive Ansatz
template <>
void Key::set<std::string>(std::string x)
{}
führt zu einer Mehrdeutigkeit bei set(std::string), warum wird nicht die
mehr spezialisierte Methode verwendet?
Will ich die Spezialisierung auch direkt als Element-Template schreiben,
bekomme ich den Fehler:
./include/key:51: error: explicit specialization in non-namespace
scope ?class kdb::Key?
../include/key:52: error: template-id ?set<std::string>? for ?void
kdb::set(std::string)? does not match any template declaration
../include/key:52: error: invalid function declaration
Auf Seite 371 von "Die C++ Programmiersprache" 4.te Deutsche Ausgabe sind
Element-Templates beschrieben. Es wird darauf hingewiesen, dass virtuelle
Element-Templates nicht unterstützt werden, allerdings kann ich nichts
betreffend Spezialisierungen finden. Wo wird detaillierter auf dieses Thema
eingegangen?
vielen Dank
mfg Markus
--
http://www.markus-raab.org | Die Klage über die Schärfe des
-o) | Wettbewerbes ist in Wirklichkeit meist nur
Kernel 2.6.18 /\ | eine Klage über den Mangel an Einfällen.
on a i686 _\_v | -- Walther Rathenau |
|
| Back to top |
|
 |
Thomas Maeder
Guest
|
| Posted: Tue Feb 27, 2007 3:34 am Post subject: Re: Element-Templates |
|
|
Markus Raab <usenet@markus-raab.org> writes:
| Quote: | class Key {
public:
template <class T
T get()
{}
template <class T
void set(T x)
{}
};
Wie kann ich zu der Element-Template Methode get() und set(T x)
Spezialisierungen schreiben?
|
Ich hab's mit XEmacs gemacht :-)
z.B.
template <>
int Key::get<int>()
{
}
| Quote: | std::string s;
set(s);
funktioniert bereits, obwohl kein POD, ohne Spezialisierung, warum?
|
Muss ein Compilerfehler sein, wenn das im globalen Namensraum steht
und übersetzt wird.
Wenn nicht, schreibe uns bitte, poste bitte das minimale Programm, wo
das funktioniert.
| Quote: | Der naive Ansatz
template
void Key::set<std::string>(std::string x)
{}
führt zu einer Mehrdeutigkeit bei set(std::string), warum wird nicht die
mehr spezialisierte Methode verwendet?
|
Für welches Programm? |
|
| Back to top |
|
|
Markus Moll
Guest
|
| Posted: Tue Feb 27, 2007 4:46 pm Post subject: Re: Element-Templates |
|
|
Hallo
Markus Raab wrote:
| Quote: | class Key {
public:
template <class T
T get()
{}
template <class T
void set(T x)
{}
};
Wie kann ich zu der Element-Template Methode get() und set(T x)
Spezialisierungen schreiben?
std::string s;
set(s);
funktioniert bereits, obwohl kein POD, ohne Spezialisierung, warum?
|
Was hat das mit PODs zu tun?
| Quote: | Der naive Ansatz
template
void Key::set<std::string>(std::string x)
{}
führt zu einer Mehrdeutigkeit bei set(std::string), warum wird nicht die
mehr spezialisierte Methode verwendet?
|
Das sollte schon gehen, außer... außer du hast bereits vor der
Deklaration der Spezialisierung set<std::string>() verwendet, so daß der
Compiler eine implizite Instantiierung vorgenommen hat (vornehmen mußte).
| Quote: | Will ich die Spezialisierung auch direkt als Element-Template schreiben,
bekomme ich den Fehler:
./include/key:51: error: explicit specialization in non-namespace
scope ?class kdb::Key?
|
Stimmt, denn das geht nicht. Die Spezialisierung für member templates
muß im die enthaltende Klasse umfassenden Namespace geschehen.
| Quote: | Auf Seite 371 von "Die C++ Programmiersprache" 4.te Deutsche Ausgabe sind
Element-Templates beschrieben. Es wird darauf hingewiesen, dass virtuelle
Element-Templates nicht unterstützt werden, allerdings kann ich nichts
betreffend Spezialisierungen finden. Wo wird detaillierter auf dieses Thema
eingegangen?
|
In TC++PL? Weiß ich gerade nicht, kann auch nicht nachsehen.
Markus |
|
| Back to top |
|
|
Markus Raab
Guest
|
| Posted: Wed Feb 28, 2007 11:00 pm Post subject: Re: Element-Templates |
|
|
Thomas Maeder wrote:
| Quote: | Markus Raab <usenet@markus-raab.org> writes:
Wie kann ich zu der Element-Template Methode get() und set(T x)
Spezialisierungen schreiben?
template
int Key::get<int>()
{
}
|
Ok, danke.
Da wird noch etwas an meinen Übersetzungseinheiten happern, siehe unten.
| Quote: | std::string s;
set(s);
funktioniert bereits, obwohl kein POD, ohne Spezialisierung, warum?
Muss ein Compilerfehler sein, wenn das im globalen Namensraum steht
und übersetzt wird.
Wenn nicht, schreibe uns bitte, poste bitte das minimale Programm, wo
das funktioniert.
|
#include <iostream>
#include <string>
#include <stdint.h>
class Key
{
public:
template <class T>
T get() {
T x; return x;
}
template <class T>
void set(T x) {
std::cout << x << std::endl;
}
};
void test_get ()
{
Key test;
test.set<int> (401);
test.get<int> ();
test.set<std::string> ("myoth");
test.get<std::string> ();
}
Hier funktioniert auch std::string.
| Quote: | Der naive Ansatz
template
void Key::set<std::string>(std::string x)
{}
führt zu einer Mehrdeutigkeit bei set(std::string), warum wird nicht die
mehr spezialisierte Methode verwendet?
Für welches Programm?
|
Obiges Programm steht in key.h und wird zu einer library gelinkt.
Wenn man jetzt in einem anderen Programm key.h inkludiert und zusätzlich die
library dazulinken will, passiert natürlich:
test.cpp:(.text+0x72): multiple definition of `void
Key::set<std::basic_string<char, std::char_traits<char>,
std::allocator<char> > >(std::basic_string<char, std::char_traits<char>,
std::allocator<char> >)
Wie man das jetzt machen kann ist nur noch interessehalber. Die Lösung mit
stringstreams operatoren << und >> zu implementieren ist eleganter als die
Spezialisierungen.
mfg Markus
--
http://www.markus-raab.org | Walking on water and developing software
-o) | from a specification are easy
Kernel 2.6.18 /\ | - if both are frozen
on a i686 _\_v | |
|
| Back to top |
|
|
Thomas Maeder
Guest
|
| Posted: Thu Mar 01, 2007 4:18 am Post subject: Re: Element-Templates |
|
|
Markus Raab <usenet@markus-raab.org> writes:
| Quote: | Muss ein Compilerfehler sein, wenn das im globalen Namensraum steht
und übersetzt wird.
Wenn nicht, schreibe uns bitte, poste bitte das minimale Programm, wo
das funktioniert.
#include <iostream
#include <string
#include <stdint.h
|
Wozu dieser Header?
| Quote: | class Key
{
public:
template <class T
T get() {
T x; return x;
}
template <class T
void set(T x) {
std::cout << x << std::endl;
}
};
void test_get ()
{
Key test;
test.set<int> (401);
test.get<int> ();
test.set<std::string> ("myoth");
test.get<std::string> ();
}
Hier funktioniert auch std::string.
|
Ok.
| Quote: | Der naive Ansatz
template
void Key::set<std::string>(std::string x)
{}
führt zu einer Mehrdeutigkeit bei set(std::string), warum wird
nicht die mehr spezialisierte Methode verwendet?
|
Meinst Du bei
test.set<std::string> ("myoth");
?
| Quote: |
Für welches Programm?
Obiges Programm steht in key.h und wird zu einer library gelinkt.
Wenn man jetzt in einem anderen Programm key.h inkludiert und zusätzlich die
library dazulinken will, passiert natürlich:
test.cpp:(.text+0x72): multiple definition of `void
Key::set<std::basic_string<char, std::char_traits<char>,
std::allocator<char> > >(std::basic_string<char, std::char_traits<char>,
std::allocator<char> >)
|
Du kannst natürlich die explizite Spezialisierung im Header
deklarieren und in einer Übersetzungseinheit definieren. So wie man's
mit anderen Funktionen auch macht. |
|
| Back to top |
|
|
Markus Raab
Guest
|
| Posted: Fri Mar 02, 2007 12:38 am Post subject: Re: Element-Templates |
|
|
Thomas Maeder wrote:
| Quote: | Markus Raab <usenet@markus-raab.org> writes:
Muss ein Compilerfehler sein, wenn das im globalen Namensraum steht
und übersetzt wird.
Wenn nicht, schreibe uns bitte, poste bitte das minimale Programm, wo
das funktioniert.
#include <iostream
#include <string
#include <stdint.h
Wozu dieser Header?
|
Gehört nicht zum minimalen Programm.
| Quote: | Der naive Ansatz
template
void Key::set<std::string>(std::string x)
{}
führt zu einer Mehrdeutigkeit bei set(std::string), warum wird
nicht die mehr spezialisierte Methode verwendet?
Meinst Du bei
test.set<std::string> ("myoth");
|
Da es ein Linker Fehler ist kann ich die Zeile nicht angeben ;)
Aber Key::set<std::basic_string...> ist schuld. Das ist in zwei
Übersetzungseinheiten definiert.
| Quote: |
Für welches Programm?
Obiges Programm steht in key.h und wird zu einer library gelinkt.
Wenn man jetzt in einem anderen Programm key.h inkludiert und zusätzlich
die library dazulinken will, passiert natürlich:
test.cpp:(.text+0x72): multiple definition of `void
Key::set<std::basic_string<char, std::char_traits<char>,
std::allocator<char> > >(std::basic_string<char, std::char_traits<char>,
std::allocator<char> >)
Du kannst natürlich die explizite Spezialisierung im Header
deklarieren und in einer Übersetzungseinheit definieren. So wie man's
mit anderen Funktionen auch macht.
|
Natürlich, vielen Dank für die Hilfe.
mfg Markus
--
http://www.markus-raab.org | Die Beleidigungen sind die Argumente jener,
-o) | die über keine Argumente verfügen. --
Kernel 2.6.18 /\ | J.J. Rousseau
on a i686 _\_v | |
|
| Back to top |
|
|
|
|
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
|
|
FAQ
Search
Memberlist
Usergroups
Register
Profile
Log in to check your private messages
Log in
