39 risposte a questa discussione

[Aldin]

Si ma cosa ci va nei puntini?
**v[i]=malloc(a*sizeof(int**));
*v[i][j]=malloc(b*sizeof(int*));
v[i][j][k]=malloc(c*sizeof(int));
?

[trallallero]

Ah, pensavo volessi leggere i valori di una matrice.
Niente, sono andato, a domani

[Aldin]

Pastiglie o gocce? Che marca?

[dreadknight]

aldin, se vuoi imparare a programmare bene in C ti consiglio questo libro

[TigerShark]

[quote name="trallallero @":3huz4za0] [quote name='"TigerShark @":3huz4za0] dio cane' date=' perche' questa tortura nel 2011 quando non solo abbiamo framework che fanno il garbage collecting automatico, ma adirittura suddividono dinamicamente i thread in funzione del numero di processori del sistema e in funzione del numero di processori DISPONIBILI IN QUEL MOMENTO???? [/quote']
Gente che sa fare queste torture ha potuto scrivere in C il Java.[/quote]
E ora c'e gente che riscrive il python in python e in java scrive scala.
cazzo.
Infatti ho specificato nel 2011.
In che anno e' nato java?
e perche' e' stato scritto in C?
E scala in che anno e' nato?
e perche' e' stato scritto in java?

[TigerShark]

aldin, se vuoi imparare a programmare bene in C ti consiglio questo libro

cristo, il deitel & deitel...
ancora e' usato dopo 10 anni che l'ho usato io?
speravo l'avessero bruciato, soprattutto nella miserrima traduzione italiana che per fortuna non ho mai comprato.

[trallallero]

@[/url]":51w18l2e]
Gente che sa fare queste torture ha potuto scrivere in C il Java.

E ora c'e gente che riscrive il python in python e in java scrive scala.
cazzo.
Infatti ho specificato nel 2011.
In che anno e' nato java?
e perche' e' stato scritto in C?
E scala in che anno e' nato?
e perche' e' stato scritto in java?

Ma ancora la meni con sta storia del cazzo ?
Se vuoi alte prestazioni scrivi in C++, c'è chi lo fa in C, programmatori Assembler sono ancora richiesti.
Se ti sta tanto sul cazzo il C/C++, cosa entri a fare nei threads che trattano C/C++ ?

[TigerShark]

@[/url]":f4rb6a1h]
E ora c'e gente che riscrive il python in python e in java scrive scala.
cazzo.
Infatti ho specificato nel 2011.
In che anno e' nato java?
e perche' e' stato scritto in C?
E scala in che anno e' nato?
e perche' e' stato scritto in java?

Ma ancora la meni con sta storia del cazzo ?
Se vuoi alte prestazioni scrivi in C++, c'è chi lo fa in C, programmatori Assembler sono ancora richiesti.
Se ti sta tanto sul cazzo il C/C++, cosa entri a fare nei threads che trattano C/C++ ?

per ricordarmi ogni tanto quanto fanno cagare come sintassi..

[trallallero]

Vero, ma è anche giusto che si imparino certe cose di basso livello altrimenti cresci viziato e finisci coll'essere capace di programmare solo in Java

[Aldin]

Il deitel mi ha messo il latte alle ginocchia. Ho quello sul C++. E' un libro si per principianti, ma anche per ritardati mentali. Ho preferito il materiale del mio prof. Diretto, ordinato e assolutamente non ridondante.

Si ma cosa ci va nei puntini?
**v[i]=malloc(a*sizeof(int**));
*v[i][j]=malloc(b*sizeof(int*));
v[i][j][k]=malloc(c*sizeof(int));
?

[trallallero]

Ops, pensavo avessi già risolto.

Come lo dichiari "v" ?

Diciamo

int*** v = NULL;

Quindi prima cosa allochi la prima dimensione senza ciclo:

v = malloc(a * sizeof(int**));

Poi per ogni indice compreso in "a", devi allocare le altre 2 dimensioni:

int ind1, ind2;

for (ind1 = 0; ind1 < a; ++ind1) 

{

   *array[ind1] = malloc(b * sizeof(int*)); // La seconda



    // Poi per ogni indice compreso in "b", devi allocare la 3a dimensione:

   for (ind2 = 0; ind2 < b; ind2++) 

   {

      array[ind1][ind2] = malloc(c * sizeof(int)); // La terza

   }

}

Dovrebbe essere così, non ho testato.
Ma sicuramente c'è almeno un errore, queste cose non funzionano mai alla prima


Altra soluzione non dinamica per cominciare il C senza puntatori è:

int v[2][10][20]; // valori a caso

[Aldin]

Ma come ho scritto all'inizio, non posso dichiararlo subito come array, e poi allocargli la memoria? O gli array hanno già memoria allocata quando vengono dichiarati? Perché se così non me ne faccio niente di tutta quella merda con i malloc.

[trallallero]

No che non puoi. Se vuoi puoi dichiararlo statico come t'ho detto, v[1][2][3],
sennò lo dichiari come puntatore e puoi allocare quello che vuoi.

Nel primo caso la misura la dichiari e non la puoi cambiare, nel secondo caso la decidi in real time.

[trallallero]

Comunque se non ti piacciono i puntatori voglio vedere se un giorno finisci a programmare con puntatori a callbacks ovvero, per esempio, passare ad una classe il puntatore alla funzione che deve chiamare quando succede qualcosa

[yorkeiser]

Il libro modifica il programma nelle pagine successive per farci qualcosa di utile. Ah:
Se volessi dichiarare un elemento del tipo v[j][k] come farei ad allocargli memria con malloc? [i]v=(double*)malloc(i*j*k*sizeof(double)); ?
O forse v=(double*)calloc(i*j*k,sizeof(double)); ? v o &v?

Certo, puoi fare come hai detto.

;

int i,j,k;

i=dim_x; j=dim_y; k=dim_z;

double* v=(double*)malloc(i*j*k*sizeof(double));

Per accedere alla cella dell'array di indici x,y,z (ovvero v[x][y][z]): se i,j,k sono le dimensioni dell'array, la formula dovrebbe essere, se non sono troppo cotto:
*(v+x+i*y+(i*j*z))

ad esempio, per v[10][15][12]:

*(v+10+i*15+i*j*12)=70.0;

printf("%f",*(v+10+i*15+i*j*12));

Praticamente agisci come se fosse un vettore monodimensionale, e gli indici te li gestisci con la formula.
Altrimenti percorri la strada di trollallero, che imho è più complicata (personalmente adoro il c ma mi è sempre venuta l'orticaria quando vedevo n asterischi, con n>1)

[trallallero]

Boh, complicata... una volta che capisci il meccanismo è semplicissima e ti apre un po la mente perché impari ad usare le multidimensioni. Non che poi servirà a molto perché, a meno che tu non debba scrivere drivers, videogiochi o simili, difficilmente dovrai usare la memoria in quel modo.

In fondo questo esempio cosa sta facendo ?

   int ***array = malloc(3 * sizeof(int**));

   int i, j;



   for (i = 0; i < 3; i++) 

   {

      *array[i] = malloc(3 * sizeof(int*));

      for (j = 0; j < 3; j++) 

      {

         array[i][j] = malloc(3 * sizeof(int));

      }

   }

Alloca 3 puntatori a, mentre mia madre succhia cazzi, interi oguno dei quali punta ad un blocco di memoria.
Per ogni blocco, alloca 3 righe di puntatori a, mentre mia madre succhia cazzi, interi.
Per ogni riga alloca 3 colonne a, mentre mia madre succhia cazzi, interi.

Semplicissimo

[yorkeiser]

Boh, complicata... una volta che capisci il meccanismo è semplicissima e ti apre un po la mente perché impari ad usare le multidimensioni. Non che poi servirà a molto perché, a meno che tu non debba scrivere drivers, videogiochi o simili, difficilmente dovrai usare la memoria in quel modo.

In fondo questo esempio cosa sta facendo ?

   int ***array = malloc(3 * sizeof(int**));

   int i, j;



   for (i = 0; i < 3; i++) 

   {

      *array[i] = malloc(3 * sizeof(int*));

      for (j = 0; j < 3; j++) 

      {

         array[i][j] = malloc(3 * sizeof(int));

      }

   }

Alloca 3 puntatori a, mentre mia madre succhia cazzi, interi oguno dei quali punta ad un blocco di memoria.
Per ogni blocco, alloca 3 righe di puntatori a, mentre mia madre succhia cazzi, interi.
Per ogni riga alloca 3 colonne a, mentre mia madre succhia cazzi, interi.

Semplicissimo

Mi pare ci sia un errore: *array[i] dovrebbe essere in realtà array[i] ?

Comunque, al di là dei punti di vista sulle catene di puntatori, l'algoritmo da te enunciato è di gran lunga il più completo in termini di allocazione dinamica, visto che puoi estendere l'array indipendentemente su tutte le tre dimensioni, mentre nella versione monodimensionale puoi estendere solo la terza senza sminchiare gli indici. La versione monodimensionale invece può essere utile al micio albino (le indentazioni ) per fare un po' di pratica con l'aritmetica dei puntatori.
O al massimo per far girare un altro po' le pelotas allo SqualoTigre

[trallallero]

Mi pare ci sia un errore: *array[i] dovrebbe essere in realtà array[i] ?

Mi sembra di no ma potresti avere ragione.
È per quello che ho detto che alla prima non funziona mai, è facile perdere il filo degli *
E poi è un bel po' che non la uso sta roba qua... per fortuna

[toyo]

si ma aldin, se non vuoi diventare scemo con le malloc (che tanto a te da fisico non te ne frega niente, ti basta avere i risultati sperimentali immagino), usa gli std::vector dai.

Altrimenti va a finire che diventi scemo per robe di basso livello, invece di fare quello che ti serve.

Se studiassi informatica ti direi il contrario, ma da fisico che cazzo te ne sbatte?

[MadJackal]

@[/url]":3ivb6584]Mi pare ci sia un errore: *array[i] dovrebbe essere in realtà array[i] ?

Mi sembra di no ma potresti avere ragione.
È per quello che ho detto che alla prima non funziona mai, è facile perdere il filo degli *
E poi è un bel po' che non la uso sta roba qua... per fortuna

E comunque rimane meglio usare *(array+i). Un pò d'amore per l'aritmetica dei puntatori, insomma.