[C/C++] Problema con funzioni

[Iena87]

Originariamente inviato da mica81
forse perchè questo deve essere un programma scritto in c...anche se assomiglia al c++. mettendo cin e cout funziona ugualmente

esatto perchè mi voglio esercitare col C...cmq perchè poi devo passare gli indirizzi??? appunto col C++ sarebbe bastato scrivere un normalissimo cin, col C perchè devo passare gli indirizzi?

[internet]

Perchè se vuoi che una funzione ti modifichi le variabili
come scanf, è necessario passargli l'indirizzo di tale variabile, in quanto in C è possibile solo il passaggio per valore.

supponi che la variabile "c" sia nella locazione 0x4000080

c  0x4000000[????????]

nel momento in cui la passi per valore ad una funzione ad esempio
void foo(int a)
la variabile "a" verrà allocata sullo stack ad esempio nella locazione 0x4000080

a  0x4000070[????????]
c  0x4000080[????????]

supponiamo che la funzione foo() assegni alla variabile "a" il numero 1, ecco cosa succede

a  0x4000070[00000001]
c  0x4000080[????????]

una volta che si esce dalla funzione, si ha questo

c  0x4000080[????????]

ossia "c" non è stata modificata.

soluzione: usare i puntatori

void foo(int* a)

la variabile c è nella locazione 0x4000080

c  0x4000080[????????]

nel momento in cui passi l'indirizzo di "c" alla funzione foo() (è sempre "passaggio per valore" che in questo caso è un indirizzo)
verrà allocata sullo stack, ad esempio nella locazione 0x4000080, una variabile che punta ad un intero, il cui contenuto è un indirizzo

a  0x4000070[0x4000080]
c  0x4000080[????????]

supponiamo che la funzione foo() assegni alla variabile a cui "a" punta, il numero 1,

*a = 1;

ecco cosa succede

a  0x4000070[0x4000080]
c  0x4000080[00000001]

una volta che si esce dalla funzione, si ha questo

c  0x4000080[00000001]

in questo caso "c" è stata modificata, ed è quello che vogliamo fare.


in C++, esiste oltre al passaggio per valore, il passaggio per riferimento (reference)

void foo(int& a);

[Iena87]

Scusami internet, ma mi sa che nn ci ho capito tanto.
Allora se io scrivo una funzione tipo:

int moltiplica(int x, int y){
     int moltiplicazione;
     moltiplicazione = x*y;
     return moltiplicazione;
}

Io passo alla funzione moltiplica() i valori di x e y, che sono parametri della funzione, giusto? nel caso in cui al posto di:

moltiplicazione = x*y;

scrivessi:

moltiplicazione = k*z;

La funzione non andrebbe più bene perchè non riconosce i parametri, giusto?
Quindi il nome che do ai parametri lo devo anche dare alle variabili che utilizzo nella funzione, perchè altrimenti nn mi funziona, ci ho provato infatti e mi trovo con questa cosa che sto dicendo.
Tu dici che passiamo la variabile c per valore alla funzione
void foo(int a).....ma come si passa in questo caso??? Potresti illustrarmi un esempio di funzione completa per capirlo?
Stessa incomprensione per quanto riguarda il passaggio di indirizzo...come si fa??? Ti prego,illustrami delle funzioni complete di esempio, così capisco meglio

[internet]

allora supponiamo di avere questo main

int main()
{
  int a = 10, b = 20;
  moltiplica(a, b);

  return 0;
}

i parametri che si passano alla funzione ("a" e "b") vengono detti parametri attuali

invece i parametri che compaiono nella definizione della funzione

int moltiplica(int a, int b)
{
  return a*b;
}

sono detti parametri formali

nel passaggio per valore, i parametri formali sono memorizzati in locazioni di memoria diverse da quelle dei paramtri attuali
cioè nel momento in cui entro nel corpo della funzione, vengono "allocati" i parametri formali, (di fatto sono nuove variabili)

questa funzione

int moltiplica(int x, int y)
{
  return x*y;
}

è identica a quella precedente perchè anche in questo caso vengono allocate 2 variabili nuove (come prima)
il cui contenuto è la copia dei paramtri attuali


di solito per capire questo concetto si parla dei record di attivazione (stack)

la funzione moltiplica la modifico per farti capire come funziona il passaggio per valore

la freccia <-- indica il punto in cui si trova l'esecuzione del processo (programma)

int main()
{
  int a = 10, b = 20, c;
  c = moltiplica(a, b);<-- 

  return 0;
}

lo stack è questo
----------
|  main  |
----------
| a | 10 |
| b | 20 |
| c | ?? |
----------

successivamente viene richiamata la funzione

int moltiplica(int x, int y) 
{<--
  x = x * 10;
  return x*y;
}

