Reference vs pointer in C++ - Performance Comparison

Time Complexity: Reference vs pointer

O(n)

Understanding Time Complexity

We want to see how using references or pointers affects the speed of a program.

How does the program's work change when we use one or the other?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

void incrementByPointer(int* ptr) {
    (*ptr)++;
}

void incrementByReference(int& ref) {
    ref++;
}

int main() {
    int a = 0;
    incrementByPointer(&a);
    incrementByReference(a);
    return 0;
}
    

This code shows two ways to increase a number: one uses a pointer, the other a reference.

Identify Repeating Operations

Look for repeated actions that take time.

• Primary operation: Incrementing the integer value.
• How many times: Each function does this once per call.

How Execution Grows With Input

Since each function just changes one number once, the work stays the same no matter the input size.

Input Size (n)	Approx. Operations
10	10 increments if called 10 times
100	100 increments if called 100 times
1000	1000 increments if called 1000 times

Pattern observation: The work grows directly with how many times you call the function.

Final Time Complexity

Time Complexity: O(n)

This means the time grows in a straight line with the number of times you run the increment.

Common Mistake

[X] Wrong: "Using pointers is always slower than references because of extra steps."

[OK] Correct: Both pointers and references usually compile to similar machine instructions, so their speed is nearly the same for simple operations.

Interview Connect

Understanding how references and pointers work helps you write clear and efficient code, a skill valued in many programming tasks.

Self-Check

"What if we passed the integer by value instead of by pointer or reference? How would the time complexity change?"

Practice

1. Which of the following statements correctly describes a reference in C++?

easy

A. A reference is an alias for another variable and cannot be changed to refer to another variable.

B. A reference holds the memory address of a variable and can be reassigned.

C. A reference can be null and does not need to be initialized.

D. A reference is a pointer that requires explicit dereferencing.

Solution

1. Step 1: Understand what a reference is

   A reference acts as another name for an existing variable and must be initialized when declared.

2. Step 2: Compare with pointers

   Unlike pointers, references cannot be changed to refer to another variable or be null.

3. Final Answer:

   A reference is an alias for another variable and cannot be changed to refer to another variable. -> Option A

4. Quick Check:

   Reference = alias, fixed binding [OK]

Hint: References alias variables and never change target [OK]

Common Mistakes:

• Thinking references can be null
• Confusing references with pointers
• Assuming references can be reassigned

2. Which of the following is the correct syntax to declare a pointer to an integer in C++?

easy

A. int ptr;

B. int *ptr;

C. int &ptr;

D. int ptr*&;

Solution

1. Step 1: Recall pointer declaration syntax

   In C++, a pointer to an int is declared using an asterisk (*) before the variable name.

2. Step 2: Analyze options

   int *ptr; uses "int *ptr;" which correctly declares a pointer to int. int ptr; declares an int variable, B declares a reference, and D is invalid syntax.

3. Final Answer:

   int *ptr; -> Option B

4. Quick Check:

   Pointer syntax = int *ptr [OK]

Hint: Pointer declaration uses * before variable name [OK]

Common Mistakes:

• Omitting the * for pointer declaration
• Using & which declares a reference
• Combining * and & incorrectly

3. What will be the output of the following C++ code?

int x = 10;
int &ref = x;
int *ptr = &x;
ref = 20;
*ptr = 30;
std::cout << x << std::endl;

medium

A. 30

B. 20

C. 10

D. Compilation error

Solution

1. Step 1: Trace reference assignment

   ref is a reference to x, so ref = 20 sets x to 20.

2. Step 2: Trace pointer assignment

   ptr points to x, so *ptr = 30 sets x to 30.

3. Final Answer:

   30 -> Option A

4. Quick Check:

   Reference and pointer both modify x = 30 [OK]

Hint: Both ref and *ptr change x directly [OK]

Common Mistakes:

• Thinking ref and ptr are independent variables
• Confusing pointer dereference syntax
• Assuming ref can be reassigned

4. Identify the error in the following code snippet:

int a = 5;
int &ref;
ref = a;
std::cout << ref << std::endl;

medium

A. Cannot assign a variable to a reference.

B. Missing * for pointer declaration.

C. Reference must be initialized when declared.

D. Reference cannot be used with std::cout.

Solution

1. Step 1: Check reference declaration rules

   References must be initialized at the time of declaration; they cannot be declared without initialization.

2. Step 2: Analyze the code

   int &ref; is invalid because ref is not initialized. Assigning ref = a; later is not initialization but assignment.

3. Final Answer:

   Reference must be initialized when declared. -> Option C

4. Quick Check:

   Reference declaration requires immediate initialization [OK]

Hint: References need initialization on declaration [OK]

Common Mistakes:

• Thinking references can be declared then assigned
• Confusing assignment with initialization
• Assuming pointers and references behave the same

5. Given the following code, what will be the output?

int x = 5;
int y = 10;
int *ptr = &x;
int &ref = y;
ptr = &y;
ref = *ptr + 5;
std::cout << x << ", " << y << std::endl;

hard

A. Compilation error

B. 5, 10

C. 5, 20

D. 5, 15

Solution

1. Step 1: Trace pointer reassignment

   ptr initially points to x, then is reassigned to point to y.

2. Step 2: Trace reference and assignment

   ref is a reference to y. The statement ref = *ptr + 5 means y = y + 5 (since ptr points to y).

3. Step 3: Final values

   x remains 5, y becomes 10 + 5 = 15.

4. Final Answer:

   5, 15 -> Option D

5. Quick Check:

   Pointer changes target; reference updates y = 15 [OK]

Hint: Pointer can change target; reference fixed to y [OK]

Common Mistakes:

• Assuming reference ref points to x
• Forgetting pointer reassignment
• Confusing reference assignment with pointer assignment