Newsgroup: it.comp.lang.c
Titolo: Putatore ad array o array di puntatori?

Perfavore, qualcuno mi può illuminare su una cosa?
se definisco un "int**", per quanto ho capito fin'ora, questo può venire
interpretato come:
- Un puntatore a puntatore a int
- Un puntatore ad array di int
- Un array di puntatori a int
- Una matrice di int (Array doppio)
Giusto?
Per quanto riguarda i due casi intermedi, è giusto allocarli nel modo
seguente?
Puntatore ad array:
  int** i;
  int x = 40; // Numero di elementi nell'array (int)
  i = (int **) malloc (sizeof (int*));
  *i = (int *) malloc (x * sizeof (int)); 
  *i[0] = 3; // cioè "(*i)[0]"  <<<---
  ...
Array di puntatori:
  int **i;
  int x =  40; // Numero di elementi nell'array (int*)
  i = (int **) malloc (x * sizeof (int*))
  *i = (int *) malloc (sizeof (int);
  *i[0] = 3; // cioè "*(i[0])"  <<<---
  ...
E' giusto? Il compilatore capisce la differenza nelle parti evidenziate,
o devo esplicitarglielo in qualche modo (ad esempio nel modo che ho
scritto fra virgolette, se è valido)?
Ultima cosa: è lo stesso scrivere "int**" e "int[][]"?
Insomma, proveniendo dal Pascal, l'equivalenza fra array e puntatore del
C mi è piuttosto ostica... :(  HELP!
Grazie!
-- 
+ ICEMAZE +
ice...@planet.it
"Hail! Hail and kick!"

 - Una matrice di int (Array doppio)
L'unica interpretazione corretta è la prima.
EMG


OK, ma un int** puo' anche essere utilizzato per accedere
ad un array di int -> quindi un puntatore ad array di int
(la seconda).
Ciao
-- 
Zack
Stefano Zacchiroli
zacc...@cs.unibo.it
za...@comune.budrio.bo.it
ICQ# 33538863
"Never understimate the dark side"

C mi è piuttosto ostica... :(  HELP!
Allora ti sara' di aiuto il nostro estratto dalle FAQ :
6.3
---
D:	Che  significa  quindi  in C "equivalenza  tra  puntatori  e
  	vettori" ?
R:	Una  certa  confusione  circa vettori e puntatori  in  C  e'
  	dovuta   sicuramente   ad  un  fraintendimento   di   questa
  	espressione.
  	Dire   che  vettori  e  puntatori  sono  "equivalenti"   non
  	significa che essi siano identici o intercambiabili.
  	Questo  vuol  dire che un puntatore e l'aritmetica  definita
  	per  esso  consentono di accedere in modo  conveniente  agli
  	elementi di un vettore o di simularlo.
  	La  chiave  per  capire  questo tipo di  equivalenza  e'  la
  	seguente :
 
        Un   lvalue   di  tipo  vettore-di-T  che  compare  in   una
  	espressione  decade (con tre eccezioni) in un  puntatore  al
  	suo primo elemento ;
  	Il tipo di questo puntatore risultante e' puntatore-a-T.
 
  	Questo  significa che laddove il nome di un vettore  compaia
  	in  una  espressione, il compilatore traduce  implicitamente
  	questo  riferimento  nel puntatore al  suo  primo  elemento,
  	come se il programmatore avesse scritto &a[0].
        Le   eccezioni  capitano  quando  il  nome  del  vettore  e'
  	argomento  di sizeof o dell'operatore &, o se esso (nel caso
  	fosse  char []) viene inizializzato con una stringa in  fase
        di dichiarazione.
 
  	Come  conseguenza  di questa definizione il compilatore  non
  	applica    diversamente    tra    vettori    e     puntatori
  	l'indicizzazione mediante [].
  	In  una espressione della forma a[i], a decade in puntatore,
  	seguendo la regola, e viene pertanto trattato come se  fosse
  	una  variabile  puntatore della forma  p[i]  (eventualmente,
  	l'accesso alla memoria differisce, come spiegato alla 6.2).
 
  	Se si compisse un'assegnazione del tipo :
 
  		p = a;
 
  	allora p[3] e a[3] conterrebbero lo stesso elemento.
 
  	Vedi anche la 6.8 e la 6.14.
 
  	Riferimenti: 
  	K&R1  Sec.  5.3  pp.  93-6; K&R2 Sec. 5.3 p.  99;  ISO  Sec.
  	6.2.2.1, Sec. 6.3.2.1, Sec. 6.3.6; H&S Sec. 5.4.1 p. 124.
--------------------------------------------------------
* Andrea Laforgia        (
andrea_...@bigfoot.com
) *
--------------------------------------------------------

(la seconda).
No, un puntatore ad array di int e' tutt'altra cosa, vedi altro msg.
