Newsgroup: it.comp.lang.c
Titolo: Vuole la busta A o la B? (array o puntatori)

Ciao a tutti.
Volevo solo un parere da gente esperta sulla
scelta tra l'uso di array o puntatori. 
Propongo due piccoli listati, fatti per prova...
Il primo utilizza array...
#include <stdio.h>
int main(int argc, char *argv[])
{
  int x[]={50,20,64,15};
  int idx[]={0,1,2,3};
  int change=1;
  int count, buf,cou;
  while (change)
  {
    change=0;
    for(count=0;count<3;count++)
    {
      if ( x[idx[count]]> x[idx[count+1]] )
      {
         buf=idx[count];
         idx[count]=idx[count+1];
         idx[count+1]=buf;
         change=1;
      }
    }
 }
      for(cou=0;cou<4;cou++)
        printf(" %d ",x[idx[cou]]);
      cou=getchar();
  return 0;
}
Il secindo puntatori...
#include <stdio.h>
#include<stdlib.h>
#define ELEMENTI 1500
int main(int argc, char *argv[])
{
  int x[ELEMENTI];
  int idx[ELEMENTI];
  int *p, *p1 ;
  int change=1;
  int count,buf;
  int rand();
  for(count=0;count<ELEMENTI;count++)
    {
      x[count]=rand()  ;
      idx[count]=count;
    }
  p=x;
  while (change)
  {
     change=0;
     count=0 ;
     for(p1=idx;count<(ELEMENTI-1);count++,p1++)
     {
      if (*(p+*p1)>*(p+*(p1+1)))
         {
           buf=*p1;
           *p1=*(p1+1);
           *(p1+1)=buf;
           change=1;
         }
     }
  }
  printf("Eseguito ^___^\n");
  count=getchar();
  printf("Idx  Valore     ");
  for(count=0;count<ELEMENTI;count++)
    printf("%d) %d   \n",count,x[count] );
  for(count=0;count<ELEMENTI;count++)
    printf("%d ",idx[count]);
    printf("\n");
  return 0;
}
Il mio esercizio era mirato ad ordinare un array
utilizzando un altro array di indici.
La differenza, a parte il codice per la
visualizzazione e i numeri casuali, sta nell'uso
dei puntatori o degli array.
A vostro parere e' solo questione di scelta
arbitraria oppure uno e' migliore dell'altro. Nel
secondo caso, perche'? 
Scusate la lunghezza.
Igor Rossetti

 scelta tra l'uso di array o puntatori.
Secondo me vanno utilizzati gli array automatici fin quando non è
indispensabile utilizzare i puntatori e cioè quando non si conosce la
dimensione dell'array in compilazione (non ricordo se questo è ancora
valido per il nuovo C) o quando lo scope dell'array deve andare oltre il
blocco in cui è definito.
EMG

 Propongo due piccoli listati, fatti per prova...
#
# CICLO FOR (VERSIONE CON ARRAY) BORLAND 2.0
#
#PUORAR2#13:  for(count=0;count<3;count++)
  cs:026D 33F6           xor    si,si
  cs:026F EB62           jmp    02D3
#PUORAR2#15:  if ( x[idx[count]]> x[idx[count+1]] )
  cs:0271 8BDE           mov    bx,si
  cs:0273 D1E3           shl    bx,1
  cs:0275 8D46F0         lea    ax,[bp-10]
  cs:0278 03D8           add    bx,ax
  cs:027A 8B1F           mov    bx,[bx]
  cs:027C D1E3           shl    bx,1
  cs:027E 8D46F8         lea    ax,[bp-08]
  cs:0281 03D8           add    bx,ax
  cs:0283 8B07           mov    ax,[bx]
  cs:0285 8BDE           mov    bx,si
  cs:0287 D1E3           shl    bx,1
  cs:0289 8D56F2         lea    dx,[bp-0E]
  cs:028C 03DA           add    bx,dx
  cs:028E 8B1F           mov    bx,[bx]
  cs:0290 D1E3           shl    bx,1
  cs:0292 8D56F8         lea    dx,[bp-08]
  cs:0295 03DA           add    bx,dx
  cs:0297 3B07           cmp    ax,[bx]
  cs:0299 7E37           jle    02D2
#PUORAR2#17:  buf=idx[count];
  cs:029B 8BDE           mov    bx,si
  cs:029D D1E3           shl    bx,1
  cs:029F 8D46F0         lea    ax,[bp-10]
  cs:02A2 03D8           add    bx,ax
  cs:02A4 8B07           mov    ax,[bx]
  cs:02A6 8946EC         mov    [bp-14],ax
