Piccola mano con C

[Brcondor]

Ciao a tutti. per un Progetto dell'uni mi sn trovato costretto a riprendere in mano c e ampliare ciò che conoscevo.
Solo che abituato a matlab, ci sto abbastanza impazzendo(sn 4 anni che non apro devcpp).
Quello che vorrei fare è questo:
una funzione che, dato un numero, esegua una serie di calcoli e restituisca due vettori contenenti il risultato di questi calcoli.
Da quel che ho capito, ovviamento le array non posso passarle quindi devo passare due puntatori.
La dichiarazione potrebbe essere del tipo
void nome_funzione(int num,lis*il propvect1,lis*pvect2)?
Dentro al corpo mi creo i due vettori e poi alla fine faccio si che i due puntatori puntino al primo elemento? Io da num, so quanti elementi devo avere, il problema che mi imdedisce un allocamento statico della memoria è che calcolo ogni volta una potenza di due di valori, quindi se ho bisogno di 1000 valori devo arrivare a 1024 e poi cancellare 24 valori.
Per invece la lista dinamica di per se, dovrei definire una cosa del tipo
struct lis{
int valore1
struct lis *next}
Dato che lo scopo di fondo è fare un programma il piu veloce possibile, vorrei cercare di ottimizzare tutto, senza stare a occupare piu memoria del necessario...

[Eltarion]

ma senza stare li ad usare liste...se ti passano l'array non allocaco (int * array) puoi fare una malloc del numero massimo di numeri che ti servono
array = (int*)malloc(max, sizeof(int))
e poi per ridemensionarlo al numero corretto fai una realloc alla fine
array = (int*)realloc(array, newsize)

[Brcondor]

Non sapevo delr realloc, mi sembra una buona soluzione.
Il mio problema è duplice: creo un array di numeri, poi faccio una ricerca e copio il numero che trovo e i 4 numeri dopo. Se arrivo a fine array voglio che mi copi i numeri rimanenti dall'inizio: questo non dovrebbe essere un problema, faccio un if e se arrivo alla fine al posto di spostarmi di 1 sul vettore metto i=0;
Il vero problema di fondo è che vorrei lavorare con numeri molto grandi, nell'ordine di 10^20 10^30: non cambia nulla se uso liste dinamiche o array nello spazio occupato nella memoria? Poi un'ultima cosa: se è veloce da fare, come faccio ad aprire un file di testo composto da soli numeri separati da spazi e dirgli di trasformarlo in un vettore di numeri?

[Eltarion]

la lista dipende come la implementi, comunque è sicuramnte più grossa come struttura rispetto ad ubn array di int. Tra l'altro non trovo nessuna buona ragione per utilizzare una lista.
Per il resto vedi http://www.cplusplus.com/doc/tutorial/files/ li trovi tutto se lavori in c++

[Brcondor]

No volevo cercare di fare tutto in c per varie ragioni(in primis, per quanto me ne ricordi poco, lo conosco meglio del c++).

[San Vegeta]

non programmo in C da anni, quindi partiamo più o meno dallo stesso livello ;)
procediamo per step:
funzione che prende in input 1 array di char e la sua equivalente con puntatore (sono la stessa cosa)


// function 1
void dosomething(char cline[]) {
...
}
// function 2
void dosomething(char *cline) {
...
}

e si usano così


char line[100];
// function 1
dosomething(line);
// function 2
dosomething(&line[0])

Devi restituire due vettori: dato che non si possono restituire due variabili, o dichiari una struct che contiene due vettori (non è male come idea, ma è poco C-style) oppure passi come parametri i vettori in cui vuoi i risultati. Scegliamo la seconda opzione, più che altro perchè non ricordo come si lavora sulle struct lol


// function 2
void doCalc(int myNumber, int *firstVector, int *secondVector) {
...
}

e si userebbe così



int* result1, int* result2;
int myNumber = 71; // 69 + 2 dita nel culo

doCalc(myNumber, result1, result2);



Cosa fa la tua funzione non lo so, però so come salvare i risultati



// function 2
void doCalc(int myNumber, int *firstVector, int *secondVector) {
int firstVectorSize = 10;
int secondVectorSize = 23;

firstVector = (int *)malloc(sizeof(int) * firstVectorSize );
secondVector = (int *)malloc(sizeof(int) * secondVectorSize );

// fai i calcoli
// salva i risultati negli array, ad esempio così
// firstVector[0] = 0;
// firstVector[1] = 1;
// ...
// firstVector[firstVectorSize - 1] = firstVectorSize - 1;

return;
}



