Week 5 Pointers

In C++, a pointer is a variable that stores the memory address of another variable. Pointers are a
powerful feature of the C++ programming language that allow for direct memory management,
dynamic memory allocation, and efficient array manipulation, among other things. Here’s a detailed
breakdown of pointers in C++:

1. Basic Concept of Pointers

• Memory Address: Every variable in C++ is stored at a specific location in memory, which
is identified by its memory address.
• Pointer Declaration: A pointer variable is declared using the asterisk (*) symbol. The type
of the pointer must match the type of the variable it points to.

Example:
int x = 10; // An integer variable
int* ptr = &x; // A pointer to an integer, initialized with the address of x
In this example:
• ptr is a pointer variable that holds the address of the integer variable x.
• The & operator is used to obtain the address of x.

2. Dereferencing Pointers
• To access or manipulate the value at the address stored in a pointer, you use the dereference
operator (*).

Example:
std::cout << *ptr; // Outputs: 10 (the value of x)
*ptr = 20; // Changes the value of x to 20
std::cout << x; // Outputs: 20

3. Pointer Types
• Null Pointer: A pointer that does not point to any valid memory location. It can be declared
using nullptr in C++11 and later.
int* p = nullptr;

• Dangling Pointer: A pointer that points to a memory location that has been deallocated or
freed. Accessing it can lead to undefined behavior.
• Void Pointer: A pointer that can point to any data type, but it must be cast to another pointer
type before use.
void* ptr; // Can point to any data type
4. Dynamic Memory Allocation
Pointers are essential for dynamic memory management, allowing the allocation of memory during
runtime using operators like new and delete.

Example:
int* arr = new int[5]; // Dynamically allocate an array of 5 integers
delete[] arr; // Free the allocated memory

5. Function Pointers
Pointers can also be used to point to functions, allowing for dynamic function calls and callback
mechanisms.

Example:
void myFunction() {
std::cout << "Hello, World!";
}

void (*funcPtr)() = &myFunction; // Pointer to a function

funcPtr(); // Calls myFunction

6. Pointer Arithmetic
Pointers can be incremented or decremented, which moves the pointer to the next or previous
memory address based on the data type size.

Example:
int arr[] = {10, 20, 30};
int* ptr = arr; // Points to the first element
ptr++; // Now points to the second element (20)
std::cout << *ptr; // Outputs: 20

Summary
Pointers are a fundamental part of C++ that provide a way to directly manage memory, work with
dynamic data structures, and enhance performance. While they offer powerful capabilities, they also
require careful management to avoid common pitfalls such as memory leaks and dangling pointers.
Understanding how to use pointers effectively is crucial for mastering C++ programming.

Why Pointers?

Pointers are a fundamental concept in C++ (and many other programming languages) that provide
several advantages and capabilities. Here are some key reasons why pointers are used:
1. Direct Memory Access
• Efficiency: Pointers allow direct access to memory addresses, which can lead to faster data
manipulation and retrieval. This is particularly important in performance-critical
applications.
• Low-Level Programming: Pointers are essential for low-level programming tasks, such as
system programming, where control over memory is crucial.

2. Dynamic Memory Management

• Dynamic Allocation: Pointers enable dynamic memory allocation, allowing developers to
allocate memory at runtime using new and deallocate it using delete. This is useful for
applications where the size of data structures is not known at compile time.
int* arr = new int[n]; // Allocate an array of n integers
delete[] arr; // Free the allocated memory

3. Efficient Array and String Manipulation

• Array Handling: Pointers are often used to work with arrays, as they provide a way to
traverse and manipulate array elements without creating copies. The name of an array acts as
a pointer to its first element.
int arr[] = {1, 2, 3, 4};
int* ptr = arr; // ptr points to the first element of arr

• Strings as Arrays: C-style strings are represented as arrays of characters. Pointers allow for
efficient string manipulation.

