<!--
Abstract:

CS 211
Computer Architecture
Lecture 04: Memory and Variable Size Arrays
-->

# CS 211 - Lecture 05 - Dynamic Memory and Debugging

Bernhard Firner

2026-02-04

---

## Review!

* Variable Length Arrays (VLAs)
* Dynamic memory allocation
* Heap Vs Stack memory

---

## Example

```C
/*
 * Stack Vs Heap example
 */

#include <stdio.h>
#include <stdlib.h>

void a() {
    unsigned char stack_memory[16];
    unsigned char *heap_memory = calloc(16, sizeof(unsigned char));

printf("a stack memory is %p\n", stack_memory);
    printf("a heap memory is %p\n", heap_memory);
    free(heap_memory);

return;
}

void b() {
    unsigned char stack_memory[16];
    unsigned char *heap_memory = calloc(16, sizeof(unsigned char));

printf("b stack memory is %p\n", stack_memory);
    printf("b heap memory is %p\n", heap_memory);

a();

free(heap_memory);

return;
}

void c() {
    unsigned char stack_memory[16];
    unsigned char *heap_memory = calloc(16, sizeof(unsigned char));

printf("c stack memory is %p\n", stack_memory);
    printf("c heap memory is %p\n", heap_memory);

b();

free(heap_memory);

return;
}

void d() {
    unsigned char stack_memory[16];
    unsigned char *heap_memory = calloc(16, sizeof(unsigned char));

printf("d stack memory is %p\n", stack_memory);
    printf("d heap memory is %p\n", heap_memory);

c();

free(heap_memory);

return;
}

int main(void) {
    d();
    return 0;
}
```

---

## Example Output

* Example values not guaranteed, direction is consistent

<pre>
$ ./a.out
d stack memory is 0x7ffc2eceb250
d heap memory is 0x55d2ddab12a0
c stack memory is 0x7ffc2eceb210
c heap memory is 0x55d2ddab16d0
b stack memory is 0x7ffc2eceb1d0
b heap memory is 0x55d2ddab16f0
a stack memory is 0x7ffc2eceb190
a heap memory is 0x55d2ddab1710
</pre>

---

## Unwinding

* When a function returns, its memory is released
  * Called unwinding because functions call functions call functions...
* Fast, efficient, and automatic
  * Stack memory is a **last in, first out**
  * Each function's memory is "on top of" the last one
    * We can unwind without checking anything but the current function
* In our example, `a` unwinds first, then `b`, `c`, `d`, and `main`

---

## Stack Overflows

* If you call enough functions, and they use enough memory, you can run out
* This is called a **stack overflow**
* Think of the **stack** as an array of fixed size that the compiler sets aside
  * Normally sufficient
  * Strange function calling patterns will cause problems

---

## Types of Arrays

