Citation : noob4ever

Citation : Pas de titre

Mon second problème est que ça ne me plait pas de limiter la taille de l'adresse donnée et la taille du texte que l'on veut écrire dans le fichier choisit, y a-il un moyen pour éviter ça ? (j'ai penser a l'allocation dynamique mais je ne veut pas non plus demander a l'utilisateur de prévoir le nombre de caractères qu'il compte taper )

C'est les limites de la console, la solution est de passé en IHM avec une RichTextBox.

Citation : gouttegd

Quelles limites ? Il suffit d’allouer un bloc mémoire d’une taille donnée (arbitraire), et au cours de la saisie, de redimensionner le bloc si besoin (avec realloc), jusqu’à ce que la saisie soit terminée.

Nul besoin de sortir le mode graphique (a fortiori une RichTextBox) pour ça...

int
read_line(char **buffer, size_t *len, FILE *f)
{
    char c = 0;
    int n = 0;

    if ( buffer == NULL || len == NULL ) {
        return -1;
    }

    if ( *buffer == NULL ) {
        *len = 0;
    }

    while ( c != '\n' && (c = fgetc(f)) != EOF ) {
        if ( n >= *len ) {
            /* Le tampon est plein (ou il n'a encore jamais été
             * alloué), on le redimensionne (ou on l'alloue). */
            *len += 512;
            *buffer = realloc(*buffer, *len);
        }

        /* On stocke le caractère lu dans le tampon. */
        *(*buffer + n++) = c;
    }

    /* On retourne le nombre de caractères lus (-1 si on est à
     * la fin du flux). */
    return n > 0 ? n : -1;
}

char *buffer = NULL;
size_t buffer_len;

read_line(&buffer, &buffer_len, stdin);

Citation : gouttegd

Citation : noob4ever

Citation : Pas de titre

Mon second problème est que ça ne me plait pas de limiter la taille de l'adresse donnée et la taille du texte que l'on veut écrire dans le fichier choisit, y a-il un moyen pour éviter ça ? (j'ai penser a l'allocation dynamique mais je ne veut pas non plus demander a l'utilisateur de prévoir le nombre de caractères qu'il compte taper )

C'est les limites de la console, la solution est de passé en IHM avec une RichTextBox.

Quelles limites ? Il suffit d’allouer un bloc mémoire d’une taille donnée (arbitraire), et au cours de la saisie, de redimensionner le bloc si besoin (avec realloc), jusqu’à ce que la saisie soit terminée.

Nul besoin de sortir le mode graphique (a fortiori une RichTextBox) pour ça...

Citation : gouttegd

@ noob4ever : Lis le code juste au-dessus, et dis-moi que l'API Win32 est plus simple.

GtkWidget* text_view=gtk_text_view_new();
gtk_box_pack_start(GTK_BOX(box),text_view,TRUE,TRUE,0);

Citation : Pas de titre

ajouter une dépendance à un toolkit graphique pour un truc aussi élémentaire, c’est ton problème.

Citation : Pas de titre

C'est les limites de la console, la solution est de passé en IHM avec une RichTextBox.

Citation : noob4ever

EDIT: j'oubliais, j'ai effectivement dit

Citation

C'est les limites de la console, la solution est de passé en IHM avec une RichTextBox.

Et je sais que tu es très rigoureux donc pour me corriger je remplace "limites" par inconvénient?

void lireFichier(void)
{
    FILE *fichier = NULL;
    char adresse[100] = "";
    char contenu[TAILLE_MAX] = ""; // TAILLE MAX vaut 1000 (peut d'intérêt pour mon problème mais bon  )

    printf ("Veuillez entrer le chemin absolu du fichier que vous voulez lire.\n");
    printf ("Si vous etes sous windows, merci de taper les \\ en double.\n\n");
    lire (adresse, 100);
    printf ("\n");

    fichier = fopen (adresse, "r");

    if (fichier != NULL)
    {
        rewind (fichier);  // Avec ou sans j'ai le même problème

        while (fgets(contenu, TAILLE_MAX, fichier) != NULL)
        {
            printf ("%s", contenu);
        }

        fclose(fichier);
    }

    else
    {
        printf ("Impossible d'ouvrir le fichier, verifiez le chemin donne.\n");
    }

}

Citation : DzEt4

Salut à tous, je pense que je ais abandonner l'idée de taille non limitée, en effet je n'ai pas tout à fait comprit ton code gouttegd...

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

#define nomFichier "fic.000"
#define tailleLecture 80


FILE *fichier = NULL;

void creerFichier();
void lireFichier();
void ecrireFichier();
void Pause(int finPause);
void Presentation();
void AffichageMenu();


int main()
{
    int continuer=1;
    while (continuer != 0)
    {
        system("cls");
        Presentation();
        AffichageMenu();
        printf("\n .......................................................................... \n");
        printf("voulez vous continuer 0= non / 1=oui ? :");
        scanf("%d",&continuer);
    }
    return 0;
}

