Recherche de valeurs extrêmes via des pointeurs

L'utilisation des pointeurs permet à une fonnction de modifier plusieurs variables dans la portée de l'appelant ou de renvoyer l'adresse d'un élément spécifique. Voici une implémentation permettant d'extraire les valeurs minimale et maximale d'un ensemble d'entiers.

#include <stdio.h>

#define TAILLE 5

void saisir_donnees(int *tab, int n);
void afficher_donnees(int *tab, int n);
void extraire_limites(int *tab, int n, int *p_min, int *p_max);

int main() {
    int valeurs[TAILLE];
    int v_min, v_max;

    printf("Veuillez saisir %d entiers :\n", TAILLE);
    saisir_donnees(valeurs, TAILLE);

    printf("Contenu du tableau :\n");
    afficher_donnees(valeurs, TAILLE);

    extraire_limites(valeurs, TAILLE, &v_min, &v_max);
    printf("\nTraitement terminé.\nMin : %d, Max : %d\n", v_min, v_max);

    return 0;
}

void saisir_donnees(int *tab, int n) {
    for (int i = 0; i < n; ++i) {
        scanf("%d", &tab[i]);
    }
}

void afficher_donnees(int *tab, int n) {
    for (int i = 0; i < n; ++i) {
        printf("%d ", tab[i]);
    }
    printf("\n");
}

void extraire_limites(int *tab, int n, int *p_min, int *p_max) {
    *p_min = *p_max = tab[0];
    for (int i = 1; i < n; ++i) {
        if (tab[i] < *p_min) *p_min = tab[i];
        if (tab[i] > *p_max) *p_max = tab[i];
    }
}

Différence entre Tableaux et Pointeurs de chaînes

En C, un tableau de caractères (char s[]) réserve un espace mémoire fixe, tandis qu'un pointeur (char *s) stocke l'adersse d'une chaîne de caractères, souvent située dans une zone de lecture seule si elle est initialisée par une constante littérale.

#include <stdio.h>
#include <string.h>

int main() {
    char str_tab[80] = "Programmation C";
    char *str_ptr = "Langage C";

    // sizeof(str_tab) renvoie 80 (taille du tampon)
    // sizeof(str_ptr) renvoie la taille du pointeur (ex: 8 octets sur syst. 64 bits)
    printf("Taille tableau: %zu, Longueur réelle: %zu\n", sizeof(str_tab), strlen(str_tab));
    printf("Taille pointeur: %zu, Longueur réelle: %zu\n", sizeof(str_ptr), strlen(str_ptr));

    return 0;
}

Accès aux tableaux multidimensionnels

Il existe plusieurs méthodes pour parcourir un tableau à deux dimensions en utilisant l'arithmétique des pointeurs. On peut soit utiliser un pointeur simple sur le premier élément, soit un pointeur vers un tableau de taille fixe.

#include <stdio.h>

int main() {
    int matrice[2][3] = {{10, 20, 30}, {40, 50, 60}};
    
    // Methode via pointeur de tableau
    int (*ptr_ligne)[3] = matrice;

    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", *(*(ptr_ligne + i) + j));
        }
        printf("\n");
    }
    return 0;
}

Manipulation et transformation de chaînes

Les fonctions suivantes illustrent le remplacement de caractères et la troncature d'une chaîne à partir d'un délimiteur donné.

#include <stdio.h>

void substituer(char *s, char cible, char remp) {
    while (*s) {
        if (*s == cible) *s = remp;
        s++;
    }
}

char *tronquer(char *s, char marqueur) {
    char *p = s;
    while (*p && *p != marqueur) p++;
    *p = '\0';
    return s;
}

int main() {
    char phrase[50] = "Utiliser_des_espaces";
    substituer(phrase, '_', ' ');
    printf("Après substitution : %s\n", phrase);
    
    tronquer(phrase, ' ');
    printf("Après troncature : %s\n", phrase);
    
    return 0;
}

Validation de format : Cas d'un identifiant

Ce script vérifie si une chaîne respecte un format standard (ici, 18 caractères, les 17 premiers étant des chiffres et le dernier un chiffre ou 'X').

#include <stdio.h>
#include <string.h>
#include <ctype.h>

int verifier_id(const char *id) {
    if (strlen(id) != 18) return 0;
    
    for (int i = 0; i < 17; i++) {
        if (!isdigit(id[i])) return 0;
    }
    
    char dernier = id[17];
    return (isdigit(dernier) || dernier == 'X');
}

int main() {
    char *test_id = "11010119900101123X";
    if (verifier_id(test_id)) {
        printf("Identifiant valide\n");
    } else {
        printf("Format invalide\n");
    }
    return 0;
}

Tri des arguments de la ligne de commande

Le programme suivant trie les chaînes de caractères passées en paramètres au programme lors de son exécution en utilisant l'algorithme du tri à bulles sur le tableau argv.

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
    if (argc < 2) return 1;

    char *temp;
    for (int i = 1; i < argc - 1; i++) {
        for (int j = 1; j < argc - i; j++) {
            if (strcmp(argv[j], argv[j+1]) > 0) {
                temp = argv[j];
                argv[j] = argv[j+1];
                argv[j+1] = temp;
            }
        }
    }

    for (int i = 1; i < argc; i++) {
        printf("Arg %d: %s\n", i, argv[i]);
    }

    return 0;
}