 |
C++Talk.NET
C++ language newsgroups
|
| View previous topic :: View next topic |
| Author |
Message |
Kai Ruhnau
Guest
|
 Posted: Mon Nov 10, 2003 9:16 am Post subject: Function => Functor |
 |
|
Hi NG,
Ich suche eine Möglichkeit, aus Funktionen einen Funktor zu machen, der
letztendlich nur die Funktion aufruft. Es muss nur eine Funktion mit einem
Parameter und Rückgabewert sein. Letztendlich etwas der Art:
template<class F>
class Adapter
{
public:
template <typename S>
S operator()(S x)
{
return F(x);
}
};
Und dann Adapter<std::cos> beispielsweise (auch wenn das so noch nicht
geht).
Das Membertemplate ist nicht so wichtig, wäre aber hübsch.
Gibts da eine schöne Lösung, ohne dass ich all die Adapter, die ich will,
von Hand schreiben muss?
Grüße
Kai
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
 |
Christoph Rabel
Guest
|
| Posted: Mon Nov 10, 2003 10:11 am Post subject: Re: Function => Functor |
|
|
Kai Ruhnau wrote:
| Quote: | Ich suche eine Möglichkeit, aus Funktionen einen Funktor zu machen, der
letztendlich nur die Funktion aufruft. Es muss nur eine Funktion mit einem
Parameter und Rückgabewert sein. Letztendlich etwas der Art:
Gibts da eine schöne Lösung, ohne dass ich all die Adapter, die ich
will,
von Hand schreiben muss?
|
Schau dir mal Loki an:
http://sourceforge.net/projects/loki-lib/
Kann allerdings manche Compiler umbringen.
mfg
Christoph
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
|
Rolf Magnus
Guest
|
| Posted: Mon Nov 10, 2003 11:09 am Post subject: Re: Function => Functor |
|
|
Kai Ruhnau wrote:
| Quote: | Hi NG,
Ich suche eine Möglichkeit, aus Funktionen einen Funktor zu machen,
der letztendlich nur die Funktion aufruft. Es muss nur eine Funktion
mit einem Parameter und Rückgabewert sein. Letztendlich etwas der Art:
template
class Adapter
{
public:
template
S operator()(S x)
{
return F(x);
}
};
|
Wozu das ganze? Keiner der Vorteile eines Funktionsobjektes lässt sich
durch deinen Adapter nutzen. Außerdem gibt's schon einen Adapter in der
Standardbibliothek, der ptr_fun() heißt.
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
|
Kai Ruhnau
Guest
|
| Posted: Mon Nov 10, 2003 11:15 pm Post subject: Re: Function => Functor |
|
|
Rolf Magnus wrote:
| Quote: | Kai Ruhnau wrote:
Hi NG,
Ich suche eine Möglichkeit, aus Funktionen einen Funktor zu machen,
der letztendlich nur die Funktion aufruft. Es muss nur eine Funktion
mit einem Parameter und Rückgabewert sein. Letztendlich etwas der Art:
template
class Adapter
{
public:
template
S operator()(S x)
{
return F(x);
}
};
Wozu das ganze? Keiner der Vorteile eines Funktionsobjektes lässt sich
durch deinen Adapter nutzen. Außerdem gibt's schon einen Adapter in der
Standardbibliothek, der ptr_fun() heißt.
|
Ich bringe dem Compiler gerade das Differenzieren bei (Über Sinn kann man
streiten, aber ich hab Langeweile) und habe nach einer einfachen
Möglichkeit gesucht, die ohnehin schon vorhandenen Funktionen aus cmath in
Klassen zu "übersetzen", mit denen ich dann Templates instanzieren kann.
Die dann instanzierten Template-Klassen sollen später im Laufenden Programm
wie der Aufruf der ursprünglichen Funktion benutzt werden.
Wenn es keinen Template-Weg gibt, werd ich mir halt mit Makros helfen.
#define Adapter_dekl(fkt) class Adapter_##fkt {
....
#define Adapter(fkt) Adapter_##fkt
Oder so ähnlich
Grüße
Kai
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
|
Rolf Magnus
Guest
|
| Posted: Tue Nov 11, 2003 12:06 pm Post subject: Re: Function => Functor |
|
|
Kai Ruhnau wrote:
| Quote: | Rolf Magnus wrote:
Kai Ruhnau wrote:
Hi NG,
Ich suche eine Möglichkeit, aus Funktionen einen Funktor zu machen,
der letztendlich nur die Funktion aufruft. Es muss nur eine Funktion
mit einem Parameter und Rückgabewert sein. Letztendlich etwas der
Art:
template<class F
class Adapter
{
public:
template
S operator()(S x)
{
return F(x);
}
};
Wozu das ganze? Keiner der Vorteile eines Funktionsobjektes lässt
sich durch deinen Adapter nutzen. Außerdem gibt's schon einen Adapter
in der Standardbibliothek, der ptr_fun() heißt.
Ich bringe dem Compiler gerade das Differenzieren bei (Über Sinn kann
man streiten, aber ich hab Langeweile) und habe nach einer einfachen
Möglichkeit gesucht, die ohnehin schon vorhandenen Funktionen aus
cmath in Klassen zu "übersetzen", mit denen ich dann Templates
instanzieren kann. Die dann instanzierten Template-Klassen sollen
später im Laufenden Programm wie der Aufruf der ursprünglichen
Funktion benutzt werden.
|
Mit den Standard-Templates kannst du das z.B. so machen:
#include
#include <cmath>
#include <iostream>
int main()
{
using namespace std;
pointer_to_unary_function<double, double> functor(&sin);
std::cout << "Der Sinus von 0.5 ist " << functor(0.5) << 'n';
}
Aber was das jetzt bringen soll, ist mir nicht klar.
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
|
Kai Ruhnau
Guest
|
| Posted: Wed Nov 12, 2003 5:18 pm Post subject: Re: Function => Functor |
|
|
(Dieser Beitrag über google ist bisher nicht erschienen, deshalb schicke
ich ihn nochmal. Ich entschuldige mich für eventuelle Mühen der Moderation
 )
