C Introduction à la Bibliothèque des meilleures pratiques linguistiques (Partie 2)

CLes fichiers de la bibliothèque pour la langue comprennent:：pthreadThread、assertAssertion、stringString、timeTemps、mathOpérations mathématiques、stdBibliothèque standard au début、sysBibliothèques système au début, etc..Parmi eux,Bibliothèque standardstdalign.h、stdarg.h、stdatomic.h、stdbool.h、stddef.h、stdint.h、stdio.h、stdlib.h.La Bibliothèque système asys/mman.h、sys/stat.h、sys/ioctl.h、sys/file.h.Cet article présente principalementstdBibliothèque standard etsysBibliothèque système.

Page précédenteCUne introduction aux fichiers de la Bibliothèque de langues est disponible：CIntroduction à la Bibliothèque des meilleures pratiques linguistiques(Allez.)

 

Table des matières

Un.、stddef.hDéfinition préalable de la macro

1、offsetof

2、ptrdiff_t

3、__func__Avec__LINE__

2.、stdio.h

1、Ouvrir le fichier

2、Lire et écrire des données 

3、Déplacer le pointeur de fichier

4、Obtenir la longueur du fichier

5、Renommer le fichier

6、 Déterminer si la fin est atteinte

7、 Réinitialiser le fichier au début

9、Supprimer le fichier

10、Fermer le fichier

Trois、stdlib.h

Quatre、string.h

Cinq、stdatomic.h

1、Type atomique 

2、 Initialisation atomique

3、 Lecture et écriture atomiques

4、Addition et soustraction atomiques

5、Échange atomique

6、Barrière de mémoire

Six、stdarg.h

Sept、sys/mmap.h

Huit、sys/stat.h

1、statStructure

2、 Informations sur les documents statistiques

Neuf、signal.h

1、Classification des signaux

2、Capture du signal

---

Un.、stddef.hDéfinition préalable de la macro

1、offsetof

stddefOffreoffsetof、size_t、ptrdiff Définition isomacro .Parmi euxoffsetof Utilisé pour obtenir la position offset de la variable Membre dans la structure .offsetof(t, d)Voici un exemple de code pour：

    struct Programmer {
        int    age;
        char* name;
        char* post;
    };

    void print_offset() {
        printf("offset of struct =%lu", offsetof(struct Programmer, name));
    }

2、ptrdiff_t

ptrdiff_t Utilisé pour calculer la différence entre deux pointeurs soustraits . Comme un pointeur vers l'en - tête d'une chaîne , Un autre pointeur pointe vers la fin de la chaîne , La différence entre les deux pointeurs est égale à la longueur de la chaîne .Voici un exemple de code:：

    char* str = "hello, world!";
    char* ptr_start = str;
    char* ptr_end = str + strlen(str);
    ptrdiff_t diff = ptr_end - ptr_start;
    printf("ptr diff=%td\n", diff);

3、__func__Avec__LINE__

Lors de la mise en service, Quel fichier devons - nous imprimer? 、Quelle fonction、 Quel est le problème? ,__FILE__、__func__、__LINE__C'est utile. Si vous voulez obtenir l'horodatage formaté actuel ,Ça marche__TIMESTAMP__. Ces macrodéfinitions commencent par un double soulignement .Voici un exemple de code:：

    printf("func=%s\n", __func__);
    printf("file=%s\n", __FILE__);
    printf("line=%d\n", __LINE__);
    printf("timestamp=%s\n", __TIMESTAMP__);

L'impression correspondante est la suivante: ：

    func=macro_define
    file=/Users/frank/Documents/FFmpegAndroid/app/src/main/cpp/test_api.c
    line=357
    timestamp=Sat Jun  4 17:19:22 2022

2.、stdio.h

stdio.h Opérations courantes pour fournir des fichiers ,Y compris:：Ouvre.、Lire et écrire、Fermer、Renommer、Supprimer、Rafraîchir、 Sortie standard, etc. . Les détails sont présentés dans le tableau ci - dessous. ：

Opérations de fichiers

