[Tech] C che stress!!!!

[Sergio Ballestrero]

 La mia risposta e' lunga, ma in fondo c'e' una domanda !! non ho ancora
deciso il premio per chi mi risponde :-P

On Mon, 2 Apr 2001, Ombra Rossa wrote:

> Ciao a tutti, sono uno stress lo so'! Scusatemi.

> Sto' facendo un programmino per divertimento, quindi non e' nulla di
> urgente, avrei bisogno di poter dare ad un array di caratteri
> bi-dimensionale una grandezza arbitraria data dall'input dell'utente.

 prima di tutto: per "array bidimensionale" intendi un array di array,
come dice il C, o una matrice, come dice il Fortran ?

> Avevo pensato ad una funzione, ma l'array non e' visibile dal corpo
> main del programma. Non so' se si puo' dichiarare una funzione che
> come renda un array.
> E' possibile?

 Per valore, no. Per puntatore, si. Comunque non risolve il problema: non
puoi fare

char **pippo(int ni,int nj) {
   char a[ni][nj];
   return a;
}

array2.c: In function `pippo':
array2.c:6: warning: return from incompatible pointer type
array2.c:6: warning: function returns address of local variable

> Certo potrei dichiararlo nel main, ma poi come gli cambio gli indici?? Si
> puo' fare?

// array of arrays

#include <stdlib.h>
#include <stdio.h>

int main (int argc,char *argv[]) {
   char **a;
   int ni,nj,i,j;
   if(argc<3) return 1;
   ni=atoi(argv[1]);
   nj=atoi(argv[2]);

   // constructor
   a=(char **)calloc(ni,sizeof(char *));
   for(i=0;i<ni;i++) {
      a[i]=(char*)calloc(nj,sizeof(char));
   }

   //user
   for(i=0;i<ni;i++) {
      for(j=0;j<nj;j++) {
	 a[i][j]='x';
	 printf("%i %i %p=%c\n",i,j,&(a[i][j]),a[i][j]);
      }
   }

   //destructor
   for(i=0;i<ni;i++) {
      free(a[i]);
   }
   free(a);

   return 0;
}

 Vantaggi: accesso 'facile': a[i][j]
 Svantaggi: complessa da inizializzare e da distruggere
            non contigua in memoria

-------------------------------------------------

// matrix

#include <stdlib.h>
#include <stdio.h>

int main (int argc,char *argv[]) {
   char *a;
   int ni,nj,i,j;
   if(argc<3) return 1;
   ni=atoi(argv[1]);
   nj=atoi(argv[2]);
   //constructor
   a=(char *)calloc(ni*nj,sizeof(char *));
   //user
   for(i=0;i<ni;i++) {
      for(j=0;j<nj;j++) {
	 a[i*nj+j]='x';
	 printf("%i %i %p=%c\n",i,j,&(a[i*nj+j]),a[i*nj+j]);
      }
   }
   //destructor
   free(a);
   return 0;
}

Vantaggi: facile da inizializzare e distruggere
          contigua in memoria
          compatibile Fortran
Svantaggi: accesso complesso: a[i*nj+j]

--------------------------------------

// Soluzione C:

int main (int argc,char *argv[]) {
   int ni,nj;
   if(argc<3) return 1;
   ni=atoi(argv[1]);
   nj=atoi(argv[2]);
   {
      char a[ni][nj];
      int i,j;
      /*user*/
      for(i=0;i<ni;i++) {
	 for(j=0;j<nj;j++) {
	    a[i][j]='x';
	    printf("%i %i 0x%p=%c\n",i,j,&(a[i][j]),a[i][j]);
	 }
      }
   }
   return 0;
}

 Un compilatore moderno non dovrebbe protestare.
 Svantaggio: alloca a sullo stack, che non e' infinito...

------------------------------------------

// Soluzione C++

#include <stdlib.h>
#include <stdio.h>

int main (int argc,char *argv[]) {
   if(argc<3) return 1;
   int ni=atoi(argv[1]);
   int nj=atoi(argv[2]);
   char a[ni][nj];
   for(int i=0;i<ni;i++) {
      for(int j=0;j<nj;j++) {
	 a[i][j]='x';
	 printf("%i %i %p=%c\n",i,j,&(a[i][j]),a[i][j]);
      }
   }
   return 0;
}

 Stesso svantaggio (stack), nessuna preoccupazione di "scope" della
variabile.
 Facile, no ?


 Ma ho un dubbio io, adesso: come cavolo passo a[][] ad una funzione,
senza forzare un cast a (char *) ??

 Sergio

-- 
--------------------------------------------------------------------------
 Things will get better despite             Sergio Ballestrero
our efforts to improve them.                       S.Ballestrero@iname.com
	-- Will Rogers