Newsgroup: it.comp.lang.c++
Titolo: Vector di puntatori a stringhe

Ciao. Sono un nuovo apprendista di questo linguaggio. Attualmente sto'
basando i miei studi su C++ Primer 4 ed.
Mi trovo a dover affrontare un esercizio per me difficile da capire.
Il testo è il seguente:
Write a program that defines a vector of pointers to strings. Read the
vector, printing each string and its corresponding size.
Non riuscendo a risolvere ho cercato un po' nel web ed ho trovato una
possibile soluzione:
const int maxSize = 5;
	vector<string*> psvec(maxSize);
	for (int i = 0; i != maxSize; ++i)
	{
		psvec[i] = new string("Some string. ");
		cout << *psvec[i] << "Length: " << psvec[i]->length() << endl;
	}
Quel che non mi è chiaro e che non sono riuscito a trovare è questa
riga:
vector<string*> psvec(maxSize);
perchè non è l'equivalente di:
vector<string>  *psvec;       // puntatore a un vector<string>
in altre parole se:
string* p;
e
string *p
sono entrambi puntatori a stringa, i due vettori sopra in cosa
differiscono?
Eventualmente potreste mostrarmi altri esempi riguardo l'esercizio?.
Grazie.

differiscono?
La sintassi dei due vettori sopra non è la stessa di questo caso, tra
stringhe. Sarebbe stata la stessa se avessi scritto:
vector<string>* p;
vector<string> *p;
In generale, dato:
T * p; // con T tipo qualsiasi...
La scrittura che si preferisce è:
T *p;
perché aiuta a riconoscere i puntatori in un contesto di dichiarazione
come il seguente:
T *p1, *p2;
da leggere come *p1 è un T, *p2 è un T.
Mentre vi sarebbe ambiguità nel caso:
T* p1, p2;
perché saresti portato a credere che p1 e p2 sono entrambi puntatori,
quando la dichiarazione equivale a:
T* p1;
T p2;
Comunque, non c'è ambiguità nel tuo caso, le due scrittura:
vector<T*> v1;
vector<T> *v2;
sono due cose assolutamente distinte.

 vector<string> *p;
Ecco. Questo era il codice che mi causava problemi. Continuavo a dare
per scontato che
vector<string*> psvec(maxSize);
fosse equivalente a
vector<string>  *psvec;
Il libro non riportava  la prima forma e in rete non ho trovato
materiale a riguardo e
qui tu mi hai spiegato bene la differenza.
Grazie . Hai fatto bene a non risolvermi l'esercizio, ora me la vedo
io seguendo i tuoi suggerimenti.
Ciao.

Ti costringe a pensare e ripensare più volte lo stesso concetto.
E' lo scopo di un libro del genere: costringere a pensare :-)
Il fatto è che non è semplicissimo il linguaggio e di conseguenza non
è facile spiegarne le caratteristiche, però devo ammettere che è un
libro fatto veramente bene. Prova anche con Thinking in C++ di Bruce
Eckel, lo scarichi gratuitamente da 
www.mindview.net
. Dovrebbe essere
alla terza edizione, se non ricordo male. Dalla terza edizione alla
quarta, comunque, C++ Primer è divenuto più organizzato e molto meno
dispersivo (almeno questa era l'idea che mi dava la terza edizione).

 La scrittura che si preferisce è:
Quel *si* a chi sarebbe riferito?
Perché è per esempio da 
http://www.research.att.com/~bs/bs_faq2.html#whitespace
[...]
A ``typical C++ programmer'' writes ``int* p;'' and explains it ``p is a 
pointer to an int'' emphasizing type. Indeed the type of p is int*. I 
clearly prefer that emphasis and see it as important for using the more 
advanced parts of C++ well.
[...]
Ciao.

 Quel *si* a chi sarebbe riferito?
A gran parte dei programmatori C e C++, come si è avuto modo di
discutere spesso.
B.S. dice: "The choice between ``int* p;'' and ``int *p;'' is not
about right and wrong, but about style and emphasis.", quindi
giustifica esattamente quello che sto dicendo: è una scelta di
"enfasi".
E di seguito aggiunge:
"The critical confusion comes (only) when people try to declare
several pointers with a single declaration:
	int* p, p1;	// probable error: p1 is not an int*
"
che è esattamente il caso di cui sto parlando io, in cui l'enfasi è
appunto ambigua.
Se si ha il caso:
int* p, i;
è *MOLTO* meglio scrivere:
int *p, i;
oppure, fugando ogni dubbio possa nascere:
int *p;
int i;

 int *p, i;
Io direi che entrambe sono da scartare alla grande...
Ciao.

 stento a crederlo, ma direi che è assolutamente ininfluente.
Quel pò che conosco lo sto imparando dal Lippman e anche lui
sconsiglia l'uso della forma
int* p;
perchè fuorviante.
In sostanza non dice che è una cattiva abitudine ma di adottare uno
stile e mantenerlo coerente.
Più o meno anche scrivendo questo codice è ammesso:
const int a = 10;
int const b = 20;
Solamente che l'uso del const dopo il tipo è meno impiegato, anche se
lo stesso Lippman consiglia di provare a scrivere per capire alcuni
tipi di costrutti.
Ciao.

 Ciao.

 perchè fuorviante.
Tra gli autori che ho citato l'unico di cui non ho un libro al momento 
disponibile è proprio Lippman, quindi per confermare ciò che ricordavo 
(ero convinto che anche lui preferisse questo stile) ho cercato con 
Google qualche frammento di codice scritto da lui, ed il primo che ho 
trovato (il suo vecchio blog su msdn, il primo link che appare cercando 
Lippman) confermava ciò che ricordavo, per cui non sono andato avanti 
nel cercare altre conferme (o smentite). In ogni caso fra gli autori da 
me citati sarebbe l'unico (per quanto riguarda gli altri ho verificato 
sui libri).
Ciao.

 niente), ma non mi ricordo di queste discussioni,
