Printable View
edit risolto. Rebuildato tutto ed è andato.
C'è un piccolo problema: ho creato un source file con dentro solo la funzione. Alla fine della funzione stampo i risultati tranquillamente. Poi mi torna del main dove c'è un menu interattivo del piffero giusto per fare piu prove. Se però provo a stampare dal main i risultati, si blocca tutto. La funzione l'ho dichiarata cosi
void funzione(int*vect1,int*vect2,int numeri)
e la chiamo
int *v1,*v2;
int numero;
funzione(v1,v2,numero);
magari guardati qualche cosa di ottimizzazione cache, che se lavori con array potrebbe tornarti utile usarle in modo corretto
in che senso si blocca tutto? vai in debug e dicci l'erroreQuote:
Originally Posted by Brcondor
Domani guardo thx. Cmq il programma si blocca e compare il robo di windows. Devo capire bene come usare il debug, che con matlab era fondamentale.... qua riempio il listato di printf idioti lol
Ma stai programmando da notepad???
Usa Visual Studio e metti i breakpoint. Pd mica siamo nel 1970
ci sono anche per c --> http://openmp.org/wp/Quote:
Originally Posted by Eltarion
mi pari usi dev++, non ricordo se c'è il debugger. comunque visual studio e vai sul sicuro :PQuote:
Originally Posted by Hardcore
SI uso devcpp. Ok proviamo sto visual studio :).
A naso, mi sembra un filino fuori dalle mie possibilità sta cosa dei calcoli paralleli. Finisco di programmare per domani con devcpp e poi mi studio sto visual studio
ma no sono semplici da usare :) le attivi poi dalle opzioni di compilazione (su visual studio)
Ok thx elta, di questa rispota e di tutto lo sbatti che ti sei fatto pagina dopo pagina :)
Cmq rimango bloccato su un qualche mio errore.
per la funzione void funct(int*v1,int*v2,int numero)
che chiamo nel main
int *vect1,*vect2,num;
funct(vect1,vect2,num)
Se faccio un printf dei valori calcolati da dentro la funzione, li stampa tutti e son pure corretti
se invece tolgo il printf dalla funzione e lo metto nel main del tipo
int *vect1,*vect2,num;
funct(vect1,vect2,num)
printf("%d %d",vect1[1],vect2[1]);
Si impalla il calcolatore. Sto installando visual studio
se li dichiari come *int i vettori devi stampare gli elementi puntati non l'indirizzo in se, quiondi dovrebbe essereQuote:
Originally Posted by Brcondor
printf("%d %d",*vect1+1,*vect2+1);
ma in c *r +4 non è la stessa cosa di r[4]?
scusa in realtà è *(r+x). si forse è la stessa cosa, ma mi pareva che r[x] valesse solo in c++ dove per allocarlo fai r = new int[x], ma in effetti ho controllato ed è la stessa cosa :sneer: sono ancora reduce dalla colazione dei "campioni" :sneer:Quote:
Originally Posted by Brcondor
vedrai che col debugger risolvi al volo
Non dovrebbe essere r+4?
così stampi l'indirizzoQuote:
Originally Posted by Hardcore
Ho provato tutti i modi, ma al massimo mi stampa l'indirizzo di cui me ne faccio poco.
se fai printf *vect1 e printf vect1 ti da la stessa cosa?
dipende come è dichiarato vectQuote:
Originally Posted by Hardcore
se è int vect[n] (statico) allora la printf di vect e di *vect saranno uguali e stamperanno l'indirizzo del primo elemento dell'array (per stampare valore si usa *(vect+i) o vect[i])
se è *int (dinamico da allocare) allora la printf di di vect darà l'indirizzo mentre la printf di *vect darà il valore del primo elemento dell'array (per stampare il valore si fa come prima)
si questo lo so, chiedevo a lui cosa gli viene fuori, perchè appunto mi sembra strana come cosa.
cosa ti sembra strano?Quote:
Originally Posted by Hardcore
è come se non creasse davvero il vettore... cmq non viene fuori nulla, non riesco a capire perchè. Sto lottando contro visual c++, perchè non esiste il toggle"usa c e non rompere il cazzo con c++".
La mia impressione è che i puntatori dentro la funzione puntino all'inizio del vettore, ma nel main si scollino e puntino al nulla. Devo fare il malloc anche dentro al main?
Nel senso.
void funz(int *v1,int *v2,int num)
{
int .... ;
v1=(int*)malloc(numelem*sizeof(int));
v2=(int*)malloc(numelem*sizeof(int));
// eseguo tutti i calcoli e scrivo tutti gli elementi dei due vettori
printf("elementi dei vettori")//li stampa, e li stampa giusti
}
mentre nel main ho fatto cosi
main{
int numero;
int *v1,*v2;
printf(inserisci il numero:)
scanf("%d",&numero)
funzione(v1,v2,numero);
//se stampo qua il programma si blocca
//se uso i risultati in altro modo il programma si blocca
}
allora per la cosa di visual studio come ti ho scritto prima basta che salvi il sorgente come .c (vedi http://support.microsoft.com/kb/829488) non c'è nulla di particolare da fare.
per il resto pasandso i vettori come puntatori una volta allocati sono allocati e basti (di fatti ti devi ricordare di fare la free). Di solito è buona norma non permettere alle fuznioni di allocare memoria, ma i buffer si dovrebbero passar alle funzioni già allocati (a volte non è possibile per vari motivi, non è un problema)
non è che nella funzione incrementi in qualche modo il valore dei puntatori ai vettori? in quel caso può succedere che v1 e v2 non puntino più al primo elemento dell'array, ma chissà dove :P
Non posso allocare lo spazio nel main, perchè la grandezza del vettore non è nota a priori. CIoè in realtà lo sarebbe, ma cmq nella funzione devo fare due realloc(prima esco fuori di tot cifre che pero non mi servono in se ma mi servono per calcolare le cifre utili e poi rialloco per ebitare di occupare spazio inutile).
Magari è la reallocazione che mi frega. Io ho fatto così:
if("devo scrivere piu elementi dello spazio allocato") v1=realloc(v1,nuovoMax*sizeof(int))
//finisco i calcoli, il realloc si esegue all'ultima iterazione
v1=realloc(v1,vecchioMax*sizeof(int))
Non è che devo prima ripulire lo spazio che poi dealloco? Magari con free, faccio puntare un nuovo puntatore alla fine del vettore "utile " e faccio free del resto...
nu se riallochi non hai bisogno di liberare la memoria. non capisco però una cosa, riallochi ogni volta che ti serve del nuovo spazio? a volte conviene allocare più memoria di quanta ne userai (senza esagerare) e riallocare alla fine.
No funziona così
Ogni ciclo ci sono due possibilità: che aumenti il numero di elementi noti di uno o che raddoppi la quantità di elementi noti.
Inizialmente alloco una quantità pari al numero di elementi che mi servono.
Se ad esempio ho già calcolato i 3/4 di elementi e finisco nel caso due, allora rialloco abbastanza spazio per contenere tutti gli elementi(quindi 6/4 dello spazio iniziale), li calcolo e poi rialloco per eliminare quei 2/4 che contengono informazioni inutili.
Dato che a priori non posso sapere se e quando succederà che raddoppio gli elementi, l'unica cosa che potrei fare è allocare una qauntità doppia di spazio. Ma così spreco sicuramente un sacco di spazio: con numeri dell'ordine di 10^9 occupo 2 gb di spazio di ram, non mi sembra il caso di tirarmi la zappa sui piedi e allocare a priori troppa memoria
effettivamente se sei in quell'ordine di grandezze allora non ti conviene allocare il massimo subito. conoscessi meglio il dettaglio dell'algoritmo potrei vededre se si può fare qualche ottimizzazione in più
CMq il punto è che poi mi vede solo un vettore di 0. Se provo a stampare v1 da un'altra funzione, in qualsiasi punto mi stampa 0.
mmm vai in debug e dacci maggiori info, ho provato a fare un piccolo programma di test e non ho questo problema. dichiaro il vettore nel main lo spippolo in una funzione e poi lo stampo dal main. nessun problema.
mi posti il tuo codice please? Non riesco a capire come far andare il debug :(
Cmq per ora ho aggirato il problema mettendo la funzione di stampa all'interno della funzione che genera i vettori, e così funziona. Se ci metto pure quella di salvataggio poi nel main posso loadare i risultati easy easy. Ecco, ora mi manca solo il salvataggio e poi il tool base è pronto a tempo di record. Qualche idea su come si salvino due vettori?
allora scusa ma prima sono statro impreciso:
se vuoi allocare dentro una funzione l'array allora il prototipo diventa
void Funzione(int **vettore);
questo in modo da poterlo passare per "riferimento" (in rtealtà in c non esiste il pasaggio byref e quindi devi passare l'indirizzo del puntatore all'array...)
nell'esempio mi funzionava perchè preallocavo l'array
quindi poi devi fare attenzione all'utilizzo del puntatore all'array dentro ala funzione. faccio un esempio
void main(int argc, char **argv)
{
int *vet = NULL;
int i = 0;
TestArray(&vet);
for (i=0;i<10;i++) {printf("%d\n", vet[i]);}
return;
}
void TestArray(int **vet)
{
int i = 0;
*vet = (int *)malloc(10 * sizeof(int));
for (i=0; i<10; i++) {*(*vet+i) = i;}
return;
}
per salvare i vettori puoi scriverli su un file (in sequenza e separati da un separatore)
per il debug invece non capisco dove sia il problema: metti i breakpoint dove vuoi e poi lanci il programma in debug e si fermerà dove hai messo i break
}
Ok sei stato preziosissimo, come immaginavo sbagliavo a lanciare la funzione del main e non passandola come puntatore ovviamente non permettevo al main di modificare quei valori. Ora provo a reimplementare con il puntatore al puntatore.
Il senso se ho ben capito dovrebbe essere:
voglio modificare un int presente nel main==> uso un puntatore funz(int*parametro)
voglio creare un array di int nel main==> funz(int**parametro).
Ora esco per una commissione e poi mi rimetto sotto thx ancora.
Cosa c'è di sbagliato in questa funzione di salvataggio? r e q sn i due vettori
#include <stdio.h>
#include <stdlib.h>
int salva(int *r,int*q,int lung,int num){
FILE *fp;
int i;
int ris;
char filename[20];
printf("\n Inserire un nome per il file(max 20 caratteri):\n");
scanf("%s",filename);
fp=fopen(filename,"w");
ris=fprintf(fp,"Numero:%d\Lunghezza:%d\nIt Q R",num,lung);
for(i=1;i<=lung;i++)
{ris=fprintf(fp,"%d %d %d",i,q[i],r[i]);}
fclose(fp);
return 1;
}
La funzione era giusta, sbagliavo io a chiamarla :)
lol stavo cercando di capire cosa c'era che non andava e non avevo letto il post sotto -.-
:)
COme un genio avevo chiamato una funzione e una variabile in modo simile, e al posto di passare la variabile, passavo la funzione come argomento :P
Ok, era tutto perfetto. Ora sorge il nuovo problema: devo gestire array con ALMENO 499.999.999.999 elementi: come cazzo li itero? Pensavo o di spezzettarli e di usare liste dinamiche, o non so, zero idee.
Ho provato a fare, fallendo ogni volta
1. float it; vect[(int)it]
2. float it; vect[floor(it)]
3. int i1, i2,i3; i1=2^32;i2=2^32;i3=50; vect[i1+i2+i3]
Usa una matrice. Ogni riga lunga 2^32, e ne metti quante ne vuoi (fino a 2^32). Numero massimo di elementi 2^32 * 2^32.Quote:
Originally Posted by Brcondor
Usi due contatoru, uno per le colonne uno per le righe. Iteri prima sulle colonne e poi sulle righe. Ogni volta che il contatore delle colonne arriva a 2^32 -1 lo rimetti a 0 e incrementi di 1 quello delle righe.
ottima idea. Però userò un array di array con ogni elemento pari a un array di 2^32-1. Cosi fotto il sistema :P. Ora devo meditare su come implementare tutto.