Newsgroup: it.comp.lang.c++
Titolo: [Linguaggio] - il ";" cosa è?

Ciao, certo che il C++ e' davvero strano!
il codice seguente compila senza alcun problema...
--------------------
class a
{
void fUno() {int b;}; /*occhio all'ultimo ; della riga, posso ometterlo */
void fDue() {}
int fTre() {return 18;}; /*occhio all'ultimo ; della riga, posso ometterlo
*/
void fQuattro();
};
void main()
{
;
;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5+3;
}
--------------------
qualcuno ha capito cosa e' il ; ?
un'istruzione? un'espressione? la sequenza? un bel minestrone?
P.S. ho compilato con il Visual C++ 6.0, non so cosa fanno gli altri
compilatori.
ciao Davide
/ - / - | - \ - \
Davide Piras
New (
pir...@engineer.com
)
Old (
pir...@iname.com
)
\ - \ - | - / - /

 un'istruzione? un'espressione? la sequenza? un bel minestrone?
Un terminatore.
EMG

un'istruzione? un'espressione? la sequenza? un bel minestrone?
Lessicalmente, un separatore, semanticamente, denota proprio la struttura 
di "sequenza". La stessa cosa accade con praticamente tutti i linguaggi di 
programmazione, dato che l'istruzione nulla  e' di solito valida - 
semplicemente non produce alcun codice oggetto.
-- 
God is Real, unless declared Integer.
ObjectZone - 
http://space.tin.it/computer/csadun/

Ciao, certo che il C++ e' davvero strano!
Non c'e` nulla di strano, la stessa cosa vale per il C, il pascal e
moltissimi altri linguaggi. Ogni linguaggio deve avere un meccanismo
che consenta di capire la fine di una espressione (istruzione) e 
l'inizio della successiva, in alcuni linguaggi si usa il ';' in altri
si usano altri sistemi
Paolo
-----------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------

 Lessicalmente, un separatore,
Perché parli di separatore? A me sembra un terminatore. Infatti anche
l'ultima istruzione di un blocco deve essere terminata con il punto e
virgola (differentemente dal Pascal). Se fosse un separatore questo non
sarebbe necessario. O sbaglio?
EMG

:

Premessa. Quando si parla di grammatiche, il nome dell'elemento lessicale 
e' generalmente poco importante, nel senso che chiamare 'separator' o 
'terminator' un elemento di una bnfg viene fatto solo per il valore 
intutivo: potresti chiamarlo "pippo" :) e il suo ruolo nella bnf non  
sarebbe diverso. Uno vale l'altro. Tant'evvero che in una specifica 
puramente lessicale (quelle lex ad esempio) 'sti nomi non si usano proprio 
- la specifica di ';' e' qualcosa del tipo <count(); return(';');> se non 
ricordo male (e' facile, e' la stessa di ',','(', etc. :).
Quindi: sono in ufficio e non ho sottomano il 'C' di K&R, ma basterebbe 
vedere come lo chiamano loro nella bnf (se lo fanno, e mi pare di no ;-) 
che c'e' nel libro - se c'e' da scegliere una convenzione meglio riferirsi 
a quella. :)
Per il valore "intutivo", mi e' venuta la parola 'separatore' perche' - ad 
esempio, non e' necessario per terminare un blocco { }: puoi scrivere
int foo() { { int pluto=3; } pippo=2; }
*senza* un ; dopo la } interna. Ovviamente lo stesso discorso potrebbe 
inficiare l'uso di "separatore". :) Siccome nella bnf "leggibile" il token 
';' termina molte regole - in particolare quella per 'espressione' (che 
comprende 'assegnamento'), avrei usato tranquillamente "terminatore" senza 
rimorsi di coscienza. 
Se uno volesse essere ultrapreciso (ma io mi annoierei :^)) dovrebbe 
specificare sia la BNF a cui si riferisce, e dire qualcosa del tipo "';' 
termina le clausole 'espressione', 'dichiarazione', etc". Ma - a parte 
quando stai facendo un parser - mi pare un po' eccessivo... 


 intutivo: potresti chiamarlo "pippo" :)
Non sono affatto esperto di grammatiche e mi riferivo appunto al nome
intuitivo.
EMG

Detto terra-terra, č un segnalatore di fine riga, un po' come il segnale EOF
segna la fine del file.
Certo, sul Basic non cera, ma c'erano i comandi per inserire il comando su
piů righe...
--
Diego "1985" Pettenň
per gli spammer la mail č
diego...@hotmail.com
per i messaggi seri č
diego....@tiscalinet.it

 segna la fine del file.
