When Should You Use Pass‑by‑Value, Reference, or Pointer in C++?

In C++, the way function parameters are passed directly influences performance, memory usage, and data safety. This article explains three common passing methods—pass‑by‑value, pass‑by‑reference, and pass‑by‑pointer—detailing their characteristics, appropriate use cases, and providing complete code examples.

1. Pass‑by‑Value

Pass‑by‑value creates a copy of the argument; modifications inside the function do not affect the original variable. It is suitable for small data types such as int, float, or char. Copying large structs or class objects may degrade performance.

Example

#include <iostream>
using namespace std;

void increment(int num) {
    num++; // modifies the copy, original unchanged
    cout << "Inside function num = " << num << endl;
}

int main() {
    int x = 10;
    increment(x);
    cout << "Outside function x = " << x << endl; // still 10
    return 0;
}

Output:

Inside function num = 11
Outside function x = 10

2. Pass‑by‑Reference

Reference passing allows the function to operate directly on the original variable, avoiding copying and improving efficiency.

The function can modify the original data.

Suitable for large structures or class objects.

Syntax is simpler and safer than pointers (no null‑reference issue).

Example

#include <iostream>
using namespace std;

void increment(int &num) {
    // using reference passing
    num++; // directly modifies the original variable
    cout << "Inside function num = " << num << endl;
}

int main() {
    int x = 10;
    increment(x);
    cout << "Outside function x = " << x << endl; // becomes 11
    return 0;
}

Output:

Inside function num = 11
Outside function x = 11

For read‑only parameters that should avoid copying, use const &:

void printLargeObject(const BigObject &obj) {
    // can read obj but not modify it
}

3. Pass‑by‑Pointer

Pointer passing is similar to reference passing but requires explicitly passing the variable’s address and dereferencing ( *) to modify the data.

Can modify the original data.

Allows passing nullptr (references cannot be null).

Useful for dynamic memory management or optional parameters.

Example

#include <iostream>
using namespace std;

void increment(int *num) {
    if (num != nullptr) {
        (*num)++; // dereference and modify
        cout << "Inside function *num = " << *num << endl;
    }
}

int main() {
    int x = 10;
    increment(&x); // pass address
    cout << "Outside function x = " << x << endl; // becomes 11
    return 0;
}

Output:

Inside function *num = 11
Outside function x = 11

4. Choosing the Right Method

Basic data types (int, float, …): use pass‑by‑value.

Large structs/classes where copying is expensive: use const & (constant reference).

When the function must modify the original data: use reference ( &).

Dynamic memory management or optional arguments: use pointer ( *).

Summary

Pass‑by‑value is ideal for small data; changes inside the function do not affect the caller.

Pass‑by‑reference is best for large data or when the function needs to modify the original value, offering safety over pointers.

Pass‑by‑pointer suits scenarios requiring dynamic memory handling or optional parameters, but requires null checks and explicit dereferencing.