# C/C++

## C/C++: Get a random number that is in a specific range1

Assuming you need to generate a random number that is in a specified range, you can do the following:

```
//int rand(void) creates a pseudo-random number in the range of 0 to RAND_MAX
//RAND_MAX is defined in stdlib.h and is the largest number rand will return (same as INT_MAX).
const int new_number = (rand() % (maximum_number + 1 - minimum_number)) + minimum_number;

```

The above code first creates a pseudo-random number that is in the range of `[0, RAND_MAX]`.
Then it will divide it with the width (+1) of the range we want to use (`maximum_number + 1 - minimum_number`) and get the remainder (modulo).
The modulo will be in the range of `[0, maximum_number - minimum_number]`, so we add to it the value of `minimum_number` to shift the result to the proper range.
This solution, as demonstrated in the example below, works for negative ranges as well.

### Full example of generating `100000` random numbers that are all in the range `[-31, 32]`.

```const int maximum_number = 31;
const int minimum_number = -32;
unsigned int i;
for (i = 0; i <= 100000; i++) {
const int new_number = (rand() % (maximum_number + 1 - minimum_number)) + minimum_number;
printf("%d\n", new_number);
}
```

## C/C++: Set and Get the name of a pthread

Naming a pthread using meaningful names, can be a very useful feature for debugging multi-threaded applications as it can make your logs very informative.
For this reason, we are presenting two examples demonstrating the use of names in `pthreads`.

### Example 1: The pthread decides for its name

The following code, creates a `pthread` which later, it will give itself a meaningful name.

```
// #define _GNU_SOURCE is needed for the resolution of the following warnings
//warning: implicit declaration of function ‘pthread_setname_np’ [-Wimplicit-function-declaration]
//warning: implicit declaration of function ‘pthread_getname_np’ [-Wimplicit-function-declaration]
#define _GNU_SOURCE
#include <stdio.h>
#include <sys/types.h>
#include <asm/errno.h>
#include <errno.h>
// #include <stdlib.h> is needed for the resolution of EXIT_SUCCESS
#include <stdlib.h>

//The thread name is a meaningful C language string, whose length is restricted to 16 characters, including the terminating null byte.

{
// Used to identify a thread.
};

// This is the thread that will be called by pthread_create() and it will be executed by the new thread.
{
// We know that the input data pointer is pointing to a thread_info_t so we are casting it to the right type.

if (setname_rv)
{
errno = setname_rv;
}

if (getname_rv)
{
errno = getname_rv;
}
//This function always succeeds, returning the calling thread's ID.
//Usually pthread_t is defined as follows:
//so we print pthread_t as an unsigned long int
fprintf(stdout, "I am thread with ID '%lu', my name is '%s' and I gave me my name by myself\n", tid, thread_name );

return NULL;
}

int main()
{

if (create_rv)
{
errno = create_rv;
return EXIT_FAILURE;
}
if (join_rv)
{
errno = create_rv;
}
return EXIT_SUCCESS;
}

```

### Example 2: The parent decides for the pthread name

The next code, creates a `pthread` and the parent gives the thread a meaningful name.

```
// #define _GNU_SOURCE is needed for the resolution of the following warnings
//warning: implicit declaration of function ‘pthread_setname_np’ [-Wimplicit-function-declaration]
//warning: implicit declaration of function ‘pthread_getname_np’ [-Wimplicit-function-declaration]
#define _GNU_SOURCE
#include <stdio.h>
#include <sys/types.h>
#include <asm/errno.h>
#include <errno.h>
// #include <stdlib.h> is needed for the resolution of EXIT_SUCCESS
#include <stdlib.h>
// #include <unistd.h> is needed for the resolution of unsigned int sleep(unsigned int seconds);
#include <unistd.h>

//The thread name is a meaningful C language string, whose length is restricted to 16 characters, including the terminating null byte.

{
// Used to identify a thread.
};

// This is the thread that will be called by pthread_create() and it will be executed by the new thread.
{
// We know that the input data pointer is pointing to a thread_info_t so we are casting it to the right type.

//Added an artificial delay for the sake of the example.
sleep(1);

if (getname_rv)
{
errno = getname_rv;
}
//This function always succeeds, returning the calling thread's ID.
//Usually pthread_t is defined as follows:
//so we print pthread_t as an unsigned long int
fprintf(stdout, "I am thread with ID '%lu', my name is '%s' and my parent gave me my name\n", tid, thread_name );

return NULL;
}

int main()
{

if (create_rv)
{
errno = create_rv;
return EXIT_FAILURE;
}

if (setname_rv)
{
errno = setname_rv;
}

if (join_rv)
{
errno = create_rv;
}
return EXIT_SUCCESS;
}

```

