Newsgroup: it.comp.lang.c++
Titolo: Array come parametri di funzione

Vorrei sapere come faccio a passare un array come argomento di funzione, 
sia per indirizzo che per valore.
Grazie
-- 
Luigi
--
bug windows [5] = {"95", "98", "NT", "Me", "2000"};

 sia per indirizzo che per valore.
Per valore ?!?
Non ha senso !!!
Alex

Non ha senso !!!
Perche' dici che non ha senso ? In C gli array vengono sempre
passati per indirizzo (viene anzi passato l'indirizzo del primo
elemento) ma anche passare un intero array potrebbe avere senso.
Per farlo in C/C++ e' necessario racchiudere l'array in una
struttura e passare la struttura... oppure (cosa molto piu'
utile) si puo' passare un std::vector invece di un array.
Ovviamente passare un array ha delle implicazioni sulle
prestazioni... questo non vuol dire che pero' sia sempre una
cosa priva di senso.
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

Non ha senso !!!
Perche' ?
--
Walkie...@Libero.It (ICQ# 8143647)

Non ha senso !!!
E perché? Ammettiamo che all'interno di una funzione io abbia bisogno
di avere tutti i campi di un certo array e magari di poterli
modificare localmente senza che le modifiche vengano poi riportate
sull'array originario..
Capisco che effettivamente si parla di un'operazione piuttosto
dispendiosa(visto che il compilatore deve eseguire una copia
dell'array)ma dire che non ha senso mi sembra un' esagerazione.
Il Ghenio
-----
ZIO : Fun and games are over with. Anyone who dares
get in my way shall perish.
-----

 struttura e passare la struttura...
Per struttura intendi proprio una struct?
Ho provato
typedef int array [5];
int pippo (array& x);
e funziona.


e funziona.
In quel caso non stai passando per valore... ma per riferimento:
in altri termini se la funzione modifica l'array il chiamante si
trova l'array modificato.
Credevo che il senso della domanda originale fosse sul come
fare invece a passare una copia dell'intero array (ovvero come
passare un array per *valore* e non per riferimento).


 passare un array per *valore* e non per riferimento).
No, era come dichiarare un array come parametro di una funzione,  il fatto 
del passaggio per valore o riferimento era una cosa successiva, di minor 
importanza


importanza
Per quello bastava meno...
   int totale(int v[])
   {
     int tot=0;
     for(int i=0; v[i]!=-1; ++i)
       tot+=v[i];
     return tot;
   }
   int main()
   {
     int a[]={1,2,3,4,5,-1};
     int t=totale(a);
     ...
     return 0;
   }
Nota che pero' la dimensione dell'array deve essere comunicata
a parte: io in questo esempio ho usato il valore -1 come "tappo"
(questo e' uno dei tanti motivi per cui e' molto meglio usare
std::vector invece degli array).
HTH


Grazie, adesso perň vorrei chiederti una cosa.
Ho seguente sorgente:
#include <iostream>
void proc (int x [1]) {
        for (int i = 0; i < 4; i++)
                x[i] = i;   <-- Super la dimensione dell'array, ma non da 
errore e mi da l'otput giusto!
};
int array [2];  <--- Dimensione diversa da quella del parametro di proc  
int main () {
        proc (array);
        for (int i = 0; i < 4; i++)
                std::cout << array[i] << std::endl; <-- Dimensione 
superata, ma non da errori e l'output č corretto!
        return 0;


}
Due cose:
 1) Se in una funzione tu indichi come parametro "int x[1]"
    allora il valore "1" che hai indicato viene completamente
    ignorato. La funzione riceve un puntatore al primo elemento
    e la cosa e' assolutamente equivalente a dichiarare il
    parametro con "int *x".
    Se passi un array bidimensionale allora la prima delle
    dimensioni indicate e' irrilevante e puo' essere
    tralasciata...
       void MyFunc(int mat[][4])
       {
         for (int riga=0; riga<10; ++riga)
           for (int colonna=0; colonna<4; ++colonna)
              std::cout << mat[riga][colonna];
       }
    In questo caso si potrebbe usare la dichiarazione alternativa
    (meno leggibile) di "int (*mat)[4]".
 2) Quando "sconfini" non e' affatto detto che succeda
    qualcosa di visibile. Quello che dice lo standard e' che
    *non puoi prevedere* cosa succede. Potrebbe succedere di tutto
    (dal formattarti il disco fisso al mandare e-mail di insulti
    al papa' della tua morosa) oppure potrebbe anche non succedere
    nulla di visibile. Quello che capita abbastanza spesso e' che
    il programma *sembra* funzionare lo stesso... poi in altri
    punti (completamente innocenti e corretti) si comporta in
    modo assolutamente bizzarro.
    Purtroppo in C++ (come in C) non esiste il concetto di
    "runtime error" in questi casi... e' quindi necessario
    prestare la massima attenzione ad evitare questo tipo di
    errori. Non e' rarissimo se non si sta attenti finire col
    passare giorni interi a cercare di capire quale e' la causa
    di un problema semplicemente perche' i sintomi si
    manifestano milioni di istruzioni eseguite dopo il punto
    in cui si e' sconfinato.
Riassumendo la tua funzione "proc" non sta violando nessuna
regola... il fatto che sia stato indicato [1] e' puramente
documentativo e non ha riflessi su cosa e' lecito passare
e cosa non e' lecito passare a "proc".
L'errore lo fa main() in quanto scrive al di fuori di un
array allocato per contenere solo due elementi. E poi passa
questo array che e' troppo piccolo anche per il loop che
viene eseguito dalla funzione "proc"...
Purtroppo non puoi pretendere che il programma si blocchi
segnalandoti "guarda che hai sconfinato dall'array":
un compilatore C++ non e' tenuto a controllare queste cose
visto che effettuari questi controlli rallenterebbe troppo
il codice.
Per avere qualche aiuto in questi frangenti dovresti
utilizzare dei container come std::vector e utilizzare
l'operatore di accesso verificato (at) invece dell'accesso
con []. Oppure si possono facilmente scrivere delle classi
simili a std::vector con controllo in cui l'accesso []
contiene una verifica di sconfinamento.
