Sizeof (Struct sem_t) получает ошибку: недопустимое приложение 'sizeof' для неполного типа 'struct sem_t'

Question

Я пытаюсь получить размер структуры sem_t, которая является структурой семафора для linux, я полагаю, но это не так. Кажется, это невозможно определить, когда я пытаюсь динамически выделять массив sem_t-структур.

Вот мой код до сих пор (я до сих пор здание главной ... Я знаю, что еще нужно очистки/закрыть темы и семафоры и все остальное):

#define _MULTI_THREADED 
#include <math.h> 
#include <unistd.h>  /* Symbolic Constants */ 
#include <sys/types.h> /* Primitive System Data Types */ 
#include <errno.h>  /* Errors */ 
#include <stdio.h>  /* Input/Output */ 
#include <stdlib.h>  /* General Utilities */ 
#include <pthread.h> /* POSIX Threads */ 
#include <string.h>  /* String handling */ 
#include <semaphore.h> /* Semaphore */ 

//#define N 5 
#define THINKING 0 
#define HUNGRY 1 
#define EATING 2 
//#define LEFT (ph_num+4)%N 
//#define RIGHT (ph_num+1)%N 

sem_t mutex; 
//sem_t S[N]; 

void * philospher(void *num); 
void take_fork(int); 
void put_fork(int); 
void test(int); 

//int state[N]; 
int *state; 

//int phil_num[N]={0,1,2,3,4}; 
int N=0; 
sem_t *S; 

int getLeft(int phNum) 
{ 
    return (phNum+4)%N; 
} 

int getRight(int phNum) 
{ 
    return (phNum+1)%N; 
} 

void *philospher(void *num) 
{ 
    while(1) 
    { 
     int *i = num; 
     sleep(1); 
     take_fork(*i); 
     sleep(0); 
     put_fork(*i); 
    } 
} 

void take_fork(int ph_num) 
{ 
    sem_wait(&mutex); 
    state[ph_num] = HUNGRY; 
    printf("Philosopher %d is Hungry\n",ph_num+1); 
    test(ph_num); 
    sem_post(&mutex); 
    sem_wait(&S[ph_num]); 
    sleep(1); 
} 

void test(int ph_num) 
{ 
    if (state[ph_num] == HUNGRY && state[getLeft(ph_num)] != EATING && state[getRight(ph_num)] != EATING) 
    { 
     state[ph_num] = EATING; 
     sleep(2); 
     printf("Philosopher %d takes fork %d and %d\n",ph_num+1,getLeft(ph_num)+1,ph_num+1); 
     printf("Philosopher %d is Eating\n",ph_num+1); 
     sem_post(&S[ph_num]); 
    } 
} 

void put_fork(int ph_num) 
{ 
    sem_wait(&mutex); 
    state[ph_num] = THINKING; 
    printf("Philosopher %d putting fork %d and %d down\n",ph_num+1,getLeft(ph_num)+1,ph_num+1); 
    printf("Philosopher %d is thinking\n",ph_num+1); 
    test(getLeft(ph_num)); 
    test(getRight(ph_num)); 
    sem_post(&mutex); 
} 


int main(int argc, char *argv[]) 
{ 
    if(argc<2) 
    { 
     printf("Come on, now, we need a number for the number of philosphers we're going to have over for dinner."); 
     return 0; 
    } 
    N = atoi(argv[1]); 
    S= 
    //S = sem_t[N]; 
    S=(struct sem_t *)malloc(N*sizeof(struct sem_t)); 
    state = malloc(N*sizeof(int)); 
     int i; 
    pthread_t thread_id[N]; 
    sem_init(&mutex,0,1); 
    for(i=0;i<N;i++) 
     sem_init(&S[i],0,0); 
    for(i=0;i<N;i++) 
    { 
     pthread_create(&thread_id[i],NULL,philospher,i);//&phil_num[i]); 
     printf("Philosopher %d is thinking\n",i+1); 
    } 
    for(i=0;i<N;i++) 
     pthread_join(thread_id[i],NULL); 

} 

Answer 1

Это происходит потому, что sem_t не структура. Вместо этого используйте sizeof(sem_t).

S = malloc(N*sizeof(sem_t)); 

или, еще лучше, на мой взгляд,

S = malloc(N*sizeof(*S)); 

Я предпочитаю последний, так как это позволяет избежать повторения типа *S.