correction-4bis.c

#include <stddef.h>

void swap(int* a, int* b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

void order(int* a, int* b)
{
    if (*a > *b) {
        swap(a, b);
    }
}

void min_max(int l, const int t[], int* min, int* max)
{
    int m = t[0];
    int M = t[0];
    for (int i = 1; i < l; i++) {
        if (m > t[i])
            m = t[i];
        if (M < t[i])
            M = t[i];
    }
    if (min)
        *min = m;
    if (max)
        *max = M;
}

char* stp_copy(char* dst, const char* src)
{
    // Rappel *src++, le ++ est fait en premier
    // mais son évaluation retourne la valeur
    // AVANT la modification du pointeur
    // En cas de doute, effectuez les ++ sur des lignes différentes
    do { // Le do while est utilisé pour ne pas avoir à copier manuellement le zéro terminal
        *dst++ = *src;
    } while (*src++ != 0);
    return dst;
}

size_t str_lenght(const char* src)
{
    const char* p = src;
    while (*p) {
        p++;
    }
    return p - src;
}

int str_compare(const char* s1, const char* s2)
{
    while (*s1) {
        if (*s2 == 0) // s2 se termine avant s1
            return -1; // s2 est donc avant dans le dictionnaire
        if (*s1 != *s2) // Les deux chaines divergents
            return *s1 - *s2; // le signe de la différence donne l'ordre
        s1++;
        s2++;
    }
    // s1 est terminée donc soit s2 l'est aussi, soit s1 est après
    return *s2 != 0;
}

char* str_concat(char* s1, const char* s2)
{
    char* p = s1 + str_lenght(s1); // on avance s1 jusqu'à son zéro terminal
    stp_copy(p, s2); // on copie s2 à la fin de s1 (p)
    return s1; // on retourne l'original
}

void b_zero(char* p, size_t n)
{
    while (n--) {
        *p++ = 0; // En cas de doute sur ce qu'il se passe, faites le en deux lignes.
    }
}

void* mem_copy(void* dst, const void* src, size_t len)
{
    const char* s = src; // on transforme nos pointeurs génériques
    char* d = dst;    // vers des pointeurs de caractères (car leur taille est un octet)
    while (len--)
        *d++ = *s++;
    return dst;
}

int mem_compare(const void* src, const void* dst, size_t len)
{
    const unsigned char* s = src; // on transforme nos pointeurs génériques
    const unsigned char* d = dst;    // vers des pointeurs de caractères non signées (cf. memcmp)
    while (len--) {
        if (*s != *d)
            return *s - *d;
        s++;
        d++;
    }
    return 0;
}

void* mem_set(void* src, int c, size_t len)
{
    unsigned char* p = src;
    unsigned char value = (unsigned char)c; // Cette notation horrible est un `cast`
    // Cela force la conversion vers un unsigned char (troncature des bits en trop etc.)
    // Les cast sont à proscrire tant que ce peut, nous sommes ici dans un des rares
    // cas qui en à besoin.
    while (len--) {
        *p++ = value;
    }
    return src;
}

void swab(const void* src, void* dest, size_t nbytes)
{
    const char* s = src;
    char* d = dest;
    while (nbytes > 1) {
        *d = *(s + 1);
        *(d + 1) = *s;
        s += 2;
        d += 2;
        nbytes -= 2;
    }
    if (nbytes) // le cas ou nbytes est impair
        *d = *s;
}