C++ Function Parameters: Pass by Value, Reference, Const

Parameters vs Arguments

A function's parameters are the named variables in its definition; the arguments are the actual values you hand it when you call it. The previous page showed how to define and call functions - this page is about how those values actually get in, because C++ gives you several ways and the choice affects both correctness and speed.

The default in C++ is pass by value: the function receives a copy.

#include <iostream>
using namespace std;

void addTen(int n) {   // n is a copy of whatever you pass
    n = n + 10;
    cout << "inside: " << n << endl;
}

int main() {
    int score = 5;
    addTen(score);
    cout << "outside: " << score << endl;   // still 5
    return 0;
}

Inside addTen, n is a separate variable initialized from score. Reassigning n touches only that copy, so score is untouched back in main. This is safe and predictable - the function cannot accidentally clobber your data - which is exactly why it is the default.

Pass by Reference: Letting a Function Change the Caller

Sometimes you want the function to modify the caller's variable. Add an & to the parameter type and it becomes a reference - an alias for the original, not a copy:

#include <iostream>
using namespace std;

void addTen(int& n) {   // n refers to the caller's variable
    n = n + 10;
}

int main() {
    int score = 5;
    addTen(score);
    cout << score << endl;   // 15 - the original changed
    return 0;
}

The only difference from the first example is the &, but now n and score are the same object. This is the standard way to "return" more than one value or to update something in place. A classic use is swapping two variables:

#include <iostream>
using namespace std;

void swapValues(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}

int main() {
    int x = 1, y = 2;
    swapValues(x, y);
    cout << x << " " << y << endl;   // 2 1
    return 0;
}

Without the &, swapValues would shuffle two copies and main would see no change at all - a very common beginner bug.

Const References: Cheap, Read-Only Access

Pass-by-value copies the argument. For an int that costs nothing, but copying a big string or vector every call is real, wasted work. The fix is a const reference (const T&): you get reference speed (no copy) plus a compiler-enforced promise not to modify the argument.

#include <iostream>
#include <string>
using namespace std;

// no copy of the string is made, and we can't accidentally change it
void greet(const string& name) {
    cout << "Hello, " << name << "!" << endl;
    // name = "x";   // would be a compile error - name is const
}

int main() {
    string visitor = "Ada";
    greet(visitor);
    greet("temporary");   // const& can also bind to a temporary
    return 0;
}

A handy rule of thumb: pass small built-in types (int, double, char, bool, pointers) by value, and pass large objects you only need to read by const reference. Reserve a plain non-const T& for the cases where you genuinely intend to modify the caller's object.

A subtle gotcha: a plain int& n cannot bind to a temporary or a literal. addTen(5) from the first example would fail to compile if the parameter were int&, because 5 is not a variable you can alias. A const int& can bind to 5, which is one more reason const references are so widely used.

Default Arguments

You can give a parameter a fallback value so callers may omit it. If the argument is missing, the default is used:

#include <iostream>
#include <string>
using namespace std;

void connect(const string& host, int port = 8080, bool secure = false) {
    cout << (secure ? "https" : "http") << "://"
         << host << ":" << port << endl;
}

int main() {
    connect("example.com");              // port=8080, secure=false
    connect("example.com", 443);         // secure=false
    connect("example.com", 443, true);   // all three given
    return 0;
}

Two rules trip people up. First, defaults must be trailing - once a parameter has a default, every parameter after it must too. You can't write void f(int a = 1, int b) because there'd be no way to supply b while skipping a. Second, when a function is declared in a header and defined elsewhere, put the default only in the declaration, never repeat it in the definition - repeating it is a compile error.

Passing Arrays and Vectors

A raw array decays to a pointer when passed, so the function loses track of its size - you almost always pass the length alongside it:

#include <iostream>
using namespace std;

int sum(const int arr[], int size) {   // arr is really an int* here
    int total = 0;
    for (int i = 0; i < size; i++) total += arr[i];
    return total;
}

int main() {
    int nums[] = {4, 8, 15, 16};
    cout << sum(nums, 4) << endl;   // 43
    return 0;
}

Because the array became a pointer, sizeof(arr) inside sum would give the size of a pointer, not the array - a notorious bug. In modern C++ prefer a std::vector (or std::span in C++20), passed by const reference, which carries its own size:

#include <iostream>
#include <vector>
using namespace std;

int sum(const vector<int>& v) {   // no copy, knows its own size
    int total = 0;
    for (int x : v) total += x;
    return total;
}

int main() {
    vector<int> nums = {4, 8, 15, 16};
    cout << sum(nums) << endl;   // 43
    return 0;
}

Note the const&: drop it and every call copies the whole vector. For a four-element vector that's harmless, but for a million elements it's a silent performance sink.

Pointer Parameters

You can also pass a pointer (T*). Like a reference, this lets the function reach the caller's data, but a pointer can be reseated or be null - so it's the right tool when "no value" is a legitimate option:

#include <iostream>
using namespace std;

// returns false when there's nowhere to write the result
bool tryParseDouble(const char* text, double* out) {
    if (out == nullptr) return false;   // guard against null
    *out = 0.0;
    for (const char* p = text; *p >= '0' && *p <= '9'; ++p) {
        *out = *out * 10 + (*p - '0');
    }
    return true;
}

int main() {
    double value;
    if (tryParseDouble("123", &value)) {
        cout << "parsed: " << value << endl;
    }
    return 0;
}

The caller passes &value to share its address, and the function writes through *out. The key difference from references: a pointer might be nullptr, so a function taking one should check before dereferencing - skipping that guard and dereferencing a null pointer is undefined behavior, usually a crash. If "no value" never makes sense, a reference is cleaner because it can't be null in the first place.

Next: References

Parameters are where references earn their keep, but references are a feature in their own right - aliases you can create for any variable, not just inside a function signature. The next page digs into how references work on their own: how to declare them, why they must be initialized immediately, the difference between an lvalue reference and a const reference, and the subtle ways a reference can end up dangling.