Pointer declaration in C++ - Step-by-Step Execution

Concept Flow - Pointer declaration

Declare variable

↓

Declare pointer with *

↓

Pointer stores address of variable

↓

Use pointer to access variable

↓

End

This flow shows how a pointer is declared to hold the address of a variable and then used to access that variable.

Execution Sample

C++

int x = 10;
int* p = &x;
std::cout << *p;

Declare an integer x, declare a pointer p to x, then print the value pointed by p.

Execution Table

Step	Action	Variable	Pointer	Value pointed by Pointer	Output
1	Declare int x = 10	x = 10	p = uninitialized	N/A	N/A
2	Declare pointer p to address of x	x = 10	p = &x (address)	10	N/A
3	Print value pointed by p (*p)	x = 10	p = &x	10	10
4	End of program	x = 10	p = &x	10	10

💡 Program ends after printing the value pointed by p.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
x	undefined	10	10	10	10
p	undefined	undefined	&x (address)	&x (address)	&x (address)

Key Moments - 2 Insights

Why do we use * in int* p when declaring a pointer?

The * indicates that p is a pointer variable that will store the address of an int. See execution_table step 2 where p stores &x.

What does *p mean when printing *p?

*p means to access the value stored at the address p points to. In step 3, *p gives the value 10 stored in x.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of p after step 2?

A The value 10

B Uninitialized

C The address of x

D Null pointer

💡 Hint

Check the 'Pointer' column in execution_table row for step 2.

At which step is the value pointed by p printed?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Output' column in execution_table to find when 10 is printed.

If we change int* p = &x; to int* p = nullptr;, what will *p output?

A Undefined behavior or crash

B Address of x

C 10

D 0

💡 Hint

Refer to pointer initialization in variable_tracker and what happens when pointer is null.

Concept Snapshot

Pointer Declaration in C++:
- Use * to declare a pointer: int* p;
- Pointer stores address of a variable: p = &x;
- Access value via pointer: *p
- Pointer holds memory address, not value
- Dereferencing *p gives variable's value

Full Transcript

This example shows how to declare a pointer in C++. First, an integer variable x is declared and set to 10. Then a pointer p is declared with int* p and assigned the address of x using &x. The pointer p now holds the memory address of x. When we print *p, it accesses the value stored at that address, which is 10. The execution table traces these steps, showing variable and pointer states. Key points are that * in declaration means pointer type, and *p accesses the value pointed to. If p is null or uninitialized, dereferencing causes errors.

Practice

1. Which of the following correctly declares a pointer to an integer in C++?

easy

A. ptr int*;

B. int ptr*;

C. *int ptr;

D. int *ptr;

Solution

1. Step 1: Understand pointer declaration syntax

   In C++, a pointer to a type is declared by writing the type followed by an asterisk (*) and then the pointer name.

2. Step 2: Check each option

   int *ptr; uses int *ptr; which is the correct syntax. Other options place the asterisk incorrectly.

3. Final Answer:

   int *ptr; -> Option D

4. Quick Check:

   Pointer declaration = type *name [OK]

Hint: Remember: type *name; declares a pointer [OK]

Common Mistakes:

• Placing * after the variable name
• Using * before the type keyword
• Omitting the * entirely

2. Which of the following is the correct syntax to declare a pointer to a double variable named p?

easy

A. double *p;

B. p double*;

C. *double p;

D. double p*;

Solution

1. Step 1: Recall pointer declaration rules

   The pointer declaration syntax is type *pointerName;. The asterisk (*) must come immediately before the pointer name.

2. Step 2: Evaluate options

   double *p; correctly declares double *p;. Other options have misplaced asterisks or wrong order.

3. Final Answer:

   double *p; -> Option A

4. Quick Check:

   Pointer to double = double *p; [OK]

Hint: Put * right before pointer name, after type [OK]

Common Mistakes:

• Writing * after the variable name
• Placing * before the type keyword
• Swapping variable and type order

3. What is the output of the following code?

int x = 10;
int *p = &x;
std::cout << *p << std::endl;

medium

A. Garbage value

B. Address of x

C. 10

D. Compilation error

Solution

1. Step 1: Understand pointer initialization

   The pointer p is assigned the address of x using &x. So p points to x.

2. Step 2: Dereference pointer to get value

   The expression *p accesses the value stored at the address p points to, which is 10.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   *p gives value at address = 10 [OK]

Hint: Dereference pointer *p to get variable value [OK]

Common Mistakes:

• Printing pointer variable instead of dereferenced value
• Confusing & (address) with * (dereference)
• Expecting address output instead of value

4. Identify the error in the following code snippet:

int a = 5;
int *ptr;
*ptr = a;

medium

A. Pointer ptr is not initialized before dereferencing

B. Variable a is not declared

C. Incorrect pointer declaration syntax

D. Missing semicolon after declaration

Solution

1. Step 1: Check pointer initialization

   The pointer ptr is declared but not assigned any address before dereferencing.

2. Step 2: Understand dereferencing uninitialized pointer

   Dereferencing *ptr without initialization leads to undefined behavior or runtime error.

3. Final Answer:

   Pointer ptr is not initialized before dereferencing -> Option A

4. Quick Check:

   Uninitialized pointer dereference = error [OK]

Hint: Always initialize pointer before using *ptr [OK]

Common Mistakes:

• Dereferencing pointer before assigning address
• Assuming declaration initializes pointer
• Ignoring runtime errors from uninitialized pointers

5. Given the code below, which pointer declaration correctly allows p to point to a constant integer value?

const int val = 100;
// Which declaration is correct?

hard

A. int *p = &val;

B. const int *p = &val;

C. int *const p = &val;

D. int *p const = &val;

Solution

1. Step 1: Understand pointer to const int

   To point to a constant integer, the pointer must be declared as pointing to a const int to prevent modification.

2. Step 2: Analyze options

   int *p = &val; cannot assign const int* to int* (discards qualifiers). const int *p = &val; correctly declares pointer to const int. int *const p = &val; declares const pointer to int (type mismatch). int *p const = &val; invalid syntax.

3. Final Answer:

   const int *p = &val; -> Option B

4. Quick Check:

   Pointer to const int = const int *p [OK]

Hint: Use const int *p to point to constant int [OK]

Common Mistakes:

• Using int *p to point to const int
• Confusing const pointer and pointer to const
• Misplacing const keyword