Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 15
  1. #1
    Utente di HTML.it
    Registrato dal
    Jun 2008
    Messaggi
    34

    [C] Prolema con Vettore di Vettori

    Ciao a tutti,
    ho un problema. Ho un vettore A composto da vettori Ai, il tutto senza sapere la dimensionedi A e dei Ai (tutti gli Ai hanno dimensione uguale ma non la so a priori).
    L'allocazione dinamica è andata a buon fine, però il problema è che vorrei copiare il contenuto degli elementi di A1 (ad esempio) in quelli di A2

    io ho fatto così
    codice:
    for(j=0; j<dimensione; j++)
    {
        A[2][j]= A[1][j];
    }
    tuttavia in questa operazione mi da segmntation fault.
    Vi prego aiutatemi è due giorni che ci sbatto la testa e non trovo alcuna soluzione..

  2. #2
    Utente bannato
    Registrato dal
    Feb 2004
    Messaggi
    2,803
    ad occhio direi che l'allocazione è sbagliata perchè l'istruzione è giusta

    cmq gdb e risolvi

  3. #3
    Utente di HTML.it
    Registrato dal
    Jun 2008
    Messaggi
    34
    è stato gdb a dirmi che l'errore di segmentation fault lo fa in questa istruzione e non prima,
    il fatto è che è una cosa iterativa anche nel primo indice di A e quindi pensavo di aver sbagliato magari
    dimenticandomi qualche asterisco, ma nulla da fare...

  4. #4
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,462
    Se il problema e' nell'allocazione, devi mostrare come l'hai fatta ...
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  5. #5
    Utente di HTML.it
    Registrato dal
    Jun 2008
    Messaggi
    34
    Allora il programma è molto più complesso, ma per non rendervi la vita impossibile ho inserito nel post il problema che riguardava l'errore segnalato da gdb.
    Se fosse colpa dell'allocazione non dovrebbe segnalarlo nel ciclo dell'allocazione?
    Comunque se volete non mi costa niente allegarlo.
    Solo che ci vorrebbero certamente almeno due post di spiegazioni...
    Se vi va, non posso fare altro che ringraziarvi dell'aiuto e mettermi a scrivere

  6. #6
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,462
    Originariamente inviato da davide84
    Se fosse colpa dell'allocazione non dovrebbe segnalarlo nel ciclo dell'allocazione?
    No ... non necessariamente ...

    Comunque se volete non mi costa niente allegarlo.
    No ... se vuoi tu ...

    Solo che ci vorrebbero certamente almeno due post di spiegazioni...
    Se vi va, non posso fare altro che ringraziarvi dell'aiuto e mettermi a scrivere
    Di nulla ... se lo fai sicuramente puoi ottenere qualche risposta piu' precisa ...
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  7. #7
    Utente di HTML.it
    Registrato dal
    Jun 2008
    Messaggi
    34
    ecco a voi il codice per intero
    codice:
    #include <stdio.h>
    #include <math.h>
    #include <malloc.h>
    #include <limits.h>
    typedef unsigned int unint;
    
    #define CEILING(X) (X-(int)(X)) > 0 ? (int)(X+1) : (int)(X)
    
    void toggle_db (int, int, int, int , int, unint *****);
    
    int main ()
    {
    	unint *board2d, *board1d, *****db;
    	int NR,NC, i, j, interi ,elem, count,config, cella, num_con, caso;
    	int start_cell;
    	float integer;
    		
    	printf("Inserire il numero NR di righe della scacchiera: ");
    	scanf("%d", &NR);
    	printf("Inserire il numero NC di colonne della scacchiera: ");
    	scanf("%d", &NC);
    	
    	/** Allocazione della scacchiera a due dimensioni **/
    	board2d=malloc(NR*NC*sizeof(unint));
    	if(board2d==NULL)
    	{	
    		printf("Spazio non disponibile\n\n");
    		return(1);
    	}
    	
    	/** Calcolo dei bit da allocare sottoforma di interi **/
    	integer= (float)(NR*NC)/(CHAR_BIT*(sizeof(unint)));
    	interi=CEILING(integer);
    	
    	/** Allocazione della scacchiera rappresentata in una dimensione **/
    	
    	board1d=malloc(interi*sizeof(unint));
    	if(board1d==NULL)
    	{	
    		printf("Spazio non disponibile\n\n");
    		return(1);
    	}
    
    	/** Inizializzazione della scacchiera 2d a zero	**/
    	
    	for(i=0;i<NR;i++)
    	{
    		for(j=0;j<NC;j++)
    		{
    			board2d[i*NR+j]=0;
    		}
    	}
    	
    	/** ******************************************************************************************************************************************* **/
    	/** Allocazione del database e sua inizializzazione tramite la funzione toggle. L'allocazione avviene secondo lo schema: num_con=2,3,4;			**/
    	/** caso=0,1,2,3 corrispondente a orizzontali, verticali, diagonali principali, diagonali secondarie;															**/
    	/** configurazione= 0,..., max per caso, esempio: caso=0 configurazioni=0, NR*(NC-(num+2))+1; 																	**/
    	/** cella= cella in cui inizia il pattern,...,cella in cui finisce, esempio primo tris orizzontale->cella=0, 1, 2. 										**/
    	/** l'indice CELLA indica l'apparteneza di una certa configurazione a quella cella della tabella, così lo stesso bis sarà considerato due volte **/
    	/** in quanto a lui apparterranno 2 celle e la differenza tra questi due pattern uguali sarà proprio l'indice cella.										**/
    	/** La funzione toggle inizializza solo il primo vettore per ogni configurazione, e poi lo stesso vettore viene copiato negli altri vettori 		**/
    	/** appartenenti alla stessa configurazione, riutilizzando le stesse condizioni usate per far variare l'indice CELLA dei singoli vettori del db **/
    	/** ******************************************************************************************************************************************* **/
    	
    	db=(unint *****)malloc(3*sizeof(unint ****));
    
    	for(num_con=0; num_con<3; num_con++)
    	{
    		db[num_con]=(unint ****)malloc(4*sizeof(unint ***));
    		for(caso=0; caso<4; caso++)
    		{	
    			switch(caso)
    			{
    				case (0):
    					start_cell = 0;
    					db[num_con][caso]=(unint ***)malloc(((NR*(NC-(num_con+2)+1)))*sizeof(unint **));
    				
    					for(config=0; config<(NR*(NC-(num_con+2)+1)); config++)   
    					{
    						db[num_con][caso][config]=(unint **)malloc((num_con+2)*sizeof(unint *));
    						for(cella=start_cell; cella<start_cell+(num_con+2); cella++)
    						{
    							db[num_con][caso][config][cella]=(unint *)malloc(interi*sizeof(unint));	
    							/** Con questo piccolo accorgimento, dopo aver creato i vettori unidimensionali, **/
    							/** se è il primo lo inizializzo a quello che voglio io, tramite la funzione toggle **/
    							/** altrimenti copio il vettore precedente in quello appena allocato. **/
    							/** Ovviamente per precedente si intende quello con indice di cella precedente, ma che appartiene allo stesso pattern **/
    							/** Tuttavia mi da segmentation fault all'atto della copia del vettore  **/
    							if(cella==start_cell)
    							toggle_db(NC, num_con, caso, config, cella, db);
    							else
    							{
    								for(i=0; i<interi; i++)
    								{
    									db[num_con][caso][config][cella][i] = db[num_con][caso][config][(cella-1)][i];
    								}
    							}
    						}
    						if ((start_cell+num_con+2)%NC != 0)
    							start_cell++;
    						else
    							start_cell += num_con+2;
    					}
    				break;
    				
    				case (1):
    					db[num_con][caso]=(unint ***)malloc((NC*(NR-(num_con+2)+1))*sizeof(unint **));
    				
    					for(config=0;config<(NC*(NR-(num_con+2)+1));config++)
    					{
    						db[num_con][caso][config]=(unint **)malloc((num_con+2)*sizeof(unint *));
    						for(cella=config;cella<config+NC*(num_con+2);cella+=NC)
    						{
    							db[num_con][caso][config][cella]=(unint *)malloc(interi*sizeof(unint));
    							if(cella==start_cell)
    								toggle_db(NC, num_con, caso, config, cella, db);
    							else
    							{
    								for(i=0;i<interi;i++)
    								{
    									db[num_con][caso][config][cella][i]=db[num_con][caso][config][(cella-NC)][i];
    								}
    							}
    						}
    					}
    				break;
    					
    				case (2):
    					start_cell=0;
    					db[num_con][caso]=(unint ***)malloc(((num_con+2)*((NC-(num_con+2)+1)*(NR-(num_con+2)+1)))*sizeof(unint **));
    					
    					for(config=0;config<((NC-(num_con+2)+1)*(NR-(num_con+2)+1));config++)
    					{
    						db[num_con][caso][config]=(unint **)malloc((num_con+2)*sizeof(unint *));
    						for(cella=start_cell;cella<start_cell+NC*(num_con+2);cella+=(NC+1))
    						{
    							db[num_con][caso][config][cella]=(unint *)malloc(interi*sizeof(unint));
    							if(cella==start_cell)
    								toggle_db(NC, num_con, caso, config, cella, db);
    							else
    							{
    								for(i=0;i<interi;i++)
    								{
    									db[num_con][caso][config][cella][i]=db[num_con][caso][config][(cella-(NC+1))][i];
    								}
    							}
    						}
    						if ((start_cell+num_con+2)%NC != 0)
    							start_cell++;
    						else
    							start_cell += num_con+2;
    					}
    				break;
    
    				case (3):
    					start_cell=num_con+1;
    					db[num_con][caso]=(unint ***)malloc(((num_con+2)*((NC-(num_con+2)+1)*(NR-(num_con+2)+1)))*sizeof(unint **));
    
    					for(config=0;config<((NC-(num_con+2)+1)*(NR-(num_con+2)+1));config++)
    					{
    						db[num_con][caso][config]=(unint **)malloc((num_con+2)*sizeof(unint *));
    						for(cella=start_cell;cella<start_cell+(NC-1)*(num_con+2);cella+=(NC-1))
    						{
    							db[num_con][caso][config][cella]=(unint *)malloc(interi*sizeof(unint));
    							if(cella==start_cell)
    								toggle_db(NC, num_con, caso, config, cella, db);
    							else
    							{
    								for(i=0;i<interi;i++)
    								{
    									db[num_con][caso][config][cella][i]=db[num_con][caso][config][(cella-(NC-1))][i];
    								}
    							}
    						}
    						if ((start_cell+1)%NC !=0)
    							start_cell ++;
    						else
    							start_cell+=num_con+2;
    					}
    					break;	
    			};
    		}
    	}
    	
    	
    	/** Disallocazione del database **/
    	
    	for(num_con=0;num_con<3;num_con++)
    	{
    		for(caso=0; caso<4; caso++)
    		{	
    			switch(caso)
    			{
    				case (0):
    					start_cell=0;
    					for(config=0;config<(NR*(NC-(num_con+2)+1));config++)   
    					{
    						for(cella=start_cell;cella<start_cell+(num_con+2);cella++)
    						{
    							free(db[num_con][caso][config][cella]);
    						}
    						if ((start_cell+num_con+2)%NC != 0)
    							start_cell++;
    						else
    							start_cell += num_con+2;	
    					}
    					free(db[num_con][caso][config]);
    				break;
    				
    				case (1):
    					for(config=0;config<(NC*(NR-(num_con+2)+1));config++)
    					{
    						for(cella=config;cella<config+NC*(num_con+2);cella+=NC)
    						{
    							free(db[num_con][caso][config][cella]);
    						}
    					}
    					free(db[num_con][caso][config]);	
    				break;
    					
    				case (2):
    					start_cell=0;		
    					for(config=0;config<((NC-(num_con+2)+1)*(NR-(num_con+2)+1));config++)
    					{
    						for(cella=start_cell;cella<start_cell+NC*(num_con+2);cella+=(NC+1))
    						{
    							free(db[num_con][caso][config][cella]);
    						}
    						if ((start_cell+num_con+2)%NC != 0)
    							start_cell++;
    						else
    							start_cell += num_con+2;
    					}
    					free(db[num_con][caso][config]);			
    				break;
    
    				case (3):
    					start_cell=num_con+1;
    					for(config=0;config<((NC-(num_con+2)+1)*(NR-(num_con+2)+1));config++)
    					{
    						for(cella=start_cell;cella<start_cell+(NC-1)*(num_con+2);cella+=(NC-1))
    						{
    							free(db[num_con][caso][config][cella]);
    						}
    						if ((start_cell+1)%NC !=0)
    							start_cell ++;
    						else
    							start_cell+=num_con+2;
    					}
    					free(db[num_con][caso][config]);
    					break;	
    			};
    			free(db[num_con][caso]);
    		}
    		free(db[num_con]);
    	}
    	free(db);
    
    	return(0);
    	
    }
    
    void toggle_db (int NC, int pedine, int caso, int config, int cella, unint *****daba)
    {
      	int i, s, set_on;																							
    	
    	switch(caso)
    	{
    		case(0):
    		{
    			for(s=cella;s<cella+(pedine+2);s++)
    			{
    				i= s/(CHAR_BIT*sizeof(unint));
    				set_on = s % (CHAR_BIT*sizeof(unint));
    				daba[pedine][caso][config][cella][i] |= (1<<set_on);												
    			}
    		}
    		break;
    		case(1):
    		{
    			for(s=cella;s<cella+NC*(pedine+2);s+=NC)
    			{
    				i= s/(CHAR_BIT*sizeof(unint));
    				set_on = s % (CHAR_BIT*sizeof(unint));
    				daba[pedine][caso][config][cella][i] |= (1<<set_on);
    			}
    		}
    		break;
    		case(2):
    		{
    			for(s=cella;s<cella+NC*(pedine+2);s+=NC+1)
    			{
    				i= s/(CHAR_BIT*sizeof(unint));
    				set_on = s % (CHAR_BIT*sizeof(unint));
    				daba[pedine][caso][config][cella][i] |= (1<<set_on);
    			}
    		}
    		break;
    		case(3):
    		{
    			for(s=cella;s<cella+(NC-1)*(pedine+2);s+=(NC-1))
    			{
    				i= s/(CHAR_BIT*sizeof(unint));
    				set_on = s % (CHAR_BIT*sizeof(unint));
    				daba[pedine][caso][config][cella][i] |= (1<<set_on);
    			}
    		}
    		break;
    	}													  
    }

  8. #8
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,462
    Scusa ... ma tu hai parlato di un semplice

    A[2][j]= A[1][j];

    ... magari dovresti indicarci il corrispondente nel tuo codice ...

    Qual e' il vettore ... quale il codice dell'allocazione ...
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  9. #9
    Utente di HTML.it
    Registrato dal
    Jun 2008
    Messaggi
    34
    Il programma è pensato per creare un database di configurazioni per il gioco forza 4.
    Tali configurazioni sono bis, tris e quaterne, identificate dall'indice NUM_CON, ognuna delle quali deve essere sia orizzontale(caso 0), che verticale(1), che diagonali principali, che diagonali secondarie (risp 2, 3).
    Per ogni NUM_CON e CASO ci sono un certo numero di CONFIGurazioni e, per ogni CONFIG e a seconda di NUM_CON, le celle della tabella del forza 4 che apparterranno alla configurazione saranno 2, 3, o 4, contigue in una delle 4 direzioni dettate dall'indice CASO.
    Il problema è che per ottimizzare il confronto con la tabella del gioco ho dovuto mappare una tabella con dei bit, raggruppati in elementi di un vettore. Il database è fatto da tanti vettori che rappresentano ognuno un bis, un tris o una quaterna. Sempre tramite i bit dei loro elementi.
    Non chiedetemi perchè ma lo DEVO FARE così ed è l'ultima materia che mi rimane all'università.

    Sempre per ottimizzare la velocità di valutazione della scacchiera, ho inserito l'indice CELLA, che indica l'appartenenza di una certa cella a una certa configurazione. Così una configurazione con NUM_CON = tris, sarà rappresentata 3 volte identica nei 3 indici NUM_CON, CASO, CONFIG, ma avrà gli indici cella che varieranno da 0 a 2.
    Cioè: se consideriamo il tris orizzontale dalla prima cella in basso a destra della tabella fino alla terza, il vettore del database avrà il primo elemento inizializzato a 7 e gli altri elementi inizializzati a zero, in quanto i bit superiori a 2^2 del primo elemento di quel vettore corrisponderanno alle celle delle righe più alte della tabella e quindi non potranno essere occupate all'inizio del gioco (il forza 4 segue la GRAVITA').

    Il probema me lo dà alla riga 91. Non mi pare che ci siano errori prima, anche perchè gcc me lo compila subito, ma gdb fa segmentation fault.

    PS La prima cella della tabella, quella con indici i= j =0, è quella in basso a destra

  10. #10
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,462
    Parli di questa riga

    db[num_con][caso][config][cella][i] = db[num_con][caso][config][(cella-1)][i];


    ?

    (E' meglio indicarla perche' sul numero potrebbe esserci qualche dubbio)

    E con quali valori in input si manifesta il problema?
    No MP tecnici (non rispondo nemmeno!), usa il forum.

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 © 2024 vBulletin Solutions, Inc. All rights reserved.