arrivato qui, non ho ben capito cosa devi fare, perchè al momento hai tutto quello che ti serve per fare le tue cose... se mi spieghi bene cosa deve fare la funzione, vediamo di continuare :)

[Brcondor]

thx mille, ora mi studio tutto quel che hai scritto e domani ti dico come è andata :)

[Brcondor]

Ok, ho letto tutto a fondo. Molti spunti interessanti(tipo modificare la size come scrivevi te). Sul passare i puntatori come risultato di una funzione ok:
dovrei fare una cosa del genere.
int *v1,*v2;
v1=(int*)malloc(num_elem*size(elem)) ;//la size la conosco prima di fare l'operazione,perche nell'operazione calcolo un numero di elementi a mia scelta
v2=(int*)malloc(num_elem*size(elem)) ;
la_mia_funzione_(v1,v2,parametri_vari);
A questo punto avrei indietro i due vettori già scritti: quel che hai scritto era proprio quello che volevo, stavo facendo un po' di try per far funzionare la funzione come fosse un main(è abbastanza complicata) e aspettavo ad inserirla nel vero main.
Sul salvare e caricare, intendo farlo da file: come carico una matrice di float dentro c? Ovviamente sapendo la sua posizione e nome(o chiedendo all'utente posizione e nome)
E invece, come faccio a salvare in un file una struct composta da determinati valori(i due vettori calcolati, alcuni interi di identificazione, un'altra matrice)?
Cioè quello che voglio fare io è:
algoritmo 1:CREAZIONE FILE. ho unamatrice esterna==> load dentro c==>operazioni varie sulla matrice per ottenere alcuni parametri==> calcolo i vettori==> modifico la matrice==> salvo in un file i due vettori,i parametri calcolati e la nuova matrice
algoritmo 2:VISUALIZZAZIONE FILE. ho un file salvato con vettori e matrice==> load dentro c
Sicuramente si può fare, ora me la smazzo un pochino, se qualcuno ha voglia ancora di darmi una piccola mano quando diventerò milionario(cosa che succederà presto) lo sotterrerò di $$ :P

[Eltarion]

letture e scritture su file ci sono nmila esempi su google. lo devi fare su linux o su windows? si usano api diverse (per win OpenFile e WriteFile, su linux hai le fopen e fread etc.)

[Brcondor]

COs'è meglio? Volendo ho una live ubuntu e potrei lavorare su quella. Se è uguale, win mi è piu comodo

[Axet]

letture e scritture su file ci sono nmila esempi su google. lo devi fare su linux o su windows? si usano api diverse (per win OpenFile e WriteFile, su linux hai le fopen e fread etc.)

Sicuro? Magari dico una cazzata che C l'ho usato l'ultima volta tipo 8 anni fa, ma mi pare di aver sempre usato fopen & co su sistemi windows

[Brcondor]

Domanda al volo slegata da tutto, con devcpp mi sn creato il mio ble project. Posso addare source file e usarli come funzioni esterne da chiamare nel main? Giusto per avere tutto ordinato e poter debuggare un pezzo di codice alla volta senza salvare nmila main che poi me li perdo in giro...

[Eltarion]

Sicuro? Magari dico una cazzata che C l'ho usato l'ultima volta tipo 8 anni fa, ma mi pare di aver sempre usato fopen & co su sistemi windows

yes you can ma solo ocn c++ se non erro. in c usi direttamente le api di winzozz

@brcondor fallo su quello che ti è più comodo

[Eltarion]

Domanda al volo slegata da tutto, con devcpp mi sn creato il mio ble project. Posso addare source file e usarli come funzioni esterne da chiamare nel main? Giusto per avere tutto ordinato e poter debuggare un pezzo di codice alla volta senza salvare nmila main che poi me li perdo in giro...

certo che puoi, basta che le dichiari

[Brcondor]

yes you can ma solo ocn c++ se non erro. in c usi direttamente le api di winzozz

@brcondor fallo su quello che ti è più comodo
Si ma il senso di quello che sto facendo è non nullo se e solo se creo la migliore ottimizzazione possibile di tutto, se no è un fail(o uno stronzo puo venire dopo di me e riciclare la mia idea).
A naso direi che linux ottimizza meglio le risorse di windows, ma magari è una cazzata.

certo che puoi, basta che le dichiari come le dichiaro? Come una funzione normale? E la chiamata nella main è uguale?

[Brcondor]

ALtra domandina veloce veloce. io ho un array di int e uno di float che però si combinano continuamente(moltiplico il valore di uno per il valore dell'altro): ogni volta devo eseguire il cast? Perchè il vettore di int lo costruisco io come vettore di numeri unitari unsigned int(perchè mi fa comodo), mentre il secondo vettore è composto da numeri molto piu alti di 65000(valore max di unsigned int) quindi per forza di cose mi serve usare o un float o addirittura un double. Oppure magari creo un vettore float ausiliario e poi trasformo quel vettore in vettore di interi...

[Eltarion]

scusa, non per fare l'hipster, ma non mi sembri un drago del c, che problemi di ottimizzazione ti fai????

si le dichiari come dichiari normalmente le funzioni e le usi normalmente dal main.

per la seconda domanda (che conferma la precedente affermazione sull'ottimizzazione)...ci sono anche i long. occhio a non castare da un tipo più grosso ad uno più piccolo o rischi di perdere informazioni.

edit:
tra l'altro ora che ci penso guarda che un int (unsigned) può avere come valore massimo anche 2^32. dipende dal sistema.

[Brcondor]

Boh elta, perchè non fare una cosa bene se si può: meglio perderci 10 minuti in piu in itinere che poi a posteriori tornare indietro e rifare tutto.
Io dovrei gestire numeri abbastanza grossi, nell'ordine di 10^20. Il punto è che sono TUTTI interi:
il primo vettore contiene solo interi unitari
il secondo vettore contiene solo interi compresi tra 1 e 10^20
Come faccio a moltiplicare il primo elemento del primo vettore con il primo elemento del secondo? (float)v1[1]*v2[1] ?
Il fatto che il primo vettore sia di numeri unitari che ottengo dal secondo e che il secondo sia fatto da numeri inter fa si che non abbia perdita di info.
Cmq mi manca solo qualche base di traduzione nel linguaggio, il problema di per se lo ho ben presente.

[Eltarion]

Boh elta, perchè non fare una cosa bene se si può: meglio perderci 10 minuti in piu in itinere che poi a posteriori tornare indietro e rifare tutto.
Io dovrei gestire numeri abbastanza grossi, nell'ordine di 10^20. Il punto è che sono TUTTI interi:
il primo vettore contiene solo interi unitari
il secondo vettore contiene solo interi compresi tra 1 e 10^20
Come faccio a moltiplicare il primo elemento del primo vettore con il primo elemento del secondo? (float)v1[1]*v2[1] ?
Il fatto che il primo vettore sia di numeri unitari che ottengo dal secondo e che il secondo sia fatto da numeri inter fa si che non abbia perdita di info.
Cmq mi manca solo qualche base di traduzione nel linguaggio, il problema di per se lo ho ben presente.

hai ragione sull'ottimizzazione, ma mi sembra tu abbia dei problemi ben più grossi rispetto alla differenza di utilizzo delle risorse tra linux e windows.
ricapitolando se l'uint non ti basta (2^32) hai anche il long (2^64). Se devi salvare il sisultato in un vettore di float allora devi castare a float.

io comincerei ad avere un qualcosa da testare e dopodichè andrei ad ottimizzare (anche perchè così ti accorgi dove potresti avere margini di miglioramento). Tra l'altro a meno che il progetto non sia composto da altre parti di cui non hai parlato, non mi sembra ci voglia poi molto a riscrverlo anche da capo per ottimizzarlo :D

[Axet]

yes you can ma solo ocn c++ se non erro. in c usi direttamente le api di winzozz

@brcondor fallo su quello che ti è più comodo

Boh mi pareva che pure in C liscio si potesse, ricorderò male :D


scusa, non per fare l'hipster, ma non mi sembri un drago del c, che problemi di ottimizzazione ti fai????


This.
Imo brcondor hai sbagliato facoltà, dovevi fare informatica a sto punto :sneer:

[Eltarion]

Boh mi pareva che pure in C liscio si potesse, ricorderò male :D


la fopen fa parte di iostream che è una classe, quindi solo c++
Ho sbagliato io a scrivere fopen prima, da su linux effettivamente è open senza la f :D

[Brcondor]

Boh mi pareva che pure in C liscio si potesse, ricorderò male :D



This.
Imo brcondor hai sbagliato facoltà, dovevi fare informatica a sto punto :sneer:
Scusa, solo quelli che fan informatica sanno programmare? Con matlab ti assicuro che do le basi a moltii informatici. Sapere scrivere un algoritmo logico è una cosa che chiunque può fare, saperlo implementare spesso pure: non devo fare nulla di trascendente.
Non è il mio lavoro ne lo sARà, è solo un progettino molto interessante: un informatico andrà molto piu a fondo su determinate questioni che a me non interessano.
Il programma base non ottimizzato già l'ho scritto, con soli int, ma serve a poco, dato che arrivo al max a 65000, numero minuscolo. Anche long secondo me finirebbe col starmi stretto prima o poi.
Il problema di fondo concettuale è il seguente: se ho un vettore di float, come faccio a castarlo come vettore di int? Dovrei forse crearmi un vettore int provvisorio e ogni volta copiare un elemento con cast?

[San Vegeta]

Ora sono al lavoro, cmq una correzione importante te la devo fare: un int arriva a due miliardi e rotti, un unsigned int a circa il doppio.
Su questo non si discute

Ovviamente int 32 bit

[Eltarion]

Ora sono al lavoro, cmq una correzione importante te la devo fare: un int arriva a due miliardi e rotti, un unsigned int a circa il doppio.
Su questo non si discute

Ovviamente int 32 bit

l'avevo già scritto due volte qq

Y U NO LISTEN TO ME?

[Axet]

la fopen fa parte di iostream che è una classe, quindi solo c++
Ho sbagliato io a scrivere fopen prima, da su linux effettivamente è open senza la f :D

Boh m'hai fatto venire il dubbio e ho controllato:
http://www.acm.uiuc.edu/webmonkeys/book/c_guide/

C'è :look:


Scusa, solo quelli che fan informatica sanno programmare? Con matlab ti assicuro che do le basi a moltii informatici. Sapere scrivere un algoritmo logico è una cosa che chiunque può fare, saperlo implementare spesso pure: non devo fare nulla di trascendente.
Non è il mio lavoro ne lo sARà, è solo un progettino molto interessante: un informatico andrà molto piu a fondo su determinate questioni che a me non interessano.

Tralasciando il "con matlab ti assicuro spacco i culi" che è abbastanza lol, ovviamente non solo quelli che fanno informatica sanno programmare. Anche perchè, per programmare, non serve mica una laurea (cambia magari la qualità di quello che è stato prodotto, ma non è sempre vero e cmq si ovvia con l'esperienza).
Il fatto è che hai aperto in poco tempo 2 thread per questioni inerenti l'informatica, da cui segue la mia battuta.

[Brcondor]

Ok, sbagliavo io. CMq 2 miliardi e rotti non mi bastano... magari me li faccio bastare per ora.
Cmq axet il punto è che durante un percorso di studi che non centra nulla con la programmazione, mi è stato chiesto per un progetto di implementare un determinato algoritmo molto particolare, che deve per forza di cose usare puntatori e usare numeri enormi. Ho implementato tutto con matlab, tutto bello tutto perfetto se non che matlab non gestisce in maniera intelligente la memoria e soprattutto non permette di implementare puntatori. Allora parlandone col prof lui mi ha detto"è qua che ti aspettavo, infatti devi farlo col c se vuoi ottenere qualcosa". Eran 4 anni che non toccavo c, e il passaggio matlab==>c è stato traumatico(con matlab ho lavorato tantissimo, per la tesina e per altri esami e lo so usare abbastanza bene). Un tempo, quando ho dato informatica 1, lo sapevo senza problemi: ora devo piano piano riscoprire tutto. Tutto questo condito da alcune specifiche fuori dall'ordinario fanno si che io mi faccia mille paranoie stupide.Con matlab il mio algoritmo si ferma con numeri nell'ordine delle decine di milioni, inizia a consumare tutta la ram. Se ri-implementando tutto in c mi fermo a 4 miliardi, sai che guadagno.

[Axet]

Torno a dire come, se non erro, ti avevo detto anche nel 3d dei numeri primi: se ci dici COSA devi fare ti si può aiutare meglio. Ad esempio, perchè servono PER FORZA i puntatori?
C non è l'unica alternativa, esistono C++, Java ed altri 2353906358524 linguaggi. Dipende tutto da quello che devi fare.

Per quanto riguarda matlab, è ottimo per modellare e fare prove ma è ben lungi dall'essere efficiente. Essendo ad alto livello poi è facile da usare ed è estremamente flessibile (tutti i vari toolkit), ma in ogni caso ha dei limiti enormi. Certo spacca per il calcolo matriciale (difatti è usatissimo in Image Processing), ma le limitazioni impongono che venga usato quasi solo per stadi iniziali.. di solito si traduce il tutto in linguaggi più efficienti come appunto C.

Tornando ai numeri grossi in C, ignoro se esista un supporto nativo anche se tbh non credo, ma potresti salvarli come un vettore di interi dove ogni cella è una cifra. In questo modo puoi crearti numeri arbitrariamente grandi, finchè c'è memoria disponibile. Altrimenti, così a naso, puoi approssimare in 240942 modi diversi ma dipende sempre da cosa devi fare: ti servono numeri esatti o vanno bene anche approssimati? Come dicevo aiutare con info così scarse è estremamente difficile.

[Brcondor]

Grazie mille cmq per le risposte:).
Io ve lo chiedo, se avete voglia di rispondermi vi sarò grato: ammettiamo che io abbia un vettore con una quantità di elementi superiore ai 2^32 citati prima. Come faccio a fare un iteratore che spazi per tutto il vettore? Se uso un int a un certo punto si impallerà tutto. Se uso un float mi da errore e mi dice che sto usando un float come posizione e per lui è sbagliato.

[Axet]

Grazie mille cmq per le risposte:).
Io ve lo chiedo, se avete voglia di rispondermi vi sarò grato: ammettiamo che io abbia un vettore con una quantità di elementi superiore ai 2^32 citati prima. Come faccio a fare un iteratore che spazi per tutto il vettore? Se uso un int a un certo punto si impallerà tutto. Se uso un float mi da errore e mi dice che sto usando un float come posizione e per lui è sbagliato.

Se stai cercando di implementare quello che ho scritto nel reply precedente (cioè rappresentare un numero come un vettore dove ogni cifra corrisponde a una cella) il problema non esiste: un numero con 2^32 cifre è qualcosa di talmente gigantesco che ti servirebbe un foglio lungo kilometri per scriverlo.
Se invece intendi il vettore in cui schiaffi i numeri, una soluzione naive potrebbe essere usarne tanti quanti te ne servono. Quando ne riempi uno passi al secondo e così via.

[Brcondor]

Se stai cercando di implementare quello che ho scritto nel reply precedente (cioè rappresentare un numero come un vettore dove ogni cifra corrisponde a una cella) il problema non esiste: un numero con 2^32 cifre è qualcosa di talmente gigantesco che ti servirebbe un foglio lungo kilometri per scriverlo.
Se invece intendi il vettore in cui schiaffi i numeri, una soluzione naive potrebbe essere usarne tanti quanti te ne servono. Quando ne riempi uno passi al secondo e così via.
Si, avevo pensato a una soluzione del tipo
int num_it=numero/2^32;
int *i;
i=(int*)malloc(num_it*sizeof(int));
E poi ogni volta che un i[k] arriva a 2^32 passo a quello dopo e come posizione uso num[i[2^32]+i[k]]

[San Vegeta]

se vai su un sistema a 64 bit, puoi usare il long che è appunto 64 bit, quindi puoi indirizzare fino a 2^64 numeri, oppure il int __attribute__ ((mode(TI))) col gcc.
è bastato cliccare sul primo link trovato su google, sicuramente esistono librerie per rappresentare numeri enormi

come idea alternativa, se non ricordo puttanate, esisteva il modo di rappresentare qualunque numero come funzione polinomica, la quale funzione andrebbe poi codificata e rappresentata... ma mi sa che stiamo andando un po' oltre il seminato

http://www.daniweb.com/software-development/cpp/threads/135667 (l'ultimo post molto bello)

http://gmplib.org/

[Mez]

ma il c non ha l'int, short, long, double ecc.. da ignorante perchè per me è arabo

[Eltarion]

usa i long che anche su sistemi a 32 bit sono comunque da 64 quindi con un unsigned long rappresenti 2^64 numeri. sprecare 4 bute di int per rappresentare solo le cifre è folle axet :sneer:

[Brcondor]

se vai su un sistema a 64 bit, puoi usare il long che è appunto 64 bit, quindi puoi indirizzare fino a 2^64 numeri, oppure il int __attribute__ ((mode(TI))) col gcc.
è bastato cliccare sul primo link trovato su google, sicuramente esistono librerie per rappresentare numeri enormi

come idea alternativa, se non ricordo puttanate, esisteva il modo di rappresentare qualunque numero come funzione polinomica, la quale funzione andrebbe poi codificata e rappresentata... ma mi sa che stiamo andando un po' oltre il seminato

http://www.daniweb.com/software-development/cpp/threads/135667 (l'ultimo post molto bello)

http://gmplib.org/
Ti adoro, grazie mille era quello che cercavo.
Mentre lavoravo ieri mi è sorto un problema. Con numeri grandi la quantita di conti da fare è abnorme: con matlab oltre un certo numero(60.000.000) saturavo la memoria e quindi si impallava tutto. Con c per fortuna questo non succede(la memoria è usata come dico io, quindi finchè il vettore non diventa piu grande dei 3 gb di ram che ho liberi lavora tranquillo). Iò èrpbòema è che usa solo il 25% del processore: c'è un modo per forzare il programma a usare il 60% del processore e metterci quindi di meno?

[Axet]

usa i long che anche su sistemi a 32 bit sono comunque da 64 quindi con un unsigned long rappresenti 2^64 numeri. sprecare 4 bute di int per rappresentare solo le cifre è folle axet :sneer:

Molto probabilmente non è la soluzione ottimale, ma se devi lavorare con numeri di 100 e passa cifre come fai? In Java c'è la classe BigInteger, in C magari c'è qualche libreria apposita, ma coi tipi primitivi non è possibile farlo

[Axet]

Ti adoro, grazie mille era quello che cercavo.
Mentre lavoravo ieri mi è sorto un problema. Con numeri grandi la quantita di conti da fare è abnorme: con matlab oltre un certo numero(60.000.000) saturavo la memoria e quindi si impallava tutto. Con c per fortuna questo non succede(la memoria è usata come dico io, quindi finchè il vettore non diventa piu grande dei 3 gb di ram che ho liberi lavora tranquillo). Iò èrpbòema è che usa solo il 25% del processore: c'è un modo per forzare il programma a usare il 60% del processore e metterci quindi di meno?

Vai in parallelo

[Eltarion]

yeah spamma thread come piovessero. tra l'altro in c++ c'è una libreria ultrafiga (segnalata da un amico, ora non ricordo come si chiama, se vuoi controllo) che gestisce automaticamente la paralellizazione dei calcoli matematici.

[Brcondor]

Sto facendo tutto in c, ora cerco qualcosa su google. Thx per la dritta

[Eltarion]

mi pare ci siano anche per c, controllo e ti faccio sapere.

[Brcondor]

Thx mille delle varie mani, sta iniziando a girare tutto :)

[Brcondor]

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);

[Hardcore]

magari guardati qualche cosa di ottimizzazione cache, che se lavori con array potrebbe tornarti utile usarle in modo corretto

[Eltarion]

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);