non sono d'accordo, se fosse "il fine riga", non lo useremmo due volte nel
for...
poi mi chiedo se ha senso che il compilatore accetti una riga di soli ; ho
capito che e' un'istruzione che non fa nulla ma perche' accettarla?
Ciao Davide

 capito che e' un'istruzione che non fa nulla ma perche' accettarla?
Ad esempio per poter usare costrutti for dove tutta l'elaborazione viene
fornita all'interno delle parentesi.
// ciclo infinito
for (;;)
    ;
E si mette su una riga a parte per non confonderlo con la riga successiva,
che non appartiene al ciclo.
Mi spiego con un esempio:
for (char a = getchar(); a != '\n'; a = getchar());
    printf ("Fine elaborazione");
Ti sembra chiaro il senso delle 2 istruzioni? Sembrerebbe a prima vista che
la seconda appartenga al ciclo, no?
L'esempio fa schifo, l'indentazione potrebbe essere più corretta, ma il
compilatore accetta anche cose così.
--
Alessandro Monti

piů righe...
Nel basic (almeno quello di molto tempo fa) c'erano i numeri di linea e 
comunque mi pare di ricordare che fosse possibile inserire piu`
comandi nella stessa linea separandoli mi pare proprio con ';'


capito che e' un'istruzione che non fa nulla ma perche' accettarla?
E` la grammatica del linguaggio che lo consente e il compilatore deve
semplicemente adattarsi. Molto probabilmente nella grammatica c'e`
una definizione del tipo
Istruzione ::= <Istruzione>;<Istruzione> | <Expr> = <Expr> | NULL | ...
Che significa semplicemente che una istruzione puo` essere un
assegnamento o anche una sequenza di due istruzioni o semplicemente
l'istruzione nulla.
D'altronde ci sono casi in cui l'istruzione nulla serve:
for(;;)    // notare ';;'
e quindi non e` eliminabile.


 comandi nella stessa linea separandoli mi pare proprio con ';'
No, erano i due punti.
EMG

Non č tanto interessante la natura del ";" ma il suo utilizzo. Serve per
indicare al compilatore che hai concluso un istruzione. Lo devi mettere al
termine di tutte le istruzioni che scrivi, sia che siano dichiarazioni (int
a;), espressioni (a = 5 + b;) o quant'altro (typedef unsigned int UINT; etc.).
Vi sono perň due eccezzioni. Una riguarda le macro (#define ABC 5) ed i
blocchi {} (int a() { return 5;}). All'ultima eccezione c'č un'altra
eccezzione: il punto e virgola va messo per terminare la dichiarazione di una
classe (class A{ int a;};) e forse anche di una struct. Alcuni costrutti
richiedono per forza una istruzione (if (a == 0) <qui ci vuole una istruzione>
oppure for (int a =0; a < 5; a++) <qui ci vuole una istruzione>) e puoi
utilizzare il punto e virgola per indicare una istruzione che non fa niente
(if (a == 0); e for (int a = 0; a < 5; a++);). Personalmente il ; mi č sempre
stato piuttosto simpatico e inoltre ti permette di scrivere il codice nella
maniera che ti pare piů bella e leggibile, mettendo piů di un'istruzione sulla
stessa riga o separando una unica istruzione (ad esempio un if molto lungo o
la dichiarazione di una funzione con molti parametri) su piů righe.Inoltre i
compilatori sono anche piuttosto precisi nel dirti quando ti sei dimenticato
un punto e virgola.
Non te la prendere con il povero piccolo ;
Ciao Fbf.

Giusto, anche la definizione di una struct va terminata con ;
anche  enum e union... e tutte le inizializzazioni
aggregate.




 aggregate.
A mano di non voler dichiarare contestualmente delle variabili di quel tipo,
presumo.
--
Alessandro Monti

Già, comunque mi son dimenticato la Q, intendevo il QBasic (più carino
rispetto al Basic e/o al GwBasic, che ho comunque provato).
--
Diego "1985" Pettenò
per gli spammer la mail è
diego...@hotmail.com
ATTENZIONE: rispondo ai messaggi di pubblicità indesiderata
su TiscaliNet con un bel messaggio al provider di competenza!
per i messaggi seri è
diego....@tiscalinet.it