#PUORAR2#18:  idx[count]=idx[count+1];
  cs:02A9 8BDE           mov    bx,si
  cs:02AB D1E3           shl    bx,1
  cs:02AD 8D46F2         lea    ax,[bp-0E]
  cs:02B0 03D8           add    bx,ax
  cs:02B2 8B07           mov    ax,[bx]
  cs:02B4 8BDE           mov    bx,si
  cs:02B6 D1E3           shl    bx,1
  cs:02B8 8D56F0         lea    dx,[bp-10]
  cs:02BB 03DA           add    bx,dx
  cs:02BD 8907           mov    [bx],ax
#PUORAR2#19:  idx[count+1]=buf;
  cs:02BF 8BDE           mov    bx,si
  cs:02C1 D1E3           shl    bx,1
  cs:02C3 8D46F2         lea    ax,[bp-0E]
  cs:02C6 03D8           add    bx,ax
  cs:02C8 8B46EC         mov    ax,[bp-14]
  cs:02CB 8907           mov    [bx],ax
#PUORAR2#20:  change=1;
  cs:02CD C746EE0100     mov    word ptr [bp-12],0001
  cs:02D2 46             inc    si
  cs:02D3 83FE03         cmp    si,0003
  cs:02D6 7C99           jl     #PUORAR2#15 (0271)
#
# CICLO FOR (VERSIONE CON PUNTATORI) BORLAND 2.0
#
  cs:027B 33F6           xor    si,si
#PUORAR#26:  for(p1=idx;count<(ELEMENTI-1);count++,p1++)
  cs:027D 8D868AE8       lea    ax,[bp-1776]
  cs:0281 8BF8           mov    di,ax
  cs:0283 EB31           jmp    02B6
#PUORAR#28:  if (*(p+*p1)>*(p+*(p1+1)))
  cs:0285 8B05           mov    ax,[di]
  cs:0287 D1E0           shl    ax,1
  cs:0289 8B5EFE         mov    bx,[bp-02]
  cs:028C 03D8           add    bx,ax
  cs:028E 8B07           mov    ax,[bx]
  cs:0290 8B5502         mov    dx,[di+02]
  cs:0293 D1E2           shl    dx,1
  cs:0295 8B5EFE         mov    bx,[bp-02]
  cs:0298 03DA           add    bx,dx
  cs:029A 3B07           cmp    ax,[bx]
  cs:029C 7E15           jle    02B3
#PUORAR#30:  buf=*p1;
  cs:029E 8B05           mov    ax,[di]
  cs:02A0 8946FA         mov    [bp-06],ax
#PUORAR#31:  *p1=*(p1+1);
  cs:02A3 8B4502         mov    ax,[di+02]
  cs:02A6 8905           mov    [di],ax
#PUORAR#32:  *(p1+1)=buf;
  cs:02A8 8B46FA         mov    ax,[bp-06]
  cs:02AB 894502         mov    [di+02],ax
#PUORAR#33:  change=1;
  cs:02AE C746FC0100     mov    word ptr [bp-04],0001
  cs:02B3 46             inc    si
  cs:02B4 47             inc    di
  cs:02B5 47             inc    di
  cs:02B6 81FEDB05       cmp    si,05DB
  cs:02BA 7CC9           jl     #PUORAR#28 (0285)
Come puoi notare c'e' una notevole differenza tra le due versioni, dato
appunto dal sovrappiu' di istruzioni che il compilatore ha dovuto
aggiungere per manipolaredati di tipo array anziche' puntatori.
C'e' pero' da dire che il compilatore in questione (BORLAND 2.0) e' un
po datato e che oggi  compilatori + moderni sono in grado di scrivere
codice piu' performante anche utilizzando array anziche'
puntatori,rendendo la differenza praticamente nulla.
Ivan Molella

secondo caso, perche'? 
"Scorrere una stringa di caratteri usando un indice:
<snip> e' equivalente a scorrerla usando un puntatore:
<snip> Non c'e' nessuna ragione per cui una versione dovrebbe essere
piu' veloce dell'altra. I compilatori moderni dovrebbero generare il
medesimo codice <snip>" [Bjarne Stroustrup "The C++ Programming
Language 3rd ed."]
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
"I know every element of C" - Ioannis Vranos


Evinco che esiste un nuovo C.... Cioe'? Puoi dirmi
di piu'?


Wow.... grazie. Uso Lcc e Dev-C++ che sono
freeware... pero' penso compilino in modo
performante.

 di piu'?
Arriva in e-mail un documento che spiega i cambiamenti.
EMG

Enrico Maria Giordano wrote:

Non e' che saresti cosi gentile da postare anche a me il documento?
Grazie Ivan.

 di piu'?
http://web.onetelnet.ch/~twolf/tw/c/c9x_changes.html
 contiene un sommario
ampio ed esauriente.  Per quanto ne so, comunque, non esistono ancora
compilatori conformi a C9X.
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it


Sai se č prevista una terza versione del libro
"The C Programming Language" di Kernighan & Ritchie
?
Grazie  Manlio Perillo