4. Function Arguments
• Pass by Reference: Pointers allow functions to modify variables defined outside their
scope. By passing a pointer to a function, you can allow that function to change the value of
the original variable.
void modify(int* p) {
*p = 20; // Modify the value at the address p points to
}

int x = 10;
modify(&x); // Pass the address of x

5. Data Structures
• Dynamic Data Structures: Pointers are fundamental for implementing dynamic data
structures such as linked lists, trees, graphs, and other complex data structures. They enable
the creation of flexible structures that can grow and shrink during runtime.
struct Node {
int data;
Node* next; // Pointer to the next node
};
6. Function Pointers and Callbacks
• Flexibility: Pointers can be used to point to functions, allowing for dynamic function calls
and implementing callback mechanisms. This can be particularly useful in event-driven
programming and implementing polymorphism.
void (*funcPtr)() = &myFunction; // Pointer to a function
funcPtr(); // Calls myFunction

7. Memory Management
• Resource Management: Pointers give developers control over resource management. You
can allocate and deallocate memory as needed, making your application more efficient in
terms of memory usage.

8. Overcoming Limitations of Variables

• Large Data Structures: When passing large data structures (like large arrays or structures)
to functions, pointers can be used to avoid copying the entire data structure, thus saving
memory and time.

Conclusion
Pointers provide significant power and flexibility in C++, enabling efficient memory management,
direct data manipulation, and the ability to implement complex data structures. However, they
require careful handling to avoid issues like memory leaks, dangling pointers, and segmentation
faults. Mastering pointers is essential for effective C++ programming and for working with
systems-level programming.

Given a code snippet for pointer operations as such in slide 4,

show the values or states of the memory locations
Explanation of Your Code
Let’s break down the key parts of your code:
void modify(int* p) {
*p = 20; // Modify the value at the address p points to
cout << p << " " << *p << " " << &p << endl; // Print p, *p, and &p
}

int main() {
int x = 10;
modify(&x); // Pass the address of x
}

What Happens
1. Inside main():

• You declare an integer x and initialize it to 10.

 • You call modify(&x), which passes the address of x to the function modify. This
means that p now holds the address of x.
2. Inside modify(int* p):

• p is a pointer variable that now points to the address of x.

• The line *p = 20; modifies the value of x to 20.
3. Output Explained:
• cout << p: This outputs the address of x (the value stored in p).
• cout << *p: This outputs the value at the address p points to (which is now 20, as
you modified it).
• cout << &p: This outputs the address of the pointer variable p itself (where p is
stored in memory).

Why Are the Addresses Different?

• p is the pointer itself, and it contains the address of x.
• &p is the address of the pointer variable p, which is a separate variable that holds the
address of x.

Because p is a local variable within the function modify, it is stored at a different memory
location than x. Therefore, p and &p will show different addresses:

• p: Address of x (the value passed to the function).

• &p: Address of the pointer variable p itself (local to the function).

Example Output
If x is located at memory address 0x7ffee8cabc5c, you might see output similar to this (the
actual addresses will vary):
0x7ffee8cabc5c 20 0x7ffee8cabc60

Here, 0x7ffee8cabc5c is the address of x, 20 is the value of x after modification, and

0x7ffee8cabc60 is the address of the pointer variable p within the modify function.

Conclusion
The different addresses for p and &p are a natural result of how pointers work in C++. Pointers hold
addresses, while &p refers to the location in memory where the pointer variable itself is stored. This
is an important concept to understand when working with pointers in C++.

Discuss passing an argument by reference using pointer in C++

• The name of an array is actually a pointer to the first element in the array. Therefore,
myArray[2] is *(myArray + 2)
 • This explains why arrays are always passed by reference: passing an array is just passing a
pointer
• This also explains why C/C++ array indices start at 0: the first element of an array is the
element that is 0 away from the start of the array
Passing large objects or arrays by reference without copying data
void modifyValue(int* ptr) {
*ptr = 100; // Modifies the original value
}

