University of Cambridge > Engineering Department > computing help > Languages > C++

Passing values in C++

Suppose there's a function f in a class c that's going to be called from another function (main for example). There are many ways that the function f can receive or return integer values. By careful use of const you can make your code safer.

Argument-passing by value or using references
Argument-passing using pointers
Returning values in C++

Argument-passing by value or using references

The examples of function f in this section can be called in the following way

int i;
c test_class;
   i=7;
   test_class.f(i);
   cout << "i="   <<i  << endl;

void c::f(int arg); - "by value" - arg is a new integer existing only in function f. Its initial value is copied from i. Modifications to arg won't affect the i in the main function.
void c::f(const int arg); - by value (i.e. copied). The const keyword means that arg can't be changed, but even if it could, it wouldn't affect the i in the main function.
void c::f(int& arg); - by reference: arg is an alias for i. In this example no copying is done. If arg were a big object rather than a single integer, this method is more efficient than the methods that use copy. Note however that changing arg will change the i in the calling function, which is a risk you might not want to take.
void c::f(const int& arg); - by reference again, but this time the integer provided by main in the call can't be changed: it's read-only. This is a useful option in bigger programs, combining safety with efficiency.

void c::f(const int& arg) const; - like the previous example, but the final const keyword means that in addition the function f can't change the member variables of c. This safety feature is worth using whenever possible. Here's a complete example -

#include <iostream>
using namespace std;

class c
{
public:
  int value;
  void f(const int& arg) const; 
};
  
// this is a member function of c
void c::f(const int& arg) const {
    cout <<  "arg=" << arg << endl; 
    // The next 2 lines are commented out - they're errors.
    // arg=9;
    // value=9;
}  

int main()
{
int i;
c test_class;
  i=7;
  test_class.f(i);
  cout << "i=" << i << endl; 
}

In C++ references are often used in situations where in the older C language pointers would be used, so if you're already confused by the range of options, it might be best to skip the next section about pointers altogether and go straight onto how to return values.

Argument-passing using pointers

For the examples in this section, function f needs to be called in the following way

void g() {
int i;
c test_class;
   i=7;
   test_class.f(&i);
}

In none of these cases is i copied to a new variable.

void c::f(int *arg); - by reference (but not using C++'s reference facility!): changing *arg will change the i integer in the calling function.
void c::f(const int *arg); - by reference, but this time the i integer in main can't be changed: it's read-only
void c::f(int * const arg); - by reference. The pointer arg can't be changed, but what it points to (namely the i of the calling function) can.

void c::f(const int * const arg); - by reference. The pointer arg can't be changed, neither can what it points to. Here's a complete example -

#include <iostream>
using namespace std;

class c
{
public:
  int value;
  void f(const int * const arg); 
};
  
// this is a member function of c
void c::f(const int * const arg) {
    cout <<  "*arg=" << *arg << endl; 
    // The next 2 lines are commented out - they're errors.
    // arg=9;
    // *arg=9;
    value=9; // This is ok    
}  

int main()
{
int i;
c test_class;
  i=7;
  test_class.f(&i);
  cout << "i=" << i << endl;   
}

Returning values in C++

Suppose there's a function f in a class c that's going to be called from another function. There are many ways that function f can return an integer value

int c::f(); - returns an integer by value. Easiest and safest.

int* c::f(); - returns a pointer to an integer. There are risks associated with this method, as illustrated here

#include <iostream>
using namespace std;

class c
{
public:
  int value;
  const int* f();
};
  
int* c::f() {
  int j=999;
    cout <<  "j=" << j << endl; 
    // The following line of code returns a pointer to the integer j.
    // Unfortunately j is a local variable whose memory is available
    // for recycling once the function's finished. This recycling 
    // might not happen straight away, but when it does, the 999
    // value could be overwritten. 
    // The line is legal, though some compilers (including the one
    // our students use) give a warning. 
    return &j;
}  

int main()
{
int *ip;
c test_class;
   ip=test_class.f();
   cout << "*ip=" << *ip << endl; 
}

const int* c::f(); - caller can't modify the integer pointed to by the returned pointer
int& c::f(); - returns a reference to an integer. This has the same risks as returning a pointer. Note also that a reference (unlike a pointer) can't have a value of 0, so you can't use 0 as an error value
const int& c::f(); - returns a reference to a const integer

An exercise

const int* c::f(const int * const arg) const;

is a legal declaration. First work out what it means, then write a program which tests to see if your compiler faithfully obeys each of the uses of const.

Passing values in C++

Argument-passing by value or using references

Argument-passing using pointers

Returning values in C++

An exercise

See also