[c++] visibilità variabile modificata in subfunzioni

[vermaccio]

lanciate questo programma.
in teoria:
all'inizio definisco
m=100
n=9999

la prima funzione dovrebbe ridefinire
y=100+10=110
ma l'"y" passato alla funzione è n quindi
n=110


ma la funzione interna alla prima funzione dovrebbe ridefinirla ancora a
s=110+1=111
ma l'"s" passato alla funzione è n quindi
n=111

alla fine nel main si dovrebbe quindi avere
n=111

INVECE vedo n=9999!
ma come è possibile se ho passato n dentro alle funzioni e l'ho modificata ed era globale?



listato:


#include<stdio.h>
#include <math.h>

double m; //global
double n; //global



// FUNZIONE -------------


#include<stdio.h>
#include <math.h>

double m; //global
double n; //global



// FUNZIONE -------------

void funzioneinterna(double s){
s=s+1;
return;
}




// FUNZIONE -------------

void primafunzione(double x, double y){
y=x+10;
funzioneinterna(y);
return;
}







// PROGRAMMA PRINCIPALE ---------

void main()
{


m =100;
n =9999;


primafunzione(m, n);

printf("risultato1: %g\n", n );


}

[huNewbie]

lanciate questo programma.
in teoria:
all'inizio definisco
m=100
n=9999

la prima funzione dovrebbe ridefinire
y=100+10=110
ma l'"y" passato alla funzione è n quindi
n=110


ma la funzione interna alla prima funzione dovrebbe ridefinirla ancora a
s=110+1=111
ma l'"s" passato alla funzione è n quindi
n=111

alla fine nel main si dovrebbe quindi avere
n=111

INVECE vedo n=9999!
ma come è possibile se ho passato n dentro alle funzioni e l'ho modificata ed era globale?



listato:


#include<stdio.h>
#include <math.h>

double m; //global
double n; //global



// FUNZIONE -------------


#include<stdio.h>
#include <math.h>

double m; //global
double n; //global



// FUNZIONE -------------

void funzioneinterna(double s){
s=s+1;
return;
}




// FUNZIONE -------------

void primafunzione(double x, double y){
y=x+10;
funzioneinterna(y);
return;
}







// PROGRAMMA PRINCIPALE ---------

void main()
{


m =100;
n =9999;


primafunzione(m, n);

printf("risultato1: %g\n", n );


}


Semplicemente perchè stai passando alle funzioni il valore di n, non n. Se invece stessi passando le variabili per riferimento, cioè con puntatori, effettivamente il valore cambierebbe. Prova con


int a;
void cambia_valore_non_funzionante(int x)
{
x = 4;
}

void cambia_valore_funzionante(int *puntX)
{
*puntX = 4; //accede alla locazione in cui è x e ne cambia il valore
}

void main()
{
a = 10;
cambia_valore_non_funzionante(a);
printf("risultato1: %d\n", a); //sarà sempre 10
cambia_valore_funzionante(a);
printf("risultato2: %d\n", a); //stavolta sarà 4
}

Il risultato non cambia se a è globale o meno: funzionerebbe lo stesso anche se a fosse locale al main.

[vermaccio]

void cambia_valore_funzionante(int *puntX)

ma *puntX non è un array?


comunque , quindi, basta che nel mio listato metto degli "*" davanti alle variabili sia nell'intestazione della fuzione sia dentro di essa?


listato:


#include<stdio.h>
#include <math.h>

double m; //global
double n; //global



// FUNZIONE -------------


#include<stdio.h>
#include <math.h>

double m; //global
double n; //global



// FUNZIONE -------------

void funzioneinterna(double *s){
*s=*s+1;
return;
}




// FUNZIONE -------------

void primafunzione(double *x, double *y){
*y=*x+10;
funzioneinterna(y);
return;
}







// PROGRAMMA PRINCIPALE ---------

void main()
{


m =100;
n =9999;


primafunzione(m, n);

printf("risultato1: %g\n", n );


}
______

[vermaccio]

ho fatto vari test. l'unico modo per riuscire a compilare è mettere gli asterischi un "&" davanti alle variabili nel richiamo della prima funzione

primafunzione(&m, &n);

ma NON nella seconda.

funzioneinterna(y);

Infatti se metto

funzioneinterna(&y);

NON funziona. Perchè?



inoltre: se invece di passare un double passavo un array che metto? l'asterisco che avrei messo per indicare "array" già c'è! ne metto due?
es: se y fosse un array devo mettere
void primafunzione(double *x, double **y){
???



listato:


#include<stdio.h>
#include <math.h>

double m = 100; //global
double n = 9999; //global



// FUNZIONE -------------

void funzioneinterna(double *s){
*s=*s+1;
return;
}




// FUNZIONE -------------

void primafunzione(double *x, double *y){
*y=*x+10;
funzioneinterna(y);
return;
}







// PROGRAMMA PRINCIPALE ---------

void main(void)
{

primafunzione(&m, &n);

printf("risultato1: %g\n", n );


}

[wingman87]

Ma perchè ti complichi sempre la vita? Allora, siccome sono variabili globali puoi anche non passarle proprio alla funzione, tanto le vede già. Se proprio vuoi passarle hai visto come si fa, e per il vettore devi togliere gli "*" e gli "&".
Per la storia che non funziona la funzione interna passando &y non funziona perchè y è un puntatore, quindi se la funzione interna si aspetta l'indirizzo di una variabile tu non gli devi passare &y (indirizzo del puntatore) ma y (indirizzo della variabile puntata da questo puntatore). Ciao!

[vermaccio]

Per la storia che non funziona la funzione interna passando &y non funziona perchè y è un puntatore, quindi se la funzione interna si aspetta l'indirizzo di una variabile tu non gli devi passare &y (indirizzo del puntatore) ma y (indirizzo della variabile puntata da questo puntatore)


uhu? :confused: :what:

<<perchè y è un puntatore>>

prima avevo scritto la roba che sta più sotto ma ora ho capito di non avere capito e pongo un altro quesito.

tu dici che y è un puntatore.

quindi vuol dire che c'è differenza tra variabile e puntatore, indirizzo della variabile e indirizzo del puntatore.

perchè y è un puntatore mentre x (nella funzione più esterna) nomn lo era (e infatti ci mettevo &)?


------------------
roba scritta prima


cioè mi dici che io alla prima funzione passo un y che in realtà, a causa dell'asterisco, è un puntatore /passo la variabile non per valore ma per indirizzo insomma).
quindi quando richiamo la seconda funzione dentreo la prima io uso una y che è GIA' un puntatore e quindi non devo mettere l'asterisco.

è giusto?

quindi se ho ben capito, se ho tante funzioni una dentro l'altra e ognuna voglio che modifichi la variabile che gli passo, alle funzioni successive ad una in cui passo con l'asterisco, non devo più mettere asterisco perchè dall'asterisco in poi io passo indirizzo.

[wingman87]

Allora, il puntatore è una variabile di dimensione 32bit, e può (o forse deve) contenere solo indirizzi.
Con l'operatore "&" puoi prendere l'indirizzo di una variabile (es: puntatore1=&variabile1), con l'operatore "*" prendi il valore contenuto all'indirizzo del puntatore (es: variabile2=*puntatore1 è uguale a scrivere variabile2=variabile1), se non usi operatori prendi il valore della variabile (es: puntatore2=puntatore1 è uguale a scrivere puntatore2=&variabile1).
Nelle funzioni in realtà i parametri sono sempre passati per valore, solo che, passando l'indirizzo di una variabile, usando un puntatore puoi accedere all'area di memoria di quella variabile modificandola direttamente.