Fonctions	Description
FILE* fopen(const char* filename, const char* mode)	Ouvrir le fichier,modeY compris:：Lire seulement、Écris seulement、Lire et écrire、Ajouter, etc.
size_t fread(void* ptr, size_t size, size_t count, FILE* stream)	Lire le fichier, Lire le contenu de la taille spécifiée dans le tampon
size_t fwrite(const void* ptr, size_t size, size_t count, FILE* stream)	Écrire un fichier, Le mode lecture - écriture écrase le contenu original , Ajouter est écrit à partir de la fin
int fseek(FILE* stream, long offset, int whence)	Déplacer le pointeur de fichier,seekMode：SEEK_SET、SEEK_CUR\SEEK_END
long ftell(FILE* stream)	Obtenir l'emplacement actuel,UnionfseekUtiliser
int fflush(FILE* stream)	Rafraîchir Le tampon de fichier
void rewind(FILE* stream)	Réinitialiser le pointeur de fichier au début du fichier
int remove(const char* filename)	Supprimer le fichier,Renvoie un succès ou un échec
int rename(const char* old, const char* new)	Renommer le fichier
int fclose(FILE* stream)	Fermer le fichier
int printf(const char* format, ...)	Imprimer sur la console
int scanf(const char* format, ...)	Lire le contenu
int sprintf(char* s, const char* format, ...)	Sortie vers la chaîne
int fprintf(FILE* stream, const char* format, ...)	Exporter vers un fichier
int vprintf(const char* format, va_list arg)	Sortie vers la liste des paramètres variables
int getc(FILE* stream)	Obtenir un caractère du fichier
int putc(int c, FILE* stream)	Écrire un caractère dans le fichier
int feof(FILE* stream)	Déterminer si le fichier arrive à la fin ,eof=-1
int ferror(FILE* stream)	Obtenir le Code d'erreur du fichier
void clearerr(FILE* stream)	Effacer les informations d'exception
void perror(const char* s)	Description de l'erreur sortie vers l'erreur standard
void setbuf(FILE* stream, char* buf)	Définir le tampon de fichier

1、Ouvrir le fichier

char* path = "sdcard/hello.txt";
FILE* file = fopen(path, "wb+");

2、Lire et écrire des données 

char *buf0  = "Just do it";
size_t size = strlen(buf0);
fwrite(buf0, size, 1, file); // Écrire des fichiers
fseek(file, 0, SEEK_SET);
char *buf1 = (char*) malloc(size * sizeof(char));
fread(buf1, size * sizeof(char), 1, file); // Lire le document

3、Déplacer le pointeur de fichier

fseek(file, 10, SEEK_SET);

4、Obtenir la longueur du fichier

fseek(file, 0, SEEK_END);
long len = ftell(file);

5、Renommer le fichier

rename("sdcard/2.txt", "sdcard/222.txt");

6、 Déterminer si la fin est atteinte

int ret = feof(file);

7、 Réinitialiser le fichier au début

rewind(file);

9、Supprimer le fichier

remove("sdcard/1.txt");

10、Fermer le fichier

 fclose(file);

Trois、stdlib.h

stdlib.h Fournir l'allocation et la libération de la mémoire 、Génération de nombres aléatoires、Sortie du processus、Exécuter la ligne de commande、Chaîne à valeur numérique type、Algorithme de recherche binaire、Algorithme de tri rapide、 Valeurs absolues, etc. . Où l'allocation de mémoire comprend: ：malloc、calloc、realloc、aligned_alloc. La comparaison détaillée est présentée dans le tableau ci - dessous. ：

Allocation de mémoire

malloc	Allocation de mémoire, Alignement de la mémoire par défaut
calloc	Allocation de mémoire,Et initialiser
realloc	Réaffectation, Copier l'ancienne mémoire dans la nouvelle zone
aligned_alloc	Aligner les allocations , Spécifier la taille de l'unit é d'alignement

stdlibLes fonctions connexes sont les suivantes:：