in che senso si blocca tutto? vai in debug e dicci l'errore

[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

[Hardcore]

Ma stai programmando da notepad???
Usa Visual Studio e metti i breakpoint. Pd mica siamo nel 1970

[Eltarion]

mi pare ci siano anche per c, controllo e ti faccio sapere.

ci sono anche per c --> http://openmp.org/wp/


Ma stai programmando da notepad???
Usa Visual Studio e metti i breakpoint. Pd mica siamo nel 1970

mi pari usi dev++, non ricordo se c'è il debugger. comunque visual studio e vai sul sicuro :P

[Brcondor]

SI uso devcpp. Ok proviamo sto visual studio :).

[Brcondor]

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

[Eltarion]

ma no sono semplici da usare :) le attivi poi dalle opzioni di compilazione (su visual studio)

[Brcondor]

Ok thx elta, di questa rispota e di tutto lo sbatti che ti sei fatto pagina dopo pagina :)

[Brcondor]

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

[Eltarion]

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 essere
printf("%d %d",*vect1+1,*vect2+1);

[Brcondor]

ma in c *r +4 non è la stessa cosa di r[4]?

[Eltarion]

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:
vedrai che col debugger risolvi al volo

[Hardcore]

Non dovrebbe essere r+4?

[Eltarion]

