---

I en template funktion er det da muligt at oprette en pointer til den
datatype man har oprettet template funktionen med ?


Eks.

template<class T> void Saenkeslagskibe<T>::something() {
T Data = new T();
T->foo();
}

Ovenstående fkt. oprettes med class Koordinat som template parameter, er det
så muligt at oprette et objekt af koordinat-typen i selve funktionen ?

Pft.
Jens

---

Jens Vestergaard wrote:

> I en template funktion er det da muligt at oprette en pointer til den
> datatype man har oprettet template funktionen med ?


Ja

> Eks.
>
> template<class T> void Saenkeslagskibe<T>::something() {
> T Data = new T();

For at lave en pointer skal det se således ud:
T *Data = new T();

> T->foo();

Dette skulle nok have været:
Data->foo();

Husk at frigive hukommelsen igen:
delete Data;

> Ovenstående fkt. oprettes med class Koordinat som template parameter, er det
> så muligt at oprette et objekt af koordinat-typen i selve funktionen ?


Ja, det er det kontainere som list og vector gør.

Ivan Johansen

---

"Ivan Johansen" <NG@Padowan.dk> wrote in message
news:3C234A3E.4050700@Padowan.dk...
> Jens Vestergaard wrote:
>
> > I en template funktion er det da muligt at oprette en pointer til den
> > datatype man har oprettet template funktionen med ?
>
>
> Ja
>
> > Eks.
> >
> > template<class T> void Saenkeslagskibe<T>::something() {
> > T Data = new T();
>
> For at lave en pointer skal det se således ud:
> T *Data = new T();
>
> > T->foo();
>
> Dette skulle nok have været:
> Data->foo();
>
> Husk at frigive hukommelsen igen:
> delete Data;
>
> > Ovenstående fkt. oprettes med class Koordinat som template parameter, er
det
> > så muligt at oprette et objekt af koordinat-typen i selve funktionen ?
>
>
> Ja, det er det kontainere som list og vector gør.
>
> Ivan Johansen
>

Hvis template parameteren er en pointer til en datatype, skal jeg vel ikke:
T* Data = new T();
så er det vel korrekt med:
T Data = new T();
eller ?

Jeg har prøvet at få ovenstående til at virke, men forgæves.

På forhånd tak
Jens

---

Zimulated wrote:

> Hvis template parameteren er en pointer til en datatype, skal jeg vel

Lad som hovedregel være med at bruge pointer typer som template parametre.


> Jeg har prøvet at få ovenstående til at virke, men forgæves.

Sådan her:
-----------------------------------------------------------------
#include <iostream>

struct Skib {
Skib() { cout << "Skib()" << endl; }
void foo() { cout << "foo()" << endl; }
~Skib() { cout << "~Skib()" << endl; }
};

template<typename T>
struct SaenkeSlagskibe {
void something();
};

template<typename T>
void SaenkeSlagskibe<T>::something() {
T* data = new T();
data->foo();
delete data;
}

int main() {
SaenkeSlagskibe<Skib> spil;

spil.something();
}
-----------------------------------------------------------------

-Claus

---

Jeg har fået det til at virke nu, men jeg synes ikke begrundelsen for at man
ikke som hovedregel skal bruge pointere som template parameter er klar nok.
"Man skal undgå dem, med mindre man _vil_ have en pointer som parameter" Det
er vel essensen af det du skrev !?
Men hvad afholder mig så fra at _ville_ have en pointer som parameter ?

Mvh. / Tak for hjælpen
- Jens


>Fordi du i templates kan lave en pointer-type udfra en ikke-pointer
parameter
>men ikke omvendt. Undtagelse er selvfølgelig de steder, hvor du faktisk
ønsker
>en pointer type. F.eks list<int*> .

>I øvrigt: Skriv lige på gruppen i stedet. Så kan andre også være med.

>-Claus

> Hvad er grunden til at man som hovedregel skal undlade at bruge pointere
> som templateparametre ?

>- Jens

"Claus Rasmussen" <clr@cc-consult.dk> wrote in message
news:a0agh1$92s$1@sunsite.dk...
> Zimulated wrote:
>
> > Hvis template parameteren er en pointer til en datatype, skal jeg vel
>
> Lad som hovedregel være med at bruge pointer typer som template parametre.
>
>
> > Jeg har prøvet at få ovenstående til at virke, men forgæves.
>
> Sådan her:
> -----------------------------------------------------------------
> #include <iostream>
>
> struct Skib {
> Skib() { cout << "Skib()" << endl; }
> void foo() { cout << "foo()" << endl; }
> ~Skib() { cout << "~Skib()" << endl; }
> };
>
> template<typename T>
> struct SaenkeSlagskibe {
> void something();
> };
>
> template<typename T>
> void SaenkeSlagskibe<T>::something() {
> T* data = new T();
> data->foo();
> delete data;
> }
>
> int main() {
> SaenkeSlagskibe<Skib> spil;
>
> spil.something();
> }
> -----------------------------------------------------------------
>
> -Claus
>
>

---

Jens Vestergaard wrote:

> Jeg har fået det til at virke nu, men jeg synes ikke begrundelsen for at
> man ikke som hovedregel skal bruge pointere som template parameter er klar
> nok. "Man skal undgå dem, med mindre man _vil_ have en pointer som
> parameter" Det er vel essensen af det du skrev !?

Nemlig.

> Men hvad afholder mig så fra at _ville_ have en pointer som parameter ?

Lad os tage et eksempel. Du har to klasser, som du gerne vil have til at
pege på hinanden (via pointere):

template<typename T>
struct A {
T* other;

T& get_other() { return *other; }
};

template<typename T>
struct B {
T* other;

T& get_other() { return *other; }
};

Objekter af disse to klasser peger på hinanden, men har /ikke/ en pointer
parameter. Det udnyttes til at danne en reference til typen T i funktionen
get_other. Sammenlign med:

template<typename TP>
struct C {
TP other; // Ok.

(*TP) get_other() { return *other; } // Fejl.
};

Pointen er, at du kan ikke på nogen måde kan få get_other til at returnere
en reference, hvis du indrettede dine klasser til at have en pointer som
parameter. Der er ikke nogen vej i C++, hvis du vil finde den type, som
en pointer peger på (*).

Altså: Du kan gå fra en ikke-pointer til en pointer, men ikke omvendt. Du
har altså langt større fleksibilitet, når du bruger ikke-pointere som
template parameter, end når du ikke gør.

-Claus


*) Det er faktisk ikke helt korrekt. Men måden man gør det på er så
horribelt kompliceret, at det i praksis kun bruges i meget specielle
tilfælde (som når man skriver libraries).