ma question est simple : si j´ai une fonction qui attend un pointeur de fonction comme paramètre, est-il possible d´écrire la fonction en cause directement lors de l´appel à la fonction ( comme lorsque l´on mets une expression là où une valeurs est attendue).

Si non ( et même si oui) est-il possible de définir une fonction local ( en fait, je sais que non) ou en tout cas, une fonction pour laquel des référence local sont valide ( celle du contexte dans lequel elle est définit).

allo ?

pas très clair tout ca . ..

pour la " localisation" tu peux passer par des namespaces si c´est de ca que tu parles ( ?) sinon l´écriture lors de l´appel je vois pas trop ce que ca peut vouloir dire ! ?

tu as un exemple ?

en gros j´aurais une fonction de ce type :

double deriv(double ( *f)(double x));

et si possible j´aimerais l´appeler :

deriv(double ( f)(double x){return 3*x;});

et même si possible non pas 3*x, mais y*x où y serait une variable local de l´endroit où je crée cette définition.

et puis en passant, est-ce que quelqu´un connaitrait un programme qui dévellope ce que fait le pré-processeur, je veux dire qui prend un fichier source et remplace toute les macro par leur véritable signification ?

merci.

ok bin alors la réponse est non,

mais si ta fonction dépend de x ET de y pourquoi ne pas en faire une fonction à 2 paramètres, f(x,y) ?

enfin si y a moyen de contourner le problème mais pas " proprement" ( à mon goût) . ..

toujours pour mon basic, c´est que l´utilisateur ne doit pas savoir qu´il écrit une fonction et il doit pouvoir utiliser toute les variable qui sont local à l´endroit où il le veut.

mais je vais passer par un while pour faire ça si ça marche pas.

. ..

( 1/2 heure plus tard)
ben en fait étonnament, le for marche vachemrnt bien avec un for !

hum je suis pas sur de comprendre tout ce que tu dis basic ? avec un while ? for qui marche bien avec un for ? hum hum

enfin bref au sujet des namespace si ca peut t´aider :

namespace LocalFunction
{
double y;

double f(double x)
{
return y * x;
}
}

. ..
LocalFunction::y = 3;
deriv(LocalFunction::f));

LocalFunction::y = 5;
deriv(LocalFunction::f));

. ..

ca revient à faire du global encapsulé dans un espace de nom, ce qui à mon gout est pas super propre ( pas de multi-threads possible etc...) mais bon je vois pas très bien où tu veux en venir.

ah, c´est parce que t´as pas vu mon utre topic ( en même temps, personne n´est obligé de le regarder) : je suis en train d´écrire un basic juste à coup de préprocesseur C.

ça rend vraiment bien, mais j´ai eu du mal pour le for qui était assez difficile à convertir d´une écriture BASIC vers du C juste avec des macro, c´est pourquoi je voulais essayer de le faire avec des fonctions.

merci quand même pour ton aide.