3 kurze anfängerfragen

hi,

ich lerne gerade c++ und habe jetzt 3 fragen zu operatoren, zeigern und templates:

1. ich weiß was operatoren sind und weclche es gibt, aber ich seh öfters funktionen oder klassen mit operatoren, also ungefähr so:

MeineKlasse MeineKlasse::operator+ (....) usw.

Das Problem ist, dass ich den Syntaxaufbau nicht ganz verstehe, vielleicht könnt ihr mir ja helfen
2. wie lange hat es bei euch gedauert, bis ihr zeiger verstanden habt und mit was (also tutorial, oder irgendwas anderes) habt ihr diese verstanden?
3. für was werden templates benötigt?

vielen dank schonmal

drakon

MeineKlasse MeineKlasse::operator+ (....)

Ist eigentlich genau gleich, wie bei normalen Funktionen:
Zuerst kommt der Rückgabetyp, dann gefolgt von Namen. (hier halt operator + ). Und MeineKlasse:: ist ja dazu da, um dem Compiler mitzuteilen, dass es keine freie Funktion ist, sondern eine Member von MeineKlasse .
Weiteres, und die man gewisse Operatoren implementiert siehe hier:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-232010.html

Phu. Ich fand Zeiger von Anfangan recht logisch und ich denke, dass ich es recht schnell kapiert habe. (Ich habe damals mit dem Buch C++ für Spieleprogrammierer angefangen). Mach am besten einfach ein paar Übungen und z.B Stringmanipulationen auf Basis von Zeiger, dann wirst du Zeiger, Arrays und ihr zusammenspiel recht schnell begreifen.

Templates sind schablonen (ohh, wär hätte das gedacht. :)), die dazu gedacht sind ganze Familien von Funktionen oder Klassen zu erzeugen, abhängig von einem, oder mehreren Typen. Am besten konsultierst du hier auch ein gutes Anfängerbuch, denn templates sind grundsätzlich auch nicht schwer zu verstehen. Man kann sehr viel damit machen und es kann sehr kompliziert werden, aber templates, wie sie am Anfang ihrer Entwicklung gedacht waren sind etwas sehr simples.

SeppJ

1. In C++ kann man eigene Operatoren definieren. Es gibt hier auf der Seite einen sehr guten Artikel dazu. Die Syntax ist die gleiche wie bei anderen Funktionen auch:

MeineKlasse MeineKlasse::operator+ (....)

Das erste ist der Rückgabewert. Es wird ein Objekt vom Typ MeineKlasse zurückgegeben.
Das MeineKlasse::operator+ ist der Name der Funktion. Man wird diesen natürlich nur selten so benutzen, da dann der ganze Witz von Operatoren verloren geht. Stattdessen schreibt man dann später um die Funktion zu benutzen:

objekt_vom_typ_MeineKlasse + irgendwas;

Das in den Klammern sind dann die Argumente. Der Plusoperator hat zwei Argumente, das was links vom + steht und das was rechts vom + steht. Die beiden müssen aber nicht unbedingt vom selben Typ sein.
Hier der Artikel dazu:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-232010.html

2. Pointer habe ich innerhalb weniger Minuten verstanden, im Infomatikunterricht mit TurboPascal. Unser Lehrer hat das anscheinend sehr gut erklärt, hatte nie wirklich Schwierigkeiten außer mit der Syntax.

3. Templates sind dafür gedacht, dass man typenunabhängigen Code schreibt. So muss man einen Algorithmus nur einmal schreiben und kann ihn für alle möglichen Datentypen verwenden. Ein gutes Beispiel sind die Container aus der STL: Es ist keine große Sache sich mit Pointern ein dynamisches Konstrukt zum Speichern von Integers zu schreiben, nennen wir es mal mein_dynamisches_array_fuer_ints. Wenn man solch ein Konstrukt erstmal hat und es für was anderes als int verwenden will, sagen wir char, dann kann man die gleichen Algorithmen verwenden, aber man muss überall int gegen char tauschen und bekommt dann mein_dynamisches_array_fuer_chars.
Dies für jeden Typ den man irgendwann einmal verwenden will zu machen ist viel unnötige Arbeit und man hat quasi den gleichen Code zigmal da stehen. Und da setzen Templates an: Man schreibt das ganze allgemein als Template und der Programmierer gibt dann an, welcher Typ verwendet werden soll. So kann man dann auch mein_dynamisches_array_fuer<MeineKlasse> verwenden, obwohl derjenige, der das dynamische Array geschrieben hat, vielleicht noch gar nichts von MeineKlasse gewusst hat.

empgodot

2. Ich hatte nen guten Lehrer, der das mal mit einem Schubladenregal erklärt hat, das ging ungefähr so:

Jede Variable ist eine Schublade, in der ein Zettel mit dem Wert der Variablen draufsteht. Die Schubladen sind außerdem nummeriert (=Speicheradresse) und können Namen haben (=Variablenname).

Ein Zeiger ist eine Schublade, in der ein Zettel liegt, auf dem die Nummer einer anderen Schublade steht.
Dann muss man eigentlich nur noch wissen, was die Operatoren tun.

Referenzieren:

int a = 5;
int *b = &a;

Man schreibt auf, welche Nummer (=Speicheradresse) die Schublade a hat und tut den Zettel in Schublade b.

Dereferenzieren:

*b

Man nimmt den Zettel aus Schublade b, da steht die Nummer von Schublade a drauf und da holt man den Wert raus.

Immer dieses Schubladendenken.

drakon

punk schrieb:

Immer dieses Schubladendenken.

Mir ist derselbe Spruch durch den Kopf.

5cript

immer wenn ein Lehrer "Schublade" sagt würde ich ihm jenige gern gegen den kopf schmeißen

EDIT: Mag ja gut zum erklären sein aber langsam nervts mich wenn das irgwer sagt. ^^

Nexus

punk schrieb:

Immer dieses Schubladendenken.

Hehe

Schubladen sind mir in C++ eigentlich eher als Metapher für Namensräume bekannt, wurde hier im Forum zumindest auch schon benutzt. Unter anderem, weil man sie mit using namespace so schön über den gesamten Zimmerboden (der meist sonst schon grausam überfüllt ist) ausleeren kann.