[C/C++]: Uso di puntatori nel passaggio di parametri (in C)

[Lak3d]

Domanda semplicissima sui puntatori, più nello specifico sulla chiamata per riferimento: la prima funzione usa una chiamata per valore passando number alla funzione che inizializza una variabile locale n per elevare al cubo, mentre la seconda usa un puntatore che punta all'intero per elevare direttamente number (chiamata per riferimento).
Eccole:

#include <stdio.h>

int CubaByValue(int n);

int main()
{
   int number=5;
   printf("The original value of number is %d\n", number);

   number=CubeByValue(number);
   printf("The new value of number is %d\n", number);

   return 0;
}
int cubeByValue (int n){
   return n*n*n;
}

#include <stdio.h>

int CubeByReference(int *Ptr);

int main()
{
   int number=5;
   printf("The original value of number is %d\n", number);
   
   CubeByReference(&number);
   printf("The new value od number is %d\n", number);

   return 0;
}

void CubeByReference(int *Ptr){
   *Ptr=*Ptr * *Ptr * *Ptr;
}

Ora la mia domanda è: in C ogni chiamata è per valore, quindi usando un puntatore posso simulare una chiamata per riferimento giusto? Fin qui ok, ma cosa mi spinge ad usare un puntatore (è comunque una variabile in più) quando posso fare come nel primo esempio e dichiarare una variabile locale n per poi assegnarla a number appena la funzione chiamante riprende il controllo? Non posso modificare direttamente number come farei col puntatore ma dichiarando la variabile locale n risolvo la questione tranquillamente perchè una volta uscita dalla funzione n si assegna a number...
Alla fine sbaglio o dichiarare un puntatore non mi cambia nulla? In ogni caso è sempre una variabile in più..

[andbin]

Originariamente inviato da Lak3d
Domanda semplicissima sui puntatori, più nello specifico sulla chiamata per riferimento: la prima funzione usa una chiamata per valore passando number alla funzione che inizializza una variabile locale n per elevare al cubo, mentre la seconda usa un puntatore che punta all'intero per elevare direttamente number (chiamata per riferimento).

La scelta del passaggio per valore o per indirizzo dipende strettamente da cosa devi fare di preciso. Nel caso di una semplice funzione che calcola il cubo di un numero è ovviamente molto meglio usare il passaggio per valore. Il valore restituito può quindi essere usato direttamente all'interno di un'altra espressione. Esempio:
result = CubaByValue(num1) + CubaByValue(num2);

Ma ci sono dei casi in cui non puoi fare a meno dei puntatori. Prendi il caso (classico) della ipotetica funzione "swap" che scambia i valori di 2 variabili. Puoi solo fare:

void swap (int *a, int *b)
{
    int t;
    t = *a;
    *a = *b;
    *b = t;
}

In altri casi una funzione deve poter restituire più valori al chiamante. Esempio: una funzione che restituisce larghezza/altezza in pixel dello schermo. Come la faresti???

[Lak3d]

Hai ragione. Grazie mille.
E' che stavo cercando di capir ei puntatori visto che arrivo dal VB e ero abituato a lavorare di default con chiamate per riferimento (ByRef)

Grazie ancora. Sei stato chiarissimo.

[Lak3d]

mmh, cè qualcosa che non mi torna... mica le chiamate di funzioni in C son tutte per valore?
Perchè questo mi funziona allora? :master:

#include <stdio.h>
int Cubo (int n);

int main(){
const int n=2;

n=Cubo(n);
printf("N vale %d\n", n);

return 0;
}

int Cubo (int n){
   return n*n*n;
}

[_sys/sid]

in C esistono solo due tipi di passaggio parametri:
- Per Valore
- Per Indirizzo

Esempio Passaggio Per Valore:

int Cubo (int n){
   return n*n*n;
}

Alla Funzione viene passato un valore e ne viene ritornato un altro.

Esempio Passaggio per Indirizzo:

void Cubo (int *n) {
    *n = (*n) * (*n) * (*n);
}

Il Valore non viene Ritornato perche' viene modificata direttamente la varibile passata

int main() {
   int n = 3;
   Cubo(&n);
   printf("Cubo: %d\n", n);
   return(0);
}

Ovviamente il Cubo non e' una funzione da passaggio per indirizzo
una funzione dove serve il passaggio per indirizzo e' ad esempio la scambia

void Scambia (int *a, int *b) {
   int tmp = *a;
   *a = *b;
   *b = tmp;
}

int main() {
   int a = 3;
   int b = 5;
   Scambia(&a, &b);
   return(0);
}

Non puoi realizzare la scambia senza utilizzare il passaggio per indirizzo

[Lak3d]

sì, tutto chiaro se non che le chiamate per valore non dovrebbero modificare il valore originale della variabile definita nel chiamante. Invece dichiaro n, la passo alla funzione e questa la modifica... addirittura dopo averla definita const...

Edit: come non detto, ho capito

[Lak3d]

Eccomi sempre coi miei amici puntatori...

#include <stdio.h>
void Mod (const int *ptr);

int main()
{
   int c=3;
   Mod(&c);
   printf("C vale %d\n", c);

   return 0;
}

void Mod(const int *ptr){
   *ptr=2;
}

ptr punta ad una costante intera. Perchè il compilatore non da segnali di errori e tutto funziona cambiando il valore della variabile COSTANTE?

[_sys/sid]

Non e' il contenuto di ptr costante ma l'indirizzo...
facendo *ptr = 2; cambia il contenuto... Non l'indirizzo

[Lak3d]

Originariamente inviato da _sys/sid
Non e' il contenuto di ptr costante ma l'indirizzo...
facendo *ptr = 2; cambia il contenuto... Non l'indirizzo

ehm, io so che un puntatore variabile a dati costanti (quello nel mio esempio) può essere modificato in modo che possa fare riferimento ad altri dati (ovviamente del tipo appropriato) ma questi non potranno essere modificati, proprio perchè dichiarati const.
Invece nel mio esempio si possono modificare...

Tu mi dici che non è il contenuto costante ma il suo indirizzo? Quello semmai è un puntatore costante a dati variabili... (int * const ptr) non quello del mio caso---> (const int *ptr)

[Lak3d]

scusate il doppio post, ma leggevo in giro che alcuni sistemi non interpretano correttamente il qualificatore const... può essere per quel motivo che mi permette di modificare la costante intera?