#include <stdio.h>
#include <stdlib.h>	// pour l19/20 (srand)
#include <time.h>	// pour l19/20 (time)

void Afficher(char c[]);
int verif_fin(char c[], char car);
int verif_case(char c[], int pos);

int main(void)
{
	int end=1, win1=0, win2=0, j, fin, pos, possible;
	char c[9], car;

	do {
		c[0] = '1', c[1] = '2', c[2] = '3', c[3] = '4', c[4] = '5', c[5] = '6', c[6] = '7', c[7] = '8', c[8] = '9';
		fin=0;
		possible=1;

		srand(time(NULL));
		j = (rand() % (2 - 1 + 1)) + 1;

		system("clear");
		Afficher(c);

		do {
			if (j == 1)
			{
					printf("\n Joueur 1 :\t");
					scanf("%d", &pos);
					j = 2;
					car = 'X';
			}

			else
			{
					printf("\n Joueur 2 :\t");
					scanf("%d", &pos);
					j = 1;
					car = 'O';
			}

					possible = verif_case(c, pos);

					if (possible == 0 || pos > 9 || pos < 1)
					{
						do {
							printf("\n Case déjà remplie, ou mauvais chiffre entré. Veuillez recommencer :\t");
							scanf("%d", &pos);
							possible = verif_case(c, pos);
						} while (possible == 0);
					}
			
			c[pos-1] = car;

			system("clear");
			Afficher(c);
			fin = verif_fin(c, car);

		} while (fin == 0);

		if (fin == 3)
		{
			printf("\n\nMatch nul.\n\n");
		}

		else
		{
			printf("\n\nVictoire du joueur %d.\n\n", fin);
		}

		if (fin == 1)
		{
			win1++;
		}

		if (fin == 2)
		{
			win2++;
		}

		printf("\tRejouer ?\t1. Oui\n\t\t\t2. Non\t\t");
		scanf("%d", &end);

	} while (end == 1);

	if (win1 > win2)
	{
		printf("Victoire %d à %d du joueur 1.\n\n", win1, win2);
	}

	if (win1 == win2)
	{
		printf("Égalité %d partout.\n\n", win1);
	}

	if (win1 < win2)
	{
		printf("\nVictoire %d à %d du joueur 2.\n\n", win2, win1);
	}

	return 0;
}



////////////////////////////////////////////////////////////////
void Afficher(char c[])
{
	printf("\n\t\t ___________");
	printf("\n\t\t|   |   |   |");
	printf("\n\t\t| %c | %c | %c |", c[0], c[1], c[2]);
	printf("\n\t\t|___|___|___|");
	printf("\n\t\t|   |   |   |");
	printf("\n\t\t| %c | %c | %c |", c[3], c[4], c[5]);
	printf("\n\t\t|___|___|___|");
	printf("\n\t\t|   |   |   |");
	printf("\n\t\t| %c | %c | %c |", c[6], c[7], c[8]);
	printf("\n\t\t|___|___|___|\n");
}



int verif_fin(char c[], char car)
{
	int fin = 0;

	if ( (c[0] == c[1] && c[1] == c[2]) || (c[3] == c[4] && c[4] == c[5]) || (c[6] == c[7] && c[7] == c[8]) || (c[0] == c[3] && c[3] == c[6]) || (c[1] == c[4] && c[4] == c[7]) || (c[2] == c[5] && c[5] == c[8]) || (c[0] == c[4] && c[4] == c[7]) || (c[2] == c[4] && c[4] == c[6]))
	{
		if (car == 'X')
		{
			fin = 1;
		}

		else
		{
			fin = 2;
		}
	}

	if ( c[0] != '1' && c[1] != '2' && c[2] != '3' && c[3] != '4' && c[4] != '5' && c[5] != '6' && c[6] != '7' && c[7] != '8' && c[8] != '9' && fin !=1 && fin !=2 )
	{
		fin = 3;
	}

	return(fin);
}



