Pourquoi est-ce que je reçois cette erreur? void * n’est pas un pointeur sur le type d’object.

void *stackAddr[NUM_THREADS]; stackAddr[i] = malloc(STACKSIZE);

Le compilateur (g ++ 4.4.3) se plaint du nom de malloc …

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

Si vous êtes intéressé à voir le code en entier, la voici …

 #include  #include  #include  #include  #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); }

Vous void *stackAddr une variable locale void *stackAddr , qui stackAddr tableau global stackAddr .

De plus, ce n’est pas un tableau, et l’application de l’opérateur [] indice tente de décaler et de déréférencer un pointeur void , d’où l’erreur de compilation.

Le déréférencement et l’arithmétique de pointeur sur les pointeurs de vide ne sont pas autorisés par la norme, car sizeof(void) n’est pas défini.

Vous avez foiré votre déclaration:

 void *stackAddr;

devrait être:

 void *stackAddr[];

(Vous devrez peut-être également définir une taille pour le tableau.)

Ensuite, vous essayez de faire ceci:

 stackAddr[tid] = malloc(STACKSIZE);

Donc, vous accédez à un élément de tableau d’un void* .

Maintenant que vous avez posté le code réel, je suppose que l’erreur se trouve dans pthread_create_with_stack , où vous avez une variable locale void * stackAddr qui masque le tableau global.

Il semble que vous devriez simplement supprimer la variable locale.

Ce que vous avez posté en premier n’est pas un problème.

 void *stackAddr[NUM_THREADS];

Mais dans le code, vous avez autre chose:

 void *stackAddr;

donc le compilateur essaie d’utiliser cette variable locale et, bien sûr, ne comstack pas ..

Dans pthread_create_with_stack , vous avez ce code:

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

L’expression stackAddr[tid] essaie de faire de l’arithmétique sur un void* .

Dans C ++, les pointeurs vides n’ont aucun atsortingbut, ce qui inclut la taille. Par conséquent, vous ne pouvez pas calculer l’adresse de décalage pour les vides du nombre i à partir du début du tableau. C’est la spécification d’un index particulier dans le tableau qui cause vos problèmes mathématiques.

Dans la version que vous avez publiée, stackAddr n’est pas un tableau, mais vous affectez à stackAddr[tid] . Le compilateur le remplace par *(stackAddr + tid) avec l’expression entre parenthèses évaluant stackAddr + tid * sizeof(void) , le compilateur vous avertit donc de sizeof(void) .