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