Take the 2-minute tour ×

I am new to C++ programming, but I have experience in Java. I need guidance on how to pass objects to functions in C++.

Do I need to pass pointers, references, or non-pointer and non-reference values? I remember in Java there are no such issues since we pass just the variable that holds reference to the objects.

It would be great if you could also explain where to use each of those options.

share|improve this question
Which book are you learning C++ from? –  anon Jan 26 '10 at 12:09
That book is strongly not recommended. Go for C++ Primer by Stan Lippman. –  Prasoon Saurav Jan 26 '10 at 12:12
Well, there is your problem. Schildt is basically cr*p - get Accelerated C++ by Koenig & Moo. –  anon Jan 26 '10 at 12:12
I wonder how nobody mentioned The C++ Programming Language by Bjarne Stroustrup. Bjarne Stroustrup is the creator of C++. A really good book to learn C++. –  George Jan 26 '10 at 13:37
@George: TC++PL is not for beginners, but it is considered to be the Bible for C++.xD –  Prasoon Saurav Jan 26 '10 at 14:11

5 Answers 5

up vote 156 down vote accepted

Rules of thumb for C++11:

Pass by value, except when

  1. you do not need ownership of the object and a simple alias will do, in which case you pass by const reference,
  2. unless you must mutate the object, in which case, use pass by a non-const lvalue reference,
  3. unless you pass objects of derived classes as base classes, in which case you need to pass by reference. (Use the previous rules to determine whether to pass by const reference or not.)

Passing by pointer is virtually never advised. Optional parameters are best expressed as a boost::optional, and aliasing is done fine by reference.

C++11's move semantics make passing and returning by value much more attractive even for complex objects.

Rules of thumb for C++03:

Pass arguments by const reference, except when

  1. they are to be changed inside the function and such changes should be reflected outside, in which case you pass by non-const reference
  2. the function should be callable without any argument, in which case you pass by pointer, so that users can pass NULL/0/nullptr instead; apply the previous rule to determine whether you should pass by a pointer to a const argument
  3. they are of built-in types, which can be passed by copy
  4. they are to be changed inside the function and such changes should not be reflected outside, in which case you can pass by copy (an alternative would be to pass according to the previous rules and make a copy inside of the function)

(here, "pass by value" is called "pass by copy", because passing by value always creates a copy in C++03)

There's more to this, but these few beginner's rules will get you quite far.

share|improve this answer
+1 - I would also note that some (i.e. Google) feel that objects that will be changed within the function should be passed via a pointer instead of a non-const reference. The reasoning being that when the address of an object is passed to a function it is more apparent that said function may change it. Example: With references, the call is foo(bar); whether the reference is const or not, with a pointer it is foo(&bar); and is more apparent that foo is being passed a mutable object. –  RC. Jan 26 '10 at 12:43
@RC Still doesn't tell you if the pointer is const or not. Google's guidelines have come in for a lot of flak in the various C++ online communities - justifiably so, IMHO. –  anon Jan 26 '10 at 12:48
While in other contexts google may be leading the way, in C++ their style guide is not really that good. –  David Rodríguez - dribeas Jan 26 '10 at 14:51
@ArunSaha: As a pure style guide, Stroustrup has a guide that was developed for an aerospace company. I browsed through the google guide and did not like it for a couple of reasons. Sutter & Alexandrescu C++ Coding Standards is a great book to read and you can get quite a few of good advices, but it is not really a style guide. I don't know of any automated checker for style, other than humans and common sense. –  David Rodríguez - dribeas Oct 30 '10 at 11:46
@anon However, you do get a guarantee that if an argument is not passed via a pointer, then it is NOT changed. That's quite valuable IMHO, otherwise when trying to trace what happens to a variable in a function, you have to examine the header files of all the function's it's passed to to determine if it's changed. This way, you only have to look at the ones it was passed via pointer. –  smehmood Mar 4 '11 at 7:20