void creerFichier()
{
    //system ("edit  fic.000");
    printf(" taper control Z et entrer merci");
    system ("copy con: fic.000");

}


void lireFichier()
{
    char chaine[tailleLecture];
    fichier = fopen( nomFichier , "r");// je peux lire uniquement
    if (fichier != NULL)
    {
         // lecture possible
        while (fgets(chaine,tailleLecture,fichier) != NULL)
        {
            printf("%s",chaine);
        }

        // fermeture fichier
        fclose(fichier);
    }
    else
    {
        //lecture impossible
    }

}


void ecrireFichier()
{
    char chaine[80];
    fichier = fopen( nomFichier , "r+");// je peux lire et ecrire
    if (fichier != NULL)
    {
        // ecriture possible
        fseek(fichier,0,SEEK_END);
        printf("quel mot voulez vous rajouter au fichier ?\n");
        scanf("%s",chaine);
        fprintf(fichier,chaine);
        fprintf(fichier,"\n");
        fclose(fichier);
    }
    else
    {
        //lecture impossible
    }
}



void Pause(int finPause)
{
    long i;
    finPause=2000000*finPause;//environ 1 seconde de repis
    for (i=0;i<finPause;i++)
    {
    }
}


void Presentation()
{
    printf("Mon premier projet en C, mon premier challenge. \n");
    printf("_______________________________________________ \n");
    printf("voici l'enonce du probleme \n \n");
    printf(" creer un fichier, pouvoir y ecrire, le lire \n");
    printf("________________________________________________\n\n");

}

void AffichageMenu()
{
    long choix=0;
    while (choix==0)
    {
       //system("cls"); // efface la console sous windows !
       printf("1 : creer un fichier\n");
       printf("2 : lire le fichier \n");
       printf("3 : ecrire dans le fichier \n");
       scanf("%ld",&choix);
       switch (choix)
       {
           case 1 :
           printf("choix 1 : creer un fichier\n");
           creerFichier();
           break;

           case 2 :
           printf("choix 2 : lire dans le fichier \n");
           lireFichier();
           break;

           case 3 :
           printf("choix 3 : ecrire dans le fichier \n");
           ecrireFichier();
           break;

           default :
           printf("Erreur recommencer votre choix\n");
           break;
       }
    }
}

Citation : zx-spectrum

Finalement j'ai le problème suivant lors de la creation de mon fichier ! la seule solution que j'ai trouvé c'est de passer par une fonction de system

Comment fait on en C, dans l'excellent cours de mateo j'ai pas vu ?

Citation : zx-spectrum

Merci, Va falloir que je m'achète des binocles !
reponse : mode d'ouverture "a+"
merci.

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

int main(int argc, char *argv[])
{
    char creer[100] = {0}, enter[100] = {0};
                      
    printf("Quel est le nom et son extention, du fichier a creer ? \n");
    scanf("%s", creer);
    fichier = fopen(creer, "w");
    if (fichier != NULL)
    {
        // On crée le fichier et ont le ferme.
        fclose (fichier);        
    }
    else
    {
         printf("Impossible de creer le fichier %s", creer);
    }
}

printf("Impossible de creer le fichier %c", creer);

Citation : ttthebest

Au fait crys' quand on t'envoie un code est-ce que tu réponds en disant genre "tu pourrais améliorer ici, ou là" ou "non ton truc bugue ici", etc. ?

Citation : gouttegd

@ yoch : Ah bon ?

int
read_line(char **buffer, size_t *len, FILE *f)
{
    char c = 0;
    int n = 0;

    if ( buffer == NULL || len == NULL ) {
        return -1;
    }

    if ( *buffer == NULL ) {
        *len = 0;
    }

    while ( c != '\n' && (c = fgetc(f)) != EOF ) {
        if ( n >= *len ) {
            /* Le tampon est plein (ou il n'a encore jamais été
             * alloué), on le redimensionne (ou on l'alloue). */
            *len += 512;
            *buffer = realloc(*buffer, *len);
        }

        /* On stocke le caractère lu dans le tampon. */
        *(*buffer + n++) = c;
    }

    /* On retourne le nombre de caractères lus (-1 si on est à
     * la fin du flux). */
    return n > 0 ? n : -1;
}

Il n’y a là que du C standard, et sauf erreur bête de ma part (je n’ai pas le temps de tester), ça marche.

On peut ainsi lire une ligne entière (jusqu’au premier caractère '\n', c’est-à-dire jusqu’à un appui sur la touche <Entrée> si on lit depuis le terminal), quelque que soit sa longueur :

char *buffer = NULL;
size_t buffer_len;

read_line(&buffer, &buffer_len, stdin);

C’est plus ou moins le comportement de la fonction (non standard) getline de la bibliothèque C GNU.