void lib_api() {
    // Allocation de mémoire
    void* malloc(size_t size);
    // Réattribuer la mémoire, Copier l'ancienne mémoire dans le nouvel espace mémoire ,Libérer l'ancienne mémoire
    void* realloc(void* ptr, size_t size);
    //  Allocation d'alignement de la mémoire 
    void *aligned_alloc(size_t alignment, size_t size);
    //  Allocation de mémoire et initialisation ,équivalent àmalloc + memset
    void* calloc(size_t nmemb, size_t size);
    // Libérer la mémoire
    void free(void* ptr);
    //  Fin anormale du processus 
    void abort(void);
    //  Fonction de fin d'enregistrement ,InexitAppelé à la sortie
    int atexit(void (*func)(void));
    // status=0Pour sortir normalement,status!=0Sortie pour exception
    void exit(int status);
    // Chaîne à valeur numérique type
    double atof (const char* nptr);
    int    atoi (const char* nptr);
    long   atol (const char* nptr);
    // Exécuter la ligne de commande,system Ouvrir un nouveau processus dans le processus original ,exec écraser le processus original avec le nouveau processus 
    int system(const char* string);
    // Recherche dichotomique
    void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
                  int (*compar)(const void *, const void *));
    // Algorithme de tri rapide
    void qsort(void* base, size_t nmemb, size_t size,
               int (*compar)(const void *, const void *));
    // Valeur absolue
    int abs(int j);
    // Générer un nombre aléatoire
    int rand(void);
    void srand(unsigned int seed);
    long random();
}

Quatre、string.h

string.h Opérations courantes pour fournir des chaînes ：Copie、Comparaison、épissage、Trouver、Diviser.Parmi eux,En partiememFonctionnement etstr Fonctionnement identique .Par exemple,,memcpy Copier la mémoire , Les structures peuvent être copiées 、Catégorie、Tableau, etc., Mais la longueur doit être spécifiée ;strcpyCopier la chaîne, Chaînes seulement ,La longueur spécifiée n'est pas requise.La comparaison entre les deux est la suivante：

void* memcpy(void* dest, const void* src, size_t n) Copier la mémoire ,Y compris les structures、Catégorie、Tableau, etc.	char* strcpy (char* dest, const char* src) Copier la chaîne
int memcmp(const void* str1, const void* str2, size_t n) Comparaison des valeurs de mémoire	int strcmp (const char* str1, const char* str2) Comparaison des chaînes
void* memchr(const void* str, int c, size_t n) Recherche de zone mémoire	char* strchr(const char* str, int c) Recherche de caractères dans une chaîne

Les autres fonctions communes sont les suivantes: ：

void string_api() {
    //  Déplacer la mémoire source d'une longueur spécifiée vers la mémoire de destination 
    void* memmove(void* dest, const void* src, size_t n);
    // Définir les valeurs de mémoire, Pour l'initialisation de la mémoire 
    void* memset(void* str, int c, size_t n);

    // Chaîne d'épissage
    char* strcat (char* dest, const char* src);
    //  Rechercher où le caractère apparaît pour la dernière fois dans la chaîne 
    char* strrchr(const char* str, int c);
    // Trouverstr2Instr1Où la chaîne apparaît
    char* strstr(const char* str1, const char* str2);
    // Diviser la chaîne
    char* strtok(char* src, const char* delim);
    //  Convertir le Code d'erreur en chaîne 
    char* strerror(int errnum);
    // Obtenir la longueur de la chaîne
    size_t strlen(const char* s);
}

Cinq、stdatomic.h

1、Type atomique 

stdatomic.h Fournir des opérations atomiques ,Sécurité des fils, Plus léger que la serrure . Les types d'atomes pris en charge sont: ：bool、char、int、short、longAttendez..Les macros sont définies comme suit(Y compris, sans s'y limiter)：

    typedef _Atomic(bool)	atomic_bool;
    typedef _Atomic(char)	atomic_char;
    typedef _Atomic(short)	atomic_short;
    typedef _Atomic(int)	atomic_int;
    typedef _Atomic(long)	atomic_long;

2、 Initialisation atomique

Utiliseratomic_init()Initialisation,Attention requise, Le premier paramètre est l'adresse de l'objet ,Les codes sont les suivants:：

    atomic_int count;
    atomic_init(&count, 1);

3、 Lecture et écriture atomiques

Utiliseratomic_load()Lire,atomic_store_explicit()Écrire,Les codes sont les suivants:：

    // Lire
    atomic_load(&count);
    // Écrire
    atomic_store_explicit(&count, 3, memory_order_seq_cst);

