[Programmazione C] - Uguaglianze tra vettori

scusate, c'ho un problema e non ne vado fuori.. l'ho fatto mezzo miliardo di volte in passato, ne sono sicuro ma ora tra assembler e java mi so scordato praticamente pure le basi del C

a una certa passo alla funzione void Func(int []) il vettore vett[5].. tanto per dire eh..
quindi:
Func(vett);

il vettore è passato automaticamente per riferiemento.. quindi se faccio ad esempio
vett[0] = 5;
all'interno di Func() assegno 5 alla prima posizione di vett e la modifica ha ripercussioni anche sul main..

ok

in Func() creo un nuovo vettore newvett[10]
ora voglio semplicemente che il vettore vett[] venga sostituito da newvett[]..

a memoria direi che devo semplicemente far puntare vett a newvett cosicchè al rientro nell'ambiente chiamante il main utilizzi il nuovo vettore..
spero di essermi spiegato..

in breve:
nel main chiamo una funzione e le passo un vettore
nella funzione il vettore viene sostituito con un altro di dimensione diversa
al ritorno il main usa il nuovo vettore creato


inutile dire che non mi serve tutto il codice ma solo la parte dell'uguaglianza..
ho provato a fare un po di casini con operatore * e operatore & ma tiro fuori solo qualche warning.. una combinazione mi da l'effetto desiderato finchè resto nell'ambiente chiamato ma poi l'effetto svanisce quando il controllo torna al main

Oddio!c++ e assembler sono le mie bestie nere....non ci capisco una mazza!meno male che ho deciso di fare l'elettronico e non il programmatore....Non ti so aiutare anche se li ho stud! :-(

ricordo più un *****, ma:

&vett = &newvett

non funge?
o dichiarare globale vett (ok, è orribile)?

assegnare qualcosa ad &vett credo sia proprio semanticamente sbagliato perchè è assegnare qualcosa ad un indirizzo non a ciò che c'è in quell'indirizzo..

la variabile globale no ti prego.. devo spiegarlo non farlo io e spiegare che devi dichiarare un vettore globale non mi va..
potrei risolverla fissando precedentemente la dimensione del vettore con un valore abbondante oltre il quale non si potrebbe andare..
però pure in questo caso significa insegnare che lo spreco di memoria è cosa buona e giusta..

dal canto mio risolverei semplicemente il problema con una lista concatenata ma purtroppo non posso perchè il ricevente della spiegazione non ha il background necessario..

te l'ho detto che non mi ricordo quasi più nulla ;) la mia idea era semplicemente quella di far puntare il primo vettore all'indirizzo del secondo (che è quello che volevi, se non ho capito, no? sono a lavoro e vado di fretta...)
se invece vuoi perseguire la strada della memoria "abbondante" non ti conviene andare di malloc e realloc? almeno in teoria non hai sprechi, no?
ps: belle le liste, mi manca non averle in autoit...

eh il problema è proprio quello.. l'allocazione esplicita non posso toccarla.. sennò due malloc e una free e avevo risolto.. l'allocazione del vettore è solo implicita con una dichiarazione classica..
poi vorrei proprio sostituire l'indirizzo puntato dal primo vettore .. e, ti dirò.. con un semplicissimo
vett = newvett
la modifica avviene.. ma è locale porca zozza.. al ritorno nell'ambiente chiamante il vettore è di nuovo il vecchio vett.. solo che ora in tutti i processi viene trattato con la nuova dimensione (che è diversa dalla sua) quindi puoi immaginare i casini

ti ringrazio comunque.. probabilmente per il momento seguirò la strada dello spreco di memoria.. alla fine è la più praticabile.. facendo ben presente che non è così che si programma xD
ma tanto, figurati.. si allocano vettori di dimensioni prese dallo standard input con

Quote:

---

int dim;
scanf("%d",&dim);
int vett[dim];

---

quindi direi che quello sarebbe il minor problema..

pure io non ricordo una fava, ma puoi postarmi per favore il prototipo e la chiamata della funzione esattamente com'è sul sorgente? Se il prototipo è quello del primo post credo umilmente che non sia corretto

ora non ce l'ho sotto mano.. comunque è la regola generale che mi interessa..
il prototipo è del tipo

int Func(int [], int);
dove magari la funzione restituisce la nuova dimensione, il primo parametro è il vettore e il secondo la dimensione al momento del passaggio.

o magari
int Func(int *, int);
che poi è la stessa cosa

premetto ancora che non ricordo una fava, ma a me verrebbe da far così

void Func(int* v, int c);


dim = Func(&v, d);



meglio se continuo col php và :lol:

e fare un:
int Func(&int[], int); (ho detto una porcheria, vero? :D)
per la programmazione coi piedi non preoccuparti, ho visto in programmi aziendali cose come while(1){
...
codice;
...
break}
quindi non ti preoccupare, i tuoi consigli saranno vani :D

Quote:

---

Originariamente inviata da Paperoga

premetto ancora che non ricordo una fava, ma a me verrebbe da far così

void Func(int* v, int c);


dim = Func(&v, d);



meglio se continuo col php và :lol:

---

no non cambia nulla cioè il nome del parametro nel prototipo non è necessario!
il passaggio di un vettore in C è automaticamente per riferimento quindi l'operatore & non è necessario.. anzi.. genera un warning

Quote:

---

Originariamente inviata da ronin.engineer

e fare un:
int Func(&int[], int); (ho detto una porcheria, vero? :D)
per la programmazione coi piedi non preoccuparti, ho visto in programmi aziendali cose come while(1){
...
codice;
...
break}
quindi non ti preoccupare, i tuoi consigli saranno vani :D

---

eh, no.. un parametro con l'operatore & davanti non ha senso.. cioè un parametro formale così non ha senso..
sono certo che tutta la parte di dichiarazioni e chiamate è giusta.. è l'uguaglianza che secondo me è impossibile..

ma vabbè.. ne ho viste pure io di cose belle.. uno ieri non riusciva ad accettare che String pippo è java.. in C è Char pippo[].. non voleva proprio accettarlo

è che pure io adesso c'ho in testa l'object oriented e sono discretamente monotasking ultimamente

Estiquazzi... chiedo al mio capo che ha programmato gestionali in C fino a 12 anni fa se vuoi XD

passare il & nella chiamata a funzione (invece che in dichiarazione)? comunque son sicuro che quello che vuoi si possa fare, mi ricordo di averlo visto all'uni (ma si parla ormai di un 6 anni fa, ricordo poco...)

quando chiami la funzione, trattandosi di un vettore, dire func(vett) o func(&vett) è la stessa cosa..
anzi.. la seconda genera un warning che non ricordo, tuttavia (credo per una forzatura de C) funziona lo stesso..
il problema è proprio dare un senso all'uguaglianza all'interno della funzione.. come a voler dire da questo momento in poi non puntare più a questa locazione (l'inizio di vett) ma punta a quest'altra locazione (l'inizio di newvett)

tipo un
vett = *newvett
ma non è manco così

uhm, ormai mi ha appassionato la cosa :D
se domani riesco a ritagliare un po' di tempo a lavoro ci provo pure io :D

io intanto l'ho risolta così xD poi se vien fuori qualcosa farò un piccolo appunto xD
adesso devo chiudermi quei due tre secoli sul java :087: