funktions-template Spezialisierung

leo aka qsch

funktioniert leider noch immer nicht

phlox81

welcher Compiler ?

leo aka qsch

momentan versuche ich es mit dem vc7.1, werd es schnell mal mit dem g++ 3.3 probieren

ssm

[quote="leo aka qsch"]ich habe hier ein Problem mit folgendem Funktions-Template

ich sehe kein Funkions-Template

meinst du Overloading oder was?
geht einfach so:

namespace myctrl
{
   bool dualctrl::isless(const dualctrl &, const dualctrl &)
   {
      //...
   }
}

er meint friend...

template<class T>void foo(T){};

class bar
{
    template<class T>
    friend void foo(T);
};

Sowas wie partielle friends gibts meines Wissens nach nicht...
Bin mir nicht sicher ob das so stimmt, aber bei template-klassen geht das so...

leo aka qsch

ich meine eine Spezialisierung der Funktion isless auserhalb der Klasse, das friend verwend ich ja nur um auf die privaten Member der dualctrl Klasse von ausen Zugriff zu erhalten

freshman

probiere es doch mal so:

// in der datei base.h
namespace myctrl
{
  class dualctrl	
  {
    public:
      // ..
      friend bool isless(const dualctrl &, const dualctrl &);

    private:
      // ..
  };//end of class
  bool isless(const dualctrl &, const dualctrl &)
  {
    // ...implementieren...
  }
};//end of namespace

[edit]peinliche Fehler beseitigt
ich weiß ja nicht wie daeine Klasse so aussieht, aber falls du deine getter inline definiert hast, kannst du die isless Funktion als freie Funktion definieren, in der du mir den gettern arbeitest; dann wäre es genau so performant wie eine friend-Funktion, da kein overhead. Ist aber nur so ein Vorschlag

Demoncleaner

ich meine eine Spezialisierung der Funktion isless auserhalb der Klasse, das friend verwend ich ja nur um auf die privaten Member der dualctrl Klasse von ausen Zugriff zu erhalten

Ein Template is ja gerade dazu da um eine Funktion unabhängig vom Typ
zu definieren / implementieren.

Schau mal da:

// in der datei base.h
namespace myctrl
{
    class dualctrl   
        {
    public:
            // ..   
        template<typename T> friend bool isless(const T& para1, const T& para2); // nur deklaration

    private:
        // ..
    }; 
};

template<typename T> bool myctrl::isless(const T& para1, const T& para2){  //definition

        //do something with para1 and para2
}

int main(){

        myctrl::dualctrl s;
        myctrl::isless<myctrl::dualctrl>(s, s); //aufruf
}

//edit ich glaube ich hab dein Problem erkannt? Aber wozu brauchst du dafür ein Template?:

template<>
    bool myctrl::isless<dualctrl> (const dualctrl &, const dualctrl &)

Wenn dus doch aus irgendwelchen Gründen brauchen solltest mach halt ne Mischform
aus meinen obigen Bsp.

Cheers
Demoncleaner

leo aka qsch

Demoncleaner schrieb:

Ein Template is ja gerade dazu da um eine Funktion unabhängig vom Typ
zu definieren / implementieren.

ja das ist mir schon klar, aber ich wollte die Funktion ja irgendwo auserhalb spezialisieren

Demoncleaner

Spezialiesieren kann man templates nur bei der Verwendung eines solchen,
aber nicht bei der Definition/Implementierung. Was sollte das für einen
Sinn machen?

Demoncleaner

Jester

@Demoncleaner: kann es sein, daß Du spezialisieren und instaziieren verwechselst?

Spezialisieren bezieht sich darauf für einen bestimmten Typ eine spezialisierte Version zu schreiben.

template <typename T> machwas(T x)
{
  // mach sehr aufwendige Sachen mit x
}

template<> machwas<MeinObject>(MeinObject x)
{
 // mit MeinObject kann man das viel effizienter erledigen
}

Was spricht eigentlich gegen einen eigenen Overload, wenn es sich nur um einen konkreten Typ handelt?

MfG Jester

Demoncleaner

Ok dann schein ich da was missverstanden zu haben.

template<> machwas<MeinObject>(MeinObject x)
{
 // mit MeinObject kann man das viel effizienter erledigen
}

Aber was für einen Sinn macht da das Template wenn die Funktion (wie in
leos Beispiel) nicht überladen wird und vor allen Dingen nicht mit
Template Parametern deklariert wurde?

Demoncleaner

leo aka qsch

demoncleaner:
ich verstehe momentan nicht was du mir sagen willst..

es ist ja nicht immer moeglich, ein Funktions-Template so einzurichten, dass es sich fuer jeden Typ eignet, darum will ich es ja fuer einen bestimmten Typ speziallisieren.

edit: der post kamm etwa zu spaet

Jester

@leo: warum überlädst Du die Funktion nicht einfach mit den passenden Parametertypen? Das gibt dann einen besseren match als die templates. Partiell spezialisieren lassen sich Funktionstemplates eh nicht.

MFG Jester