Shinmen, di questo problema nella dichiarazione si discute spesso
ovunque nei gruppi e nei testi.
Oltretutto è una questione piuttosto sterile, che riguarda
semplicemente lo stile di ogni programmatore.
Non c'è alcun problema nell'usare "int *p" o "int* p", l'ambiguità
esiste solo nel caso nei casi da me già citati (peraltro anche da
Stroustrup). Sul fatto di preferire "int* p" in C++ e quindi fare una
scelta di enfasi sul tipo, poi, posso essere d'accordo. Io so *per
certo* che molti programmatori, sia C che C++, preferiscono la forma
"int *p" a "int* p". Tutto qui.

 Google qualche frammento di codice scritto da lui
Be', qui ad esempio:
http://blogs.msdn.com/slippman/archive/2004/08/27/221373.aspx
Lippman usa lo stile "T *p" e non "T* p" (si parla di C++/CLI e non di
semplice C++, ma il discorso non cambia molto).
Oppure qui: 
http://msdn.microsoft.com/msdnmag/issues/07/02/NettingC/default.aspx?loc=it
//native code clone pattern ...
class AndQuery : public Query {
public:
    virtual Query *clone() const
          { return new AndQuery( *this ); }
    // ...
};
Ma sono sicuro che cercando ancora spuntano fuori altri esempi.

 la forma "int *p" a "int* p". Tutto qui.
I programmatori C, come già detto li escluderei in quanto irrilevanti su 
questo NG, per quello che riguarda i programmatori C++ io so *per certo* 
che molti preferiscono la forma "int* p" a "int *p". Tutto qui. :)
Ciao.

 
http://blogs.msdn.com/slippman/archive/2004/08/27/221373.aspx
Come ho detto mi sono fermato al primo link ed al primo codice visto. 
Tra l'altro scorrendo verso il basso si vede quanto lo stesso Lippman 
predichi bene nel libro ma razzoli molto male nel codice :) scrivendo 
prima int^ result e poche righe più in basso Rectangle  ^hit
Ciao.

prima int^ result e poche righe più in basso Rectangle  ^hit
Non capisco dove vuoi arrivare col tuo "razzoli molto male". Si
tratta, come già detto, di regole stilistiche. Discutere di questo
argomento è come discutere del sesso degli angeli.

questo NG, [...]
A volerla dire tutta, non esistono i programmatori C e i programmatori
C++, come categorie distinte e separate: esistono programmatori C++
che, normalmente, hanno programmato per anni in C e quindi è lecito
che molti di loro (come di fatto è) adottino regole di programmazione
dettate dal buon senso. Nessuno, da nessuna parte, è "irrilevante".
Se vuoi continuare in questa discussione sterile e stupida, cercati un
altro interlocutore perché ignorerò il thread. Io conosco decine di
programmatori C e C++ che preferiscono adottare il metodo da me
descritto. Non continuerò questo battibecco stupido, come già detto.

 tratta, come già detto, di regole stilistiche.
Come riportato da Andrea (non tu), Lippman nel suo libro dice di 
scegliere lo stile che si preferisce ma di essere poi coerenti ed 
utilizzare sempre lo stesso. Nel suo codice però utilizza uno stile in 
una riga e l'altro poche righe dopo... Questo non è propriamente essere 
coerenti.
Ciao.

 Se vuoi continuare in questa discussione sterile e stupida
