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

Q: Differentiate between C-style string and std::string (brief).

**C-style string** is a `char` array ending with **'\0'** and often uses ` ` functions like `strlen`. **std::string** is a C++ class that manages memory automatically and supports easy operations like concatenation and length using methods. C-style strings need careful size handling; std::string is safer.

Question 1

Define array.

Accepted Answer

An **array** is a collection of same-type elements stored in **contiguous memory locations**.

Question 2

What is the index of first element in C++ array?

Accepted Answer

The first index is **0**.

Question 3

What is a pointer?

Accepted Answer

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

Question 4

What is a C-style string?

Accepted Answer

A **C-style string** is a character array terminated by **'\0'**.

Question 5

What does `delete[]` do?

Accepted Answer

`delete[]` releases memory allocated using **new[]** (dynamic arrays).

Question 6

Define dangling pointer.

Accepted Answer

A **dangling pointer** points to memory that has already been freed.

Question 7

Explain 1D array declaration and traversal with example.

Accepted Answer

A **1D array** stores multiple values of the same type.
Declaration: `int a[5];`
Initialization: `int a[5]={1,2,3,4,5};`
Traversal uses a loop: `for(i=0;i<5;i++) cout<<a[i];`

Because elements are contiguous, indexing is fast.

Question 8

Differentiate between C-style string and std::string (brief).

Accepted Answer

**C-style string** is a `char` array ending with **'\0'** and often uses `<cstring>` functions like `strlen`.
**std::string** is a C++ class that manages memory automatically and supports easy operations like concatenation and length using methods.

C-style strings need careful size handling; std::string is safer.

Question 9

Explain & and * operators in pointers.

Accepted Answer

`&` (address-of) gives address of a variable, e.g., `p=&x`.
`*` (dereference) accesses value at address stored in pointer, e.g., `y=*p`.

They are fundamental for pointer usage.

Question 10

Explain pointer arithmetic in simple terms.

Accepted Answer

Pointer arithmetic moves the pointer by the size of its type. If `p` is `int*`, then `p+1` moves by **sizeof(int)** bytes to the next integer location.

This is why `a[i]` is equivalent to `*(a+i)`.

Question 11

What is dynamic memory allocation? Mention one advantage.

Accepted Answer

**Dynamic memory allocation** allocates memory at **runtime** using **new** and frees it using **delete**.
Advantage: size can be decided during execution (e.g., `new int[n]`), so memory is used more efficiently.

Question 12

Write short note on memory leak and how to avoid it.

Accepted Answer

A **memory leak** occurs when allocated memory is not freed (missing `delete/delete[]`). Over time, program consumes more memory.
Avoid by always releasing dynamic memory and setting pointers to **nullptr** after delete.

Question 13

Explain pointers in C++ with address and dereference using a table/diagram.

Accepted Answer

### **Explain pointers in C++ with address and dereference (with diagram/table)**

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

**Key operators**:
- **Address-of (`&`)**: gives the address of a variable.
- **Dereference (`*`)**: gives the value stored at that address.

Example idea:
- `int x = 10;`
- `int *p = &x;`  (p stores address of x)
- `*p` gives 10

| Symbol | Meaning | Example |
|---|---|---|
| `&` | address-of | `p = &x` |
| `*` | dereference | `y = *p` |

```text
x (value=10) stored at some address, say 1000
p stores 1000
*p reads value at 1000 → 10
```

Thus pointers help programs access and manipulate memory efficiently.

Question 14

Explain pointer arithmetic and the relation between arrays and pointers with a table/flow.

Accepted Answer

### **Explain pointer arithmetic and relation between arrays and pointers**

**Pointer arithmetic** means moving a pointer to the next/previous element of the same type.

If `p` is `int*`:
- `p + 1` moves by **sizeof(int)** bytes (not 1 byte).

**Arrays and pointers relation**:
- Array name `a` represents the address of the first element: **`a == &a[0]`**.
- Indexing is equivalent to pointer form:
  - `a[i]` is same as `*(a + i)`

| Expression | Meaning |
|---|---|
| `a` | address of first element |
| `a[i]` | ith element |
| `*(a+i)` | ith element (pointer form) |

```text
a → [a0][a1][a2][a3]...
     ^
   a+0, a+1, a+2 ...
```

So pointer arithmetic is the reason array indexing works.

Question 15

Explain dynamic memory allocation using new/delete (and new[]/delete[]) with steps.

Accepted Answer

### **Explain dynamic memory allocation using new/delete (with steps)**

**Dynamic memory allocation** allocates memory at **runtime** (when size is known during execution).

**For a single variable**:
- `int *p = new int;`
- use `*p`
- `delete p;`

**For an array**:
- `int *a = new int[n];`
- use `a[i]`
- `delete[] a;`

**Common mistakes**:
- forgetting `delete` → **memory leak**
- using pointer after delete → **dangling pointer**

```text
Input n → new int[n] → use array → delete[] → set pointer = nullptr
```

Therefore, `new/delete` allow flexible memory usage, but require careful cleanup.

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

8 more questions to unlock