int verif_case(char c[], int pos)
{
	int res;

	if ( (pos==1 && c[0]!='1') || (pos==2 && c[1]!='2') || (pos==3 && c[2]!='3') || (pos==4 && c[3]!='4') || (pos==5 && c[4]!='5') || (pos==6 && c[5]!='6') || (pos==7 && c[6]!='7') || (pos==8 && c[7]!='8') || (pos==9 && c[8]!='9') || pos > 9 || pos < 1 )
	{
		res=0;
	}

	else
	{
		res=1;
	}

	return(res);
}

#include <stdio.h>

int
main(void) {

    int resultat = 0, nb = 0;
    char op = '+';

    while (op != 'q') {
        printf("Entrez un nombre : ");
        scanf("%d",&nb);
        while (getchar() != '\n');

        if (op == '+')
            resultat += nb;
        else if (op == '-')
            resultat -= nb;
        else if (op == '*')
            resultat *= nb;
        else if (op == '/')
            resultat /= nb;

        printf("Quelle operation (+, -, *, /, c, q) : %d ", resultat);
        op = getchar();

        if (op == 'c') {
            resultat = 0;
            op = '+';
        }
    }

    return 0;
}

Citation : Lithrein

Prérequis

• Entrées / Sorties
• Manipulations de fichiers.
• Gestion des erreurs.
• (Ré)allocation de mémoire.
• Utilisation de fonctions.

Énoncé

La fonction 'getline` qui sert à récupérer une ligne - chaine de caractères se terminant par un '\n'. C'est une extension de la bibliothèque standard fournie par la glibc. Elle n'existe donc pas sur Windows, par contre, elle existe sur les Unix-like (pensez donc à nommer votre fonction autrement).

L'exercice suivant vous propose de réécrire cette fonction qui est assez intéressante puisqu'elle fait appel à vos connaissances en C plutôt qu'à d'autres choses.

Le manuel de la fonction :
man (3) getline : (fr), (en).

La gestion des entrées sorties et des erreurs n'est pas forcément évidente, n'hésitez donc pas à faire le travail étape par étape et à approfondir les concepts.
Toute question est la bienvenue sur le fil destiné à cet usage →.

L'idée originale est de yoch

Bonne Chance.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <errno.h>

/********* Documentation ***********************************************************
 * getline()  lit  une  ligne  entiere et stocke l'adresse du tampon contenant le  *
 * texte  dans *lineptr. Le tampon se termine par un 0 terminal et inclut le cara- *
 * ctere saut-de-ligne, si un tel separateur a ete trouve.                         *
 * Si  *lineptr  vaut NULL, la routine getline() alloue un tampon pour recevoir la *
 * ligne, ce tampon devra etre libere par le programme utilisateur.                *
 * Alternativement,  avant d'appeler getline(), *lineptr peut contenir un pointeur *
 * vers  un  tampon alloue par malloc() et de taille *n octets. Si le buffer n'est *
 * pas  suffisant  pour  recevoir  la  ligne  saisie,  getline()  redimensionne le *
 * tampon afin de s'adapter grace a realloc(), mettant a jour *lineptr et *n comme *
 * il se doit. Quoi qu'il en soit, en cas de succes, *lineptr et *n seront adaptes *
 * afin de rendre compte respectivement de l'adresse et de la taille du tampon.    *
 * getdelim()  fonctionne  comme getline(), si ce n'est qu'un separateur different *
 * de  saut-de-ligne  peut etre specifie en tant qu'argument delimiter. Tout comme *
 * avec  getline(),  aucun  separateur  n'est  ajoute  s'il  n'y en avait pas dans *
 * l'entree avant que la fin du fichier ne soit atteinte.                          *
 ***********************************************************************************/
/*#ifndef _SSIZE_T_
#define _SSIZE_T_
typedef long ssize_t; * signed size_t *
#endif*/

#define BUF_SIZE (256) /* 1 << 8  */
#define DEBUG 1

struct buffer_s {
    char * string;
    size_t buf_length;
};