Donc, nul besoin de changer le comportement du terminal pour lire les caractères un par un (ce qui, effectivement, serait impossible avec la seule bibliothèque C standard).

int read_line(char **buffer, size_t *len, FILE *f)
{
    char c = 0;
    size_t n = 0;

    if ( buffer == NULL || len == NULL )
    {
        return -1;
    }

    if ( *buffer == NULL )
    {
        *len = 0;
    }

    while ( c != '\n' && (c = fgetc(f)) != EOF )
    {
        if ( n >= *len )
        {
            /* Le tampon est plein (ou il n'a encore jamais été
             * alloué), on le redimensionne (ou on l'alloue). */
            *len += 512;
            *buffer = realloc(*buffer, *len + 1);
        }

        /* On stocke le caractère lu dans le tampon. */
        *(*buffer + n++) = c;
    }
    /* On termine la chaine par un caractere nul */
    *(*buffer + n) = '\0';
    /* On retourne le nombre de caractères lus (-1 si on est à
     * la fin du flux). */
    return (n > 0) ? (int) n : -1;
}

Citation : yoch

Je me permet de corriger un petit oubli dans ta fonction :

/* On termine la chaine par un caractere nul */
*(*buffer + n) = '\0';

Citation : yoch

J'aurais pensé que l'on ne peut pas corriger la saisie, mais j'ai testé et on peut...

Correction pour zReader

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

#define TAILLE 5000

typedef struct fichier
{
    FILE* doc;
    char* chemin;
} fichier;

void read(fichier*);
void write(fichier*);
void creat(fichier*);

void buf(){
    int c = 0;
    while ((c = getchar()) != '\n');
}
void wait(){
    printf("\n Appuyez sur entrer pour retourner au menu...");
    buf();
}
void strcle(char* str){
    char* d = strchr(str, '\n');
    if (d) *d = '\0';
    else buf();
}

int main()
{
    fichier monFichier;
    monFichier.doc = NULL;
    monFichier.chemin = NULL;
    char choixSec[2];
    int choix;

    printf("\n Bienvenue sur zReader - lisez, cr\x82""ez et \x82""crivez dans vos fichiers !\n");

    do{
        printf("\n 1. Lire"
               "\n 2. Ecrire"
               "\n 3. Cr\x82""er"
               "\n 4. Quitter \n"
               "\n Votre choix ? ");

        fgets(choixSec,2,stdin); buf();
        choix = atoi(choixSec);

        if(choix == 1) read(&monFichier);
        else if(choix == 2) write(&monFichier);
        else if(choix == 3) creat(&monFichier);
        else if(choix == 4) break;
        else printf("\n Mauvaise saisie !\n");

    }while(1);

    return EXIT_SUCCESS;
}

void read(fichier* monFichier)
{
    monFichier->chemin = malloc(TAILLE * sizeof(char));
    char c[TAILLE];

    printf("\n Entrez le chemin du fichier : ");
    fgets(monFichier->chemin, TAILLE, stdin);
    strcle(monFichier->chemin);
    printf("\n\n");

    if(monFichier->doc = fopen(monFichier->chemin,"r"))
    {
        printf(" Contenu du fichier : \n\n");
        while (fgets(c,TAILLE,monFichier->doc) != NULL)
        printf(c);
        fclose(monFichier->doc);
    }
    else
    {
        printf(" Le fichier n'existe pas ! \n");
    }
    free(monFichier->chemin);
    wait();
}

void write(fichier* monFichier)
{
    monFichier->chemin = malloc(TAILLE * sizeof(char));
    char inputInFile[TAILLE*3];

    printf("\n Entrez le chemin du fichier (si invalide, le fichier sera cr\x82""e) : ");
    fgets(monFichier->chemin, TAILLE, stdin);
    strcle(monFichier->chemin);
    printf("\n\n");

    monFichier->doc = fopen(monFichier->chemin,"w");
    printf(" Saisie dans le fichier (pour fermer, tapez \"f.close\") : \n\n");
    while(fgets(inputInFile,TAILLE*3,stdin))
    {
        if (strstr(inputInFile,"f.close"))
            break;
        fputs(inputInFile,monFichier->doc);
    }
    fclose(monFichier->doc);
    free(monFichier->chemin);
    printf("\n Contenu enregistr\x82"".");
    wait();
}

void creat(fichier* monFichier)
{
    char path[TAILLE];
    char ext[30];

    printf("\n\n Nom du fichier (extension non-incluse) : ");
    fgets(path,TAILLE,stdin);
    strcle(path);
    printf("\n Extension du fichier : ");
    fgets(ext,30,stdin);
    strcle(ext);

    strcat(path,".");
    strcat(path,ext);

    monFichier->doc = fopen(path,"w");
    fclose(monFichier->doc);
    printf("\n Fichier cr\x82""e avec succ\x8a""s \n\n");
}