Arrays, Strings and Pointers: Memory Basics, Pointer Arithmetic and Dynamic Memory (new/delete)

Why arrays and pointers matter

Arrays and pointers are core topics in C/C++ because they directly connect to how memory works.

• Arrays help store multiple values of same type under one name.
• Pointers allow programs to work efficiently with memory, arrays, strings, and dynamic data structures.

Understanding them early makes later OOP topics (dynamic objects, references, data structures) easier.

Arrays: definition and properties

An array is a collection of elements of the same data type stored in contiguous memory locations.

Key properties:

• fixed size (for normal/static arrays)
• indexing starts from 0
• fast random access using index

Example: int a[5]; stores 5 integers.

1D arrays: declaration, initialization and traversal

Declaration

• int a[5];

Initialization

• int a[5] = {1,2,3,4,5};
• partial initialization: int a[5] = {1,2}; (remaining become 0)

Traversal

Use a loop:

• for (int i=0; i<5; i++) cout << a[i];

2D arrays (matrix): basics and memory idea

A 2D array is like a table (rows × columns). Example: int m[3][4];

Access element:

• m[i][j]

Memory idea (simple):

• Stored row-wise (row-major order) in contiguous memory.

Array operations (common exam patterns)

Typical tasks:

• find maximum/minimum
• sum and average
• searching (linear search)
• counting occurrences

In exams, always mention:

• loop, condition, update

Strings in C++: C-style vs std::string (overview)

There are two common string forms:

1. C-style string: character array ending with a null character \0

• Example: char name[20] = "Amar";

2. std::string (C++ string class)

• Example: string s = "Hello";

For Sem 1 exams, you must understand C-style strings basics because they are pointer-related.

C-style strings: '\0' and common functions

A C-style string ends with null character \0 which marks the end.

Common string functions (from <cstring>):

• strlen(s) → length
• strcpy(dest, src) → copy
• strcat(dest, src) → concatenate
• strcmp(a,b) → compare

Important note: these functions assume proper null-terminated arrays and enough space.

Pointers: meaning and declaration

A pointer is a variable that stores the address of another variable.

Declaration:

• int *p; → pointer to int

Initialization:

• int x = 10; int *p = &x;

Address-of (&) and dereference (*)

• &x gives address of x.
• *p gives the value stored at address in p (dereference).

Example:

• if p = &x, then *p is the value of x.

Pointer arithmetic (what it means)

Pointer arithmetic means moving the pointer to the next/previous memory location of the same type.

If p is int*:

• p + 1 moves by sizeof(int) bytes (not by 1 byte).

This is why pointer arithmetic is closely related to arrays.

Pointers and arrays (relationship)

Key idea:

• The array name represents the address of the first element.

So:

• a is like &a[0]
• *(a + i) is same as a[i]

This equivalence is frequently asked.

Dynamic memory: new/delete (why and how)

Static arrays have fixed size known at compile time. Sometimes we need memory at runtime.

Dynamic memory allocation allows:

• creating arrays/objects whose size is decided during execution
• efficient memory usage

In C++:

• new allocates memory
• delete releases memory

Example:

• int *p = new int; (one integer)
• delete p;

Dynamic arrays: new[] / delete[]

For arrays:

• int *a = new int[n];
• delete[] a;

Important rule: use delete[] for memory allocated with new[].

Common bugs: dangling pointer, memory leak, wild pointer

These are high-scoring short notes.

• Wild pointer: uninitialized pointer (points to unknown location).
• Dangling pointer: pointer pointing to memory that has been freed.
• Memory leak: allocated memory not freed (program uses more memory over time).

To avoid:

• initialize pointers (e.g., nullptr)
• delete memory and set pointer to nullptr

Mini tables/flowcharts for exam answers

Array vs Pointer (quick)

Pointer operators

Dynamic memory workflow

Decide size at runtime → new/new[] → use memory → delete/delete[] → set pointer nullptr

Quick Recap (1-minute revision)

• Arrays store same-type values in contiguous memory.
• 1D/2D arrays use indexing starting at 0.
• C-style strings end with '\0'; strlen/strcpy/strcmp are common.
• Pointer stores an address; & gets address and * gets value.
• Pointer arithmetic moves by sizeof(type).
• Dynamic memory uses new/delete (and new[]/delete[]).
• Watch for wild pointers, dangling pointers and memory leaks.