int main() {
int x = 10;
modifyValue(&x); // Passing the address of 'x'
cout << x; // Outputs: 100
}

What could be the values of different variables for different

operations as discussed in slide 17
Let's break down each scenario step-by-step to explain the behavior of pointers, character arrays,
and pointer arithmetic in C/C++. The code involves operations on a character array (p[]) and a
pointer (q), along with pre- and post-increment operators.

Given:
char p[] = "XAD"; // p points to the character array with values 'X', 'A', 'D', '\0'
char *q = p; // q is a pointer that initially points to the first character of the array p
char c;

Here's a table summarizing the behavior of each expression, showing how c, p, and q change based
on the operations:

Pointer q
Value Value
Expression (after Explanation
of c of p
operation)
*q points to p[0] ('X'), ++*q increments 'X' to
q = p (points
c = ++*q; 'Y' "YAD" 'Y', and c is assigned the new value 'Y'. Pointer q
to 'Y')
still points to the first character.
++q moves q to the second character (p[1], 'A'),
q = p + 1
and *q dereferences it to get 'A', which is then
c = *++q; 'A' "YAD" (points to
assigned to c. Pointer q now points to the second
'A')
character.
*q retrieves the value at p[0] ('Y'), and q++
q = p + 1
moves the pointer to the second character (p[1]).
c = *q++; 'Y' "YAD" (points to
The value 'Y' is assigned to c, and q now points to
'A')
the second character.
c= (*q)++; 'Y' "ZAD" q = p (points *q retrieves the value at p[0] ('Y'), and (*q)++
to 'Z') increments the value at p[0] from 'Y' to 'Z'. The
value 'Y' is assigned to c, and q still points to the
 Pointer q
Value Value
Expression (after Explanation
of c of p
operation)
first character, now 'Z'.

Explanation Recap:

Case 1: c = ++*q;
• Expression Breakdown:
1. *q dereferences the pointer q, which initially points to the first character of p (i.e.,
'X').
2. ++*q increments the value pointed to by q ('X'), changing it to 'Y'. So, the
content of p[0] becomes 'Y'.
3. The updated value 'Y' is then assigned to c.
• Result:
1. c = 'Y': The first character of p (which was 'X') has been incremented to 'Y',
and c stores this updated value.
2. p = "YAD": The array p[] now contains "YAD", as the first element was
modified.
3. q = p: The pointer q still points to the first character of the array, which is now
'Y'.

Case 2: c = *++q;
• Expression Breakdown:
1. ++q increments the pointer q, moving it from the first character (p[0], which is
'Y') to the second character (p[1], which is 'A').
2. *q dereferences the updated pointer q, so it retrieves the value at p[1], which is
'A'.
3. The value 'A' is then assigned to c.
• Result:
1. c = 'A': The second character of the array (p[1]) is 'A', and this value is stored
in c.
2. p = "YAD": The array p[] remains unchanged as no modification to the contents
occurred.
3. q = p + 1: After the ++q operation, q now points to p[1], which is 'A'.
Case 3: c = *q++;
• Expression Breakdown:
1. *q dereferences the pointer q, which is currently pointing to p[0] (the first
character, 'Y' after the previous case).
2. The value 'Y' is fetched and stored in c.
3. The pointer q is then incremented by ++, so it moves from p[0] to p[1] (from the
first to the second character, 'A').
• Result:
1. c = 'Y': The character 'Y' (from p[0]) is stored in c before the pointer q is
incremented.
2. p = "YAD": The array p[] remains unchanged.
3. q = p + 1: After the q++ operation, q now points to p[1], which is 'A'.

Case 4: c = (*q)++;
• Expression Breakdown:
1. *q dereferences the pointer q, which is currently pointing to p[0] (the first
character, 'Y' after the first case).
2. (*q)++ increments the value at p[0], changing it from 'Y' to 'Z'.
3. The original value 'Y' is returned and assigned to c, before the increment operation
occurs.
• Result:
1. c = 'Y': The value 'Y' (from p[0]) is stored in c before the post-increment
modifies it.
2. p = "ZAD": The first character of the array (p[0]) is incremented from 'Y' to
'Z', so the array becomes "ZAD".
3. q = p: The pointer q still points to the first character of the array, which is now
'Z'.

