Visualizzazione dei risultati da 1 a 10 su 10
  1. #1

    [C++] Allocazione dinamica Array

    Salve, la seguente funzione, dovrebbe "allungare" un array di interi... solo che la prima volta che la invoco con l'array x di un elemento e la nuova lunghezza pari a 5 tutto funziona correttamente, quando la invoco per la seconda volta con l' array di lunghezza 5 e nuova lunghezza 8 mi và in segmentation fault... e non capisco perchè...

    codice:
    int *allunga(int *x, int vl, int nl){ // vl--> vecchia lunghezza nl--> nuova lunghezza
    	int j;
    	int *q = new int[nl]; //creo il nuovo array, qui ottengo il segmentation fault
    	for (j=0; j<vl; j++)
    		q[j]= x[j]; //copio quello vecchio in quello nuovo
    	for (j = vl; j< nl; j++)
    		q[j] = -1;		
    	delete []x; //cancello quello vecchio
    	x = q; //faccio puntare x al nuovo array
    	return x;
    	}
    Grazie

  2. #2
    mi correggo l'errore lo ottengo solo le due dimensioni sono consecutive es: 5,6 o 7,8... mentre se vado da 4 a 7 funziona tutto benissimo...

  3. #3
    anzi il mistero si infittisce... non và con alcune coppie di numeri come 5,6 e 7,8 mentre con gli altri funziona... incredibile...

  4. #4
    Utente di HTML.it L'avatar di anx721
    Registrato dal
    Apr 2003
    Messaggi
    2,352
    la funzione mi pare corretta, l'errore potrebbe essere altrove.

    Sun Certified Java Programmer

    EUCIP Core Level Certified

    European Certification of Informatics Professionals

  5. #5

    Re: [C++] Allocazione dinamica Array

    Originariamente inviato da Tigre851
    Salve, la seguente funzione, dovrebbe "allungare" un array di interi... solo che la prima volta che la invoco con l'array x di un elemento e la nuova lunghezza pari a 5 tutto funziona correttamente, quando la invoco per la seconda volta con l' array di lunghezza 5 e nuova lunghezza 8 mi và in segmentation fault... e non capisco perchè...

    codice:
    int *allunga(int *x, int vl, int nl){ // vl--> vecchia lunghezza nl--> nuova lunghezza
    	int j;
    	int *q = new int[nl]; //creo il nuovo array, qui ottengo il segmentation fault
    	for (j=0; j<vl; j++)
    		q[j]= x[j]; //copio quello vecchio in quello nuovo
    	for (j = vl; j< nl; j++)
    		q[j] = -1;		
    	delete []x; //cancello quello vecchio
    	x = q; //faccio puntare x al nuovo array
    	return x;
    	}
    come invochi questa funzione?
    dovresti postare il main perché è corretta,
    comunque, nella linea contrassegnata in blu,
    l'array x punta si al vettore q, ma solo nell'ambito della funzione allunga.

    es:
    codice:
    int* x = new int[5];
    
    allunga(x, 5, 6);
    così facendo x non viene modificato

    a meno che tu non la invochi così

    codice:
    x = allunga(x, 5, 6);
    in pratica le cose stanno così

    prima di richiamre allunga, la variabile x starà in una certa
    locazione di memoria, es 0xF000, il contenuto di x invece è
    un puntatore al vettore che hai allocato in precedenza, es 0xFA00

    codice:
    Indirizzo  - Contenuto
    [0xF000][x]->[0xFA00]
    quando chiami la funzione viene allocata una variabile locale
    x (parametro formale) nella funzione allunga, in un'altra
    locazione, es 0xEB00, il valore è lo stesso della x
    (parametro attuale) passata alla funzione, quindi 0xFA00

    codice:
    Indirizzo  - Contenuto
    [0xEB00][x]->[0xFA00] // variabile vista dalla funzione allunga
    [0xF000][x]->[0xFA00]

    supponendo che q, nella funzione allunga, quando viene
    allocato il vettore, punti a 0x4300, allora quando modifichi
    x nella assegnazione
    x = q

    succede questo

    codice:
    Indirizzo  - Contenuto
    [0xEB00][x]->[0x4300] // variabile vista dalla funzione allunga
    [0xF000][x]->[0xFA00]
    come vedi la x del main è rimasta intatta.

    Tutto questo perchè stai passando la variabile x (che è un puntatore a int) per copia.
    Visto che usi C++ puoi provare con il passaggio by reference (per riferimento)

    void allunga(int* &x, int vl, int nl)

    in questo caso le modifiche che farai sulla variabile x, si
    ripercuoteranno anche alla x dichiarata nel main.

    Comunque sarebbe utile se postassi il codice del main.

  6. #6
    la funzione inserisci chiama allunga:

    codice:
    void inserisci(int elemento, int elem[], int* x[]){
    int posizione = elemento/100;
    	int i = elemento - (posizione * 100);
            if (elem[posizione] == -1){
                    x[posizione] = new int[1];
                    elem[posizione] = 1;
            }
    	if (elem[posizione] < i){
    		x[posizione] = allunga(x,elem[posizione],i)
    		inizializza(x[posizione]);
    		elem[posizione]=i;
    		
    	}
    
    	
    	x[posizione][i] = elemento;
    		
    	
    	
    	}
    il main non è particolarmente interessante, si limita a chiamare inserisci. cmq il codice è il seguente:

    codice:
    main(){
    	int n_elem[10];
    	int* x[10]={NULL};
    	int opz;
    	int elemento;
    	for (int i=0; i<10; i++){
    		n_elem[i] = -1;
    		}
    	do{
    		cout << "Inserisci un elemento \n";
    		cin >> elemento;
    		inserisci(elemento, n_elem, x);
    		cout << "Vuoi inserire ancora? 0-->no 1-->si" << endl;
    
    		cin >> opz;
    		}while(opz);
    }
    Vi posto anche la richiesta dell'esercizio a questo punto altrimenti non si capisce come deve essere la struttura:

    Vogliamo gestire valori da 0 a 999 con dieci array, allocati dinamicamente, di massimo 100 elementi.
    L’idea e’ che il primo array deve contenere gli elementi tra 0 e 99 (se ce ne sono), il secondo contiene gli elementi tra 100 e 199, e cosi via.
    Quindi ogni valore da 0 a 999 ha un suo posto nella struttura,
    ad esempio il valore 103 e’ l’elemento di indice 3 del secondo array.

    La struttura dati che utilizziamo e’ un array X di puntatori ad interi,
    inizializzati a NULL. Durante l’esecuzione del programma, gli elementi di X saranno degli array allocati dinamicamente.

    Si chiede di realizzare le operazioni di inserimento, ricerca e cancellazione, per gestire questa struttura dati.

    Inserimento. Vogliamo inserire il valore N, nell’array appropriato, alla posizione che gli compete (vedi esempio sopra).
    Allocando solo il numero di locazioni strettamente necessarie

    Ricerca. La funzione ricerca testa se un certo valore N e’ presente in X.

    Cancellazione. La funzione cancella elimina il valore dato N, se presente in X. Nella cancellazione puo’ capitare che uno degli array si svuoti, in questo caso l’array va deallocato.

    grazie

  7. #7

    Re: Re: [C++] Allocazione dinamica Array

    Originariamente inviato da internet
    come invochi questa funzione?
    dovresti postare il main perché è corretta,
    comunque, nella linea contrassegnata in blu,
    l'array x punta si al vettore q, ma solo nell'ambito della funzione allunga.

    es:
    codice:
    int* x = new int[5];
    
    allunga(x, 5, 6);
    così facendo x non viene modificato

    a meno che tu non la invochi così

    codice:
    x = allunga(x, 5, 6);
    certo dal prototipo di allunga la funzione torna un int* quindi la invoco di sicuro così:

    x = allunga(x,5,6);

  8. #8
    Puoi postare il codice del main, così vediamo dove è il problema?

    edit:
    ops non avevo letto il messaggio di sopra
    ho fatto la ricerca e ho letto solo la tua risposta
    ora ci do' una controllata

  9. #9
    Originariamente inviato da Tigre851
    la funzione inserisci chiama allunga:

    codice:
    void inserisci(int elemento, int elem[], int* x[]){
    int posizione = elemento/100;
            /* qui potevi anche fare così */
            /* int i = elemento % 100; */ 
    	int i = elemento - (posizione * 100);
            if (elem[posizione] == -1){
                    x[posizione] = new int[1];
                    elem[posizione] = 1;
            }
    	if (elem[posizione] < i){
    		x[posizione] = allunga(x,elem[posizione],i)
    		inizializza(x[posizione]);
    		elem[posizione]=i;
    		
    	}
    
    	
    	x[posizione][i] = elemento;
    		
    	
    	
    	}
    dunque, il main è corretto, il problema è nella riga contrassegnata in blu

    correggi così
    codice:
    x[posizione] = allunga(x[posizione],elem[posizione],i);
    comunque, il compilatore che hai usato ti avrebbe dovuto segnalare questo errore

    a.cpp: In function `void inserisci(int, int*, int**)':
    a.cpp:25: error: cannot convert `int**' to `int*' for argument `1' to `int*
    allunga(int*, int, int)'


    quale hai usato e che versione?
    io ho usato gcc ver. 3.3.2

    ah, la funzione inizializza cosa fa?

  10. #10
    quella è stata una svista mia... siccome ieri dovevo consegnare qualcosa avevo tolto allunga e avevo gestito gli array in maniera statica (se inserivo allocavo ugualmente 100 posizioni)... oggi postando il codice l'ho dovuto riscrivere e mi sono perso x[posizione] in realtà nella versione non funzionante di eri era chiamata così x= allunga(x[posizione],elem[posizione],i);

    uso gcc 3.3.5.

    inizializza mette a -1 le posizioni vuote.

    grazie!
    ciao

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.