Newsgroup: it.comp.lang.c++
Titolo: Problema passaggio dimensione array

Vi illustro il codice, poi espongo il problema:
const short int DIM = 10;
void InsertionSort(int* v, int n)
{
//	int mulo[n]; //NON FUNZIONA
	int mulo[DIM] //FUNZIONA
	int pos;
 
 
//	InitVett(mulo);
	mulo[0] = v[0];
 
	for (int i=1; i < n; i++)
	{
		pos = TrovaPosIns(mulo, n, v[i]);
		InserisciElem(mulo, n, v[i], pos);
	}
 
	CopiaArray(mulo, v, n);
}
main()
{
	//int arr[DIM]= {9,0,1,8,2,7,4,6,5,3}; //primo set di dati
	int arr[DIM]= {2,2,2,2,2,2,2,2,2,2}; // secondo set di dati
	InsertionSort( arr, DIM);
	cout << endl;
	cout << endl;
	cout << endl;
	StampaVettore(arr, DIM);
}
Utilizzo il compilatore g++ (gcc 3.3.3); Il problema e' che col primo 
set di dati passando la dimensione dell'array DIM nella funzione 
InsertionSort tutto funziona bene. Col secondo set di dati invece quando 
  dichiaro
 
	int mulo[n];
nello stack risulta correttamente passato il parametro n=10, pero' crea 
un array di due soli elementi mulo[0] e mulo[1]. E' un problema del 
compilatore ( e quindi riguarda l'ambiente) o e' un problema di mia 
ignoranza dello standard? Nella seconda ipotesi qual'e' l'errore?
Vi ringrazio anticipatamente dell'attenzione.

 Vi illustro il codice, poi espongo il problema:
[CUT]
dimenticavo di aggiungere che il problema nasce durante l'esecuzione, 
mentre la compilazione va a buon fine. Il programma esce con codice di 
errore 0 ma il vettore ovviamente non e'ordinato e anzi presenta valori 
random nel vettore di uscita.

 int mulo[DIM] //FUNZIONA
Attenzione!
In C++ la dimensione dell'array può essere impostata solo con
un valore const!
Quello che vuoi fare lo si può fare in C99, ma non in C++
(né in C89/90)
In C++ puoi sempre rimediare usando un <vector>, ma non so se
è appropriato al tuo caso (ho letto solo le prime righe del tuo codice)
ciao
-- 
Gerolamo
www.overweb.it

 
Ciao e grazie!

...

Se per altro caso intendi:
const short int DIM = 10;
int mulo[DIM];
Attenzione che DIM e' una 'costante statica intera' riconosciuta come
tale in fase di compilazione e quindi alternativa valida per
specificare la dimensione dell'array.
Ciao,
Nicola

 Nicola
Gavrila

 crea un array di due soli elementi mulo[0] e mulo[1].
Come fai a sapere che crea un array di 2 elementi?
      Mauro

> Vi ringrazio anticipatamente dell'attenzione.
Ciao,
secondo me in generale č meglio usare std::vector, in particolare dato che
l'esempio non č molto complesso e a priori conosci le dimensione massima
dell'array (ma che perň č contenuta in una variabile e quindi non si
dovrebbe tentare l'allocazione statica) potresti usare efficacemente
l'allocazione dinamica dello stesso con gli operatori new e delete.
Prova a vedere se ti č chiaro questo esempio che ho scritto velocemente...
#include <iostream>
#include <algorithm>
#include <iterator>
using namespace std;
void InsertionSort(int V[],int sz)
{
        int* mulo=new int[sz]; // alloca dinamincamente l'array di servizio
        // esegue l'insertion sort
        mulo[0]=V[0];
        for (int i=1;i<sz;++i)
        {
                int j=i-1,temp=V[i];
                while ((mulo[j]>temp) && (j>=0)) mulo[j+1]=mulo[j--];
                mulo[j+1]=temp;
        }
        // copia l'array
        copy(mulo,mulo+sz,V);
        delete [] mulo; // rimuove l'array di servizio
}
int main()
{
        int arr[]= {9,0,1,8,2,7,4,6,5,3};  // array di dimensioni qualsiasi
        int sz=sizeof(arr)/sizeof(*arr); // ricava le dimensioni dell'array
non c'č bisogno di DIM!
        InsertionSort(arr,sz);
        cout << endl << endl;
        copy(arr, arr+sz ,ostream_iterator<int>(cout, " "));
        cout << endl;
        return 0;
}

Non so se č giusto, ma prova a passare l'argomento n di InsertionSort
con un const davanti

       Mauro
Grazie e scusa il ritardo nella risposta ma ho avuto problemi col server.
Gavri

  int sz=sizeof(arr)/sizeof(*arr); // ricava le dimensioni dell'array
Questa e' effettivamente la soluzione migliore!
[SNIP]
Ti ringrazio per il tuo tempo e scusami la risposta tardiva ma il server 
news non ne voleva sapere :/

 con un const davanti
Ottima idea provero'!
Grazie e scusami la risposta tardiva!

 inseriti.
Allora bisogna passare come secondo parametro il numero di elementi
gia` inseriti, non il totale, quindi va chiamata con:
  pos = TrovaPosIns(mulo, i, v[i]);
(non ho controllato tutti i confronti, quindi potrebbe essere anche
i+1 o i-1, ma sicuramente n non va bene)
      Mauro

       Mauro
Grazie,
Gavri