Сортировка массив структур: qsort выдает Expression syntax

qsort (base, n, sizeof(people), namecmp);

int namecmp (const void * a, const void * b)
{
    return strcmp (((people*)a).FIO, ((people*)b).FIO);
}

return strcmp( ((people*)a)->FIO, ((people*)b)->FIO );

#include <stdio.h>
#include <stdlib.h>
 
typedef struct {
    char * name;
    int growth;
} person_t;
 
int name_cmp(const void * a, const void * b) {
    return strcmp(((person_t*)a)->name, ((person_t*)b)->name);
}
 
#define PERSONS 3
 
int main(void) {
    person_t array[PERSONS] = {
        { "Petrov", 178 },
        { "Sidorov", 175 },
        { "Ivanov", 180 }
    };
    int i;
    
    printf("Unsorted:\n");
    for ( i = 0; i < PERSONS; ++i )
        printf("%s\t%d\n", array[i].name, array[i].growth);
    qsort(array, PERSONS, sizeof(person_t), name_cmp);
    printf("Sorted by name:\n");
    for ( i = 0; i < PERSONS; ++i )
        printf("%s\t%d\n", array[i].name, array[i].growth);
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
 
//---------------------------------------------------------------------------
FILE *database;
struct {char FIO [25]; float s2; int amount;} people;
 
void view_all();
void add_item();
void sort();
int namecmp(const void* a, const void* b);
int s2cmp(const void* a, const void* b);
int amount(const void* a, const void* b);
 
void main()
{
    int t;
 
    if ((database = fopen ("database.db", "rb+")) == NULL)
    {
        printf ("File not found! Create new? [Y/N] \n");
        char n [1];
        scanf ("%s", n);
        if (n[0] == 'y')
        {
            database = fopen ("database.db", "wb+");
            system ("cls");
        }
        else
        {
            t = 10;
        }
    }
    fclose (database);
 
    if (t != 10)
    {
 
        do
        {
            printf ("[1]View All\t[2]Add Item\t[0]Exit\n");
            scanf ("%d", &t);
            switch (t) {
                case 1: system("cls");
                    view_all();
                    break;
 
                case 2: system("cls");
                    add_item();
                    break;
                case 3: system("cls");
                    sort();
                    break;
            }
        }
        while (t != 0);
    }
}
 
void view_all()
{
    database = fopen ("database.db", "rb");
    fread (&people, sizeof (people), 1, database);
    while (!feof(database))
    {
        printf ("FIO \t\tSquare \t\tAmount \n%s \t\t%f \t%i \n", people.FIO, people.s2, people.amount);
        fread (&people, sizeof (people), 1, database);
    }
    fclose (database);
    system ("pause"); system ("cls");
}
 
void add_item()
{
    database = fopen ("database.db", "ab");
    puts ("Input FIO");
    scanf ("%s", &people.FIO);
    puts ("Input square");
    scanf ("%f", &people.s2);
    puts ("Input amount");
    scanf ("%i", &people.amount);
    system ("cls");
    fwrite (&people, sizeof(people), 1, database);
    fclose (database);
}
 
void sort()
{
    int i = 0;
    int c;
    struct {char FIO [25]; float s2; int amount;} base [100];
    database = fopen ("database.db", "rb");
 
    while (!feof(database))
    {
        fread (&people, sizeof (people), 1, database);
        strcpy (base[i].FIO, people.FIO);
        base[i].s2 = people.s2;
        base[i].amount = people.amount;
    }
 
    printf ("Sort by: \n[1]FIO \t[2]Square \t[3]Amount");
    scanf ("%d", &c);
    int n = i;
    switch (c)
    {
        case 1: system("cls");
        qsort (base, n, sizeof(people), namecmp);
        for (i = 0; i < n; i++)
        {
            printf ("%s\t%f\t%i", base.FIO, base.s2, base.amount);
        }
        break;
 
 
        case 2: system("cls");
        break;
 
        case 3: system("cls");
        break;
 
    }
}
 
int namecmp (const void * a, const void * b)
{
    return strcmp ( ((people*)a)->FIO, ((people*)b)->FIO);
}
 
int s2cmp (const void* a, const void* b)
{
    float d = ((people*)a).s2 - ((people*)b)s2;
    return ( d < 0.0 ) ? -1 : ( d > 0.0 ) ? 1 : 0;
}
 
int amountcmp (const void* a, const void* b)
{
    return (*(people*)a).amount - (*(people*)b).amount;
}
 
 
//---------------------------------------------------------------------------

typedef struct {
    char FIO [25];
    float s2;
    int amount;
} People;

People people;

(People*)a

#ifndef _PERSONS_H_
#define _PERSONS_H_ 1
 
#include <string.h>
 
#define NAME_LENGTH 32
#define DB_FILE "persons.db"
 
typedef struct PERSON {
    char   name[NAME_LENGTH];
    int    growth;
    double weight;
} person_t;
 
int name_cmp(const void * a, const void *b) {
    return strcmp(((person_t*)a)->name, ((person_t*)b)->name);
}
 
int growth_cmp(const void * a, const void * b) {
    return ((person_t*)a)->growth - ((person_t*)b)->growth;
}
 
int weight_cmp(const void * a, const void * b) {
    double d = ((person_t*)a)->weight - ((person_t*)b)->weight;
    return ( d < 0.0 ) ? -1 : ( d > 0.0 ) ? 1 : 0;
}
 
void dump(const person_t * pPerson) {
    printf("%-20s %6d %6.1f\n", pPerson->name, pPerson->growth, pPerson->weight);
}
 
#endif /* _PERSONS_H_ */

#include <stdio.h>
#include <stdlib.h>
#include "persons.h"
 
#define NUM_PERSONS 3
 
int main(void) {
    person_t persons[NUM_PERSONS] = {
        { "Sidorov", 178, 98.9 },
        { "Petrov", 182, 78.5 },
        { "Ivanov", 185, 79.2 }
    };
    FILE * f;
    
    if ( ! ( f = fopen(DB_FILE, "wb") ) ) {
        perror("fopen");
        exit(1);
    }
    
    if ( fwrite(persons, sizeof(person_t), NUM_PERSONS, f) != NUM_PERSONS ) {
        fprintf(stderr, "Can't write to db file.\n");
        if ( fclose(f) )
            perror("fclose");
        exit(1);
    }
    
    if ( fclose(f) ) {
        perror("fclose");
        exit(1);
    }
    
    fprintf(stderr, "Wrote information for %u persons.\n", NUM_PERSONS);
    
    exit(0);
}

#include <stdio.h>
#include <stdlib.h>
#include "persons.h"
 
int main(void) {
    FILE * f;
    long nFileLength;
    person_t * pPersons;
    size_t i, nPersons;
    
    if ( ! ( f = fopen(DB_FILE, "rb") ) ) {
        perror("fopen");
        exit(1);
    }
    
    if ( fseek(f, 0, SEEK_END) ) {
        perror("fseek");
        if ( fclose(f) )
            perror("fclose");
        exit(1);
    }
    if ( ( nFileLength = ftell(f) ) < 0 ) {
        perror("ftell");
        if ( fclose(f) )
            perror("fclose");
        exit(1);
    }
    if ( nFileLength == 0 ) {
        fprintf(stderr, "DB file is empty.\n");
        if ( fclose(f) )
            perror("fclose");
        exit(1);
    }
    if ( nFileLength % sizeof(person_t) ) {
        fprintf(stderr, "DB file is corrupt!\n");
        if ( fclose(f) )
            perror("fclose");
        exit(1);
    }
    rewind(f);
    
    nPersons = nFileLength / sizeof(person_t);
    if ( ! ( pPersons = malloc(sizeof(person_t) * nPersons) ) ) {
        perror("malloc");
        if ( fclose(f) )
            perror("fclose");
        exit(1);
    }
    if ( fread(pPersons, sizeof(person_t), nPersons, f) != nPersons ) {
        fprintf(stderr, "Can't read from DB file.\n");
        if ( fclose(f) )
            perror("fclose");
        exit(1);
    }
    
    if ( fclose(f) ) {
        perror("fclose");
        exit(1);
    }
    
    printf("By name:\n");
    qsort(pPersons, nPersons, sizeof(person_t), name_cmp);
    for ( i = 0; i < nPersons; ++i )
        dump(&pPersons[i]);
    
    printf("\nBy growth:\n");
    qsort(pPersons, nPersons, sizeof(person_t), growth_cmp);
    for ( i = 0; i < nPersons; ++i )
        dump(&pPersons[i]);
    
    printf("\nBy weight:\n");
    qsort(pPersons, nPersons, sizeof(person_t), weight_cmp);
    for ( i = 0; i < nPersons; ++i )
        dump(&pPersons[i]);
    
    free(pPersons);
    
    exit(0);
}

typedef struct people {char FIO [25]; float s2; int amount;} people_t;
people_t * Peoples;

void add_item()
{
    database = fopen ("database.db", "ab");
    puts ("Input FIO");
    scanf ("%s", Peoples->FIO);