Newsgroup: it.comp.lang.c
Titolo: [OT] Nested functions senza GCC

Un saluto generale (è il primo messaggio che sendo a questa ML, colgo 
quindi l'occasione per presentarmi :-)),
editando un software per il source auditing mi è apparso un dubbio circa 
una questione palesemente OT con l'ANSI C.
Oggetto della mia perplessità sono le nested functions (funzioni 
annidate) in C su piattaforme Microsoft-like.
Le funzioni annidate (nested functions) altro non sono che funzioni 
dichiarate all'interno di un'altra funzione e non fanno parte dell' ANSI 
C, esse rappresentano esclusivamente un estensione, relativamente utile, 
del GCC.
Non avendo modo di provare le stesse su sistemi operativi Microsoft mi 
appello a voi....
Indi per cui la richiesta si traduce, semplicemente: qualcuno ha provato 
esperienze con funzioni nested in ambiente *NON* unix-like, senza 
l'ausilio di GCC ?
Ciao a tutti ! :-)

 del GCC.
OT per OT... mi sto domandando a cosa possano essere utili... cioe', in che
caso sono piu' pratiche (dubito esista un singolo caso in cui siano
"necessarie") da usare che 2 funzioni "piatte"...
-- 
Firma in costruzione


Mah, posso dirti come le ho usate io, saltuariamente:
avevo un algoritmo ricorsivo di visita di una
certa struttura. L'algoritmo doveva visitare
e memorizzare via via certe informazioni
da utilizzare in caso dovesse arrivare ad una
certa configurazione.
Ho usato le funzioni annidate per evitare
di usare dei globali ed evitare
potenzialmente costosi (e inutili) passaggi di parametri.
void funz1(argomenti)
{
    variabili pseudo-globali,
     visibili anche a funz2;
     void funz2(arg)
     {ricorsiva....funz2()}
     BODY funz1 che chiama la funz2
}
in questo modo la funz2 poteva accedere a delle
informazioni vitali (locali a funz1) senza dover
ogni volta passarsele ad ogni chiamata ricorsiva.
Avevo visto che in questo modo il programma
era piu' sporco, ma piu' veloce (trattandosi
di programmi di carattere matematico/combinatorio
che vengono usati poche volte, solo da me e
possono girare anche molto a lungo, tipicamente
me ne infischio bellamente di portabilita' e
di tutti i paradigmi per una buona programmazione,
e se riesco a ridurre il tempo di qualche ora anche
il goto non mi fa schifo! :-)
ciao,
v.

ZeD ha scritto:

In Python, ma non so se in GCC l'implementazione e' la stessa, *il* 
vantaggio di usare funzioni nidificate e che possono usare le variabili 
locali della funzione padre.
Esempio banale:
 >>> def sumto(a):
	def helper(x):
		return x + a
	return helper
 >>> print sumto(5)(10)
15
Saluti  Manlio Perillo

 "necessarie") da usare che 2 funzioni "piatte"...
Per quanto concerne la reale utilita' posso anche convenire con te... ma 
l'oggetto della mia curiosita' era principalmente legato ad un esempio, 
essendo il sottoscritto impossibilitato, nell'ottica d'ambiente win-like.
E` infatti palese che le stesse siano per lo piu' causa di codice 
"sporco" ed intrinsecamente limitative nell'ottica di programmazione 
modulare standard con l'utilizzo di funzioni "piatte" :-)
Ciao !

  [CUT]
Beh, le funzioni nidificate servono solo ed esclusivamente a questo, e 
la loro *comodita'* risiede appunto nell'ereditarietą delle variabili 
d'ambito locale, questo e' un concetto vero per tutte i lang. che 
permettono l'uso di funzioni nested (e python e' uno di questi).
Ciao !

 }
Si puo` tradurre in qualcosa come:
struct foo {
        variabili interessanti;
};
void funz2(struct foo *bar) {
        ....
}
void funz1(args) {
       struct foo var;
       funz2(&var);
}
L'overhead dovuto al passaggio di un puntatore e` trascurabile rispetto
alla chiamata a funzione...
Tornando alla tua domanda originale, ICC e il compilatore della MS non
supportano questo costrutto. Come alternativa puoi usare uno dei porting
del gcc per win32.
Luca
-- 
Home: 
http://kronoz.cjb.net
"Chi parla in tono cortese, ma continua a prepararsi, potra` andare avanti;
 chi parla in tono bellicoso e avanza rapidamente dovra` ritirarsi" 
Sun Tzu -- L'arte della guerra

 alla chiamata a funzione...
Poi pero' magari si paga un po' anche per l'indirezione.
E piu' che altro non avevo voglia di introdurre
una nuova struttura e quindi allungare il codice,
visto che potevo usare le funzioni annidate...
Tieni conto che annidavo solo funzioni di poche righe di
codice e che come ho specificato non avevo interesse
a portabilita', leggibilita', riusabilita', etc.etc.
Che poi, ripensandoci, e' vero che non sono
standard, ma non sono neanche tanto "sporche".
In fondo il posto migliore per definire
una funzione che mi serve solo in un punto
e' vicino a dove mi serve, specialmente
se la funzione e' corta.
(Come tutte le cose, va usata a proposito).
In effetti mi sembra di averle incontrate in passato
in diversi altri linguaggi di programmazione.
ciao,
v.