[RISOLTO] Cosa sbaglio con la classe vector? (C++)

[giuscri]

Sto dando un'occhiata alla classe vector: sembra possa essermi molto utile. Ho cominciato a scrivere queste righe di codice ma sull'array non riesco a caricare nulla.
Posto:

#include <iostream>
#include <fstream>
#include <vector>

void loadVector (std::vector<int> );
void printVector (std::vector<int> );

int main(){

	std::Vector<int> v(5);
		//dichiaro un array "lungo 5";

	loadVector(v);
		//carico vettore da file già stabilito

	printVector(v);
		//stampo array

	
}

void loadVector(std::vector<int> vett) {

	std::ifstream ingresso;
	
	int dato;

	int i = 0;

	ingresso.open("dati.txt");
		//"dati.txt" e' presente nella stessa
		//cartella dell'eseguibile

	ingresso >> dato;

	while ( !ingresso.eof() ){

		vett[i] = dato;

		i++;

		ingresso >> dato;

	}

	ingresso.close();

}

void printVector(std::vector<int> vett){

	for(int j = 0; j < vett.size(); j++)
		std::cout << vett[j] << " ";

	std::cout << std::endl;

}

Quella che viene stampato è un riga di 5 zeri, nonostante il file "dati.txt" contenga una riga di 6 interi.

?!

Grazie per la pazienza!

[claudio862]

Nella funzione "loadVector()" passi "v" per valore, quindi viene copiato dentro quella funzione, e la variabile del chiamante (main()) non viene modificata. È esattamente quello che succede con i tipi primitivi, come int:

void f(int b)
{
    // Modifica "b", variabile locale di "f()".
    b = 5;
}

int main()
{
    int a = 4;

    // Il valore di "a" viene copiato dentro la variabile locale "b" di "f()".
    // La variabile "a" non viene modificata.
    f(a);

    std::cout << a << '\n';
    // Stampa 4, non 5.
}

Quindi la funzione "loadVector()" legge effettivamente i valori dal file, però li copia in un vettore che è una variabile locale della funzione "loadVector()", e il vettore del main() non viene modificato.

Potresti passare il vettore come riferimento (funzionerebbe anche passandolo come puntatore, ma per riferimento è più sicuro):

void loadVector(std::vector<int> & v)
{
    // Modifica "v".

    // "v" è un riferimento ad una variabile passato dal chiamante.
}

int main()
{
    std::vector<int> v;

    // Passa alla funzione un riferimento a "v". Tutte le modifiche verranno
    // fatte sulla variabile "v" del main().
    loadVector(v);
}

Oppure puoi semplicemente restituire un vettore, come faresti con un intero:

std::vector<int> loadVector()
{
    std::vector<int> v;
    // "v" è una variabile locale a questa funzione.

    // Modifica "v".

    // Restituisce questa variabile al chiamante.
    return v;
}

int main()
{
    std::vector<int> v = loadVector();
    loadVector(v);
}

[giuscri]

"claudio86":Nella funzione "loadVector()" passi "v" per valore, quindi viene copiato dentro quella funzione, e la variabile del chiamante (main()) non viene modificata. È esattamente quello che succede con i tipi primitivi, come int.

Questo non mi era per nulla chiaro. Grazie!