– comparaison pour identifier l’égalité ou l’inégalité.

Le but pratique d'une énumération est de définir un ensemble de constantes symboliques distinctes d'un type entier.

Un exemple d'utilisation de variables énumérées :

mo=1, tu, we, th, fr, sa, di ) jours ;

puts(“ Entrez le jour de la semaine (de 1 à 7) : ”); scanf("%d", &t_day);

w_day = su; début = mois ;

fin = w_day -t_day ;

printf("\nLundi est le %d jour de la semaine, \maintenant est le %d jour.\n\

Jusqu'à la fin de la semaine %d jours (jours). », début, t_day, fin);

Résultat du programme : Saisir le jour de la semaine (de 1 à 7) : 2

Lundi est le 1er jour de la semaine, maintenant c'est le 2ème jour. Il reste 5 jours (jours) jusqu'à la fin de la semaine.

18. Fichiers en langage C

Un fichier est un ensemble de données localisées sur un support externe et considérées comme un tout lors du traitement. Les fichiers contiennent des données destinées au stockage à long terme.

Il existe deux types de fichiers : texte et binaire. Les fichiers texte sont une séquence de caractères ASCII et peuvent être visualisés et modifiés à l'aide de n'importe quel éditeur de texte.

Les fichiers binaires (binaires) sont une séquence de données dont la structure est déterminée par un logiciel.

Le langage C dispose d'un large éventail de fonctions pour travailler avec des fichiers, dont la plupart se trouvent dans les bibliothèques stdio.h et io.h.

18.1. Ouvrir un fichier

Chaque fichier se voit attribuer un nom logique interne, qui est utilisé ultérieurement lors de son accès. Le nom logique (identifiant du fichier) ​​est

pointeur vers le fichier, c'est-à-dire vers une zone mémoire contenant toutes les informations nécessaires sur le fichier. Le format de déclaration d'un pointeur vers un fichier est le suivant :

	FILE * pointeur vers le fichier ;
FILE – identifiant du type de structure décrit dans la bibliothèque standard
stdio.h et contenant les informations suivantes :
tapez structure(
	– le nombre d'octets non lus restant dans la mémoire tampon ;
	la taille habituelle du tampon est de 512 octets ; dès que niveau=0,
	le bloc de données suivant est lu dans le tampon à partir du fichier ;
	– indicateur d'état du fichier – lecture, écriture, ajout ;
	– descripteur de fichier, c'est-à-dire numéro définissant son no-
conservation de caractères non signés ;	– caractère non transmis, c'est-à-dire caractère ungetc ;
	– taille du tampon intermédiaire interne;
tampon de caractères non signé ;	– valeur du pointeur pour l'accès à l'intérieur du tampon, c'est-à-dire
	spécifie le début du tampon, le début de la ligne ou la valeur actuelle
	La valeur du pointeur à l'intérieur du tampon en fonction du mode
	ma mise en mémoire tampon ;
caractère non signé *curp;	– valeur actuelle du pointeur d’accès à l’intérieur du
	fera, c'est-à-dire spécifie la position actuelle dans le tampon d'échange
	continuez avec le programme ;
istemp non signé ;	– indicateur de fichier temporaire ;
	– indicateur lorsque vous travaillez avec un fichier ;
) DÉPOSER;

Avant de commencer à travailler avec le fichier, c'est-à-dire Pour pouvoir lire ou écrire des informations dans un fichier, celui-ci doit être ouvert pour y accéder. À cette fin, la fonction est généralement utilisée

FILE* fopen(char* nom_fichier, char* mode);

il prend une représentation externe - le nom physique d'un fichier sur un support (disquette, disque dur) et lui fait correspondre un nom logique.

Nom physique, c'est-à-dire le nom du fichier et son chemin d'accès sont spécifiés par le premier paramètre

– une ligne, par exemple « a:Mas_dat.dat » – un fichier nommé Mas_dat.dat situé sur une disquette, « d:\\work\\Sved.txt » – un fichier nommé Sved.txt situé sur le disque dur conduire dans le répertoire de travail.

Attention! La barre oblique inverse (\), en tant que caractère spécial, est écrite deux fois sur une ligne.

Lors d'une ouverture réussie, la fonction fopen renvoie un pointeur vers le fichier (ci-après dénommé le pointeur de fichier). En cas d'erreur, NULL est renvoyé. Cette situation se produit généralement lorsque le chemin d'accès au fichier à ouvrir est mal spécifié. Par exemple, si dans la classe d'affichage de notre université vous spécifiez un chemin interdit à l'écriture (généralement d:\work\ est autorisé).

Le deuxième paramètre est une ligne qui spécifie le mode d'accès au fichier :

w – le fichier est ouvert en écriture ; s'il n'existe aucun fichier portant le nom donné, il sera créé ; si un tel fichier existe, alors les informations précédentes sont détruites avant ouverture ;

r – le fichier s'ouvre en lecture seule ; s'il n'existe pas de fichier de ce type, une erreur se produit ;

a – le fichier est ouvert pour ajouter de nouvelles informations à la fin ;

r+ – le fichier est ouvert pour éditer les données – l'écriture et la lecture des informations sont possibles ;

w+ – le même que pour r+ ;

a+ – comme pour a, seule l'écriture peut être effectuée n'importe où dans le fichier ; la lecture de fichiers est également disponible ;

t – le fichier s'ouvre en mode texte ; b – le fichier s'ouvre en mode binaire.

Le mode texte diffère du mode binaire en ce sens que lorsqu'un fichier est ouvert sous forme de texte, la paire de caractères « saut de ligne », « retour chariot » est remplacée par un seul caractère : « saut de ligne » pour toutes les fonctions d'écriture de données dans le fichier. , et pour toutes les fonctions de sortie le caractère "saut de ligne" " est désormais remplacé par deux caractères : "saut de ligne", "retour chariot".

Par défaut, le fichier s'ouvre en mode texte. Exemple : FICHIER *f; – un pointeur vers le fichier f est déclaré ;

f = fopen("d:\\work\\Dat_sp.cpp", "w"); – un fichier de nom logique f, qui porte le nom physique Dat_sp.cpp, situé sur le lecteur d, dans le répertoire de travail, est ouvert en écriture ; ou plus brièvement

FICHIER *f = fopen("d:\\work\\Dat_sp.cpp", "w");

18.2. Fermer un fichier

Après avoir travaillé avec un fichier, l'accès à celui-ci doit être fermé. Ceci est fait par la fonction int fclose (pointeur de fichier). Par exemple, d'après l'exemple précédent, le fichier est fermé comme ceci : fclose (f);

Pour fermer plusieurs fichiers, une fonction est introduite, déclarée comme suit : void fcloseall (void) ;

Si vous devez modifier le mode d'accès à un fichier, vous devez d'abord fermer le fichier puis l'ouvrir à nouveau, mais avec des droits d'accès différents. Pour ce faire, utilisez la fonction standard :

FILE* freopen (char*file_name, char *mode, FILE *file_pointer);

Cette fonction ferme d'abord le fichier déclaré pointeur_fichier(comme le fait la fonction fopen), puis ouvre le fichier avec le nom de fichier et les autorisations "mode".

Le langage C a la capacité de travailler avec des fichiers temporaires qui ne sont nécessaires que pendant l'exécution du programme. Dans ce cas, la fonction est utilisée

FILE* fichier tmp (vide);

qui crée un fichier temporaire sur le disque avec les droits d'accès « w+b » ; une fois le programme terminé ou après la fermeture du fichier temporaire, il est automatiquement supprimé.

18.3. Écrire – lire des informations

Toutes les actions de lecture et d'écriture de données dans un fichier peuvent être divisées en trois groupes : les opérations d'entrée-sortie caractère par caractère ; opérations d'E/S ligne par ligne ; bloquer les opérations d’E/S.

Regardons les principales fonctions utilisées dans chacun de ces trois groupes d'opérations.

E/S caractère par caractère

Dans les fonctions d'E/S caractère par caractère, un caractère est reçu d'un fichier ou un caractère est envoyé à un fichier :

E/S de ligne

Transfert des fonctions E/S ligne depuis un fichier ou vers

Bloquer les E/S

Les fonctions d'E/S de bloc fonctionnent sur des blocs entiers

information:
int fread (void*p, intsize,	– lit n blocs de taille en octets chacun dans le fichier
int n, FICHIER *f)	la f vers une zone mémoire avec le pointeur p (obligatoire
int fwrite (void*p, intsize,	allouer de la mémoire à l'avance pour le bloc à lire);
	– écrit n blocs de taille octets chacun à partir du
int n, FICHIER *f)	zone mémoire avec pointeur p vers le fichier f.

Les E/S formatées sont produites par des fonctions.

Pour faciliter l'accès, les informations contenues dans les périphériques de stockage sont stockées sous forme de fichiers.

Un fichier est une zone nommée de mémoire externe allouée au stockage d'un tableau de données. Les données contenues dans les fichiers sont de nature très diverse : programmes en langage algorithmique ou machine ; données initiales pour le fonctionnement du programme ou les résultats de l'exécution du programme ; textes libres; images graphiques, etc.

Répertoire (dossier, répertoire) - une collection nommée d'octets sur un support de stockage contenant les noms des sous-répertoires et des fichiers, utilisée dans le système de fichiers pour simplifier l'organisation des fichiers.

Système de fichiers appelé la partie fonctionnelle du système d'exploitation qui effectue des opérations sur les fichiers. Des exemples de systèmes de fichiers sont FAT (FAT – File Allocation Table), NTFS, UDF (utilisés sur les CD).

Il existe trois versions principales de FAT : FAT12, FAT16 et FAT32. Ils diffèrent par la profondeur de bits des enregistrements dans la structure du disque, c'est-à-dire le nombre de bits alloués pour stocker le numéro de cluster. FAT12 est principalement utilisé pour les disquettes (jusqu'à 4 Ko), FAT16 – pour les disques de petite capacité, FAT32 – pour les lecteurs FLASH de grande capacité (jusqu'à 32 Go).

Examinons la structure du système de fichiers en utilisant FAT32 comme exemple.

Structure du fichier FAT32

Les périphériques de mémoire externes du système FAT32 ont un adressage par bloc plutôt que par octet. Les informations sont écrites sur un périphérique de mémoire externe sous forme de blocs ou de secteurs.

Un secteur est l’unité adressable minimale de stockage d’informations sur des périphériques de stockage externes. Généralement, la taille du secteur est fixée à 512 octets. Pour augmenter l'espace d'adressage des périphériques de mémoire externes, les secteurs sont regroupés en groupes appelés clusters.

Un cluster est une union de plusieurs secteurs, qui peuvent être considérés comme une unité indépendante possédant certaines propriétés. La principale propriété d'un cluster est sa taille, mesurée en nombre de secteurs ou en nombre d'octets.

Le système de fichiers FAT32 a la structure suivante.

Les clusters utilisés pour l'écriture des fichiers sont numérotés à partir de 2. En règle générale, le cluster n°2 est utilisé par le répertoire racine, et à partir du cluster n°3, le tableau de données est stocké. Les secteurs utilisés pour stocker les informations au-dessus du répertoire racine ne sont pas regroupés.
La taille minimale de fichier requise sur le disque correspond à 1 cluster.

Le secteur de démarrage commence par les informations suivantes :

• EB 58 90 – saut inconditionnel et signature ;
• 4D 53 44 4F 53 35 2E 30 MSDOS5.0 ;
• 00 02 – nombre d'octets dans le secteur (généralement 512) ;
• 1 octet – nombre de secteurs dans le cluster ;
• 2 octets – nombre de secteurs de réserve.

De plus, le secteur de démarrage contient les informations importantes suivantes :

• 0x10 (1 octet) – nombre de tables FAT (généralement 2) ;
• 0x20 (4 octets) – nombre de secteurs sur le disque ;
• 0x2С (4 octets) – numéro de cluster du répertoire racine ;
• 0x47 (11 octets) – étiquette de volume ;
• 0x1FE (2 octets) – signature du secteur de démarrage (55 AA).

Le secteur d'informations du système de fichiers contient :

• 0x00 (4 octets) – signature (52 52 61 41) ;
• 0x1E4 (4 octets) – signature (72 72 41 61) ;
• 0x1E8 (4 octets) – nombre de clusters libres, -1 si inconnu ;
• 0x1EC (4 octets) – numéro du dernier cluster enregistré ;
• 0x1FE (2 octets) – signature (55 AA).

La table FAT contient des informations sur l'état de chaque cluster sur le disque. Les 2 octets inférieurs de la table FAT stockent F8 FF FF 0F FF FF FF FF (ce qui correspond à l'état des clusters 0 et 1, physiquement absents). De plus, l'état de chaque cluster contient le numéro du cluster dans lequel le fichier en cours se poursuit ou les informations suivantes :

• 00 00 00 00 – le cluster est gratuit ;
• FF FF FF 0F – fin du fichier en cours.

• 8 octets – nom du fichier ;
• 3 octets – extension de fichier ;

Le répertoire racine contient un ensemble d'enregistrements d'informations 32 bits sur chaque fichier, contenant les informations suivantes :

Lorsque vous travaillez avec des noms de fichiers longs (y compris les noms russes), le nom du fichier est codé à l'aide du système de codage UTF-16. Dans ce cas, 2 octets sont alloués pour coder chaque caractère. Dans ce cas, le nom du fichier est écrit dans la structure suivante :

• 1 octet de séquence ;
• 10 octets contiennent les 5 caractères inférieurs du nom de fichier ;
• attribut de 1 octet ;
• 1 octet réservé ;
• 1 octet – somme de contrôle du nom DOS ;
• 12 octets contiennent les 3 caractères inférieurs du nom de fichier ;
• 2 octets – numéro du premier cluster ;
• les caractères restants du nom long.

Travailler avec des fichiers en langage C

Pour le programmeur, un fichier ouvert est représenté comme une séquence de données en cours de lecture ou d'écriture. Lorsqu'un fichier est ouvert, il est associé à Flux d'E/S. Les informations de sortie sont écrites dans le flux, les informations d'entrée sont lues à partir du flux.

Lorsqu'un flux est ouvert pour les E/S, il est associé à une structure FILE standard, définie dans stdio.h. La structure FILE contient les informations nécessaires sur le fichier.

L'ouverture d'un fichier se fait à l'aide de la fonction fopen(), qui renvoie un pointeur vers une structure FILE pouvant être utilisée pour des opérations ultérieures sur le fichier.

FICHIER *fopen(nom, type);

nom – nom du fichier à ouvrir (y compris le chemin),
type est un pointeur vers une chaîne de caractères qui définit la manière dont le fichier est accessible :

• "r" - ouvre le fichier en lecture (le fichier doit exister) ;
• "w" - ouvre un fichier vide en écriture ; si le fichier existe, son contenu est perdu ;
• "a" - ouvre le fichier pour l'écrire jusqu'à la fin (pour l'ajouter) ; le fichier est créé s'il n'existe pas ;
• "r+" - ouvre le fichier en lecture et en écriture (le fichier doit exister) ;
• "w+" - ouvre un fichier vide en lecture et en écriture ; si le fichier existe, son contenu est perdu ;
• "a+" - ouvre le fichier pour le lire et l'ajouter ; si le fichier n'existe pas, il est créé.

La valeur de retour est un pointeur vers le flux ouvert. Si une erreur est rencontrée, NULL est renvoyé.

La fonction fclose() ferme le ou les flux associés aux fichiers ouverts à l'aide de la fonction fopen(). Le flux à fermer est déterminé par l'argument de la fonction fclose().

Valeur de retour : valeur 0 si le flux a été fermé avec succès ; EOF constant si une erreur survient.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#inclure
int main() (
FICHIER *fp;
nom du caractère = "mon.txt" ;
if ((fp = fopen(name, "r" )) == NULL )
{
printf( "Échec de l'ouverture du fichier");
getchar();
renvoie 0 ;
}
// réussi à ouvrir le fichier
... // actions requises sur les données
fclose(fp);
getchar();
renvoie 0 ;
}

Lire un caractère à partir d'un fichier:

char fgetc(flux);

L'argument de la fonction est un pointeur vers un flux de type FILE. La fonction renvoie le code du caractère lu. Si la fin du fichier est atteinte ou qu'une erreur se produit, la constante EOF est renvoyée.

Écrire un symbole dans un fichier:

fputc(char, flux);

Les arguments de la fonction sont un caractère et un pointeur vers un flux de type FILE. La fonction renvoie le code du caractère lu.

Les fonctions fscanf() et fprintf() sont similaires aux fonctions scanf() et printf(), mais fonctionnent avec des fichiers de données et ont un pointeur de fichier comme premier argument.

fscanf(flux, "InputFormat", arguments);

Pour le programmeur, un fichier ouvert est représenté comme une séquence de données en cours de lecture ou d'écriture. Lorsqu'un fichier est ouvert, il est associé à Flux d'E/S . Les informations de sortie sont écrites dans le flux, les informations d'entrée sont lues à partir du flux.

Lorsqu'un flux est ouvert pour les E/S, il est associé à une structure FILE standard, définie dans stdio.h. La structure FILE contient les informations nécessaires sur le fichier.

L'ouverture d'un fichier se fait à l'aide de la fonction fopen(), qui renvoie un pointeur vers une structure de type FILE pouvant être utilisée pour les opérations ultérieures sur le fichier.

FICHIER *fopen(nom, type);

nom – nom du fichier à ouvrir (y compris le chemin),
type - pointeur vers une chaîne de caractères définissant la manière dont le fichier est accessible :

· "r" - ouvre le fichier en lecture (le fichier doit exister) ;

· "w" - ouvre un fichier vide en écriture ; si le fichier existe, son contenu est perdu ;

· "a" - ouvre le fichier pour l'écrire jusqu'à la fin (pour l'ajouter) ; le fichier est créé s'il n'existe pas ;

· "r+" - ouvre le fichier en lecture et en écriture (le fichier doit exister) ;

· "w+" - ouvre un fichier vide pour la lecture et l'écriture ; si le fichier existe, son contenu est perdu ;

· "a+" - ouvre le fichier pour lecture et ajout ; si le fichier n'existe pas, il est créé.

La valeur de retour est un pointeur vers le flux ouvert. Si une erreur est détectée, NULL est renvoyé.

La fonction fclose() ferme le ou les flux associés aux fichiers ouverts à l'aide de la fonction fopen(). Le flux à fermer est déterminé par l'argument de la fonction fclose().

Valeur de retour : valeur 0 si le flux a été fermé avec succès ; EOF constant si une erreur survient.

#inclure
int principal()

char name="mon.txt";

si(fp = fopen(nom, "r")!=NULL)

// était-il possible d'ouvrir le fichier ?
... // actions requises sur les données

else printf("Échec de l'ouverture du fichier");

Lire un caractère à partir d'un fichier:

char fgetc(flux);

L'argument de la fonction est un pointeur vers un flux de type FILE. La fonction renvoie le code du caractère lu. Si la fin du fichier est atteinte ou qu'une erreur se produit, la constante EOF est renvoyée.
Écrire un symbole dans un fichier:

fputc(char, flux);

Les arguments de la fonction sont un caractère et un pointeur vers un flux de type FILE. La fonction renvoie le code du caractère lu.

Les fonctions fscanf() et fprintf() sont similaires aux fonctions scanf() et printf(), mais fonctionnent avec des fichiers de données et ont un pointeur vers le fichier comme premier argument.

fscanf(flux, "Format d'entrée", arguments);
fprintf(stream, "Format de sortie", arguments);

Les fonctions fgets() et fputs() sont conçues pour l'entrée/sortie de chaînes ; elles sont analogues aux fonctions gets() et puts() pour travailler avec des fichiers.

fgets (pointeur vers la ligne, nombre de caractères, flux);

Les caractères sont lus à partir du flux jusqu'à ce qu'un caractère de nouvelle ligne "\n" soit lu, qui est inclus dans la chaîne, ou jusqu'à ce que le flux termine EOF ou que le nombre maximum de caractères ait été lu. Le résultat est placé dans un pointeur de chaîne et se termine par le caractère nul "\0". La fonction renvoie l'adresse de la chaîne.

fputs (pointeur vers chaîne, flux);

Copie une chaîne dans le flux à partir de la position actuelle. Le caractère nul de fin n'est pas copié.
Exemple Entrez le numéro et enregistrez-le dans le fichier s1.txt. Lisez le numéro du fichier s1.txt, augmentez-le de 3 et enregistrez-le dans le fichier s2.txt.

Nous avons déjà appris à écrire des informations dans un fichier texte. – Si vous n’avez pas appris comment faire, consultez l’article précédent. C'est raconté et décrit en détail

Mais que se passe-t-il si le fichier existe déjà et que nous devons en lire des informations pour les traiter ? Heureusement, c'est aussi assez simple. Permettez-moi de vous rappeler qu'il existe plusieurs options pour mettre en œuvre cette tâche ; je n'en ai décrit qu'une seule. Celui décrit est celui qui, pour une raison quelconque, me semble personnellement le plus simple à comprendre.

#inclure

int principal()
{
caractère s1 //La variable lira la chaîne
ifstream dans (« C:\\\FromC\\myfile.txt » ); //Ouvrez le fichier pour lire les informations
dans >>s1 ; //lire la ligne
in.close() // Fermeture du dossier

cout<Afficher la valeur s1à l'écran
renvoie 0 ;
}

Voici le programme le plus simple pour lire la première ligne d'un fichier texte situé le long du chemin
C:\\\FromC\\monfichier.txt –
Puisqu'il s'agit d'une continuation de l'article précédent, j'ai décidé d'utiliser le fichier que nous y avons créé. Cela ne devrait probablement pas poser de difficultés.
Mais revenons au code. Nous ouvrons d’abord le fichier pour en lire les informations, pour cela nous utilisons la commande ifstream entre parenthèses, nous indiquons soit le nom du fichier, soit le chemin d'accès au fichier, comme je l'ai fait. (« C:\\\FromC\\monfichier.txt » );
Lorsque nous ouvrions un fichier pour en lire quelque chose, nous déclarions une variable comme char -
caractère s1
Il ne nous reste plus qu'à attribuer à la variable la valeur de la chaîne du fichier. Nous faisons cela en équipe dans
Faites attention aux équerres dans >>
En fait, comme cela devrait ressortir des commentaires sur le code du programme, pour que la variable attribue la valeur lue, nous devons l'écrire après dans >>
dans >>s1 ;

Cela ne semble pas être une tâche particulièrement difficile, surtout si vous maîtrisez déjà parfaitement et avez appris à utiliser le matériel de l'article précédent - tout est absolument pareil, seules 2 commandes sont différentes

Créer un fichier et y écrire des informations C++

de flux dehors ( Nom de fichier );
dehors<< (Chaîne à écrire);
dehors.fermer();
=============================

Lire le texte d'un fichier et imprimer le texte à l'écran en C++

ifstream dans (Nom de fichier );
dans>> (Lire la ligne);
dans.fermer();(Fermez le fichier)
============================
Écrivons un programme simple qui lira le texte saisi au clavier et l'écrira dans un fichier :

#inclure
#inclure

int principal()
{
\\ 3 futures lignes
clrscsr(); // Effacer l'écran

cout<<“Wwedi pervuu stroku” ; cin >>a ; fin ;
cout<<“Wwedi wtoruu stroku” ; cin >>b ; fin ;
cout<<“Wwedi tretuu stroku” ; cin >>c ; fin ;
clrscr(); //

/*Commence à travailler avec le fichier*/
ofstream out (« C:\\\FromC\\myfile.txt » ); //Ouvrir un fichier en écriture
dehors<Écrivez la première ligne
dehors<Écrivez la deuxième ligne
dehors<Écrivez la troisième ligne
out.close(); // Fermeture du dossier

// Remise à zéro des variables

pour (int je =0 ;je<=255 ;i ++)
(a =*"" ; b =*"" ; c =*"" ;)

ifstream dans (« C:\\\FromC\\monfichier.txt » );
dans >>a >>b >>c ; //Nous lisons chaque nouvelle ligne dans une nouvelle variable
joindre(); // Fermeture du dossier

/* */

pour (i =0 ;a !=*“” ;i ++)
{
si (i >sizeof(a )) casser ;
cout<
}
cout<<“\n” ; \\

/* */

{
si (i > taille de (b)) casser ;
cout<
}
cout<<“\n” ; \\ Déplacement du curseur vers une nouvelle ligne

/* */

pour (i =0 ;с !=*“” ;i ++)
{
si (i >sizeof(c )) casser ;
cout<<с ;
}

renvoie 0 ;
}
===================

Dans les exemples ci-dessus, il y en a un ÉNORME défaut. Si nous essayons de saisir une ligne contenant des espaces, le programme ne fonctionnera pas comme nous le souhaitons. Probablement, non seulement moi, mais aussi de nombreuses autres personnes ont rencontré cette erreur. Par conséquent, je laisse le code incorrect afin que vous puissiez voir ce que vous pourriez rencontrer.

Comme il n'y a pas de livres à la maison, j'ai recommencé à parcourir Internet et j'ai trouvé beaucoup de bêtises sophistiquées de toutes sortes. Mais d'une manière ou d'une autre, j'ai trouvé une solution à mon problème.
Ça m'a aidé de lire ça cout soutient ses méthodes. Et sur Internet tous les conseils vont vers l'utilisation de la fonction obtenir la ligne Heureusement pour moi, j'ai découvert très rapidement comment utiliser cette fonction, puis je l'ai utilisée dans le code.
En général, cela vaut la peine de mentionner et de décrire cette fonction, mais pour l'instant je ne la comprends pas vraiment, je comprends juste qu'elle doit être utilisée et je comprends comment, je vais donc donner un exemple plus correct de notre programme en cours de développement :

#inclure
#inclure

int principal()
{
caractère a,b,c; \\ 3 futures lignes
clrscsr(); // Effacer l'écran

/* Saisir les valeurs des variables*/

cout<<“Wwedi pervuu stroku” ; cin.getline(a,sizeof(a)); fin ;
cout<<“Wwedi wtoruu stroku” ; cin.getline(a,sizeof(b)); fin ;
cout<<“Wwedi tretuu stroku” ; cin.getline(a,sizeof(c)); fin ;
clrscr(); //Après avoir entré les valeurs, l'écran a été effacé

/*Commence à travailler avec le fichier*/
ofstream out (« C:\\\FromC\\myfile.txt »); // Ouvrir un fichier en écriture
dehors<Écrivez la première ligne
dehors<Écrivez la deuxième ligne
dehors<Écrivez la troisième ligne
out.close(); // Fermeture du dossier

// Remise à zéro des variables

pour (int je =0 ;je<=255 ;i ++)
(a =*"" ; b =*"" ; c=*"" ;)

/*Continuer à travailler avec le fichier*/

si diffuser dans (« C:\\\FromC\\monfichier.txt » );
in.getline(a,sizeof(a));// UN
in.getline(b,sizeof(b));// Lire une ligne dans une variable b
in.getline(c,sizeof(c)); // Lire une ligne dans une variable c
joindre(); // Fermeture du dossier

/* On lit la première ligne caractère par caractère et on l'affiche à l'écran */

pour (i =0 ;a !=*“” ;i++)
{
si (i >sizeof(a )) casser ;
cout<
}
cout<<“\n” ; \\ Déplacement du curseur vers une nouvelle ligne

/* On lit la deuxième ligne caractère par caractère et on l'affiche à l'écran */

pour (i =0 ;b !=*“” ;i ++)
{
si (i > taille de (b)) casser ;
cout<
}
cout<<“\n” ; \\ Déplacement du curseur vers une nouvelle ligne

/* Nous lisons la troisième ligne caractère par caractère et l'affichons à l'écran */

pour (i =0 ;с !=*“” ;i++)
{
si (i>taille de (c )) casser ;
cout<<с[i];
}

getch(); \\En attente que la touche Entrée soit enfoncée
renvoie 0 ;
}
===================

Ce document décrit un exemple de lecture d'informations caractère par caractère. Puisque je n'ai pas décrit le travail avec des variables comme carboniser, les débutants peuvent rencontrer des difficultés à comprendre le code. Je ne savais juste pas quel type carboniser a quelques particularités et j'ai pensé que tout était plus simple. Par conséquent, certains moments incompréhensibles du programme ci-dessus peuvent être lus dans l'article suivant travailler avec des caractères V C++ pour les débutants

Sinon, l'exemple donné sur la façon de lire les lignes d'un fichier texte en C++ devrait être accessible et tout à fait compréhensible. Ce n'est pas l'option de mise en œuvre optimale pour le moment, et j'ai raté certains points importants, mais puisque nous commençons à apprendre le langage C++, cela suffit pour l'instant. Plus tard, j'atteindrai probablement ce qui m'a manqué, mais maintenant je n'ai besoin de percevoir que le plus nécessaire.

Si vous et moi comprenons ce document, cela signifie que nous avons fait un petit pas vers notre professionnalisme.

Note:
casser ;– C'est la commande qui sort de la boucle. Nous avons si le compteur de cycles pour devient plus grand que la taille déclarée de la variable carboniser, puis on sort de force de la boucle
!= – C'est la condition que nous avons posée. Cette condition est notée par l'inégalité
si(a !=b )– Se lit comme si un pas égal b

fin ; – Cela déplace le curseur vers une nouvelle ligne à l'intérieur de la console (pour autant que je sache)
Cette commande est similaire à "\n"

Auparavant, lors de la saisie et de la sortie de données, nous travaillions avec des flux standard - le clavier et le moniteur. Voyons maintenant comment le langage C implémente la réception de données à partir de fichiers et leur écriture là-bas. Avant de pouvoir effectuer ces opérations, vous devez ouvrir le fichier et y accéder.

Dans le langage de programmation C, un pointeur vers un fichier est de type FILE et sa déclaration ressemble à ceci :
FICHIER *monfichier ;

D'autre part, la fonction fopen() ouvre un fichier à l'adresse spécifiée comme premier argument en mode lecture ("r"), en mode écriture ("w") ou en mode ajout ("a") et renvoie un pointeur au programme. Par conséquent, le processus d'ouverture d'un fichier et de connexion au programme ressemble à ceci :
monfichier = fopen("hello.txt", "r");

Lors de la lecture ou de l'écriture de données dans un fichier, celui-ci est accessible via un pointeur de fichier (dans ce cas, monfichier).

Si pour une raison ou une autre (il n'y a pas de fichier à l'adresse spécifiée, l'accès à celui-ci est refusé) la fonction fopen() ne peut pas ouvrir le fichier, alors elle renvoie NULL. Dans les programmes réels, ils gèrent presque toujours une erreur d'ouverture de fichier dans la branche if, mais nous l'omettrons davantage.

La déclaration de la fonction fopen() est contenue dans le fichier d'en-tête stdio.h, elle doit donc être incluse. Également dans stdio.h, le type de structure FILE est déclaré.

Une fois le travail terminé avec un fichier, il est d'usage de le fermer pour libérer le tampon des données et pour d'autres raisons. Ceci est particulièrement important si le programme continue de s'exécuter après avoir travaillé avec le fichier. La rupture de la connexion entre un fichier externe et un pointeur vers celui-ci à partir du programme se fait à l'aide de la fonction fclose(). Un pointeur vers le fichier lui est passé en paramètre :
fclose(monfichier);

Plus d'un fichier peut être ouvert dans le programme. Dans ce cas, chaque fichier doit être associé à son propre pointeur de fichier. Cependant, si le programme travaille d'abord avec un fichier puis le ferme, le pointeur peut être utilisé pour ouvrir un deuxième fichier.

Lire et écrire dans un fichier texte

fscanf()

La fonction fscanf() a une signification similaire à la fonction scanf(), mais contrairement à elle, elle fournit une entrée formatée à partir d'un fichier plutôt que le flux d'entrée standard. La fonction fscanf() prend en paramètres : pointeur de fichier, chaîne de format, adresses des zones mémoire pour l'écriture des données :
fscanf(monfichier, "%s%d", str, &a);

Renvoie le nombre de données lues avec succès ou EOF. Les espaces et les caractères de nouvelle ligne sont comptés comme délimiteurs de données.

Disons que nous avons un fichier contenant la description suivante des objets :

Pommes 10 23,4 bananes 5 25,0 pain 1 10,3

#inclure main () ( FILE * fichier; struct food ( char name[ 20 ] ; quantité non signée; float price; ) ; struct food shop[ 10 ] ; char i= 0 ; file = fopen ( "fscanf.txt", "r" ) ; while (fscanf (file, "%s%u%f" , shop[ i].name , & (shop[ i].qty ) , & (shop[ i].price ) != EOF) ( printf ( "%s %u %.2f \n", boutique[i].nom, boutique[i].qté, boutique[i].prix) ;

je++;

) )

Dans ce cas, une structure et un tableau de structures sont déclarés. Chaque ligne du fichier correspond à un élément du tableau ; un élément de tableau est une structure contenant une chaîne et deux champs numériques. La boucle lit une ligne par itération. Lorsque la fin du fichier est rencontrée, fscanf() renvoie EOF et la boucle se termine.
fgets()

La fonction fgets() est similaire à la fonction gets() et effectue une saisie ligne par ligne à partir d'un fichier. Un appel à fgets() lira une ligne. Dans ce cas, vous ne pouvez pas lire la ligne entière, mais seulement une partie depuis le début. Les paramètres fgets() ressemblent à ceci :
fgets (character_array, number_of_characters_read, pointer_to_file)

Par exemple:

#inclure #define N 80 main () ( FILE * file; char arr[ N] ; file = fopen ( "fscanf.txt" , "r" ) ; while (fgets (arr, N, file) != NULL) printf (" %s" , arr) ; printf (" \n") ;

fclose(fichier);

)

Dans ce programme, contrairement au précédent, les données sont lues ligne par ligne dans le tableau arr. A la lecture de la ligne suivante, la précédente est perdue. La fonction fgets() renvoie NULL si elle ne parvient pas à lire la ligne suivante.

getc() ou fgetc() \n" La fonction getc() ou fgetc() (les deux fonctionnent) vous permet d'obtenir le caractère suivant d'un fichier. \0 " while ((arr[ i] = fgetc (file) ) != EOF) ( if (arr[ i] == " \n") (arr[je] = " \0 " while ((arr[ i] = fgetc (file) ) != EOF) ( if (arr[ i] == " \n";

printf("%s

, arr) ;

je = 0 ;

• ) sinon je++;
• )arr[i] = "
• , arr) ;

L'exemple de code affiche les données d'un fichier à l'écran.

Écrire dans un fichier texte

Tout comme l'entrée, la sortie vers un fichier peut être différente. \n" Sortie formatée. Fonction fprintf (file_index, format_string, variables) .

Sortie post-par-ligne. Fonction fputs(string, file_pointer) .

Sortie caractère par caractère. Fonction fputc() ou putc(symbol, file_pointer) . \n" Vous trouverez ci-dessous des exemples de code qui utilisent trois méthodes de sortie de données dans un fichier.

Écriture des champs d'une structure sur chaque ligne du fichier :

fichier = fopen ("fprintf.txt" , "w" ) ;

while (scanf ("%s%u%f" , shop[ i].name , & (shop[ i].qty ) , & (shop[ i].price ) ) != EOF) ( fprintf (fichier, " %s %u %.2f

, boutique[i].nom, boutique[i].qté, boutique[i].prix) ;

je++;

)

Les fonctions fread() et fwrite() prennent en paramètres :

1. adresse de la zone mémoire dans laquelle les données sont écrites ou lues,
2. la taille d'un modèle donné, quel que soit son type,
3. la quantité de données lues de la taille spécifiée,
4. index des fichiers.

Ces fonctions renvoient le nombre de données lues ou écrites avec succès. Ceux. vous pouvez « commander » la lecture de 50 données, mais n’en recevoir que 10. Il n’y aura pas d’erreur.

Un exemple d'utilisation des fonctions fread() et fwrite() :

#inclure #inclure main () ( FILE * fichier; char Shelf1[ 50 ], Shelf2[ 100 ] ; int n, m; file = fopen ("shelf1.txt" , "rb" ) ; n= fread (shelf1, sizeof (char ) , 50 , fichier) ; fclose (fichier) ; fichier = fopen ("shelf2.txt" , "rb" ) ; m= fread (shelf2, sizeof (char ) , 50 , fichier) = " \0 " ; \n"étagère2[m] = " \0 " ;

étagère2[ m+ 1 ] = "

;

1. fichier = fopen ("shop.txt" , "wb" ) ;
2. fwrite (strcat (étagère2, étagère1) , sizeof (char ) , n+ m, fichier) ;