Detailed Explanation:
1. Pre-increment (++) and Dereference (*) are both unary operators and belong to the
same precedence level. The precedence table groups them together, but their associativity
is what determines the order of evaluation in complex expressions.
2. Associativity for these unary operators (pre-increment, dereference, address-of, etc.) is
right-to-left. This means that when you have multiple unary operators (like ++*q), the
operator closest to the operand (*q) is evaluated first, followed by the pre-increment.

3. Post-increment (q++), on the other hand, has a higher precedence than both pre-
increment (++q) and dereferencing (*). This means that post-increment will always be
applied before dereferencing if both are present in the same expression.
Operator Precedence and Associativity Summary:
Let’s look at the relevant section of the precedence table again:

Precedence Operators Associativity

1 (highest) () Left-to-right
2 ++ (post), -- (post) Left-to-right
3 ++ (pre), -- (pre), *, &, +, -, ! Right-to-left

How It Works in Practice:

Let's clarify using specific examples:
1. c = ++*q;

• The expression ++*q has *q evaluated first because of right-to-left associativity

for the unary operators.
• Then, the ++ is applied to the value pointed to by q (the dereferenced value).
2. c = *q++;

• The q++ is evaluated first because post-increment (++) has a higher precedence
than dereferencing (*).
• After q++ is evaluated, * is applied to the old value of q (before incrementing).
3. c = *++q;

• Since ++ (pre-increment) and * (dereference) have the same precedence but right-
to-left associativity, ++q is evaluated first, updating the pointer q to point to the
next element.
• Then, * is applied to the new value of q.

Final Answer:
• Pre-increment (++) and Dereference (*) have the same precedence.
• The associativity of unary operators (++, *, etc.) is right-to-left, which determines the
order in complex expressions like ++*q.
• Post-increment (q++) has higher precedence than both, so it is evaluated before the
dereference.
I hope this clears up the confusion!

Review the code examples in slide 19, 20, 21

Example:
char amsg[] = "now is the time"; // amsg is a constant address, pointing to an array
char* pmsg = "now is the time"; // pmsg is a pointer to a string literal

amsg++; // INVALID, you cannot change the base address of an array

pmsg++; // VALID, pmsg can point to the next character in the string literal
In C++, the reason why the statement amsg++ results in a compiler error while pmsg++ is allowed
has to do with the types of amsg and pmsg and how they are treated in memory. Let’s break it
down:
1. Array (amsg[]) vs. Pointer (char* pmsg)
a) amsg[] (Array):
• When you declare char amsg[] = "now is the time";, you are creating a
character array that holds a copy of the string "now is the time".

• amsg is not a pointer, but the name of an array. In C++, the name of an array behaves like
a constant pointer to the first element of the array, but it cannot be modified. You can think
of amsg as a fixed address (constant), which always points to the first element of the array.

• Important: You cannot change where amsg points because array names are constant
addresses, and trying to do amsg++ is like attempting to modify the address of the
array itself, which is illegal.

b) pmsg (Pointer):
• When you declare char* pmsg = "now is the time";, pmsg is a pointer that
points to a string literal.
• A pointer variable is allowed to change where it points (i.e., it can be incremented or
reassigned).
• So, pmsg++ is valid because you're simply modifying the pointer to point to the next
character in the string literal.
• Important: Although pmsg++ is valid (you can increment the pointer), be aware
that modifying the string literal through the pointer (e.g., *pmsg = 'X') would
result in undefined behavior because string literals are stored in read-only memory
in most C++ implementations.

2. Why amsg++ is Invalid:

