Newsgroup: it.comp.lang.c++
Titolo: T const f();

scusate, cosa vuol dire la notazione di cui al subject?
si tratta di un metodo all'interno di una definizione di una classe.
class C {
    const T a();
        /* il tipo ritornato è taggato const, quindi non sarà
modificabile...*/
    T b() const;
        /* la funzione non modifica lo stato dell'instanza su cui viene
invocata... */
    T const c();
        /* ??? credevo che la funzione NON POTESSE essere ridefinita
            in una classe derivata, ma il compilatore che uso non batte
            ciglio quando la ridefinisco  (BCB 5.0) */
};
grazie a chiunque mi dedichi questo minutino per la risposta.
    rony.
P.S. se poi sapete dirmi dove si trova sullo Stroustroup la spiegazione, vi
offro pure un caffé (virtuale).

T const equivale a const T; anzi, da un certo punto di vista e'
preferibile, perche' rende piu' chiara una dichiarazione come
T const * const t;
Leggendo (all'inglese) da destra a sinistra hai "constant pointer to
constant T".
Ciao,
Nicola

 ha scritto nel messaggio
news:3A62DF05...@divalsim.it...


ehm... ma const void f() (o void const()) che vuol dire?


che non puoi scrivere f()=(void)(X);
Sent via Deja.com
http://www.deja.com/

 scusate, cosa vuol dire la notazione di cui al subject?
La stessa cosa di
const T f();
EMG

 ehm... ma const void f() (o void const()) che vuol dire?
Credo niente.
EMG

ehm... ma const void f() (o void const()) che vuol dire?
Nulla.
Come non vuol dire nulla anche:
    const int f();
Sono pero' forme "tollerate" perche' semplificano la
scrittura di template.
Un altro esempio di codice legale che a prima vista
appare essere senza senso e' il seguente:
   void f()
   {
     ...
   }
   void g()
   {
     ...
     return f();
   }
Anche in questo caso la validita' di questa sintassi
permette di dover gestire meno casi particolari durante
la stesura di template.
HTH
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff


Niente di piu' falso.
Esempio: quale dovrebbe essere il prototipo secondo te
per l'operatore + tra due classi A?
Tu mi dirai:
A operator+(const A& a, const A& b);
e se qualcuno scrivesse:
A a,b,c;
...
(a + b) = c;
non andrebbe come minimo avvisato in fase di compilazione
che ha scritto qualcosa di insensato?
quindi il prototipo esatto sara':
const A operator+(const A& a, const A& b);


 per l'operatore + tra due classi A?
...
Infatti non si stava parlando di classi ma di "void".
Io ho detto che con "void" non serve a nulla, come non
serve a nulla con "int".
Se non ti spiace ti pregherei in futuro di riportare il
minimo di contesto che renda comprensibile a cosa "Nulla"
faceva riferimento.
Andrea
--
----------------------------------------------------------------
 <\___/>  Andrea        email: agriff at tin dot it
 / . . \  "6502"          irc: _6502_@EFNET#italia
(  (")  ) Griffini   homepage: 
http://www.netservers.com/~agriff


 ha scritto nel messaggio
news:94118c$5vu$1...@nnrp1.deja.com...


     const int f();
Non e` esatto, prendi ad esempio
T operator+(const T& lhs, const T& rhs);
questo prototipo ti permette di scrivere cose tipo
T a, b, c;    // consentitemi la forma deprecata....
...
(a+b) = c;
const T operator+(const T& lhs, const T& rhs);
semplicemente non lo permette.
Dubito che mai qualcuno scrivera` volontariamente una cosa simile
all'assegnamento di prima, ma come dice S. Meyers
perche` rischiare, soprattutto quando per i tipi primitivi la
cosa non e` permessa [1]?
Paolo
[1] Dato che f() ritorna int, il cost sarebbe dunque inutile, ma io
propendo sempre per l'uniformita`, minori sono le eccezione e piu`
facile e` la vita.
--
Paolo Marotta
Duck Communication Entertainment s.r.l.
Largo Arenula, 11 - Roma
http://www.duckce.com
p.ma...@duckce.com
-- 
Posted from 
HA-server-a.cs.interbusiness.it
 [151.99.250.31] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

>ehm... ma const void f() (o void const()) che vuol dire?
Niente, nel senso che essendo la funzione void il const mi pare
decisamente superfluo.
Paolo


faccia le veci, quindi un puntatore...);
La cosa non e` sicuramente valida per via del void (come giustamente
spieghi poi di seguito), ma se la funzione tornasse un T (T non tipo 
primitivo),
dato che (mi pare di ricordare) il temporaneo deve sopravvivere fino alla 
totale
valutazione dell'espressione, esso verrebbe utilizzato come l-value.


faccia le veci, quindi un puntatore...);
La cosa non e` sicuramente valida per via del void (come giustamente spieghi
poi di seguito), ma se la funzione tornasse un T (T non tipo primitivo),
dato che (mi pare di ricordare) il temporaneo deve sopravvivere fino alla
totale valutazione dell'espressione, esso verrebbe utilizzato come l-value.
Infatti, dici bene. Tuttavia non avrebbe più senso per il compilatore
verificare che un l-value sia
a) un nome dell'ambiente oppure
b) un'espressione esplicitamente dichiarata come tale (T&, come avviene per
i tipi primitivi) oppure
c) il risultato di una dereferenziazione (il che ricade nel secondo caso, se
consideriamo l'operatore di dereferenziazione definito e overloadato come
    T& operator*( T* const))?
Ammetterai che, a parte per il side-effecting, un'espressione del tipo (a+b)
= c non abbia poi tutto questo significato...
Inoltre, ma si tratta solo di un parere da "esteta" (qual poi più di tanto
non sono...), non sarebbe bella una semantica del linguaggio in cui i tipi
primitivi e quelli non non primitivi, almeno in queste cose, abbiano
significato (come dici altrove... "sarebbe dunque inutile, ma io propendo
sempre per l'uniformita`, minori sono le eccezione e piu` facile e` la
vita.")?
Cordiali salumi,
    Rony.

vita.")?
E` verissimo, solo che non sempre si puo` fare a meno delle eccezioni.


(questa e` d'altronde la filosofia del C++).
Io parlavo di pulizia... su di un linguaggio che prevede il "goto".
E' un po' come parlare di differenza tra scalogno e cipolla dentro a un
McDonald...
Scherzi a parte, ciao ciao,
    Rony.