[C++]Problema Vector

[Luc@s]

Per studiare gli iteratori e gli algoritmi generici ho sfornato sto cod:

#include <iostream>
#include <vector>
#include <string>

using namespace std;

vector<int> elabora(vector<int> &elem);

int main()
{
	int def[5]={'1', '3', '9', '4', '7'};
	vector<int> es(5, def);
	elabora(es);
	return 0;
}

vector<int> elabora(vector<int> &elem)
{
	sort(elem.begin(), elem.end());// ordina
	vector<int>::iterator it = elem.begin();// itera e monstra
	for(;it<elem.end();it++)
	{
		cout << *it <<endl;
	}
	return elem;
}

Ma mi da:

Compilatore: C++ Optimized Maximum
Esecuzione di g++.exe...
g++.exe "C:\Documents and Settings\Admin\Desktop\Vector.cpp" -o "C:\Documents and Settings\Admin\Desktop\Vector.exe" -fexpensive-optimizations -O2 -I"C:\Dev-Cpp\include\c++" -I"C:\Dev-Cpp\include\c++\mingw32" -I"C:\Dev-Cpp\include\c++\backward" -I"C:\Dev-Cpp\include" -L"C:\Dev-Cpp\lib"
C:/Documents and Settings/Admin/Desktop/Vector.cpp: In function `int main()':
C:/Documents and Settings/Admin/Desktop/Vector.cpp:12: invalid conversion from

`int*' to `int'
C:/Documents and Settings/Admin/Desktop/Vector.cpp:12: initializing argument
2 of `std::vector<_Tp, _Alloc>::vector(unsigned int, const _Tp&,
std::_Vector_base<_Tp, _Alloc>::allocator_type&) [with _Tp = int, _Alloc =
std::allocator<int>]'

Esecuzione terminata

[r0x]

Non:

vector< int > es( 5, def );

Ma:

vector< int > es( def, def + 5 );

P.S.: non passare/ritornare strutture complesse per valore, perche` vedo che lo fai spesso.

[Luc@s]

grazie r0x, ti ho visto ora!
Cmq io(come te) ho poi risolto cosi:

 #include <vector>
#include <string>
#include <cstdio>
#include <algorithm>
#include <iostream>


using namespace std;

// PROTOTIPI
vector<int> elabora(vector<int> &elem);
// \PROTOTIPI

int main()
{
    int def[5]={ 1,3,9, 4, 7};
	vector<int> es(def, def+5);
	elabora(es);
	system("PAUSE");
	return 0;
}
/**
* Elabora il vettore passato per riferimento
*/
vector<int> elabora(vector<int> &elem)
{
    /*
	* Lo ordina
	*/
	sort(elem.begin(), elem.end());
	/*
	* Lo itera e ciclando lo mostra
	*/
	vector<int>::iterator it = elem.begin();
	for(;it<elem.end();it++)
	{
		cout << *it <<endl;
	}
	return elem;
}

>P.S.: non passare/ritornare strutture complesse per valore, perchè vedo che lo fai spesso.

So che rompo, whi?

[r0x]

Perche` chiami 98570923673 costruttori di copia.

Ah un`altra piccola nota: quando confronti degli iteratori usa != perche` il < non sempre e` supportato (vedi il for).

[Luc@s]

Originariamente inviato da r0x
Perche` chiami 98570923673 costruttori di copia.

Ah un`altra piccola nota: quando confronti degli iteratori usa != perche` il < non sempre e` supportato (vedi il for).

Tnk per la nota!
Per i valori.............cosa mi suggereresti quindi?

[r0x]

Esempio banale. Invece che:

Oggetto funzione() { ... }
...
Oggetto o = funzione();

Fai:

void funzione( Oggetto& ) { ... }
...
Oggetto o;
funzione( o );

O in modo piu` esplicito tramite un puntatore, altrimenti non ti rendi conto, guardando la chiamata, di quando un parametro venga passato per riferimento, essendo la sintassi identica al passaggio per valore:

void funzione( Oggetto* ) { ... }
...
Oggetto o;
funzione( &o ); // il '&' evidenzia una potenziale modifica del parametro attuale

E per parametri non destinati ad essere modificati fai sempre:

void funzione( const Oggetto& ) { ... }

I tipi primitivi invece passali sempre per valore. Questo ovviamente quando non si richiede side-effect.

[Luc@s]

quindi diventera:

 vector<int> elabora(vector<int> elem);

vector<int> elabora(vector<int> elem)
{
	sort(elem.begin(), elem.end());// ordina
	vector<int>::iterator it = elem.begin();// itera e monstra
	for(;it<elem.end();it++)
	{
		cout << *it <<endl;
	}
	return elem;
}

Giusto?

[r0x]

Scusa ma non hai capito una mazza.

E poi che utilita` ha qui il 'return'?

vector<int> elabora(vector<int> &elem)
{
    /*
	* Lo ordina
	*/
	sort(elem.begin(), elem.end());
	/*
	* Lo itera e ciclando lo mostra
	*/
	vector<int>::iterator it = elem.begin();
	for(;it<elem.end();it++)
	{
		cout << *it <<endl;
	}
	return elem;
}

Tolto 'return' e il tipo restituito:

void elabora(vector<int> &elem)
{
    /*
	* Lo ordina
	*/
	sort(elem.begin(), elem.end());
	/*
	* Lo itera e ciclando lo mostra
	*/
	vector<int>::iterator it = elem.begin();
	for(;it<elem.end();it++)
	{
		cout << *it <<endl;
	}
}

[Luc@s]

a si!
Mi ero dimenticato di togliere il return

[r0x]

A parte quello.. la penultima versione e` farlocca, passi il parametro per valore. Ho rimesso il '&' della prima versione.