ich raffs nich

mc_ginley

hallo,

ich bastel eine einfache c++ anwendung. da ich schwerpunktmäßig was in c++ lernen will wollt ich mal nich nur char[..] und so weiter rumfuchteln.
zum einlesen einer datei wollte ich ifstream verwenden. also unter visual stuio 6.0 hab ich das ja alles irgendwie noch geblickt, aber nun hab ich .net (obwohl ich eigentlich nur c++ mache, da is die entwicklungsumgebung schöner) .
und da sieht die definition (mal abgesehen dass es da ein ifstream und ein basic_ifstream gibt) so aus:

typedef basic_ifstream<char, char_traits<char> > ifstream;

so was is das nun bitteschön? wieso laufen mir in letzter zeit immer diese spitzen klammern übern weg? gibts das schon immer? mir sagt das überhauptnichts. kann mir das ma jemand erklärn?

gruß

HumeSikkins

mc_ginley schrieb:

und da sieht die definition (mal abgesehen dass es da ein ifstream und ein basic_ifstream gibt) so aus:
typedef basic_ifstream<char, char_traits<char> > ifstream;

So sieht die Definition auch unter dem VC 6.0 aus. Zumindest, wenn du den Standardheader <fstream> statt der alten Nicht-Standard-Streams <fstream.h> verwendest.

so was is das nun bitteschön?

basic_ifstream ist eine Templateklasse die zwei Templateparameter erwartet.

ifstream ist ein typedef für die basic_ifstream-Klasse das die beiden Templateparameter mit char und char_traits<char> belegt.

ifstream ist also eine Streamklasseninstanz für normale zeichenbasierte Dateieingabe.

http://www.c-plusplus.net/forum/viewtopic.php?t=39469

japro

das sind templates (vgl. irgendein gescheites c++ buch).

otze

das was du in den eckigen klammern siehst nennt sich: explizite template instantiierung.

templates dienen dazu,klassen, funktionen, methoden usw auf verschiedene datentypen portabel zu machen(zb dass der erste parameter von einem beliebigen typ sein kann,also int char,long...).
dabei werden in den klassen platzhalter verwendet, welche dann normalerweise vom programm den richtigen typ zugewiesen bekommen.
bei der expliziten instantiierung wählt einfach nur der programmierer aus, für was für einen typ die klasse ausgelegt ist.

hier die erklärung zu char traits<>

The template structure char_traits<charT> defines the types and functions necessary to implement the iostreams and string template classes. It is templatized on charT, which represents the character container type. Each specialized version of char_traits<charT> includes the default definitions corresponding to the specialized character container type.

HumeSikkins

das was du in den eckigen klammern siehst nennt sich: explizite template instantiierung.

Nö. Nennt es sich nicht.
Hier ist nirgends eine explizite Template-Instanziierung in Sicht (eine explizite Template-Instanziierung beginnt *immer* mit template)
Genaugenommen ist hier überhaupt keine Instanziierung vorhanden. Weder eine implizite noch eine explizite.

welche dann normalerweise vom programm den richtigen typ zugewiesen bekommen.
bei der expliziten instantiierung wählt einfach nur der programmierer aus, für was für einen typ die klasse ausgelegt ist.

Bei einer Template-Klasse muss der Typ *immer* explizit angegeben werden. Das hat aber nichts mit expliziter Template-Instanziierung zu tun. Ich glaube du verwechselst die Begriffe hier ein wenig.

otze

stimmt ich habs mit der expliziten instantiierung für template funktionen verwechselt, da geht das nämlich(nach ANSI)...

Genaugenommen ist hier überhaupt keine Instanziierung vorhanden. Weder eine implizite noch eine explizite.

genaugenommen hast du recht, es ist eine typedef, andererseits würde das benutzen von ifstream eine implizite instantiierung erzeugen.

deshalb sind deine folgenden aussagen falsch:

eine explizite Template-Instanziierung beginnt *immer* mit template

->funktionstemplates( min<long>(x,y); )

Bei einer Template-Klasse muss der Typ *immer* explizit angegeben werden

basic_ifstream<char, char_traits<char> > Instanz_der_Klasse;//implizit
template class Stack<long double,50>;//explizit

mc_ginley

ok danke. zumindest ein kleiner lichtblick. mit templates usw hab ich noch nie was zu tun gehabt.
ich hab mein ifstream ding dann aber noch auf die reihe bekommen.
is auf jeden fall ne sehr unübersichtliche sache irgendwie.
sollte mir wohl mal ein gescheites c++ buch holen

ciao

HumeSikkins

otze schrieb:

deshalb sind deine folgenden aussagen falsch:

eine explizite Template-Instanziierung beginnt *immer* mit template

->funktionstemplates( min<long>(x,y); )

Tu mir bitte den Gefallen und versuche nicht mich über Dinge aufzuklären von denen ich scheinbar mehr Ahnung habe also du.

Wie man im Standard unter 14.7.2 eindeutig nachlesen kann, beginnt eine explizite Template-Instanziierung immer mit template.
Für ein Funktionstemplate sieht das so aus:

// Template-Funktion
template <class T>
void func(T* p) {}

// explizite Instanziierung für T = int
template void func<int>(int* p);
// oder auch
template void func(int* p);

otze schrieb:

Bei einer Template-Klasse muss der Typ *immer* explizit angegeben werden
basic_ifstream<char, char_traits<char> > Instanz_der_Klasse;//implizit

Dein Kommentar sagt zwar implizit, das ändert aber nichts daran, dass du die Parameter hier *explizit* angibst. Implizit Herleitung von Template-Parameter gibt es *nur* bei Funktionstemplates.
Also nocheinmal: Zur Instanziierung einer Templateklasse müssen die Template-Parameter *immer* explizit angegeben werden. Punkt. Mehr habe ich nicht gesagt. Das darfst du natürlich nicht mit einer "expliziten Template-Instanziierung" verwechseln.

Zusammengefasst:
1. Man unterscheidet implizite und explizite Template-Instanziierung, implizite und explizite Template-Argument-Spezifikation und explizite und partielle Spezialisierung.

2. Eine explizite Template-Instanziierung beginnt *immer* mit template

3. Template-Argumente von Klassentemplates müssen *immer* explizit angegeben werden.

4. Template-Argumente von Funktionstemplates können häufig *implizit* hergeleitet werden.

5. Es gibt explizite Template-Instanziierungen von Funktionstemplates mit *impliziter* Template-Argument-Herleitung.

6. Es gibt implizite Template-Instanziierungen von Funktionstemplates mit *expliziter* Template-Argument-Spezifikation.

7. Nur Klassentemplates können partiell spezialisiert werden.
Es gibt *keine* partielle Spezialisierung von Funktionstemplates.

8. Es gibt *keine* explizite Template-Instanziierungen eines Klassentemplates mit *impliziter* Argumentherleitung.

9. Es gibt *keine* implizite Template-Instanziierung eines Klassentemplates ohne *explizite* Template-Argument-Spezifikation.

10. Weder explizite noch partielle Spezialisierung darf man mit einer Spezialisierung verwechseln. Als Spezialisierung bezeichnet man das Ergebnis der Ersetzung von Templateparamtern mit aktuellen Argumenten. Eine Spezialisierung erhält man also entweder durch eine Instanziierung oder durch eine explizite Spezialisierung.

11. Ein typedef auf eine Templatespezialisierung führt *nicht* zur Instanziierung eines Templates.