4、Addition et soustraction atomiques

  Support d'opération atomique plus 、Moins、Ou、XOR、Avec. Exemple d'addition et de soustraction ：

    atomic_fetch_add(&count, 5);
    atomic_fetch_sub(&count, 3);

5、Échange atomique

L'étape d'échange atomique est divisée en trois étapes ：Lire、Comparaison、Écrire.Les codes sont les suivants:：

    atomic_exchange(&count, 6);

6、Barrière de mémoire

Opérations atomiques fenceBarrière de mémoire,Et les mots clésvolatileSimilaire, Assurer l'ordre de la mémoire .Il y a unmemory_orderType d'énumération, Inclure les opérations d'acquisition 、Opération de libération、Accès et libération、 Opérations de consommation 、Désorganisation、Ordre, etc,Les détails sont les suivants：

    typedef enum {
        memory_order_relaxed = __ATOMIC_RELAXED,
        memory_order_consume = __ATOMIC_CONSUME,
        memory_order_acquire = __ATOMIC_ACQUIRE,
        memory_order_release = __ATOMIC_RELEASE,
        memory_order_acq_rel = __ATOMIC_ACQ_REL,
        memory_order_seq_cst = __ATOMIC_SEQ_CST
    } memory_order;

Fonction correspondanteAPIComme suit：

    atomic_thread_fence(memory_order order);

Six、stdarg.h

stdarg.h Fournit une traversée des paramètres variables ,Parva_start()、va_arg()Etva_end() Trois fonctions ,Il y en a un autre.va_listListe des paramètres variables.Parmi euxva_start() Est le début de la liste des paramètres ,va_arg() Est le suivant pour obtenir la Liste ,va_end() Fin de la traversée pour libérer la mémoire .Voici un exemple de code:：

void sum_args(int args, ...) {
    int sum = 0;
    va_list ap;
    va_start(ap, args);
    for (int i=0; i<args; i++) {
        sum += va_arg(ap, int);
    }
    va_end(ap);
    printf("sum=%d\n", sum);
}

Vous pouvez deviner le résultat de cet appel de fonction ：

sum_args(3, 11, 22, 33);

Sept、sys/mmap.h

mmap.h Fonction qui fournit la cartographie de la mémoire , La fonction de corrélation est déclarée comme suit: ：

    /**
     * [mmap](http://man7.org/linux/man-pages/man2/mmap.2.html)
     * creates a memory mapping for the given range.
     *
     * Returns the address of the mapping on success,
     * and returns `MAP_FAILED` and sets `errno` on failure.
     */
    void* mmap(void* addr, size_t size, int prot, int flags, int fd, off_t offset);

    /**
     * [munmap](http://man7.org/linux/man-pages/man2/munmap.2.html)
     * deletes a memory mapping for the given range.
     *
     * Returns 0 on success, and returns -1 and sets `errno` on failure.
     */
    int munmap(void* addr, size_t size);

mmap()Quatrième argument de la fonctionprotLes types comprennent:：Lire、Écris.、Mise en œuvre、Pas de permission.Comme le montre la figure ci - dessous：

Cinquième paramètreflag Les bits de drapeau comprennent: ：Partagé、Privé、Fixe.Comme le montre la figure ci - dessous：

​​​​​​​ 

Voici un exemple de code pour la cartographie de la mémoire ：

void mapping() {
    char *buf = "hello, world";
    // file：use data in buf
    int fd = open("sdcard/hello.txt", O_RDWR);
    write(fd, buf, strlen(buf));
    // mapping：use data at address
    fd = open("sdcard/hello.txt", O_RDWR);
    void* address = mmap(0, strlen(buf), PROT_READ, MAP_PRIVATE, fd, 0);
}

Huit、sys/stat.h

1、statStructure

stat.h Utilisé pour obtenir des informations sur l'état du fichier ,Y compris:：Matérielid、Taille du fichier、Accès aux fichiers、Temps de modification du fichier、Temps d'accès au fichier、Numéro de série、 Nombre de liens de fichiers, etc. .statLa structure est la suivante：

    struct stats {
        dev_t st_dev;     // ID of device containing file
        ino_t st_ino;     // file serial number
        mode_t st_mode;   // mode of file
        nlink_t st_nlink; // number of links to the file
        uid_t st_uid;     // user ID of file
        gid_t st_gid;     // group ID of file
        dev_t st_rdev;    // device ID
        off_t st_size;    // file size in bytes
        int st_blksize;   // a filesystem-specific preferred I/O block size
        long st_blocks;   // number of blocks allocated for this object
        struct timespec st_atim; // time of last access
        struct timespec st_mtim; // time of last data modification
        struct timespec st_ctim; // time of last status change
    };

