How do you pass an int value through a void pointer paramater of a function and convert it back to an int value?

Question

I am trying to create a multi-thread program that creates a thread for every file that is taken it (file1.txt to file20.txt) and I need to pass in a variable into the function using pthread_create. I am having difficulties passing my int value into the function because pthread_create only takes in void* so my function has to take in a void*.

I have some experience with pointers but I don't understand the concept of a void pointer very well. As far as I have been able to figure out is that my pthread_create is suppose to look something simular to this pthread_create(&tids[i], NULL, getSales, (void*)i );

in main():

using namespace std;

int main(int argc, char **argv){
    int numfiles = 20;
    // Thread_ID's
    pthread_t tids[numfiles];

    // create threads
    for(int i = 1; i <= numfiles; i++){
        pthread_create(&tids[i], NULL, getSales, (void*)i );
    }

    // wait until threads are done
    //join threads together so they run simultaneously
    for(int i = 1; i <= numfiles; i++){
        pthread_join(tids[i], NULL);
    }
}

currently in getSales:

void* getSales(void* fileNum){
    int* num = (int*)fileNum;
    cout << &num <<endl;
    pthread_exit(0);
}

currently when I compile this code it crashes and giving me multiple lines of back trace but it seems that the error is just the getSales function currently the output should print the numbers 1 to 20 in random order because the function is multi-threaded.

gcc staplemax.cpp -lpthread -o staplemax
staplemax.cpp: In function ‘int main(int, char**)’:
staplemax.cpp:114:57: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
         pthread_create(&tids[i], NULL, getSales, (void*)i );
                                                         ^
/tmp/ccf6zgpk.o: In function `getSales(void*)':
staplemax.cpp:(.text+0x10e): undefined reference to `std::cout'
staplemax.cpp:(.text+0x113): undefined reference to `std::ostream::operator<<(void const*)'
staplemax.cpp:(.text+0x118): undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&)'

edit:

I'm now compiling with g++ staplemax.cpp -lpthread -o staplemax instead of gcc staplemax.cpp -lpthread -o staplemax as recommended.

I also changed main due to it being pointed out that &i was likely changed with the call of each loop of the for loop. my code currently looks like this

void* getSales(void* fileNum){
    int num = *(int*)fileNum;
    cout << num <<endl;
    pthread_exit(0);
}

int main(int argc, char **argv){
    int numfiles = 20;

    // Thread_ID
    pthread_t tids[numfiles];
    int args[numfiles];

    // create thread
    for(int i = 0; i < numfiles; i++){
        args[i] = i+1;
        pthread_create(&tids[i], NULL, getSales, &args[i] );
    }

   // wait until thread is done  //join
    for(int i = 0; i < numfiles; i++){
        pthread_join(tids[i], NULL);
    }
}

This compiles (with g++) but not all numbers are 1-20

3
2
9
1
10
6
87

5
4
11
12
13
14
15
16
17
18
19
20

Answer 1

The classical solution to this is to have an array of objects that represent the argument to each pthread. That is, each thread will have an associated unique location that will hold its argument. You just need to pass a pointer to that unique location.

Here's an example:

void *pthread_func(void *_arg) {
    int arg = *(int*)_arg; // we're receiving an int
    // ...
}

int main() {
    pthread_t threads[20];
    int       args[20]; // unique arg location for each thread

    for (int i = 0; i < 20; ++i) {
        args[i] = (whatever you want to pass)

        // create the thread, give it its unique arg location
        pthread_create(&threads[i], NULL, pthread_func, &args[i]);
    }

    // ... join the threads, etc. ...
}

The problem with passing the loop variable by address (i.e. &i) is that it might (most definitely will) be changed before each thread completes.

For instance, in iteration i=0 you pass &i. Unless you immediately join the newly-created thread, the next loop iteration changes i to 1, which will most certainly mess up the thread you just created. Even worse, it's possible the i=0 thread never even sees 0, as the thread creation could be delayed depending on what the system is doing. Since they all point to the same location, they all observe the same value (aside from pedantic memory ordering considerations).

Edit:

Because the number of threads you use will (should) always be small (since you should never make more running threads than you have processors to run them), the memory overhead for the above method is small. However, if you're passing an integer type and you want to want to save as much space as possible you can cast it into a void* (because pointers are also an integer type).

The only caveat is that casting between integer types and pointers is only allowed if they have the same number of bits. To facilitate this, use intptr_t or uintptr_t as an intermediary.

Here's an example of that:

void *pthread_func(void *_arg) {
    int arg = (int)(intptr_t)_arg; // we're receiving an int encoded as void*
    // ...
}

int main() {
    pthread_t threads[20];

    for (int i = 0; i < 20; ++i) {
        void *arg = (void*)(intptr_t)(whatever you want to pass);

        // create the thread, give it its packed argument
        pthread_create(&threads[i], NULL, pthread_func, arg);
    }

    // ... join the threads, etc. ...
}

Answer 2

You cast an int to void*. To undo it, cast a void* back to an int. So:

int* num = (int*)fileNum;

Should be:

int num = (int)fileNum;