Newsgroup: it.comp.lang.c++
Titolo: passare un puntatore di un vector: come?

Dovrei passare un vettore ad una funzione.
Come evitare che la funzione si ricopi tutto il vettore?
per la funzione:
void nome_funzione(vector<int> v)
viene copiato il vettore passato creandone uno identico v oppure v è ul
"link" a quello passato?
ne caso il vettore venga copiato come come evitare questo?
Grazie in anticipo, Mario.

 
void nome_funzione(vector<int> * v)	// puntatore
void nome_funzione(vector<int> & v)	// reference
-- 
"Come un nano sull'orlo di un orinale dovevo muovermi in punta dei piedi"

 void nome_funzione(vector<int> & v) // reference
quale è la differenza?
come gestisco o accedo a  v nel codice:  v.push_bach(...) oppure
*v.push_.... oppure.....?
Grazie ancora, Mario.

_mario lat wrote:

nel primo caso v->push_back(...)
nel secondo caso v.push_back(...)


 >>void nome_funzione(vector<int> & v) // reference
Quale dei due mi consigli?
quale è la differenza?
Per quanto riguarda il "return vector" cosa mi consigli?
(devo usare vettori molto lunghi!)
Grazie!
Mario.


Miiiii, ma questi sono argomenti che trovi in un qualunque 
libro/tutorial di C++, dopo le prima 20 pagine :D
Cmq, il reference e' poco piu' di syntactic sugar per i puntatori - 
probabilmente nel tuo caso e' la scelta migliore.
Per ritornare grossi vector, allocali con new, e ritorna un puntatore 
(ricordati pero' di distruggerlo prima o poi con un delete...), oppure 
fatti passare un vector vuoto per reference, e riempilo all'interno 
della funzione. Dipende sempre comunque dal genere di operazioni che 
devi fare.
-- 
Mat/tia Belletti - Undergraduate student @ 
cs.unibo.it
ICQ: 33292311    - email: 
mbel...@cs.unibo.it
IRC: RedGlow     - site(s): 
http://www.cs.unibo.it/~mbellett
Linux registered user 299762 @ Linux registered machine 213003

che ne pensate se faccio qualcosa di simile?
vector<int> funzione()
{
     vector<record_completo> v;
     while(...) //10000 volte
     {
            v.push_back(...);
     }
 return v;
}
Grazie, Mario.

 ha scritto nel messaggio
news:LK7Oc.21711$OH4.5...@twister1.libero.it...

Pesante esattamente quanto funzione(vector<int> v) infatti richiameresti la
funzione in questo modo:
vector<int> v;
v = funzione(); //esegue una copia bit a bit del vettore restituito da
funzione() in v quindi è come se passassi v per valore cioè
funzione(vector<int> v). Se vuoi aumentare l'efficienza su vettori di grandi
dimensioni sui cui devi fare numerose push_back dentro un ciclo (come nel
tuo caso), è meglio usare prima del ciclo v.reserve(10000) in modo da
allocare all'inizio lo spazio sufficiente a tutti gli inserimenti.
P.S.
Cosa vuol dire <record_completo>?
Ciao Andrea

 Cosa vuol dire <record_completo>?
scusami! in realtà v è un vector di una struct ... ma per farmi capire
meglio
ho fatto un vector di int. solo che nel cambiamento del codice... ho
dimenticato di mettere int al posto di record_completo
Grazie per avermi risposto,Mario.
====================================================


Grazie, Mario
Di niente.
Ciao, Andrea

 }
non č piů elegante qualcosa come:
vector<int> *   funzione()
{
    vector<int>  v;
    v.reserve(10000);
   for (int i = 0; i< 10000;i++)
            v.push_back(...);
        return v;
 }
e uso la funzione come:
vector<int> x=funzione();
Sintatticamente č corretto? ho messo bene i simboli di puntatore ec...
ec...?
Grazie ancora, Mario.

 {
Sicuramente questa è la soluzione più efficiente tra quelle discusse. 
Va ricordato comunque che un buon compilatore, nei casi in cui una 
variabile locale è restituita per valore, è in grado, a certe condizioni, 
di ottimizzare al punto di far coincidere "fisicamente" la variabile locale 
con l'oggetto temporaneo restituito. Se provi il seguente codice con una 
versione sufficientemente recente del GCC (credo > 3.3.0)... 
 struct A
 {
        A() {   cout << "A() " << this << endl; }
        A( const A& ) { cout << "A(A) " << this << endl; }
        ~A() {  cout << "~A() " << this << endl; }
 };
 A func()
 {
        A a;
        return a;
 }
 int main()
 {
        A a = func();
 }
scoprirai che, nonostante siano dichiarate due variabili e sia restituito 
un oggetto per valore, viene in realtà costruito *UN* solo oggetto A. (Una 
piccola magia permessa dallo Standard.)
Max

C'è qualcosa che non va nella sintassi:
Come si scrive questa funzione?
vector<int>*  rappresentanti::carica_records_in_vettore()
{
 vector<int> v;
 while(...)
     {
    ...
      v.push_back(rc);
     }
 return &v;
}
Grazie, Mario.

 Come si scrive questa funzione?
Non si scrive...!
vector<int>*  rappresentanti::carica_records_in_vettore()
{
 vector<int> v;
 while(...)
     {
    ...
      v.push_back(rc); //rc? bho ma cosa è? come lo crei?
     }
 return &v; //restituisci una variabile locale? E' un errore o meglio un
ORRORE proprio da niubbio!
}//v viene cancellato qui!
Chiamando la funzione così:
int main(void) {
vector<int> *gv;
v = carica_records_in_vettore(); //supponiamo che la funzione non appartenga
alla classe rappresentanti
//qui gv risulta ancora vuoto! Ma... che bello eh?
}
P.S. ma l'hai capito il consiglio che ti abbiamo dato?
Ciao
Andrea

> P.S. ma l'hai capito il consiglio che ti abbiamo dato?
Scusami, rileggendo i post ho capito ( la migliore è quella che usa &v )
Il mio insistere sul puntatore è dovuta ad una erata interpretazione della
tua e-mail.
Grazie (a te e a tutti)  per il tempo che hai dedicato per rispondermi.
Mario.