2、 Informations sur les documents statistiques

stat()Voici un exemple d'utilisation d'une fonction：

void file_stat() {
    struct stat buf;
    const char* path = "sdcard/hello.txt";
    stat(path, &buf);
    printf("file mode:%u\n",buf.st_mode);          // Accès aux fichiers
    printf("file size:%lu\n",buf.st_size);         // Taille du fichier
    printf("file access time:%lu\n",buf.st_atime); // Temps d'accès au fichier
    printf("file modify time:%lu\n",buf.st_mtime); // Temps de modification du fichier
}

Neuf、signal.h

1、Classification des signaux

signal.h Est le signal fourni par le système ,Y compris:：Directive illégale、 Piège de fonction 、Résiliation anormale、Adresse illégale、Tuer le processus、Exception de mémoire、Sortie du processus、 Exception au point flottant, etc. .Par exemple,, Accéder à un pointeur vide , Ou un pointeur libéré , Ou la zone mémoire pointée par le pointeur d'accès est hors limite ,Le système envoieSIGSEGVSignal.Encore une fois., Tuer le processus en utilisant la ligne de commande kill -9 pid, Le système va se produire SIGKILLSignal. Les signaux et valeurs spécifiques sont indiqués dans le tableau ci - dessous. ：

Signal du système

Signal	Description	Signal	Description
SIGHUP  1	Signal en attente	SIGCHLD 17	Fin du sous - processus
SIGINT    2	Interruption du signal	SIGCONT 18	Reprise du processus
SIGQUIT 3	Sortie du processus	SIGSTOP 19	Arrêt du programme
SIGILL     4	Directive illégale	SIGTSTP 20	Arrêter le processus
SIGTRAP 5	Piège de fonction	SIGTTIN 21	Lire les données
SIGABRT 6	Résiliation anormale	SIGTTOU 22	Écrire des données
SIGBUS   7	Adresse illégale	SIGURG 23	Traitement d'urgence
SIGFPE    8	Débordement de points flottants	SIGXCPU 24	Au - delà deCPURestrictions
SIGKILL   9	Tuer le processus	SIGXFSZ 25	Document élargi
SIGUSR1 10	Rétention des utilisateurs	SIGVTALRM 26	Horloge virtuelle
SIGSEGV 11	Exception de mémoire	SIGPROF 27	CPUHorloge
SIGUSR2 12	Rétention des utilisateurs	SIGWINCH 28	Changement de fenêtre
SIGPIPE 13	Tuyauterie de signalisation	SIGIO 29	Descripteur de fichier prêt
SIGALRM 14	Horloge chronométrée	SIGPWR 30	Alimentation anormale
SIGTERM 15	Fin de la procédure	SIGSYS 31	Appel système illégal
SIGSTKFLT 16	Exception à la pile du processeur	SIGRTMIN 32	Signal en temps réel

2、Capture du signal

Les fonctions de traitement du signal comprennent: ：Capture du signal、Interruption、Attendez.、En attente、Générer un signal、Tuer le processus.Les détails sont les suivants：

    int sigaction(int signal, struct sigaction* new_action, struct sigaction* old_action); // Signal capté
    int siginterrupt(int signal, int flag); // Interruption du signal
    int sigwait(const sigset_t* set, int* signal); // Signal en attente
    int sigsuspend(const sigset_t* mask); //  Signal en attente 
    int raise(int signal); // Envoyer un signal
    int kill(pid_t pid, int signal); // Tuer le processus

Ensuite, nous simulons le processus de transmission et d'acquisition des signaux. ：

void process_signal() {
    printf("receive sig=%d\n", SIGFPE);
}

void test_signal() {
    struct sigaction action;
    action.sa_handler = process_signal; //  Déclarer une fonction de traitement du signal 
    sigaction(SIGFPE, &action, NULL); // Signal capté
    raise(SIGFPE); // Envoyer un signal
}