Newsgroup: it.comp.lang.c++
Titolo: Scope dei puntatori a funzioni

Se io dichiaro un puntatore a funzione come ad esempio il seguente:
    void (*p_funzione)();
il suo linkage sarà interno, esterno o inesistente? Da quanto mi risulta
dovrebbe essere no linkage, ma quel che mi interessa maggiormente ne è la
motivazione.
1) Potrebbe essere perché contestualmente alla variabile sto dichiarando
anche un prototipo di funzione, e i simboli dichiarati all'interno di un
prototipo di funzione non hanno linkage.
2) In alternativa, perché sto a tutti gli effetti dichiarando un nuovo tipo
di variabile alla stregua di un typedef o di un'enumerazione, casi in cui
appunto il nuovo tipo dichiarato non ha linkage.
Cosa ne pensate?
Saluti

 dovrebbe essere no linkage, ma quel che mi interessa maggiormente ne č la
In che scope?  Se definisci questa variabile a livello di file,
sara` a linkage esterno (se non specifichi static); se entro un
blocco, interno.  Ne` piu` ne` meno come se la definissi int,
o int*.  Perche` pensi che il tipo della variabile che definisci
ne modifichi il linkage?
Alex




ne modifichi il linkage?
E' scritto a chiare lettere sui manuali C++ (almeno sui migliori) che i tipi
che ti ho elencato prima hanno intrinsecamente "No linkage".
Sono considerati un'eccezione perché, se ci pensi bene, anche a livello
teorico un int, float o char, non sono esattamente la stessa cosa di un
typedef o di un enum: nel primo caso faccio uso di tipi preesistenti, nel
secondo li sto dichiarando. La differenza concettuale è netta.
Ti dimostro col codice seguente che, pur dichiarando un int e un puntatore a
funzione all'interno della stessa classe (e quindi allo stesso livello in
termini di blocco), il loro linkage è ben diverso.
Prova a compilarlo e vedi cosa succede (io uso Visual C++ 5.0).
Class A
{
    /* Costruttori, etc
    .
    .
    .
    */
    int intero;                                // Questa variabile ha
linkage interno
    void (*p_funzione)();            // Questa variabile invece NON ha
linkage
};
void FunzioneProva(A* p_A)
{
    // Questa funzione è dichiarata al global scope
    p_A->intero=0;                    // Compila correttamente
    (p-A->*p_funzione)()             // Questo invece NON compila! Il
compilatore dice che "p_funzione" è
                                                    // un identificatore non
dichiarato
}
Fai la prova e vedrai: come vedi il tipo di variabile nei casi citati
modifica il linkage del simbolo dichiarato.
Ora rifaccio la domanda: dato che i puntatori a funzione non sembrano avere
linkage, a quale dei due motivi da me riportati tendereste a dare credito?

Fausto
Ci sono delle categorie particolari di tipi che si comportano in modo
diverso, più precisamente quelli creati dal programmatore a differenza di
quelli preesistenti: per maggiori dettagli vedi la risposta che ho dato ad
Alex Martelli, osservando in particolare il codice in fondo alla pagina.
Non è inoltre il solo linker ad occuparsi del linkage: a lui spetta
risolvere solo i linkage esterni, mentre quelli interni sono appannaggio del
compilatore.

 dichiarato
Forse  volevi scrivere
    ( *p-A->p_funzione )();
Ma non credo, visto che in questo caso il codice si compila benissimo.
Il tuo codice 
  (p-A->*p_funzione)();
sarebbe accettabile soltanto se p_funzione fosse dichiarato come:
  void (A::*p_funzione)();
e NON come membro di A. Oppure, se lo vogliamo membro di A, lo possiamo
usare solo così:
   (p_A->*(p_A->p_funzione))(); 
Max

 linkage, a quale dei due motivi da me riportati tendereste a dare credito?
I puntatori a funzione hanno lo stesso linkage di qualsiasi altra
variabile; non tenderei a dare nessun credito, in termini di C++,
a chi non capisce le sottigliezze di operator->*.  (In effetti e`
molto difficile resistere alla tentazione di chiedere "da che
Pulpito viene la predica").
Alex

tua giusta osservazione.
Dio perdona lui, perche' non sa cosa sta facendo !!! :))

tutti intrinsecamente caratterizzate, per definizione, da "No linkage":
Dal vangelo secondo Bruce Eckel ("Thinking in C++"), I volume,
capitolo 10 :
"Controlling linkage
Ordinarily, any name at file scope (that is, not nested inside a class
or function) is visible throughout all translation units in a program.
This is often called external linkage because at link time the name is
visible to the linker everywhere, external to that translation unit.
Global variables and ordinary functions have external linkage.
There are times when you’d like to limit the visibility of a name. You
might like to have a variable at file scope so all the functions in
that file can use it, but you don’t want functions outside that file
to see or access that variable, or to inadvertently cause name clashes
with identifiers outside the file.
An object or function name at file scope that is explicitly declared
static is local to its translation unit (in the terms of this book,
the cpp file where the declaration occurs). That name has internal
linkage. This means that you can use the same name in other
translation units without a name clash.
One advantage to internal linkage is that the name can be placed in a
header file without worrying that there will be a clash at link time.
Names that are commonly placed in header files, such as const
definitions and inline functions, default to internal linkage.
(However, const defaults to internal linkage only in C++; in C it
defaults to external linkage.) Note that linkage refers only to
elements that have addresses at link/load time; thus, class
declarations and local variables have no linkage."
Mi sembra che il tuo caso non rientri in quelli citati come soggetti a
"no linkage", in quanto definisci una variabile di tipo puntatore che,
stando a quanto affermato nel primo punto (Global variables and
ordinary functions have external linkage), ha "external linkage".

    (p-A->*p_funzione)() 
p_A->p_funzione();
o se preferisci
(*p_A->p_funzione)()
Non devi utilizzare operator->* che e` molto diverso
Paolo
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------

 wrote in message
8hrbpd$as2$1...@nslave1.tin.it...