There are some differences in calling conventions in C++ and Java. In C++ there are technically speaking only two conventions: pass-by-value and pass-by-reference, with some literature including a third pass-by-pointer convention (that is actually pass-by-value of a pointer type). On top of that, you can add const-ness to the type of the argument, enhancing the semantics.

Pass by reference

Passing by reference means that the function will conceptually receive your object instance and not a copy of it. The reference is conceptually an alias to the object that was used in the calling context, and cannot be null. All operations performed inside the function apply to the object outside the function. This convention is not available in Java or C.

Pass by value (and pass-by-pointer)

The compiler will generate a copy of the object in the calling context and use that copy inside the function. All operations performed inside the function are done to the copy, not the external element. This is the convention for primitive types in Java.

An special version of it is passing a pointer (address-of the object) into a function. The function receives the pointer, and any and all operations applied to the pointer itself are applied to the copy (pointer), on the other hand, operations applied to the dereferenced pointer will apply to the object instance at that memory location, so the function can have side effects. The effect of using pass-by-value of a pointer to the object will allow the internal function to modify external values, as with pass-by-reference and will also allow for optional values (pass a null pointer).

This is the convention used in C when a function needs to modify an external variable, and the convention used in Java with reference types: the reference is copied, but the referred object is the same: changes to the reference/pointer are not visible outside the function, but changes to the pointed memory are.

Adding const to the equation

In C++ you can assign constant-ness to objects when defining variables, pointers and references at different levels. You can declare a variable to be constant, you can declare a reference to a constant instance, and you can define all pointers to constant objects, constant pointers to mutable objects and constant pointers to constant elements. Conversely in Java you can only define one level of constant-ness (final keyword): that of the variable (instance for primitive types, reference for reference types), but you cannot define a reference to an immutable element (unless the class itself is immutable).

This is extensively used in C++ calling conventions. When the objects are small you can pass the object by value. The compiler will generate a copy, but that copy is not an expensive operation. For any other type, if the function will not change the object, you can pass a reference to a constant instance (usually called constant reference) of the type. This will not copy the object, but pass it into the function. But at the same time the compiler will guarantee that the object is not changed inside the function.

Rules of thumb

This are some basic rules to follow:

  • Prefer pass-by-value for primitive types
  • Prefer pass-by-reference with references to constant for other types
  • If the function needs to modify the argument use pass-by-reference
  • If the argument is optional, use pass-by-pointer (to constant if the optional value should not be modified)

There are other small deviations from these rules, the first of which is handling ownership of an object. When an object is dynamically allocated with new, it must be deallocated with delete (or the [] versions thereof). The object or function that is responsible for the destruction of the object is considered the owner of the resource. When a dynamically allocated object is created in a piece of code, but the ownership is transfered to a different element it is usually done with pass-by-pointer semantics, or if possible with smart pointers.

Side note

It is important to insist in the importance of the difference between C++ and Java references. In C++ references are conceptually the instance of the object, not an accessor to it. The simplest example is implementing a swap function:

// C++
class Type; // defined somewhere before, with the appropriate operations
void swap( Type & a, Type & b ) {
   Type tmp = a;
   a = b;
   b = tmp;
int main() {
   Type a, b;
   Type old_a = a, old_b = b;
   swap( a, b );
   assert( a == old_b );
   assert( b == old_a ); 

The swap function above changes both its arguments through the use of references. The closest code in Java:

public class C {
   // ...
   public static void swap( C a, C b ) {
      C tmp = a;
      a = b;
      b = tmp;
   public static void main( String args[] ) {
      C a = new C();
      C b = new C();
      C old_a = a;
      C old_b = b;
      swap( a, b ); 
      // a and b remain unchanged a==old_a, and b==old_b

The Java version of the code will modify the copies of the references internally, but will not modify the actual objects externally. Java references are C pointers without pointer arithmetic that get passed by value into functions.

share|improve this answer
@david-rodriguez-dribeas I like the rules of thumb section, specially "Prefer pass-by-value for primitive types" –  yadab Oct 13 '10 at 14:39

There are several cases to consider.

Parameter modified ("out" and "in/out" parameters)

void modifies(T &param);
// vs
void modifies(T *param);

This case is mostly about style: do you want the code to look like call(obj) or call(&obj)? However, there are two points where the difference matters: the optional case, below, and you want to use a reference when overloading operators.

...and optional

void modifies(T *param=0);  // default value optional, too
// vs
void modifies();
void modifies(T &param);

Parameter not modified

void uses(T const &param);
// vs
void uses(T param);

This is the interesting case. The rule of thumb is "cheap to copy" types are passed by value — these are generally small types (but not always) — while others are passed by const ref. However, if you need to make a copy within your function regardless, you should pass by value. (Yes, this exposes a bit of implementation detail. C'est le C++.)

...and optional

void uses(T const *param=0);  // default value optional, too
// vs
void uses();
void uses(T const &param);  // or optional(T param)

There's the least difference here between all situations, so choose whichever makes your life easiest.

Const by value is an implementation detail

void f(T);
void f(T const);

These declarations are actually the exact same function! When passing by value, const is purely an implementation detail. Try it out:

void f(int);
void f(int const) { /* implements above function, not an overload */ }

typedef void NC(int);       // typedefing function types
typedef void C(int const);

NC *nc = &f;  // nc is a function pointer
C *c = nc;    // C and NC are identical types
share|improve this answer
+1 I didn't know about const being an implementation when passing by value. –  balki Sep 25 '12 at 7:02

Pass by value:

void func (vector v);

Pass variables by value when the function needs complete isolation from the environment i.e. to prevent the function from modifying the original variable as well as to prevent other threads from modifying its value while the function is being executed. This is the default in C/C++.

The cost is the CPU cycles spent to copy the object.

Pass by const reference:

void func (const vector & v);

The main intention of this form is to allow pass-by-value behavior while removing the copying overhead. This gives the function read-only access to the original object, but it cannot modify its value.

The downside is thread safety: any change made to the original object by another thread will show up inside the function while it's still executing.

Pass by non-const reference:

void func (vector & v)

Use this if modifications made to the variable inside the function need to be reflected outside.

Just like the const reference case, this is not thread safe.

Pass by const pointer:

void func (const vector * vp);

Functionally same as pass by const-reference except for the different syntax, plus the fact that the calling function can pass NULL pointer to indicate that it has no valid data to pass.

Not thread safe.

Pass by non-const pointer:

void func (vector * vp);

Has the advantage of pass by const pointer, where the calling function can ask the function not to send it any data. This is seen in many glibc APIs. Example:

void func (string * str, /* ... */) {
    if (str != NULL) {
        *str = "some_value"; // assign to *sig only if it's non-null

As with all pass by reference/pointer, not thread safe.

share|improve this answer

There are three methods of passing an object to a function as a parameter:

  1. Pass by reference
  2. pass by value
  3. adding constant in parameter

Go through the following example:

class Sample
    int *ptr;
    int mVar;

    Sample(int i)
        mVar = 4;
        ptr = new int(i);

        delete ptr;

    void PrintVal()
        cout << "The value of the pointer is " << *ptr << endl
             << "The value of the variable is " << mVar;

void SomeFunc(Sample x)
cout << "Say i am in someFunc " << endl;

int main()

  Sample s1= 10;
  char ch;
  cin >> ch;


Say i am in someFunc
The value of the pointer is -17891602
The value of the variable is 4

share|improve this answer
what about the other two options? this doesn't explain anything... –  mmdanziger Oct 30 '12 at 13:26

protected by Daniel A. White Feb 20 '11 at 21:26


Would you like to answer one of these unanswered questions instead?
