Newsgroup: it.comp.lang.c++
Titolo: Vettore allocato dinamicamente in una struttura

Ciao, scusate se riposto il messaggio ma ho spedito la bozza con le idee e  
non il messaggio finale,
Il mio problema è la gestione di un vettore allocato dinamicamente in una  
lista di strutture.
Nel file .hpp definisco la struttura e il vettore v:
typedef struct Word
{ char* Name;
   vector<int> v;
   Word* Next;
   Word()
   {Next=NULL;
    Name=NULL;
   }
};
typedef Word* ListPtr;
Nel file .cpp costruisco la struttura e vorrei anche gestire il vettore:  
come ad esempio, azzerarlo.
Nel file .cpp il punto dove definisco la struttura è questo...
CList:: CList()
{
   int i;
   Head = new Word;
   Tail=Head;
   CurrentPtr = Head;
   v.pushback(10); //Mi ritorna un errore nella funzione pushback, dice che  
non è definita.
   for (i=0;i<10;i++)
   Tail->v[i]=1; //Mi ritorna Segmentation Fault
}
Devo cercare in qualche modo di azzerare la lista, definire il num di  
elementi ecc ecc
In sintesi non riesco a farci nulla...  mi aiutate?
Grazie mille
Daniele
"Il saggio non schiaccia gli
altri con la sua superiorità; non
li umilia mettendo in rilievo la
loro incapacità."
Confucio

 non è definita.
push_back()
http://www.cppreference.com/cppvector.html

 
http://www.cppreference.com/cppvector.html
si, devo mettere v.push_back(10), ma non riesco cmq ad accedere in nessun  
modo al vettore allocato nella struttura.
Grazie cmq
Daniele

 modo al vettore allocato nella struttura.
certo perchè il vettore è dinamico!
Devi fare
...
   Head = new Word; //hai defrinito Word* Head; e Word*Tail; mi
immagino.....
   Tail=Head;
   CurrentPtr = Head;
   v.pushback(10); //a cosa serve?
   for (i=0;i<v.size();i++) //anche se non capisco il senso di questo for,
almeno non da segmentation fault...
       Tail->v[i]=1; //il vettore è dinamico e non hai bisogno di
"azzerarlo"!
...
Prima di imbatterti nelle STL ti consiglio di darti almeno un pò di lettura
a della documentazione a riguardo....


Lo sto facendo ma ogni volta ho problemi nuovi... :-)
Daniele

 In sintesi non riesco a farci nulla...  mi aiutate?
Probabilemnte ti conviene cominciare a studiare il C++ dall'inizio,
partendo dalle cose piu` semplici, lasciando perdere i puntatori per
un po' di tempo, e senza andare per tentativi.
        Mauro

         Mauro
:oD

 Se non lo azzero me lo setta automaticamente tutto a 1
No forse non ho spiegato bene. Il vettore non ha un numero di elementi
fissato (per lo meno a te non serve che il numero di elementi sia per forza
10).
Ogni volta che inserirai un elemento farai v.push_back(valore) e il vettore
conterrà ogni volta 1,2,3,...n elementi ed ogni volta ne avrà uno nuovo...
in una sola parola è "dinamico"! :o)
Quindi mentre per un vettore statico magari faresti
int v[10];
for (i=0;i<10;i++)
    v[i] = 0; //azzera i 10 elementi
col vettore dinamico non ne hai bisogno, perchè il vettore all'inizio è
vuoto e si riempie man mano che inserisci (push_back()) nuovi elementi. Se
proprio vuoi allocare per forza sti benedetti 10 elementi e azzerarli puoi
fare:
std::vector<int> v;
v.reserve(10); //alloca nel vettore 10 elementi
for (i=0;i<10;i++)
    v[i] = 0;
Ciao Andrea

     v[i] = 0;
Il vettore e` ancora vuoto, quindi non puoi usare gli elementi 
da 0 a 9.
Per un vettore di 10 zeri:
  vector<int> v1(10);
  vector<int> v2(10, 0);
 
  vector<int> v3;
  v3.resize(10, 0)
  vector<int> v4;
  ...
  v4.assign(10, 0);
  vector<int> v5;
  fill_n(back_inserter(v5), 10, 0);
        Mauro

