Newsgroup: it.comp.lang.c++
Titolo: Funzioni "dinamiche"

Salve ragazzi ho una domanda da farvi.
Osservate il seguente codice scritto in Turbo Pascal 7.0:
    procedure p1;
     begin
      Writeln('Esecuzione della procedura 1');
     end;
    var p2: procedure;
    begin
     p1;
     Addr(p2):=@p1;
     p2;
   end.
Esso da in output i messaggi:
    Esecuzione della procedura 1
    Esecuzione della procedura 1
che è proprio quello che volevo...
Qualcuno di voi sa come fare la stessa cosa in C++?
Grazie da Amleto.

 Qualcuno di voi sa come fare la stessa cosa in C++?
Certo, e` veramente simile:
    void p1() {
        printf("Esecuzione della procedura 1\n");
    }
    void (*p2)();
    int main() {
        p1();
        p2 = p1;
        p2();
        return 0;
    }
Alex


Eccolo qua...
void p1();
main()
{void (*p2)(void);
 clrscr();
 p1();
 p2=p1;
 (*p2)();
 getch();
}
void p1()
{
 printf("\n     ECCOLO     ");
}
Fai attenzione all'utilizzo dei puntatori a fuinzioni in C.Comunque sono
descritti bene su praticamente tutti i libri sul lunguaggio.
ciao
Zag
zag...@libero.it


Scusa, Alex, ma sei sicuro della chiamata a p2()? Io penso che debba
essere riscritta cosě: 
(*p2)();
Dimmi se sto sbagliando. Ciao!

(*p2)();
Non stai sbagliando, ma viene accettata anche la forma p2()...
Paolo
-----------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------

 Dimmi se sto sbagliando. Ciao!
"Stai sbagliando", nel senso che la notazione che tu proponi funziona,
ma funziona anche quella che preferisco io.  L'operatore di "()"
(chiamata di funzione) applicato ad un puntatore a funzione ne
causa l'implicito de-referencing, quindi non occorre (anche se
non causa danni) porre un de-referencing esplicito come tu fai.
Questo vale "da sempre" in C++; in C, da quando esiste lo
standard ISO (in realta` da un po' prima, cioe` dal precedente
standard ANSI, e da varie implementazioni di C ancora piu`
vecchie).  Se uno deve compilare su di un compilatore C che
abbia piu` di 20 anni circa, allora la notazione che tu proponi
e` senza dubbio preferibile.
Alex

>abbia piu` di 20 anni circa, allora la notazione che tu proponi
mmhh...20 anni...Zortech C 1.0 ? :)
a pensarci bene, quale e' stato il primo compilatore C (e C++) 
commerciale? io non ho tanta memoria storica...
-- 
universe::earth::internet::albion->Greetz++;
 
darX...@tin.it
 
alb...@libero.it
  Fido 2:335/234.21   
http://darxstar.cjb.net
  ICQ UIN# 11151997 - eggdrop on demand
<the trees that whisper in the evening...>

Su DOS che io ricordi, Lattice C, poi Microsoft C. Io devo averlo
incontrato intorno a '85-'86. Il primo in assoluto probabilmente risale
al primo UNIX commerciale, forse Interactive, che io sappia dell'inizio
degli '80.
Per il C++ si puo' dedurre da "Design & Evolution..." di B. Stroustrup.
Io ne ho incontrato uno su SCO Unix intorno al '93, ma potrebbero
essercene stati di precedenti.
Ciao,
Nicola

 commerciale? io non ho tanta memoria storica...
I primi compilatori C (e, separatamente, i primi compilatori
C++, qualche anno dopo) furono tutti prodotti dalla AT&T.
Non sono sicuro di cosa tu intenda per "commerciali", ma
tipicamente essi venivano distribuiti per il semplice costo dei
nastri, pur essendo AT&T una azienda commerciale.
Naturalmente, i primi compilatori C non giravano su PC (che
ancora non esisteva), bensi` su macchine come il glorioso
mini "PDP-11" della Digital Equipment.
Alex

 essercene stati di precedenti.
Usavo un compilatore C++ (su mainframe IBM) nel 1984 (decidemmo
che non era ancora un linguaggio maturo per le nostre esigenze, ma
poteva forse avere promessa per il futuro:-).
Alex

 essercene stati di precedenti.
Io ho (e uso ancora, a volte) il TurboC++ 1.01 che è del 1990.
EMG

 
Pero'...
Ciao,
Nicola

 io UNIX si e' cominciato a venderlo all'inizio degli anni 80.
Mi pare invece che si vendessero degli Unix gia` negli anni '70.
Specificamente, dal 1978 (Unix version 7).  Penso che, gia`
l'anno prima, si potesse comprare la versione "Programmers'
Workbench" di Unix (solo per PDP-11, credo), ma non ne
sono sicuro.  Il "Portable C Compiler" di Johnson (la prima
implementazione di C alternativa ai compilatori di Ritchie e
Thomson) data dagli stessi anni (fine dei '70).
Le versioni di C per computer come ad esempio i mainframe
IBM (370) sono un po' precedenti, anche se e` discutibile in 
che senso fossero "commerciali" (all'epoca, il software per i
mainframe normalmente non si _vendeva_ -- piuttosto, si
_noleggiava_ come parte del noleggio del mainframe stesso).
Alex

Mi sa che devo rispolverare il diavoletto...
Ciao,
Nicola

Su DOS che io ricordi, Lattice C, poi Microsoft C. 
Il Microsoft C non e' altro che il Lattice C mascherato.
La MS infatti compro' il compilatore e produsse l'MSC.
 
--
Andrea Laforgia        (
andrea_...@bigfoot.com
)

 La MS infatti compro' il compilatore e produsse l'MSC.