e questo è lo stack, in cui le variabili locali sono x e y
le variabili a e b non sono accessibili alla funzione moltiplica (perchè non sono variabili globali)
--------------
| moltiplica | 
|------------|
|  x  |  10  |
|  y  |  20  |
--------------
|    main    |
--------------
|  a  |  10  |
|  b  |  20  |
|  c  |  ??  |
--------------


int moltiplica(int x, int y) 
{
  x = x * 10; 
  return x*y; <--
}

lo stack (N.B. "a" non è stata modificata)
--------------
| moltiplica | 
|------------|
|  x  | 100  |
|  y  |  20  |
--------------
|    main    |
--------------
|  a  |  10  |
|  b  |  20  |
|  c  |  ??  |
--------------


int main()
{
  int a = 10, b = 20, c;
  c = moltiplica(a, b);

  return 0; <-- 
}

lo stack è ora questo
--------------
|    main    |
--------------
|  a  |   10 |
|  b  |   20 |
|  c  | 2000 |
--------------

ora se al posto di quella moltiplica metti

int moltiplica(int a, int b)
{<--
  a = a * 10;
  return a*b;
}

lo stack è
--------------
| moltiplica | 
|------------|
|  a  |  10  |
|  b  |  20  |
--------------
|    main    |
--------------
|  a  |  10  |
|  b  |  20  |
|  c  |  ??  |
--------------

int moltiplica(int a, int b) 
{
  a = a * 10; 
  return a*b; <--
}

lo stack (N.B. "a" del main non è stata modificata)
--------------
| moltiplica | 
|------------|
|  a  | 100  |
|  b  |  20  |
--------------
|    main    |
--------------
|  a  |  10  |
|  b  |  20  |
|  c  |  ??  |
--------------


int main()
{
  int a = 10, b = 20, c;
  c = moltiplica(a, b);

  return 0; <-- 
}

lo stack è ora questo
--------------
|    main    |
--------------
|  a  |   10 |
|  b  |   20 |
|  c  | 2000 |
--------------

ecco perchè le funzioni sono "identiche"

[Iena87]

Internet nn so come ringraziarti
Adesso grazie anche all'entrata in gioco dello stack, la cosa mi è chiara
Se ho altri problemi, riposto qui!

[Thor82]

scusate, ma mi sbaglio o and e or erano parole chiave?

[andrea_NET-_DSL]

Originariamente inviato da Thor82
scusate, ma mi sbaglio o and e or erano parole chiave?

sono operatori logici ma non sono keyword almeno in c/c++:

in c/c++ permettono di verificare clausole logiche/espressioni booleane cioè: 


AND &&


OR ||


NOT !

mentre le seguenti

sempre in c/c++

AND &

OR  |

XOR ^ (or esclusivo)

eseguono le cosidette operazioni bit a bit(bit to bit :gren: )
Ossia eseguono le operazioni di AND, OR o XOR appunto tra ,ad esempio,due stringhe binarie:

int stringa_binaria_1 = 01001101;
int stringa_binaria_2 = 00111010;

int and_res = stringa_binaria_1 & stringa_binaria;
int not_res = stringa_binaria_1 | stringa_binaria;
int xor_res = stringa_binaria_1 ^ stringa_binaria;

printf("AND :%d\n NOT :%d\n XOR:%d\n",and_res,not_res,xor_res);

ciaoo

[Thor82]

no calma, so cosa sono le operazioni booleane, ma mi pareva di ricordare che anche facendo a AND b invece che a && b funzionasse lo stesso, forse mi sbaglio

[andrea_NET-_DSL]

Originariamente inviato da Thor82
no calma, so cosa sono le operazioni booleane, ma mi pareva di ricordare che anche facendo a AND b invece che a && b funzionasse lo stesso, forse mi sbaglio

ripeto per fare le operazioni bit to bit devi utilizzare gli "operatori" che ti ho scritto sopra(and,ecc NON sono keyword almeno in c/c++)


ps cmq non puoi fare a && b ma a & b

puoi utilizzare && ad es in una condizione if

if ( i < 5 && j >= 4 ) //esegue le istruzioni dell'if se entrambe ( && == AND) le clausole sono verificate
// ... corpo if ...

[Thor82]

in quanto a "and" e "or" è vero, e mi devo essere confuso con qualcos'altro

è possibile usare sia && che &, solo che hanno esiti diversi:

int a,b,c,d;

a=2;
b=3;

c = a &&b;
d = a & b;

il risultato è che c è true (1) perchè lui confronta i valori booleani di a e b (ovvero essendo diversi da 0 true e true)e il risultato è true

facendo

a & b il risultato di d è invece 2, perchè è il risultato della bitwise,quindi sono output diversi

quindi è possibile utilizzare entrambi i metodi, solo che sono 2 cose divese