## How does the expression, “*pointer++” evaluate?

`*pointer++` will increment the position of the pointer first but it will return the value that was pointed before the position of the pointer changed.

`*pointer++` is equivalent to `*(pointer++)`. This happens because the postfix `++` and `--` operators have higher precedence than the indirection (dereference).

To increment the value pointed to by `pointer`, use `(*pointer)++`.

To increment the position of the pointer and return the value that is pointed after the position of the pointer changed use `*++pointer`.

### Examples

The following example will increment the position of the pointer but return the value that was originally pointed.
By the end of the following block, `pointer` will point to position 1 and the `value` variable will have the value 11.

```
const unsigned int values[] = {11, 12, 14, 18};
const unsigned int *pointer = values;
const unsigned int value = *pointer++;

```

The following example will increment the position of the pointer and return the value that the new position is pointing to.
By the end of the following block, `pointer` will point to position 1 and the `value` variable will have the value 12.

```
const unsigned int values[] = {11, 12, 14, 18};
const unsigned int *pointer = values;
const unsigned int value = *++pointer;

```

## C/C++: Full example using a linked list with custom struct

The following code is an example that presents some basic functionality on simply linked lists. Specifically, it presents how to add an element to an empty list and then how to add more elements either to the start (`prepend`) or to the end (`append`) of the list.

We assume that our structure holds an integer and a dynamically created string, which we free after `pop`.

## Source file (list_helpers.c)

```#include <malloc.h>
#include "list_helpers.h"

void append(node_t **head, element_t *element) {

struct node_t *new = malloc(sizeof(node_t));
new->element = element;
new->next = NULL;

return;
}

while (current->next != NULL) {
current = current->next;
}

current->next = new;
return;
}

void prepend(node_t **head, element_t *element) {
struct node_t *new = malloc(sizeof(node_t));

new->element = element;
}

node_t *next = NULL;

return NULL;
}

return element;
}

while (current != NULL) {
free(current);
}
}
```

```#ifndef GM_S_LITTLE_HELPERS_LIST_HELPERS_H
#define GM_S_LITTLE_HELPERS_LIST_HELPERS_H

#ifdef __cplusplus
extern "C" {
#endif

typedef struct element_t element_t;
struct element_t {
//We add random members to the element struct for the sake of the example
unsigned int server;
};

typedef struct node_t node_t;
struct node_t {
element_t *element;
node_t *next;
};

#ifdef __cplusplus
}
#endif

#endif //GM_S_LITTLE_HELPERS_LIST_HELPERS_H
```

## Usage example (main.cpp)

```#include <iostream>
#include "list_helpers.h"

element_t *create_user(const unsigned int server, const char *username) {

element_t *user = (element_t *) malloc(sizeof(element_t));
user->server = server;

//For the sake of the example we used snprintf.
//Upon successful return, snprintf returns the number of characters printed (excluding the null byte used to end output to strings).
//For that reason we add one at the end of the length.
const int length = snprintf(NULL, 0, "%s", username) + 1;
user->username = (char *) malloc((sizeof(char) * length));
return user;
}

int main(int argc, char *argv[]) {

//Popping each one to process it and then free it
//Clearing the list
while (current != NULL) {