Veramente sei tu che stai continuando in questa discussione sterile e 
stupida travisando ciò che dico ed insistendo, in modo tra l'altro 
piuttosto maleducato ed arrogante, sul fatto che sia solo una questione 
di stile, bla, bla, bla... però ribadendo immancabilmente che quasi 
tutti i programmatori che conosci tu utilizzano un certo stile. Se non è 
importante perché non perdi occasione per farlo notare?
Poi, per carità, se ti fa contento lo scrivo anche io che tutti i 
programmatori C/C++ preferiscono scrivere int *p piuttosto che int* p...
Ciao.

  p...
Boh, ultimamente sto programmando poco in C++ e molto in altri
linguaggi (alcuni addirittura non degni del nome di linguaggio),
quindi sicuramentenon faccio testo.
Ma tra int* p e int *p preferisco la seconda perche' e' piu' chiara
quandosono coinvolte piu' variabili, come ad esempio:
standard " *"
int 	*p, *q; // e' chiaro, p e q sono puntatori
int 	*p, q; // q non e' un puntaore
ma se voglio rispettare lo standard "* " come scrivo le due
dichiarazioni?
int* p, * q; // spaziatura fantasiosa, ma passabile
int* p, q; // molto poco chiaro
e quest'ultima diventa peggiore se, come alcuni usano fare, si usa
unatabulazione invece della spaziatura
int*	    p, q; // qui sembra proprio che p e q siano dello stesso tipo
.. alla fine, comunque, uno standard vale l'altro, e se non si
vuoleandare incontro a problemi basta scrivere:
int *p;
int *q;
o
int* p;
int* q;
in entrambi i casi sembra chiaro che p e q sono dello stesso tipo, e
sono del tutto equivalenti se trascuriamo il costo di usura dei tasti
"i", "n" e "t" =)
--
Marco
 
-- 
I'm trying a new usenet client for Mac, Nemo OS X.
You can download it at 
http://www.malcom-mac.com/nemo

 int 	*p, q; // q non e' un puntaore
Sono d'accordo che non sia chiaro, ma questo è un problema che non 
sussiste in C++ (e da un po' neppure in C) in quanto le dichiarazioni 
delle variabili vanno fatte: il più tardi possibile, con lo scope minore 
possibile, inizializzandole (quasi) sempre (sono pochi i casi in cui può 
essere preferibile non inizializzarle), e quindi una per riga :-P
Ciao.

 riga :-P
La deduzione non mi e' chiara, dal momento che
int *p = a, *q = b;
e' legale sia in C che in C++, ed e' equivalente a:
int *p = a;
int *q = b;
Tutte le forme con numero variabile di spazi prima e dopo
l'asteriscosono equivalenti.
L'unico motivo per preferirne una tra le tante e' la solo materia
distile di programmazione (materia del tutto personale).


 distile di programmazione (materia del tutto personale).
Però credo che nessuno scriva
* p = a;
e quindi perché scrivere
int* p = a;
?
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg
The EMG Music page:         
http://www.emagsoftware.it/emgmusic
 

  ?
L'asterisco nelle due espressioni indica due cose diverse, quindi
mipare perfettamente giustificabile usare due notazioni diverse.
Comunque forse non sono stato chiaro ma anch'io preferisco la
notazione int *p, semplicemente mi pare inutile discuterne: essendo
sintatticamenteequivalenti, e' pura estetica (cosi' come indentazione,
graffa
inlinea o a capo, ecc...).


 mipare perfettamente giustificabile usare due notazioni diverse.
Be', diverse fino ad un certo punto. Stiamo comunque parlando di puntatori e 
asterischi. :-)


 Be', diverse fino ad un certo punto.
Io direi proprio completamente diverse. Viene usato accidentalmente lo
stesso segno, ma non c'č nessuna ragione per la quale non si potevano usare
costrutti diversi. Anzi, io trovo che l'uso dello stesso segno sia piů
fonte di confusione che altro. 
Per il neofita, intendo. Ho visto alcuni che, convinti si trattasse di due
impieghi dello stesso "operatore", cercavano di applicare lo stesso
ragionamento a '&' (dichiaratore di reference / operatore address-of) e
andavano in crisi.
Max

 Io direi proprio completamente diverse.
A parte che hai tolto la faccina che indicava che un po' stavo scherzando. 
Comunque fino ad un certo punto: stiamo parlando di stile sintattico non di 
semantica. E dal punto di vista formale non c'è poi tutta questa differenza, 
neanche se fosse stato un simbolo diverso.


  Stiamo comunque parlando di puntatori e asterischi. :-)
Mi pare una differenza non da poco, nonostante siano entrambi
asterischi.
