Why do I get this error? void* is not a pointer to object type.

Question

void *stackAddr[NUM_THREADS];

stackAddr[i] = malloc(STACKSIZE);

The compiler (g++ 4.4.3) complains where the malloc is called...

warning: pointer of type ‘void *’ used in arithmetic
error: ‘void*’ is not a pointer-to-object type

If you are interested in seeing the whole code, here it goes...

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define NUM_THREADS 4

void *stackAddr[NUM_THREADS];
pthread_t thread[NUM_THREADS];
pthread_attr_t attr;

void *BusyWork(void *t)
{
   int i;
   long tid;
   double result=0.0;
   tid = (long)t;

   printf("Thread %ld starting...\n",tid);
   for ( i = 0; i < 1000; i++)
   {
      result = result + sin(i*tid) * tan(i*tid);
   }
   printf("Thread %ld done. Result = %e\n", tid, result);
   pthread_exit((void*) t);
}

void pthread_create_with_stack( pthread_t * pthread, void *(*start_routine) (void *), int tid )
{
    const size_t STACKSIZE = 0xC00000; //12582912
    void *stackAddr;
    int rc;
    size_t i;
    pthread_t thread;
    pid_t pid;

    stackAddr[tid] = malloc(STACKSIZE); // Error here!
    pthread_attr_setstack(&attr, stackAddr[tid], STACKSIZE);

    rc = pthread_create( pthread, &attr, start_routine, (void*)tid );
}

int main (int argc, char *argv[])
{
   int rc;
   long t;
   void *status;

   /* Initialize and set thread detached attribute */
   pthread_attr_init(&attr);
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

   for(t=0; t<NUM_THREADS; t++) 
   {
      printf("Main: creating thread %ld\n", t);
      rc = pthread_create_with_stack(&thread[t], BusyWork, t); 
      if (rc) 
      {
         printf("ERROR; return code from pthread_create() is %d\n", rc);
         exit(-1);
      }
   }

   /* Free attribute and wait for the other threads */
   pthread_attr_destroy(&attr);
   for(t=0; t<NUM_THREADS; t++) 
   {
      rc = pthread_join(thread[t], &status);
      if (rc) 
      {
         printf("ERROR; return code from pthread_join() is %d\n", rc);
         exit(-1);
      }
      printf("Main: completed join with thread %ld having a status"   
            "of %ld\n",t,(long)status);
    }

    printf("Main: program completed. Exiting.\n");
    pthread_exit(NULL);
}

Answer 1

You are declaring a local variable void *stackAddr , which shadows the global stackAddr array.

Moreover, it is not an array, and applying the [] subscript operator attempts to offset and dereference a void pointer, hence the compile error.

Dereferencing and pointer-arithmetic on void pointers is not permitted by the standard since sizeof(void) is undefined.

Answer 2

You messed up your declaration:

void *stackAddr;

should be:

void *stackAddr[];

(You may also need to set a size for the array.)

Then you try to do this:

stackAddr[tid] = malloc(STACKSIZE);

So you're accessing an array element of a void* .

Answer 3

Now you've posted the real code, I'm guessing the error is in pthread_create_with_stack , where you have a local variable void * stackAddr that hides the global array.

It looks like you should just remove the local variable.

Answer 4

What you posted first, is not a problem.

void *stackAddr[NUM_THREADS];

But in the code you have something else:

void *stackAddr;

so the compiler tries to use that local variable, and of course fails to compile..

Answer 5

In pthread_create_with_stack , you have this code:

void *stackAddr;
...
stackAddr[tid] = malloc(STACKSIZE)

The expression stackAddr[tid] tries to do arithmetic on a void* .

Answer 6

In the version you posted, stackAddr isn't an array, yet you're assigning to stackAddr[tid] . The compiler replaces this with *(stackAddr + tid) with the parenthetical expression evaluating to stackAddr + tid * sizeof(void) , so the compiler warns you about sizeof(void) .

Answer 7

In C++ void pointers have no attributes, that includes size. As a result, you cannot calculate the offset address for i-number voids from the beginning of the array. It is the specification of a particular index in the array is causing your math issues.