Capisco che non sono bravo nel C++, capisco anche che non ho letto tutto  
il manuale... ma da lì ad un'umilazione personale di questo calibro ce ne  
passa parecchio.
Se invece di polemizzare mi avresti detto dove sbagliavo forse facevi una  
figura più da signore e non la classica figura del secchioncello che per  
far vedere che sà liquida il problema con la frase: "Cosa sono tutte  
queste porcherie!".
Cordialmente e con rispetto
Daniele
PS: Se leggevi bene capivi che non era una struttura ma una lista di  
strutture, cmq accetto le tue critiche non costruttive.

 
No. Semmai
  v.resize(10); //alloca nel vettore 10 elementi
'reserve' non serve a modificare la dimensione del vector, ma soltanto a
stabilire la dimensione massima entro la quale non avrà luogo una nuova
riallocazione.
Max

 da 0 a 9.
Non è vero. Posso farlo benissimo!
v.reserve(10) assicura che il vettore non riallochi memoria fino a 10
elementi perchè alloca lui i 10 elementi. Quindi i primi 10 elementi, seppur
non inizializzati (sono "grezzi"), sono accessibili.
In ogni caso posso essere d'accordo che è preferibile di solito usare
resize() (che inizializza gli elementi al default e modifica anche il valore
restituito da size()), ma in questo specifico caso (seppure discutibile),
l'inizializzazione veniva fatta a "mano".
Ciao
Andrea

 Max
Sono d'accordo con te sull'uso del reserve e del resize, eccetto per il
fatto che nel reserve l'allocazione viene effettivamente fatta.
Ciao
Andrea

 v[0] = 4;
No. 'v[i]' ha comportamento definito soltanto con i<v.size().
Max

 Max
Ah si? dove lo hai letto questo? Puoi darmi il link o il libro sul quale c'è
scritto?
Da me
std::vector<int> vect;
vect.reserve(10);
for (int i=0;i<10;i++)
    vect[i]=0;
funziona benissimo...
Ciao
Andrea

 ha scritto nel messaggio
news:opsbhtfe...@localhost.localdomain...

Non te la prendere, Daniele, però, in effetti una cosa è domandare qualcosa
che non si ha ben capito e un'altra è postare una richiesta e del codice che
non stanno insieme.
Prendila come ti pare, tuttavia se vuoi veramente migliorare, devi studiare
e non saltare i capitoli.
Purtroppo si evince che le tue lacune sono importanti, non è solo questione
di non conoscere come si usa std::vector, la questione è che il codice che
hai scritto non ha purtroppo alcun senso.
Avevo risposto anche all'altro post che avevi mandato, ma ora che ho visto
il resto del codice ritengo che devi lavorare ancora tanto.
Prendila come vuoi, ma è una critica costruttiva, devi prendere atto se vuoi
progredire che sei ancora in una fase dove non capisci bene quello che
scrivi (riguardo al C++), le osservazioni che ti ha fatto Mauro Casini, sono
ahìme tutte giuste e "pesanti" (nel senso che mettono in evidenza il fatto
che la programmazione ti è ancora estranea, almeno in C++).
Riprovaci e vedrai che saremo lieti di aiutarti, tanti in questo NG vengono
ogni giorno aiutati, però ognuno deve fare i propri sforzi.
ciao.

 spazio per 10 elementi, cosa che tu hai inizialmente negato. Sbagliando.
Ma nemmeno per sogno. Non ho negato che 'reserve' allochi spazio per 10 
elementi. Se la 'capacity' è 0, 'reserve' allocherà certamente spazio 
sufficiente per poter successivamente accogliere almeno 10 elementi senza 
effettuare ulteriori allocazioni.
Quegli elementi, però, non ci sono. Non puoi farvi riferimento, né 
applicarvi l'operatore assegnamento.
Ora, è ovvio che se il tipo è 'int'  e l'implementazione di 'vector' in 
qualche modo ti "assiste", scrivere 'v[n]' con n < v.capacity() può anche 
non produrre effetti sgradevoli visibili. Ma pensa al caso generale, in cui 
il tipo è una classe qualsiasi: 'reserve' alloca spazio ma non costruisce 
alcun oggetto. Trattare una qualsiasi locazione come se vi fosse stato 
creato un oggetto, quando ciò non è avvenuto, produce effetti indefiniti.
Prova questo, ad esempio:
        std::vector<std::string> v;
        v.reserve(10);
        v[0] = "ciao";
Max

        v[0] = "ciao";
Ok. Correggo il ciclo che avevo postato:
std::vector<int> v;
v.reserve(10); //alloca nel vettore 10 elementi
for (i=0;i<10;i++)
   v.push_back(0);