Questa proprio non la sapevo. Allora di suo la Microsoft ha fatto proprio
solo il Basic!!!
--
Alessandro Monti

solo il Basic!!!
Il BASIC e' nato nel 1963 da John Kemeny e Thomas Kurtz, due
professori del Dartmouth College, il primo interprete non e' stato di
certo quello MS, quindi e' probabile che MS abbia comprato il codice
anche di questo !!! ;)
--
Andrea Laforgia        (
andrea_...@bigfoot.com
)

 anche di questo !!! ;)
Il codice del primo interprete Basic della Microsoft fu hackerato da
Allen e Gates, nel giro di qualche settimana, in buona parte _dopo_
averlo gia` "venduto" all'azienda che aveva lanciato il primo
microcomputer per hobbisti (lo Altair, basato su Intel 8080).
D'altra parte, neanche il microcomputer esisteva veramente
(l'interprete Basic MS fu in gran maggioranza sviluppato su di 
un _simulatore_ di microprocessore 8080).
Si trattava di un "vero interprete" (linea per linea, con linee
obbligatoriamente numerate, ecc ecc), una tecnologia molto
diversa da quella del Basic di Kurtz e Kemeny (che infatti, piu`
tardi, cercarono di rilanciare il loro prodotto come "True Basic"),
che era piu` vicina, se mai, a "semi-interpreti" come e` oggi il
Perl (si esegue prima un vero e proprio compilatore sull'intero
sorgente del programma -- questo diagnostica eventuali errori,
o, se non ne trova, produce un codice intermedio, un "byte-code"
come viene spesso chiamato, su cui poi viene eseguito un
"interprete interno", che puo` essere molto piu` compatto e 
ottimizzato di un "vero interprete linea per linea").  Il VB di
oggi usa un approccio piu` simile a quello di K&K, che non a
quello del primo Basic Microsoft.
Incidentalmente, anche il Microsoft C (da molti anni) non ha
piu` alcun rapporto con il C della Lattice.  MS compro` e
ridistribui` il C della Lattice per "tappare un buco" sulla sua
linea di prodotti, mentre un gruppo dei suoi programmatori
sviluppava quello che sarebbe poi divenuto il suo compilatore.
Non appena MS giudico` pronto per il mercato il suo
compilatore C, smise di rinnovare il contratto con Lattice
e si mise a vendere, invece, il suo, senza dovere royalty
a nessuno.
Lo ricorda bene, naturalmente, chi soffri` la migrazione da
"un release all'altro" del prodotto "Microsoft C" -- che non
era in realta` il tipo di migrazione che si ha fra due release
dello stesso prodotto, relativamente indolore, bensi` il tipo
di migrazione "sangue, sudore e lacrime" che si ha fra due
compilatori, nessuno dei due particolarmente maturo, e
completamente privi di qualsivoglia parentela tecnica.
C'erano, per fortuna, compilatori C assai migliori, sia del
Lattice, sia del MS, come ad esempio il Datalight (il cui
autore passo` poi a scrivere il compilatore "Zorland", che,
dopo violente minacce legali dalla Borland, fu costretto a
rinominare "Zortech"), l'unico compilatore per DOS, a
quei tempi, ad avere un ottimizzatore di qualita` davvero
eccellente.
Alex

 Il BASIC e' nato nel 1963 da John Kemeny e Thomas Kurtz, due
Intendevo "un interprete BASIC", non il linguaggio stesso.
Comunque è una precisazione utile, dato che a sentire MS, hanno inventato
loro anche Internet (oltre a tutto il resto) :-)))
Di informazioni su quanto altro MS ha comprato o rubato, ne so parecchie. Mi
mancava giusto il BASIC, ritenendo che almeno quello lo avessero scritto
tutto loro. (l'interprete, intendo, almeno il primo)
--
Alessandro Monti

 Specificamente, dal 1978 (Unix version 7).  Penso che, gia`
SNIP
Posso confermare, unix era commerciale già nel 78 (al momento non riesco a
trovare notizie su date precedenti, ma giurerei di aver letto qualcosa al
riguardo). Però non so se era già incluso un compilatore C, anche se credo
di si...
San Vegeta



Unix e' stato scritto da Dennis Ritchie e Ken Thompson nel 1969 ai
Bell Labs su un PDP-7.  Nel periodo 1972-74 e' stato riimplementato
in C, rendendolo cosi' "portabile"; il linguaggio C data, credo, al
1971: ma di questa data non sono sicuro (delle altre due si).
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

Bell Labs su un PDP-7.
Se volete vedere com'era fatto un PDP7 :
http://www.digital.com/timeline/1964-3.htm
Mentre per il PDP11 (altro computer d'importanza storica) :
http://www.digital.com/timeline/1970-2.htm
La storia completa del C invece e' alla pagina :
http://www.cs.bell-labs.com/~dmr/chist.html
ed e' scritta dal suo autore (Dennis M. Ritchie)
ciao

>mini "PDP-11" della Digital Equipment.
E cosi' il PDP11 aveva uno (o piu') compilatori C? non lo sapevo...molto 
interessante
-- 
  . 
darX...@tin.it
      . 
darx...@wappi.com
 (GSM SMS)
   . Fido 2:335/241.5     . 
http://darxstar.cjb.net
  ICQ UIN# 11151997 -   
  trough Britannia: Gwydion the Mage <UO: EUROPA,now in Trisinc>
---
I don't want my freedom: there's no reason for living, with a broken heart
 -- The Queen

interessante
Be', sul PDP11 venne riscritto Unix, per la prima volta, interamente
in C.
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
---------------------------------------------

 interessante
E' una delle prime cose che si imparano del C dato che ne parlano K&R
nell'introduzione del loro libro. :-)
EMG