Newsgroup: it.comp.lang.c
Titolo: accesso agli alementi di un array di struct

Saluti.
Supponendo di avere una struttura come
struct foo {
    a int;
    b char;
};
ed un array di questa struttura.
Volendo accedere agli elementi dell'array in sola lettura, conviene 
accedere per valore o per riferimento?
Grazie  Manlio Perillo

 accedere per valore o per riferimento?
Anche se passi l'array per valore ne starai passando il puntatore al 
primo elemento, non credo tu possa "impedirti" di modificare i campi 
delle struct.
Quello che puoi fare è usare const nella dichiarazione del parametro,
del tipo:
void fooFunc( const struct foo * )



No, mi devo essere spiegato male.
Mi riferivo all'accesso ai singoli elementi dell'array in un loop.
E' più efficiente fare:
  struct foo elem;
  for (i = 0; i < N; ++i) {
     elem = array[i];
  }
oppure:
  struct foo *elem;
  for (i = 0; i < N; ++i) {
     elem = &array[i];
  }
?
Grazie  Manlio Perillo

   }
Non è questione di efficienza, stai facendo due cose diverse. C'è 
sostanzialmente un solo modo per accedere agli elementi di un array.
E.

   }
In c++ faccio cose simili:
std::vector<struct foo> el;
for(size_t i = 0, i_size = el.size(); i < i_size; ++i)
{
  const foo& riferimento = &(el[i]);
}
a livello di efficienza di codice non cambia nulla, ma così dico al 
compilatore di ricordarmi che non voglio modificare il vettore.
-- 
Mio figlio: 
http://it.youtube.com/davideippopotamo
La violenza non può essere una esclusiva dei malfattori.
Ladri del mio appartamento, vi siete dimenticati un coltellaccio da 
cucina, tornate.

 a livello di efficienza di codice non cambia nulla, 
Rispetto a copiare l'elemento del vettore?
    foo riferimento = el[i]
Ciao  Manlio

     foo riferimento = el[i]
Io non faccio nessuna copia. Non è detto che la copia sia un'operazione 
che costi "poco".
Poi se fai una copia puoi modificare l'elemento copiato che l'elemento 
originale rimane "immutato". Ma è questo che vuoi? Di solito io non 
voglio nemmeno avere questa possibilità perché modificare la copia di 
solito per me non ha senso, e poterlo fare mi potrebbe indurre in 
errore. E' la mia convenzione per dire che sto ciclando su qualcosa e 
che quel qualcosa rimarrà costante. In C++, a quel punto se fosse una 
classe potrei usare solo funzioni const. Limitazione che non avrei con 
la copia. Certo, questo è un gruppo di discussione sul C e non sul C++. 
Ammetto di usare poco il C.
In C++ puoi usare i const_iterator, ma per motivi in "completamento" 
dell'ide, e per chiarezza mia, ci sono casi in cui preferisco usare un 
const reference.
In C penso che usarei quella malefica sintassi di puntatore costante ad 
oggetto puntato costante che non mi ricordo mai.


 [...]
Ciao  Manlio

 agli elementi di un array per copia o tramite puntatori.
Secondo me a livello pratico non cambia nulla. Se ci vai di puntatore 
ci accedi di puntatore; se ti fai una copia ti metti al minimo 5 byte 
sullo stack, e poi ci accedi attraverso di fatto con un puntatore 
(anche se la cosa ti è mascherata dal compilatore).
Se proprio devi andare a limare potresti fare così:
register struct foo elem;
for (i = 0; i < N; ++i) {
  elem = array[i];
oppure addirittura così su un'architettura a 64 bit:
union raschiamo_il_barile
{
  struct foo original;
  int64 sprecone;
}
register raschiamo_il_barile elem;
for (i = 0; i < N; ++i) {
  elem = array[i];
e sperare che il compilatore sia in vena e ottimizzi usando i registri 
_giusti_. Non so se potresti misurare la differenza di esecuzione dei 
diversi tipi di codice.
