Newsgroup: it.comp.lang.c++
Titolo: Novellino del C++ alle prese con la creazione di Array

Exit code: 1
Grazie 1000 in anticipo a tutti
Ciao Marco

 char[] inizializzaArray (int dim){
Non puoi restituire un array in questo modo. Utilizza std::vector<char>
E.

 }
Come ti hanno già fatto osservare, invece degli array dovresti usare dei
contenitore STL (std::vector va di sicuro bene). Impararsi i dettagli degli
array non deve essere una priorità se sei un principiante, anzi
probabilmente è pure dannoso. Un oggetto vector, per esempio, ha un metodo
size() per sapere quanti elementi contiene, può essere passato come
argomento e restituito come risultato, e non richiede di deallocare la
memoria con delete (le perdite di memoria sono problemi seccanti, e allora
è molto meglio tagliare la testa al toro e non allocare quando non ce n'è
bisogno).
Altro suggerimento: usa const! Ricordati che semmai devi trovare una ragione
per _non_ usare const, non una ragione per usarlo.
Segue il tuo file, come l'avrei implementato io:
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
using std::string;
using std::ostringstream;
using std::vector;
using std::cout;
using std::endl;
string convertiNumString(const int& num)
{
        ostringstream oss;
        oss << num;
        string s = "ciao " + oss.str();
        return s;
}
vector<char> inizializzaVettore(const int& dim)
{
        vector<char> vettore(dim);
        for(int i = 0; i < dim; i++){
                cout << "Inserisci il carattere in posizione " << i << endl;
                char tmp;
                std::cin >> tmp;
                vettore.push_back(tmp);
        }
        return vettore;
}
void stampaVettore(const vector<char>& vettore)
{
        for(unsigned int i = 0; i < vettore.size(); ++i)
                cout << "Elemento in posizione " << i << ": " << vettore[i] << endl;
}
int main()
{
        const int numero = 10;
        cout << "Ciao Marco!!! " << numero << endl;
        cout << convertiNumString(20) << endl;
        stampaVettore(inizializzaVettore(5));
        return 0;
}

 per _non_ usare const, non una ragione per usarlo.
Per qual motivo dici di usare il const?

Domanda stupida da ignorante in materia, che cosa serve la & dopo il
tipo di dato??
grazie 1000 ancora. stasera mi metto a giocare ancora un pò con il
codice
Ciao Marco

 Java..
Si può fare, si può fare :D Il fatto è che te l'hai fatto sbagliato. 
Infatti sizeof ritorna un size_t (che generalmente corrisponde ad un 
unsigned int) corrispondente al numero di byte dell'oggetto. Quindi un 
sizeof(int) generalmente torna 4. E quindi se ho:
int qualcosa[4];
int grandezza=sizeof qualcosa;
grandezza risulta tendenzialmente uguale a 16 (dipende dalla 
piattaforma e dal compilatore ovviamente). Per utilizzarlo come vuoi te 
lo devi dividere per il primo elemento dell'array quindi fare:
int qualcosa[4];
int grandezza=(sizeof qualcosa)/(sizeof qualcosa[0]);

 vector<char> inizializzaVettore(const int& dim)
Quali sono i vantaggi di passare interi by reference invece che by value?
Io vedo solo un grosso svantaggio (passi 64bit invece che 32 se la 
piattaforma e` a 64 bit)!
Bye,
  Gabry

 int grandezza=(sizeof qualcosa)/(sizeof qualcosa[0]);
Simpatica questa cosa, soprattutto devo dire molto intuitiva...
ciao e grazie ancora
Marco

 Simpatica questa cosa, soprattutto devo dire molto intuitiva...
A questo sitema ci arrivi pensando che ogni elemento di un array occupa 
lo stessa quantità di memoria


 stessa quantità di memoria
Ah un'altra cosa... Stai attento a questo sistema quando usi gli array 
tramite i puntatori
Se tu fai qualcosa del genere:
int main(){
    int qualcosa[100];
    MiaFunzione(qualcosa);
}
void MiaFunzione(int[] qualcosa){
    cout<<sizeof qualcosa/sizeof qualcosa[0];
}
hai come risultato sempre 1 dato in MiaFunzione qualcosa é un puntatore 
a qualcosa[100]...
Meglio sarebbe creare MiaFunzione come:
void MiaFunzione(int qualcosa[], size_t lunghezza)
dove size_t è il risultato di sizeof qualcosa/sizeof qualcosa[0]

 piattaforma e` a 64 bit)!
Be', dubito che il programma diventi una lumaca solo per questo...
comunque grazie dell'osservazione, chissà che non mi rimanga utile.
Ciao,
- -Federico
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)
Comment: Using GnuPG with SUSE - 
http://enigmail.mozdev.org
iD8DBQFJJvcrBIpu+y7DlLcRAnvbAJ0fbQh72ZbVYTSyvcUQBk8ZRH5EogCgsmac
LrYKEd79yPik/Qv9jhOi6V8=
=bczS
-----END PGP SIGNATURE-----

 tipo di dato??
La & indica un riferimento, cioè invece di essere copiata, la variabile
stessa viene passata con un nome che fa da alias (come si fa in Fortran,
se non sbaglio). Se già usi const, usare & ti fa risparmiare
l'operazione di copia (anche se, come è stato osservato altrove, farlo
su un int fa risparmiare poco o niente, è solo una mia abitudine).
Quindi, se modifichi la variabile (ovviamente non ci può essere const in
quel caso), modifichi quella originale, non una copia:
Per capire meglio, fai del codice simile:
void aumenta( int& i )
{
	++i;
}
int main()
{
	int i = 0;
	aumenta(i);
	cout << i << endl;
}
Ciao,
- -Federico
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)
Comment: Using GnuPG with SUSE - 
http://enigmail.mozdev.org
iD8DBQFJJwDHBIpu+y7DlLcRAiG6AJ91Tr0gAVpJLwbktRddCQ+RXNDzvQCgqTHJ
/UpMv/z5wVxP0R7quFKlTu0=
=KkRt
-----END PGP SIGNATURE-----