Non dovrebbe essere r+4?

così stampi l'indirizzo

[Brcondor]

Ho provato tutti i modi, ma al massimo mi stampa l'indirizzo di cui me ne faccio poco.

[Hardcore]

se fai printf *vect1 e printf vect1 ti da la stessa cosa?

[Eltarion]

se fai printf *vect1 e printf vect1 ti da la stessa cosa?

dipende come è dichiarato vect

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)

[Hardcore]

si questo lo so, chiedevo a lui cosa gli viene fuori, perchè appunto mi sembra strana come cosa.

[Eltarion]

si questo lo so, chiedevo a lui cosa gli viene fuori, perchè appunto mi sembra strana come cosa.

cosa ti sembra strano?

[Brcondor]

è 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


}

[Eltarion]

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

[Brcondor]

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...

[Eltarion]

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.

[Brcondor]

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

[Eltarion]

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ù

[Brcondor]

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.

[Eltarion]

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.

[Brcondor]

mi posti il tuo codice please? Non riesco a capire come far andare il debug :(

[Brcondor]

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?

[Eltarion]

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
}

[Brcondor]

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.

[Brcondor]

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;
}

[Brcondor]

La funzione era giusta, sbagliavo io a chiamarla :)

[Eltarion]

lol stavo cercando di capire cosa c'era che non andava e non avevo letto il post sotto -.-

