Sizeof（Struct sem_t）获取错误：“Sizeof”对不完整类型“Struct sem_t”的应用无效

我试图得到sem_t struct的大小，这是linux的信号量结构，我相信，但当我试图动态分配一个sem_t struct数组时，它似乎无法确定它的大小

这是我的代码，到目前为止，我仍在构建主。。。我知道我仍然需要清理/关闭线程和信号量以及其他任何东西：

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

}

这是因为sem\u t不是一个结构。请改用sizeofsem\t

或者，在我看来更好

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

我更喜欢后者，因为它避免了*S类型的重复。

这是因为sem\u t不是一个结构。请改用sizeofsem\t

或者，在我看来更好

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

---

我更喜欢后者，因为它避免了重复*S.

+1-虽然我同意第二种更好，但我通常更喜欢解释为什么它更好。后者更好，因为它是一个大家都应该知道的通用成语。它甚至可以用于分配多维VLA，如：int*matrix[cols]=mallocrows*sizeof*matrix+1-虽然我同意第二个更好，但我通常更愿意解释为什么它更好。后者更好，因为它是一个大家都应该知道的通用成语。它甚至可以用于分配多维VLA，如：int*matrix[cols]=mallocrows*sizeof*matrix；