struct buffer_s
create_buffer (char * bufptr, int n) {
    struct buffer_s buf = {NULL, 0};

    if (bufptr == NULL) {
        errno = 0;
        if ((buf.string = calloc(BUF_SIZE, sizeof *(buf.string))) == NULL) {
            puts(strerror(errno));
        }
    } else {
        buf.string = bufptr;
    }

    buf.buf_length = (bufptr) ? n : BUF_SIZE;

    return buf;
}

int
buffer_append (struct buffer_s * buf, char * content) {
    size_t content_len;
    size_t buf_len;

    if (!buf || !content)
        return -1;

    content_len = strlen(content);
    buf_len     = strlen(buf->string);
    errno       = 0;

    if (content_len == 0)
        return -1;

    if (buf_len + content_len + 1 > buf->buf_length) {
        char * new_lineptr = NULL;
        long needed = buf->buf_length + 2 * content_len + 1;

        if (needed < 0) {
            errno = ERANGE;
            return -1;
        }

        if ((new_lineptr = realloc(buf->string, needed)) == NULL)
            return -1;

        buf->string     = new_lineptr;
        buf->buf_length = needed;
    }

    /* /!\ strncat ajoute un '\0' en plus des 'content_len` caracteres
      si celui-ci n'est pas present. */

    strncat(buf->string, content, content_len);

    return errno;
}

int
buffer_fix (struct buffer_s * buf) {
    char * new_lineptr = NULL;
    size_t str_len;

    if (buf == NULL)
        return -1;

    errno = 0;
    str_len = strlen(buf->string);

    if ((new_lineptr = calloc(str_len + 1, sizeof *(buf->string))) == NULL)
        return errno;

    strncpy(new_lineptr, buf->string, str_len);
    new_lineptr[str_len] = '\0'; /* Useless */

    free(buf->string), buf->string = NULL;

    buf->string = new_lineptr;
    buf->buf_length = str_len+1;

    return errno;
}

ssize_t _getline(char **lineptr, size_t *n, FILE *stream);
ssize_t _getdelim(char **lineptr, size_t *n, int delim, FILE *stream);

ssize_t
_getdelim(char **lineptr, size_t *n, int delim, FILE *stream) {
    struct buffer_s buffer;
    long nb_car;
    int c, i;
    char tmp[BUF_SIZE+1] = {0};

    if (!lineptr || !n || !stream) {
        errno = EINVAL;
        return -1;
    }

    errno = 0;
    buffer = create_buffer(*lineptr, *n);
    nb_car = 0;

    if (errno == ENOMEM)
        return -1;

    for (i = 0 ; (c = getc(stream)) != delim && c != EOF ; ++nb_car, i = (i + 1) % BUF_SIZE) {
        int err = 0;

        if (i == 0)
            memset(tmp, 0, BUF_SIZE);
        else if (i == BUF_SIZE - 1)
            err = buffer_append(&buffer, tmp);

            tmp[i] = c;

        if (err)
            return -1;
    }

    if (buffer_append(&buffer, tmp))
        return -1;

    if (c == EOF)
        return -1;
    if (c == delim) {
        char tmp[2] = {0};
        tmp[0] = delim;
        buffer_append(&buffer, tmp);
    }

    /* '\0' est present de base a la fin du buffer */
    if (buffer_fix(&buffer))
        return -1;

    *lineptr = buffer.string;
    *n = strlen(*lineptr);

    return nb_car;
}

ssize_t
_getline(char **lineptr, size_t *n, FILE *stream) {
    return _getdelim(lineptr, n, '\n', stream);
}

#if DEBUG
int
main(int argc, char * argv[]) {
     FILE * fp;
     char * line = NULL;
     size_t len = 0;
     ssize_t read;
    if (argc < 2)
        return EXIT_FAILURE;
     fp = fopen(argv[1], "r");
     if (fp == NULL)
         return EXIT_FAILURE;

     while ((read = _getline(&line, &len, fp)) != -1) {
        /* printf("Retrieved line of length %zu :\n", read);*/
     }
     printf("%s", line);

     if (line)
         free(line);
     return EXIT_SUCCESS;
}
#endif

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

int
main (void) {
    char delim = '\n';
    printf("%d", (int) strlen((char *) &delim));

    return 0;
}