Newsgroup: it.comp.lang.c++
Titolo: Varie

Avrei vari dubbi e domande, colgo l'occasione coloro che si
prodigano nel rispondere a chi ne sa meno di loro.
1) Allora, prima cosa: qualcuno conosce e/o usa una libreria per i CGI?
(a proposito, mi dite come si pronuncia CGI in italiano? Ho sentito
dire "ci gi i" e "ci gi ai".. che mi dite?)
2) Se io in una classe ho un char* pippo nella parte private, e
voglio creare una funzione pubblica che restituisca pippo come
const char*, come devo fare? Non mi sembra che si possa fare
qualcosa del genere: return const(pippo) (anche perche' io voglio
una stringa costante, mica un puntatore costante)
3) Lippman nel "C++ Primer" (3a edizione inglese, pag. 754) parla
dell'operatore [] per la classe String (che lui ridefinisce per
esercizio qua e la' per il libro, non so se e' proprio uguale
a quella originale, ma non credo perche' ad esempio c_str()
ritorna char* e non const char*):
inline char&
String::operator[](int elem) const
{
    assert( elem >= 0 && elem < _size);
    return _string[ elem ];
}
Quello che mi non mi torna e' che quel const indica che la funzione
non modifica i dati della classe classe e infatti se uno
fa: "String a("ciao"); cout << a[0];" l'operator [] non scrive da
nessuna parte. Pero', avendo come valore di ritorno char&, si puo'
fare anche, credo: "const String a("ciao"); a[0]='C';" e quindi in
questo caso non mi pare proprio che la definizione const per l'operator
sia appropriata..con const String l'operator [] dovrebbe potersi
applicare in quanto ho letto che a un oggetto const si applicano
costruttori, distruttori e funzioni const..ma le cose non tornano.
-- 
Saluti,
 Francesco Cipriani

 costruttori, distruttori e funzioni const..ma le cose non tornano.
Infatti, a meno che _string non sia dichiarata mutable questa
funzione non dovrebbe venire accettata dal compilatore.  Ti
consiglio di verificare se ci sono errata in rete x il libro.
Alex

 
-- 
"Time flies like an arrow; fruit flies like a banana."

sia appropriata
A me sembra corretto. 'const' specifica che *la funzione membro* non
modifica i dati, ma non qualifica il risultato. L'uso che ne fai e' un
altro discorso.
Saluti, Alberto.

 wrote in message news:Pine.LNX.4.10.100012...@c64.comm2000.it...
: On Tue, 25 Jan 2000, Alex Martelli wrote:
: >
: > Infatti, a meno che _string non sia dichiarata mutable questa
: > funzione non dovrebbe venire accettata dal compilatore.  Ti
: > consiglio di verificare se ci sono errata in rete x il libro.
:
: Scusa, non capisco. Se _string (come immagino) è un membro di tipo char*
: (che presumibilmente rimanda a un buffer allocato dinamicamente), in un
: metodo const quel membro dovrebbe essere visto come char * const, il che
Si`, se _string e` un char* -- pensavo che fosse un array di char, nel
qual caso il mio discorso e`giusto.  Purtroppo, come fai notare, il
compilatore non e` in grado di evidenziare le violazioni di "logical"
constness quando avvengono attraverso un puntatore (senza, quindi,
violare la "physical" constness).
Alex

 Saluti, Alberto.


 costruttori, distruttori e funzioni const..ma le cose non tornano.
Forse fai confusione tra le tre forme:
const T *metodo();
T * const metodo();
T *metodo() const;
EMG

    int & m() const { return i; };
In effetti ho "smarrito" ill vero significato dei cv-qualifier
applicati alle funzioni. Come da stardard, il cv-qualifier influenza
non tanto la funzione in se, ma il tipo di this (e il function type).
Quindi this diventa un (const *) e 'return i' ritorna un (const int).
Saluti, Alberto.

una stringa costante, mica un puntatore costante)
class A {
  private:
     char* Pippo;
  public:
    const char* GetPippo() { return Pippo; }
};
Paolo
-----------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------

 Quindi this diventa un (const *) e 'return i' ritorna un (const int).
Davvero? Io pensavo che servisse solo alla prima (this che diventa const
*). Siamo sicuri che anche l'oggetto restituito dal metodo diventa
automaticamente const?
EMG

consiglio di verificare se ci sono errata in rete x il libro.
Gli errata ci sono ma quella pagina non compare, e cmq sono stato
fortunato ad avere la seconda ristampa con gli errori gia' corretti.
Comunque in effetti come Max ha fatto notare _string era un char*
quindi la constness stava nel puntatore a quel certo carattere.
Comunque a prima vista la definizione di metodi const e magari
relativi data members mutable mi sembra un po' una cosa rattoppata..
-- 
Saluti,
 Francesco Cipriani - 
http://village.flashnet.it/~rm03703

lvalue se str è const.
Interessante! E molto furbo :-)


T *metodo() const;
Spero di no..allora, la prima ritorna un puntatore a T costante,
la seconda e' un puntatore costante a T, la terza ritorna un
puntatore al tipo T e si impegna a non toccare i dati della classe
dove e' definita. Cmq la funzione che avevo scritto io era lecita
in quanto in pratica c'era di mezzo un puntatore e il valore
restituito era char* const, e si poteva modificare il campo tramite
puntatore. Per avere qualcosa di piu' blindato ci voleva, credo:
const char& String::operator[](int i) const {};
Pero' mi vengono dei dubbi.. const char& e' una reference a carattere
costante, giusto? Quindi dovrebbe andare, no?
-- 
Saluti,
 Francesco Cipriani

 Per avere qualcosa di piu' blindato ci voleva, credo:
Devi comunque considerare che in C++ i controlli di accesso non sono
fatti per proteggere contro intrusioni volute ma contro quelle
involontarie.
EMG



Come sempre (o quasi) non sono stato preciso. Con 'ritorna (const
int)' non mi riferivo al tipo ritornato dalla funzione (che non e' il
function type e rimane quello della dichiarazione) ma al tipo di 'i'.
Se il tipo di ritorno non e' un const il compilatore alza un warning.
Dallo standard non sono riuscito a capire se il compilatore deve dare
un warning (come DJGPP) o un errore (come VC5).
Alberto

costante, giusto? Quindi dovrebbe andare, no?
Basta "const T&" nel caso di reference, questo perche` un reference
al contrario dei puntatori non e` modificabile.