• amsg[] is an array. When you declare an array, its name (like amsg) represents the
starting address of the array, and this address is constant.
• You cannot change the base address of the array by incrementing amsg. The expression
amsg++ tries to change the address of amsg, which is not allowed because the array name
is not a modifiable lvalue (it’s essentially a constant pointer).

3. Why pmsg++ is Valid:

• pmsg is a pointer. Unlike an array name, a pointer can be incremented or decremented
because it’s a variable holding an address.
• pmsg++ simply moves the pointer to the next memory location (the next character in the
string "now is the time"), which is legal and allowed in C++.

Conclusion:
• amsg[] is an array, and its name represents a fixed, constant address, which cannot be
modified, making amsg++ illegal.
• pmsg is a pointer, and pointers are modifiable, so pmsg++ is valid as it changes the
address stored in pmsg to point to the next character in the string.
Example: Explain the Error
int a[4] = { 1, 4, 7, 9 };
*a = 3;
*(a + 1) = 4;
*++a = 4; //compiler error
Let's break this down step by step for each of the expressions involving the array a in your
example, explaining why the first two are valid and why the third one results in a compiler error.

Array Initialization:
int a[4] = {1, 4, 7, 9}; // 'a' is an array of 4 integers: {1, 4, 7, 9}
Here, a is an array of integers, with the values {1, 4, 7, 9} stored in contiguous memory
locations. The name a is a constant pointer to the first element of the array, i.e., a == &a[0].
However, since a is an array, the base address a itself cannot be changed.

1. *a = 3;
This expression is valid.
• What happens?
• The expression *a dereferences the array a, which points to the first element of the
array (a[0]).
• So, *a refers to the first element of the array (a[0]), which currently holds the
value 1.
• The assignment *a = 3; changes the value of a[0] to 3.
• Step-by-step explanation:
• a is the base address of the array, pointing to the first element (a[0]).
• *a dereferences this pointer, accessing a[0].
• The assignment *a = 3; changes the value at a[0] to 3.
After this, the array looks like this: {3, 4, 7, 9}.

2. *(a + 1) = 4;
This expression is also valid.
• What happens?
• The expression a + 1 moves the pointer a to point to the second element of the
array (a[1]).
• *(a + 1) dereferences this new pointer, accessing the value at a[1] (which is
currently 4).
• The assignment *(a + 1) = 4; assigns the value 4 to a[1], which is already 4,
so it doesn’t actually change the array in this case.
• Step-by-step explanation:
• a is the base address of the array (a == &a[0]).
 • a + 1 is pointer arithmetic that moves the pointer a to point to the second element
of the array (a[1]).
• *(a + 1) dereferences this new pointer, accessing the value at a[1].
• The assignment *(a + 1) = 4; assigns the value 4 to a[1].

After this operation, the array remains the same: {3, 4, 7, 9}.

3. *++a = 4;
This expression is invalid, and it results in a compiler error.
• Why?
• The issue here is that a is an array name, and as such, it behaves like a constant
pointer to the first element of the array. The base address of the array cannot be
changed.
• ++a attempts to increment the pointer a, which is not allowed because a is not a
regular pointer but a constant array address.
• Step-by-step explanation:
• ++a is trying to increment the array name a. This operation attempts to change the
base address of the array, which is illegal because a is a constant pointer.
• You cannot change the base address of an array, so this operation results in a
compiler error.
The error occurs because a is not a modifiable lvalue; it cannot be incremented or assigned a
new address.

Summary of Why Each Statement Behaves Differently:

1. *a = 3; is valid because a is implicitly treated as a pointer to the first element of the array
(a[0]), and you can modify the value stored at this location.
2. *(a + 1) = 4; is valid because a + 1 is pointer arithmetic, which results in a pointer
to a[1], and dereferencing it allows you to modify the value stored at a[1].
3. *++a = 4; is invalid because a is an array, and you cannot modify its base address. The
increment operation (++a) tries to change the constant pointer, which is illegal in C+

