Reference vs Pointer to Const

When it comes to function parameters, both references to const and pointers to const are commonly used for passing objects efficiently without allowing modification. However, there are some key differences in their behavior and use cases.

Let's compare them

In this example, we compare the two types:

1#include <iostream>
2#include <string>
3
4void PrintByRef(const std::string& str) {
5  std::cout << "Reference: " << str << '\n';
6}
7
8void PrintByPtr(const std::string* str) {
9  if (str) {
10    std::cout << "Pointer: " << *str << '\n';
11  } else {
12    std::cout << "Null pointer\n";
13  }
14}
15
16int main() {
17  std::string message{"Hello, World!"};
18
19  PrintByRef(message);
20  PrintByPtr(&message);
21  PrintByPtr(nullptr);  // This is valid
22
23  // This would be a compile-time error
24  PrintByRef(nullptr); 
25}

1Reference: Hello, World!
2Pointer: Hello, World!
3Null pointer

Key differences:

1. Nullability: Pointers can be null, references cannot. This means you can pass nullptr to a function expecting a pointer, but not to one expecting a reference.
2. Syntax: References use more intuitive syntax (just like passing by value), while pointers require dereferencing with when accessing the value.
3. Optionality: Pointers can represent optional parameters (by allowing null), while references always expect a valid object.
4. Safety: References are generally safer as they can't be null and don't require checking before use.

In terms of performance, references and pointers are essentially identical. The compiler typically implements references using pointers under the hood.

Both const T& and const T* prevent modification of the pointed-to object:

1#include <iostream>
2
3void ModifyByRef(const int& x) {
4  // x++;  // Compilation error
5  std::cout << "Reference value: " << x << '\n';
6}
7
8void ModifyByPtr(const int* x) {
9  // (*x)++;  // Compilation error
10  if (x) {
11    std::cout << "Pointer value: " << *x << '\n';
12  }
13}
14
15int main() {
16  int value{42};
17  ModifyByRef(value);
18  ModifyByPtr(&value);
19}

Use references when:

• The parameter is required and will always be valid.
• You want a cleaner syntax in the function body.
• You want to prevent accidental null dereferences.

Use pointers when:

• The parameter is optional (can be null).
• You might need to change what the pointer points to.
• You're working with C-style APIs or older codebases.

In modern C++, references are often preferred for their safety and cleaner syntax, unless you specifically need the nullability or rebinding capabilities of pointers.