* [https://cppreference.com/w/c/language/array.html](https://cppreference.com/w/c/language/array.html)
* Three types:
  * Known constant size
  * Variable length
  * Unknown size

---

## Constant size arrays

```C
#include <stdio.h>
#include <stdbool.h>

void print_array(bool array[10]) {
    for (int i = 0; i < 10; ++i) {
        printf("%i: %i\n", i, array[i]);
    }
}

int main(int argc, char** argv) {
    {
        // This has a fixed size
        bool bool_array[10];
        print_array(bool_array);
    }
    {
        // We could initialize with a set of values
        bool bool_array[] = {false, false, false, false, false,
                             true, true, true, true, true};
        print_array(bool_array);
    }
    {
        // Or we could just set some values
        bool bool_array[10] = {false, false, true};
        print_array(bool_array);
    }
    return 0;
}
```

---

## Initialization

* Any initialization will force C to initialize all elements with a default
* But initialization like this is only available with constant size arrays
  * Once we use a VLA, the compiler does not know what initialization is safe

---

## Initialization and VLAs

* This is okay for a fixed size array:
  * `bool not_prime[101] = {true, true};`
* Not okay for a VLA
  * `bool not_prime[atoi(argv[1])] = {true, true};`
  * We don't know if there are two elements, so the compiler objects

---

## Initialization and VLAs

* You can initialize no elements, which will clear the memory
  * `bool not_prime[atoi(argv[1])] = {};`
* Or you can use a loop to set particular values:

```C
    for (int i = 2; i < size; ++i) {
        not_prime[i] = false;
    }
```

---

## VLA Sieve

```C
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int main(int argc, char** argv) {
    if (argc < 2) {
        printf("Please provide a number!\n");
        return 0;
    }
    unsigned int size = atoi(argv[1]);
    // Find and print the primes to 100
    bool not_prime[size] = {};
    not_prime[0] = true;
    not_prime[1] = true;
    // We need to initialize the rest ourselves
    for (int i = 2; i < size; ++i) {
        not_prime[i] = false;
    }

// Loop over all numbers to 100
    for (int i = 2; i < size; ++i) {
        // Loop over all multiples of any prime numbers
        if (!not_prime[i]) {
            // Mark all multiples as not prime
            for (int j = 2*i; j < size; j+=i) {
                not_prime[j] = true;
            }
        }
    }

// Print the primes
    for (int i = 0; i < size; ++i) {
        if (!not_prime[i]) {
            printf("%i is prime.\n", i);
        }
    }

return 0;
}
```

---

## Returning Arrays

* Ideally, the sieve code should go into a function
* What would that look like?
  * Probably something like: `int* sieve(size_t max)`
* But we cannot return stack memory; how will make memory for the primes?

---

## `malloc`, `calloc`, and `free`

* **Dynamically allocate** memory on the **heap**
  * This memory does *not* go out of scope
* In `stdlib.h`
  * Read the **man** pages
* Joined by `realloc` and `reallocarray`
  * Which you should avoid unless you know what you are doing

```C
void *malloc(size_t size);
void free(void *_Nullable ptr);
void *calloc(size_t nmemb, size_t size);
```

---

## `malloc` and `calloc`

```C
void *malloc(size_t size);
void *calloc(size_t nmemb, size_t size);
```

* `malloc` allocates `size` bytes
  * You need to do the math
  * Memory is not initialized
* `calloc` allocates `nmemb*size` bytes
  * Also sets it to 0
* Both return (void*), so you must assign the type correctly

---

## Failure

* Calloc and malloc can fail!!!!
  * If they do, they return `NULL`
    * Which is a special pointer value to indicate failure
  * Set `errno` (a special global number)

---

## `free`

```C
void free(void *_Nullable ptr);
```

* Gives the memory back
  * Tells the OS that you are done with it

---

## `free` Rules

```C
void free(void *_Nullable ptr);
```

* Only call `free` on memory that you allocate
  * e.g. from `malloc` and `calloc`
* Don't call it on the same memory twice
  * Your program will crash if you are lucky
* A lot of pointer documentation mentions "undefined behavior"
  * Just means that anything could happen

---

## Stack Vs Heap Memory

* `calloc` and `malloc` use memory on the heap
* Stack memory is more organized, and is kept separate
* In x86 (architecture we use)
    * Stack decreases from the top
    * Heap increases from the bottom

</div>
<div>

<table>
<tr><td>Higher</td><td><b>stack</b></td></tr>
<tr><td></td><td>$\big\downarrow$</td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td>$\big\uparrow$</td></tr>
<tr><td>Lower</td><td><b>heap</b></td></tr>
</table>

</div>
</div>

---

## Tracking Size

* Remember that these are called "unknown size" arrays
* All we have is a pointer
  * We'll have to track the array size ourselves
* But wait, if a function is going to return an array, how can it also return the size?

---

## Returning Multiple Values

* We want to have a function that returns multiple values
  * Something like: `unsigned int*, int sieve(size_t max)`
* But that isn't valid C
* There are two possible solutions

---

## Returning Multiple Values

* One solution involves something called **structs**
  * but let's save those for a another day
* We can also solve our problem with pointers
  * `unsigned int* sieve(size_t max, size_t* size)`

---

## Pointer Arguments

```C
#include <stdio.h>

int getTwo(size_t* a) {
    // I can return one value through 'a', and the other through a regular return.
    *a = 3;
    return 4;
}

int main(void) {
    size_t ret_a;
    size_t ret_b = getTwo(&ret_a);
    printf("The two values are %lu and %lu\n", ret_a, ret_b);
    return 0;
}

```

---

## What are arguments?

* Doesn't this mean that we don't need returns from functions?
  * All returns could be done through arguments, right?
* When we get to assembly, you'll see that there is no difference
  * Arguments to a function are either passed in special temporary variables or on the stack
  * Return values from functions are the same

---

## Updating Sieve

* Now let's update the sieve code
* This version will return discovered primes in a new array

---

## Our sieve

```C
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

unsigned long* sieve(size_t max, size_t *size) {
    bool not_prime[max] = {};
    not_prime[0] = true;
    not_prime[1] = true;
    // We need to initialize the rest ourselves
    for (int i = 2; i < max; ++i) {
        not_prime[i] = false;
    }

// Remember how many primes we have found.
    *size = 0;

// Loop over all numbers to 100
    for (int i = 2; i < max; ++i) {
        // Loop over all multiples of any prime numbers
        if (!not_prime[i]) {
            *size += 1;
            // Mark all multiples as not prime
            for (int j = 2*i; j < max; j+=i) {
                not_prime[j] = true;
            }
        }
    }

// Allocate memory for all of the primes
    unsigned long* primes = calloc(*size, sizeof(unsigned long));
    unsigned long* cur_prime = primes;
    int index = 0;
    for (int i = 0; i < max; ++i) {
        if (!not_prime[i]) {
            // V 1: Array access.
            //primes[index] = i;
            //++index;
            // V 2: Access with pointer syntax.
            //*(primes + index) = i;
            //++index;
            // V 3: Access with pointer syntax, and update the pointer location from the index.
            //*cur_prime = i;
            //++index;
            //cur_prime = primes + index;
            // V 4: Use the pointer as an iterator. An external index variable is not required.
            *cur_prime = i;
            ++cur_prime;
        }
    }
    return primes;
}

int main(int argc, char** argv) {
    if (argc < 2) {
        printf("Give me an argument!\n");
        return 1;
    }
    size_t max = atoi(argv[1]);
    if (max < 3) {
        printf("Give me a larger number!\n");
        return 1;
    }

size_t num_primes = 0;
    unsigned long* primes = sieve(max, &num_primes);

for (int i = 0; i < num_primes; ++i) {
        printf("%lu is prime.\n", primes[i]);
    }
    free(primes);
    return 0;
}
```

---

## Iterating vs Indexing

```C
// Allocate memory for all of the primes
unsigned long* primes = calloc(*size, sizeof(unsigned long));
unsigned long* cur_prime = primes;
int index = 0;
for (int i = 0; i < max; ++i) {
    if (!not_prime[i]) {
        // V 1: Array access.
        //primes[index] = i;
        //++index;
        // V 2: Access with pointer syntax.
        //*(primes + index) = i;
        //++index;
        // V 3: Access with pointer syntax, and update the pointer location from the index.
        //*cur_prime = i;
        //++index;
        //cur_prime = primes + index;
        // V 4: Use the pointer as an iterator. An external index variable is not required.
        *cur_prime = i;
        ++cur_prime;
    }
}
```

---

## Iterators

* Why use the iteration syntax?
  * It is sometimes simpler to remove the index variable
  * Often favored when writing recursive functions
* Not so vital for this class, just a good test to see if you understand pointers

---

## Debugging

* Let's talk about debugging
* We are using memory now, so things could go wrong
* Your binary executables may run into errors
  * Usually ends in program termination
* But we can also make memory mistakes, which won't even crash

---

## Finding Errors

* There are two useful tools
  * Valgrind
  * gdb

---

## Valgrind

* This tool checks for memory mistakes
  * Modifies any allocated memory so that it can be tracked
* Not all-knowing

---

## Flawed Sieve

```C[|61]
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// Remember how many primes we have found.
    *size = 0;

size_t num_primes = 0;
    unsigned long* primes = sieve(max, &num_primes);

for (int i = 0; i < num_primes; ++i) {
        printf("%lu is prime.\n", primes[i]);
    }
    return 0;
}
```

---

## Missing free

<pre>
$ valgrind ./sieve 10
==635231== Memcheck, a memory error detector
==635231== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
==635231== Using Valgrind-3.22.0 and LibVEX; rerun with -h for copyright info
==635231== Command: ./sieve 10
==635231== 
2 is prime.
3 is prime.
5 is prime.
7 is prime.
==635231== 
==635231== HEAP SUMMARY:
==635231==     in use at exit: 32 bytes in 1 blocks
==635231==   total heap usage: 2 allocs, 1 frees, 1,056 bytes allocated
==635231== 
==635231== LEAK SUMMARY:
==635231==    definitely lost: 32 bytes in 1 blocks
==635231==    indirectly lost: 0 bytes in 0 blocks
==635231==      possibly lost: 0 bytes in 0 blocks
==635231==    still reachable: 0 bytes in 0 blocks
==635231==         suppressed: 0 bytes in 0 blocks
==635231== Rerun with --leak-check=full to see details of leaked memory
==635231== 
==635231== For lists of detected and suppressed errors, rerun with: -s
==635231== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
</pre>

---

## Limitations

* valgrind is observational
  * So if your program has different behavior with different inputs, some problems may not be present
* So program testing requires a wide range of test inputs

---

## No Initialization

```C[|7-10]
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

unsigned long* sieve(size_t max, size_t *size) {
    bool not_prime[max];
    not_prime[0] = true;
    not_prime[1] = true;
    // We need to initialize the rest ourselves

// Remember how many primes we have found.
    *size = 0;

size_t num_primes = 0;
    unsigned long* primes = sieve(max, &num_primes);

for (int i = 0; i < num_primes; ++i) {
        printf("%lu is prime.\n", primes[i]);
    }
    free(primes);
    return 0;
}
```

---

## Debug Symbols

* We're going to add a new flag when compiling
  * gcc -g sieve.c -o sieve
* `-g` tells the compiling to leave in extra debugging information
* It will allow valgrind to give us code locations for an error
  
---

<pre>
$ valgrind ./sieve 10
==635381== Memcheck, a memory error detector
==635381== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
==635381== Using Valgrind-3.22.0 and LibVEX; rerun with -h for copyright info
==635381== Command: ./sieve 10
==635381== 
==635381== Conditional jump or move depends on uninitialised value(s)
==635381==    at 0x1092D0: sieve (sieve.c:18)
==635381==    by 0x109432: main (sieve.c:52)
==635381== 
==635381== Conditional jump or move depends on uninitialised value(s)
==635381==    at 0x10935D: sieve (sieve.c:32)
==635381==    by 0x109432: main (sieve.c:52)
==635381== 
2 is prime.
3 is prime.
5 is prime.
7 is prime.
==635381== 
==635381== HEAP SUMMARY:
==635381==     in use at exit: 0 bytes in 0 blocks
==635381==   total heap usage: 2 allocs, 2 frees, 1,056 bytes allocated
==635381== 
==635381== All heap blocks were freed -- no leaks are possible
==635381== 
==635381== Use --track-origins=yes to see where uninitialised values come from
==635381== For lists of detected and suppressed errors, rerun with: -s
==635381== ERROR SUMMARY: 8 errors from 2 contexts (suppressed: 0 from 0)
</pre>

---

## --track-origins=yes

<pre>
$ valgrind --track-origins=yes  ./sieve 10
==635391== Memcheck, a memory error detector
==635391== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
==635391== Using Valgrind-3.22.0 and LibVEX; rerun with -h for copyright info
==635391== Command: ./sieve 10
==635391== 
==635391== Conditional jump or move depends on uninitialised value(s)
==635391==    at 0x1092D0: sieve (sieve.c:18)
==635391==    by 0x109432: main (sieve.c:52)
==635391==  Uninitialised value was created by a stack allocation
==635391==    at 0x1091E9: sieve (sieve.c:6)
==635391== 
==635391== Conditional jump or move depends on uninitialised value(s)
==635391==    at 0x10935D: sieve (sieve.c:32)
==635391==    by 0x109432: main (sieve.c:52)
==635391==  Uninitialised value was created by a stack allocation
==635391==    at 0x1091E9: sieve (sieve.c:6)
</pre>

---

## Heap and Stack

* The VLA is using stack memory
* And valgrind checks both the stack and the heap
* Let's fix the initialization and see what valgrind has to say
  * `bool not_prime[max] = {};`

---

## Happy valgrind

<pre>
$ valgrind --track-origins=yes  ./sieve 10
==635455== Memcheck, a memory error detector
==635455== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
==635455== Using Valgrind-3.22.0 and LibVEX; rerun with -h for copyright info
==635455== Command: ./sieve 10
==635455== 
2 is prime.
3 is prime.
5 is prime.
7 is prime.
==635455== 
==635455== HEAP SUMMARY:
==635455==     in use at exit: 0 bytes in 0 blocks
==635455==   total heap usage: 2 allocs, 2 frees, 1,056 bytes allocated
==635455== 
==635455== All heap blocks were freed -- no leaks are possible
==635455== 
==635455== For lists of detected and suppressed errors, rerun with: -s
==635455== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
</pre>

---

## Using Valgrind

* You can run valgrind on any program
  * At worst, it costs you a few seconds

---

## Debugging crashes

* What if our program crashes?
  * Valgrind won't help us out
* The `-g` flag tells the compiler to leave information in the binary file
  * Associates compiled code to its source
  * It helped out Valgrind, but another tool can also use it

---

## gdb

* `gdb` (the gnu debugger) is a tool (like `gcc`)
* Launch a program through gdb to debug it:

<pre>
$ gcc -g sieve.c -o sieve
$ gdb sieve
GNU gdb (Ubuntu 15.0.50.20240403-0ubuntu1) 15.0.50.20240403-git
Copyright (C) 2024 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Type "show copying" and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<https://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
    <http://www.gnu.org/software/gdb/documentation/>.

For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from sieve...
(gdb)
</pre>

---

## Now What?

* `gdb` has a `help` command
* To run you program, use `run <arguments>`

---

## Example

<pre>
(gdb) run 10
Starting program: /home/bfirner/Documents/Teaching/teaching/CS211/lectures/sieve 10
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
2 is prime.
3 is prime.
5 is prime.
7 is prime.
[Inferior 1 (process 3037633) exited normally]
</pre>

---

## Breakpoints

* Let's examine our code as it executes

---

## Setting a breakpoint

<pre>
(gdb) break sieve.c:28
Breakpoint 1 at 0x55555555534f: file sieve.c, line 28.
(gdb) run 10
Starting program: /home/bfirner/Documents/Teaching/teaching/CS211/lectures/sieve 10
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Breakpoint 1, sieve (max=10, size=0x7fffffffe530) at sieve.c:28
28	    unsigned long* primes = calloc(*size, sizeof(unsigned long));
(gdb)
</pre>

---

## Inspection

* You can now inspect values

<pre>
(gdb) print primes
$4 = (unsigned long *) 0x555555557d90
(gdb) print *primes
$5 = 93824992235968
(gdb) print primes[0]
$6 = 93824992235968
(gdb) print max
$7 = 10
(gdb) print *size
$8 = 4
</pre>

---

## Stepping

* `primes` isn't actually set yet
  * The breakpoint stopped at the line of code, before it's happened
* We can advance by one line with the `step` command

---

## Stepping

<pre>
(gdb) step
__libc_calloc (n=3, elem_size=8) at ./malloc/malloc.c:3699
warning: 3699	./malloc/malloc.c: No such file or directory
(gdb) step
3709	in ./malloc/malloc.c
</pre>

* These steps are too small!
* And we don't have debugging symbols in malloc.c!
* Use `finish` to get out
* Or continue to let the program run

<pre>
(gdb) finish
Run till exit from #0  __libc_calloc (n=4, elem_size=8) at ./malloc/malloc.c:3699
0x0000555555555363 in sieve (max=10, size=0x7fffffffe530) at sieve.c:28
28	    unsigned long* primes = calloc(*size, sizeof(unsigned long));
Value returned is $9 = (void *) 0x5555555592a0
(gdb) print primes
$10 = (unsigned long *) 0x555555557d90
</pre>

---

## Examination

* You can see what functions have been called with `bt` (for backtrace)

<pre>
(gdb) bt
#0  sieve (max=10, size=0x7fffffffe0e0) at sieve.c:28
#1  0x000055555555529b in main (argc=2, argv=0x7fffffffe228) at sieve.c:21
</pre>

* Not very deep
* `frame` will print your current line

---

## Going up and down

* `up` and `down` go up and down the call list

<pre>
(gdb) run 10
Starting program: /common/home/bfirner/examples/debug_sieve_example 10
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Breakpoint 1, sieve (max=10, size=0x7fffffffe0e0) at sieve.c:25
25	    unsigned long* primes = calloc(*size, sizeof(unsigned long));
(gdb) up
#1  0x000055555555529b in main (argc=2, argv=0x7fffffffe228) at using_sieve.c:21
21	    unsigned long* primes = sieve(max, &num_primes);
(gdb) up
Initial frame selected; you cannot go up.
(gdb) down
#0  sieve (max=10, size=0x7fffffffe0e0) at sieve.c:25
25	    unsigned long* primes = calloc(*size, sizeof(unsigned long));
(gdb) down
Bottom (innermost) frame selected; you cannot go down.
(gdb) up
#1  0x000055555555529b in main (argc=2, argv=0x7fffffffe228) at using_sieve.c:21
21	    unsigned long* primes = sieve(max, &num_primes);
(gdb) print max
$21 = 10
(gdb) print num_primes
$22 = 3
(gdb) print *num_primes
Cannot access memory at address 0x3
(gdb) print &num_primes
$23 = (size_t *) 0x7fffffffe0e0
</pre>

---

## Debugging

* Using gdb is far better than printing out variables and hoping to catch your error

---

## Next topics

* Structs
* Cleaning up our code
* And then we'll go on to non-integer numbers!

---

## Class Code

```C
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

unsigned int* sieve(int max, size_t* num_primes) {
    // Set to 0 because I don't trust the caller
    *num_primes = 0;
    bool not_prime[max] = {};
    not_prime[0] = true;
    not_prime[1] = true;

for (int i = 2; i < max; ++i) {
        if (!not_prime[i]) {
            ++(*num_primes);
            // Set all multiples to be not prime
            for (int j = 2*i; j < max; j += i) {
                not_prime[j] = true;
            }
        }
    }

// Calloc sets the memory to 0
    unsigned int* primes = calloc(*num_primes, sizeof(unsigned int));
    // Malloc doesn't change the values
    /*
    unsigned int* primes = malloc(*num_primes * sizeof(unsigned int));
    for (int i = 0; i < *num_primes; ++i) {
        primes[0] = 0;
    }
    */
    int cur_idx = 0;
    unsigned int* cur_ptr = primes;

// Put the primes inside
    for (int i = 2; i < max; ++i) {
        if (!not_prime[i]) {
            //primes[cur_idx] = i;
            //++cur_idx;
            //*(primes + cur_idx) = i;
            //++cur_idx;
            *cur_ptr = i;
            ++cur_ptr;
        }
    }

return primes;
}

int main(int argc, char** argv) {
    if (argc < 2) {
        printf("We need a number!\n");
        return 1;
    }

int size = atoi(argv[1]);
    if (size < 2) {
        printf("The number %i is too small!\n", size);
        return 1;
    }

size_t num_primes;
    unsigned int* primes = sieve(size, &num_primes);

// Print out the primes
    unsigned int* end = primes+num_primes;
    for (unsigned int* p = primes; p != end; ++p) {
        printf("%u is prime\n", *p);
    }
    free(primes);

return 0;
}
```