Quando cambio un parametro all'interno di una funzione, cambia anche per il chiamante?

Question

Ho scritto una funzione qui sotto:

void trans(double x,double y,double theta,double m,double n) 
{ 
    m=cos(theta)*x+sin(theta)*y; 
    n=-sin(theta)*x+cos(theta)*y; 
} 

Se li chiamo nello stesso file da

trans(center_x,center_y,angle,xc,yc); 

sarà il valore di xc e yc cambiamento? Se no, cosa dovrei fare?

Answer 1

Dal momento che si sta utilizzando C++, se si vuole xc e yc per cambiare, è possibile utilizzare i riferimenti:

void trans(double x, double y, double theta, double& m, double& n) 
{ 
    m=cos(theta)*x+sin(theta)*y; 
    n=-sin(theta)*x+cos(theta)*y; 
} 

int main() 
{ 
    // ... 
    // no special decoration required for xc and yc when using references 
    trans(center_x, center_y, angle, xc, yc); 
    // ... 
} 

Mentre se si sta utilizzando C, si dovrà passare puntatori espliciti o indirizzi, come ad come:

void trans(double x, double y, double theta, double* m, double* n) 
{ 
    *m=cos(theta)*x+sin(theta)*y; 
    *n=-sin(theta)*x+cos(theta)*y; 
} 

int main() 
{ 
    /* ... */ 
    /* have to use an ampersand to explicitly pass address */ 
    trans(center_x, center_y, angle, &xc, &yc); 
    /* ... */ 
} 

mi sento di raccomandare check-out la C++ FAQ Lite's entry on references per qualche informazione in più su come utilizzare i riferimenti correttamente.

Answer 2

è necessario passare le variabili per riferimento il che significa

void trans(double x,double y,double theta,double &m,double &n) { ... } 

Answer 3

passaggio per riferimento è davvero una risposta corretta, tuttavia, C++ sorta-di permette valori multipli restituisce utilizzando std::tuple e (per due valori) std::pair :

#include <cmath> 
#include <tuple> 

using std::cos; using std::sin; 
using std::make_tuple; using std::tuple; 

tuple<double, double> trans(double x, double y, double theta) 
{ 
    double m = cos(theta)*x + sin(theta)*y; 
    double n = -sin(theta)*x + cos(theta)*y; 
    return make_tuple(m, n); 
} 

In questo modo, non è necessario utilizzare i parametri di uscita.

Sul lato chiamante, è possibile utilizzare std::tie per decomprimere la tupla in altre variabili:

using std::tie; 

double xc, yc; 
tie(xc, yc) = trans(1, 1, M_PI); 
// Use xc and yc from here on 

Spero che questo aiuti!

Answer 4

come detto sopra, è necessario passare per riferimento per restituire valori alterati di 'm' e 'n', ma ... considerare di passare tutto per riferimento e usare const per i parametri che non si desidera modificare all'interno vostra funzione cioè

void trans(const double& x, const double& y,const double& theta, double& m,double& n)