Rolf Magnus wrote:
| Quote: | Kai Ruhnau wrote:
[...]
Ich bringe dem Compiler gerade das Differenzieren bei (Über Sinn kann
man streiten, aber ich hab Langeweile) und habe nach einer einfachen
Möglichkeit gesucht, die ohnehin schon vorhandenen Funktionen aus
cmath in Klassen zu "übersetzen", mit denen ich dann Templates
instanzieren kann. Die dann instanzierten Template-Klassen sollen
später im Laufenden Programm wie der Aufruf der ursprünglichen
Funktion benutzt werden.
Mit den Standard-Templates kannst du das z.B. so machen:
#include <functional
#include
#include
int main()
{
using namespace std;
pointer_to_unary_function
std::cout << "Der Sinus von 0.5 ist " << functor(0.5) << 'n';
}
Aber was das jetzt bringen soll, ist mir nicht klar.
|
Ja, das ist das, was prinzipiell bei der Laufzeit rauskommen soll.
Was ich zusätzlich noch haben möchte ist folgendes:
Struktur bisher:
------Schnipp--------
template
class Add
{
public:
typedef Add<typename T::Result, typename U::Result> Result;
template<typename S>
S operator()(S x)
{
typename T::Result t;
typename U::Result u;
return t(x)+u(x);
}
};
class X
{
public:
typedef X Result;
template<typename S>
S operator()(S x)
{
return x;
}
};
template<int I>
class Scalar
{
public:
typedef Scalar<I> Result;
template<typename S>
S operator()(S)
{
return S(I);
}
};
typedef Add<X,Scalar<2> > myfunc; //f(x)=x+2
------Schnapp--------
Und ähnliche Klassen für Multiplikation, Division, Potenzieren.
Das Herzstück ist ein Template
template<typename T> Differentiate;
Das ich für die anderen Klassen spezialisiere.
Beispielsweise
------Schnipp--------
template<typename T,typename U>
Differentiate<Add
{
public:
typedef typename
Add<typename Differentiate
typename Differentiate<U>::Result>::Result Result;
template<typename S>
S operator()(S)
{
Result t;
return t(x);
}
};
typedef Differentiate<myfunc> dmyfunc; //f'(x)=1
int main()
{
dmyfunc a;
for (int i=0;i<10;++i)
std::cout<
// 0: 1
// 0.1: 1
// etc.
}
------Schnapp--------
Ich möchte also zur Compilezeit die Ableitung (formal) berechnen. Das
'Result' benutze ich um Vereinfachungen zu ermöglichen (0+x=x u.ä.)
Bisher bin ich auf gebrochen rationale Funktionen beschränkt, möchte
das aber noch auf andere Funktionen erweitern, wie beispielsweise cos
oder sin.
Meine Frage ist jetzt, ob ich cos, sin, etc. "generisch" in ein
kompatibles Template mappen kann, auf das ich dann Differentiate<>
spezialisiere, oder ob ich für jede Funktion einzeln eine neue Klasse
schreiben muss.
@Christoph
Bei Loki hab ich nichts entsprechendes gefunden (Kann aber gut sein, dass
ich Das Richtige[TM] übersehen habe)
Grüße
Kai
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| 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