Takeaway:
• Array names (a) are constant pointers to the first element of the array, and you cannot
change the address they represent. Therefore, operations like ++a or a++ are illegal.
• You can perform pointer arithmetic on pointers, but not on array names.

Code:
int* p = (int*)malloc(8); // Allocating 8 bytes of memory
*p = 5;
std::cout << p[0] << std::endl; // prints 5
*++p = 9;
std::cout << p[1] << std::endl; // prints garbage
std::cout << p[0] << std::endl; // prints 9
free(p - 1); // freeing memory
Step-by-Step Explanation:
1. int* p = (int*)malloc(8);
• What happens:
• You allocate 8 bytes of memory using malloc. Since an int typically takes
4 bytes on most systems, this means you're allocating enough space for two
integers.
• The return value of malloc(8) is a pointer to the first byte of the allocated
memory block.
• You cast the return value of malloc to int* because malloc returns a
void*, and you want p to be a pointer to an int.

• After this, p is pointing to the first element of this newly allocated memory
block.
• Memory Layout: The 8 bytes of memory are initialized to uninitialized
values (possibly garbage values).
• Memory Visualization:
p -> [??] [??]

2. *p = 5;
• What happens:
• The dereferencing of p (*p) accesses the first element of the allocated memory block
(the first int), and you assign it the value 5.
• Now, the first 4 bytes of the allocated memory hold the value 5.
• Memory Visualization:
p -> [5] [??]

3. std::cout << p[0] << std::endl; // prints 5

• What happens:
• p[0] is the same as *p, which accesses the first element of the memory block,
which is currently 5.
• Therefore, 5 is printed.
• Memory Visualization:
p -> [5] [??]

4. *++p = 9;
• What happens:
• ++p increments the pointer p, so p now points to the second element of the
allocated memory block.
• Now, p no longer points to the first element but to the second element in memory.
• After incrementing p, the dereference *p now refers to the second element.
 • The assignment *p = 9 places the value 9 into the second element of the memory
block.
• Memory Visualization:
(p - 1) -> [5] [9]
p -> [9]
• Important Note: Now that p points to the second element, the original base address of the
allocated memory block is lost. This is important when you eventually need to free the
memory.

6. std::cout << p[1] << std::endl; // prints garbage

What happens:
• p[1] is the same as *(p + 1). Since p now points to the second element of the memory
block, p[1] refers to memory beyond the allocated block.
• You only allocated 8 bytes of memory (enough for two int values). Accessing p[1] (the
memory after the two allocated ints) leads to undefined behavior, which is why garbage is
printed.
• The program prints some garbage value because you're reading uninitialized or invalid
memory beyond the allocated block.
7. std::cout << p[0] << std::endl; // prints 9
What happens:
• p[0] refers to the memory currently pointed to by p, which is the second element of the
memory block.
• The value at this location is 9, so the program prints 9.
Memory Visualization:
(p - 1) -> [5] [9]
p -> [9]

7. free(p - 1); // freeing memory

• What happens:
• p - 1 moves p back to its original position (the base of the allocated
memory block).
• You are calling free on the original address of the allocated block, which is
correct because malloc returns a pointer to the start of the memory block,
and free must be called on that same address.
• If you had called free(p) directly (without the p - 1 adjustment), it
would lead to undefined behavior since p no longer points to the original base
of the memory block.
• By doing free(p - 1), you correctly free the memory.
Key Points to Note:
• Pointer Arithmetic: ++p shifts p to point to the next integer in the allocated memory block.
After ++p, p no longer points to the base of the block.
• Dereferencing after Increment: After ++p, *p modifies the second element in memory.
• Out-of-Bounds Access: When you do p[1] after incrementing p, you're accessing memory
beyond the allocated block, leading to undefined behavior (printing garbage).
• Memory Deallocation: Since p no longer points to the original base of the memory block,
you need to adjust the pointer before calling free, which is why free(p - 1) is used.

By carefully tracking where p points, you avoid accessing memory out of bounds or freeing the
wrong address.