Newsgroup: it.comp.lang.c
Titolo: puntatori

Ciao,
sto riprendendo in mano il C, ho un dubbio sui puntatori, spero che
qualcuno me lo possa chiarire
so che alle funzioni e procedure il passaggio delle variabili e' sempre
per valore, per modificare una variabile allora si usano i puntatori,
ok, solo che non capisco perche' riesco a modificare una stringa (array
di char) e non un vettore di int nelel funzioni che ritornano un int,
invece nel caso di char si
sono gestite differentemente dal compilatore?
mi riferisco alle funzioni 1 e 2 (per la due il compilatore mi da un
warning, ma non capisco perche' non me lo da anche per la 1):
#include <stdio.h>
#include <stdlib.h>
/*funziona (1)*/
char * swap(){
	char *b = "CBA";
	return b;
}
/*non funziona (2)*/
int *swapInt(){
	int vt[5]={5,4,3,2,1};
	return vt;
}
//devo per forza fare cosi'
void swapVec(int *v){
	int i,vt[5]={5,4,3,2,1};
	for(i=0;i<5;*(v+i)=*(vt+i++));
	return;
}
int main(){
	/*ok*/
	char *a = "ABC";
	printf("1- %s\n", a);
	a = swap(a);
	printf("2- %s\n", a);
	/*no*/
	int i,v[5]={1,2,3,4,5},*vp=v;
	for(i=0;i<5;printf("%d: %d\n",i,*(vp+i++)));
	vp=swapInt();
	/* stampa solo 1 giusto poi solo spazzatura
	for(i=0;i<5;printf("%d: %d\n",i,*(vp+i++)));
	/*va*/
	/*
	swapVec(v);
	for(i=0;i<5;printf("%d: %d\n",i,*(vp+i++)));*/
}
grazie
ciao
-- 
Ciao!
Nobuteru
Jabber ID 
nobu...@jabber.org
Download free Jabber client from 
www.jabber.org

 }
Infatti qui tu vai a modificare proprio l'array originale v, che ïż½ 
quello che bisognerebbe fare.  L'array vt, dichiarato all'interno della 
funzione, ti serve solo come supporto e poi non serve piïż½.  E' per 
questo che funziona!
Anche in questo caso, perïż½, dovresti cercare di scrivere una funzione 
piïż½ generica.  Quindi dovresti passare almeno anche l'informaione sulla 
dimensione dell'array v, oltre al suo puntatore.
All'interno della funzione, poi, l'array di appoggio vt[] non ti servirïż½ 
perchïż½ non puoi sapere a priori quali sono gli elementi dell'array che 
viene passato come parametro.  Quindi dovrai per forza effettuare uno 
swap tra il primo e l'ultimo elemento dell'array; tra il secondo e il 
penultimo; e cosïż½ via.  Per farlo, dovrai utilizzare una variabile di 
supporto.

 dimensione dell'array v, oltre al suo puntatore.
ciao ti ringrazio per la risposta.
allora il warning il compilatore gcc me lo da solo sulla funzione array
di int, sull'"array" char o char* non me lo da (vedi sotto), la funzione
funziona sempre, anche mettendo una stringa piu' lunga (o piu' corta)
nel corpo funzione.
non sto facendo funzioni di inversione, e' solo un esempio (e' solo il
caso che ho scritto abc e cba e 12345 e 54321), so benissimo dei buffer
overflow e come modificare variabili nel corpo delle funzioni,
tranquillo che nel codice faccio tutti i controlli sulle dimensioni :-),
questo e' solo una prova.
la mia domanda del primo post sui puntatori, e' questa:
ho notato che la modifica di un char * da parte di una funzione
assegnandogli il char * dichiarato all'interno di essa funziona e con
altri tipi di dati no. tutto qua!
sembra che i char* dichiarati locali "sopravvivano"  alla funzione
mi domandavo se i char* sono gestiti dal compilatore o magari nello
standard C in maniera diversa
la fine dell'output di compilazione e' il seguente :
gcc    -c -g -MMD -MP -MF build/Debug/GNU-Linux-x86/main.o.d -o
build/Debug/GNU-Linux-x86/main.o main.c
main.c: In function ‘swapInt’:
main.c:21:2: warning: function returns address of local variable
mkdir -p dist/Debug/GNU-Linux-x86
gcc     -o dist/Debug/GNU-Linux-x86/053_-puntatori_da_postare
build/Debug/GNU-Linux-x86/main.o
make[2]: uscita dalla directory "/home/nobuteru/NetBeansProjects/053
-puntatori da postare"
make[1]: uscita dalla directory "/home/nobuteru/NetBeansProjects/053
-puntatori da postare"
BUILD SUCCESSFUL (total time: 257ms)
purtroppo non ho possibilita' di provare lo stesso esempio con altri
compilatori su altre piattaforme per vedere se il comportamento e' lo
stesso o no


 sembra che i char* dichiarati locali "sopravvivano"  alla funzione
Le variabili dichiarate all'interno di una funzione sono *tutte* 
automatiche, cioè vengono allocate/deallocate automaticamente dal 
sistema entrando/uscendo dalla funzione.
Se tu definisci un array di char (o int o altro) all'interno di una 
funzione, questo non sarà più valido all'uscita della funzione. Quindi 
non ha senso ritornare da una funzione il puntatore ad un array 
dichiarato all'interno della funzione.
Se funziona in qualche caso è solo per una combinazione di fattori e non 
è per nulla garantito dal linguaggio.

 è per nulla garantito dal linguaggio.
ok grazie!
era quello che volevo sapere


> sistema entrando/uscendo dalla funzione.
Ah, dimenticavo. Se la variabile, pur dichiarata all'interno di una 
funzione, è static, allora continua ad essere valida anche all'esterno 
della funzione.


eh no.
Una static dichiarata all'interno di una funzione non viene
deallocata, cioe' non cessa di esitere, all'uscita della funzione, ma
il suo scope e' solo la funziona quindi esiste SOLO all'interno della
funziona e non e' valida fuori (non la puoi usare al di fuori della
funzione).
Ciao Jack

 funzione).
Si, forse mi sono espresso male.  Volevo dire che si può fare una cosa 
del genere:
Object *foo(void) {
   static Object obj;
   ...
   return &obj;
}