[Brcondor]

:)
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

[Brcondor]

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]

[Axet]

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.
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.

[Brcondor]

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.

[Axet]

A dir il vero la matrice E' un array di array :sneer:

[Brcondor]

:P Sisi, ma intendevo un'altra cosa. Nel senso, al posto di vederla come righe e colonne cerco di vederla come sequenze di righe ordinate. Era una cosa per me, per poterla visualizzare come dicevo io.

[Brcondor]

Ok una parte dei problemi mo son risolti.
Ora rimane un problema cardine che ho posposto fino a quando ho potuto: come diavolo si leggono le immagini .bmp con c? Qualcuno ha qualche idea? Leggendo su internet, è come se un file bmp fosse una struct, con un'intestazione e un campo info e poi la matrice di valori. Dovrei creare una struct con le stesse caratteristiche del file bmp e poi andare a leggere con la dot quotation i valori che mi interessano?

[Eltarion]

se sei su winzoz ci sono le ap, altrimenti per aprirle in modo brutal le apri come vettori di byte e poi vai tu ad interpretare le sequenze

[Brcondor]

che sono le ap? Cmq si, secondo me il top sarebbe leggerle come vettore di byte... alla fine dovrei aver trovato lo schema di come sono composte, quind mi basterebbe far puntare a tot byte dopo e leggere tot byte alla volta...

[San Vegeta]

adesso ti incazzi (anche se non lo dico per farti incazzare):

tu vorresti tirare fuori un superalgoritmo a cui nessuno ha pensato, veloce e usabile su qualunque numero, senza sapere come rappresentare i tuoi dati, senza sapere programmare (dai ammettiamolo, sai le basi, punto) e senza conoscere le tecniche di ottimizzazione del codice, che spesso richiedono di inventarsi microalgoritmi ad hoc solo per rendere un pelo più veloci alcune operazioni?
davvero?
ma non è il caso di mirare un po' più in basso?

[Brcondor]

A me serve un prototipo funzionante sotto ipotesi che facilitano il tutto, mi serve far vedere che anche senza quelle ipotesi funziona. Fatte ste due cose diventerà la mia tesi di laurea e avrò due anni per fare tutto a modo. Non ci vedo nulla di male. L'algoritmo è semplice, il problema per me è il linguaggio di programmazione.

[San Vegeta]

Non c'è assolutamente niente di male, ma un algoritmo risolve un problema teorico: per risolvere un problema reale si usa un programma basato su quell'algoritmo. Il programma è strettamente vincolato dalla piattaforma, dal linguaggio, dal programmatore e dai dati in input.
In ogni caso buona fortuna con la tesi :)