Discussion :

[bahita]

BONJOUR

SVP si vous pouvez m'indiquer comment créer un fichier en C++ contenant des matrices du type entier et réel (216 matrices ) et bien sur comment pouvoir faire les opérations d'ajout , suppression ,et de consultation de ces matrices pour subir un traitement .
merci.

[Emmanuel Deloget]

Je ne comprends pas tout.

Est-ce que tu pourrais être plus clair stp ? merci

[themadmax]

Ton post est super large... On ne sait pas, ton niveau, ce que tu a deja codé et ou tu bloque. Je te conseillerai de regarder du coté de la sérialisation, et de revenir nous voire pour un pb plus precis.

Bonne chance

[Alp]

Pour les matrices en C++, une recherche dans le forum t'apportera un certain nombre de bibliothèques fournissant ce genre de classes.

[bahita]

bonjour
normalement c'est clair je veux faire un traitement sur plusieurs matrices du type entier ou réel (206 matrices) donc j'ai besoin de les stocker dans une structure de données assez suffisante donc je doit utiliser un fichier dont chaque élèment est une matrice et automatiquement ce fichier doit me permettre d'accéder directement à ces matrices exactement aux lignes et colonnes , je précise l'accés doit etre direct pas séquentiel .
NB
comme dans le turbo pascal si veux stocker des données dans
une structure de données gigantesque j'utilise un fichier (file) par exemple un fichier de plusieurs etudiants qui sert à calculer les moyennes dont chaque enregistrement est un (record) contenant les informations de chaque etudiant(nom,prenom, modules, notes, coefficient de chaque module ..) ,seulement dans mon cas avec le C++ chaque enregistrement devient une matrice qui va subir un traitement .

et bien sur cette structure de données doit me permettre de faire l'ajout la suppression , la consultation ou modification des ces matrices .

merci

[koala01]

Salut, et bienvenue sur le forum.

Déjà, il serait intéressant de se faire une petite idée de la taille de tes matrices...

En effet, si tu as 206 matrices 3*3, il reste tout à fait raisonnable de les maintenir en mémoire, et de ne les placer dans un fichier que pour pouvoir les récupérer ultérieurement, et cela, même si les éléments qu'elles contiennent sont des entiers

Il n'y a en définitive que lorsque tes matrices atteignent des tailles excessive (de l'ordre de plusieurs (dizaines de) milliers d'éléments) qu'il peut effectivement devenir opportun d'envisager de les maintenir sous forme de fichiers.

En outre, le fait d'assurer un acces direct aux données d'un fichiers ne va pas sans poser certains problèmes, dont, entre autres, le fait de s'assurer que chaque élément utilisera un nombre de caractères (ou d'espaces) identique, et de pouvoir au minimum s'assurer de retrouver le début de chaque groupe.

Les solutions peuvent passer par le fait d'utiliser des fichiers dits "binaires", avec en prévision des problèmes de compatibilité principalement dûs à la différence de taille potentielle des types primitifs en fonction de l'architecture ou du compilateur ou par le formatage du fichier afin de s'assurer de l'obtention d'un fichier correctement "espacé"...

Enfin, je ne suis pas sûr que l'idée de faire "comme en (...) "soit la meilleure idée que tu puisse avoir.

Et ce, d'autant plus que ton projet semble pouvoir se marier parfaitement avec une optique orientée objet et les différentes possibilités que ce concept peut offrir

[bahita]

salut
koala svp
-si vous pouvez etre plus clair comment déclare t on un fichier binaire ....
-et qu est ce que vous voulez dire par "n'utiliser un fichier que pour pouvoir récupérer les matrices ulterieurement" car meme si je les garde en memoire je vais les utiliser biensur ulterieurement .
-vous voulez dire" par garder ces matrices en memoires" que je déclare les 206 par exemple chacune à part pareillement à la declaration de matrices en pascal c'est comme meme trop..!!!.
enfin veuillez svp etre plus clair car je n'ai jamais travaliller avec la C++ .

merci

[koala01]

Reporte toi à la question correspondante de la FAQ car, une fois le fichier ouvert, il reste quelques particularités à prendre en compte

[bahita]

salut
svp kaolo
pour créer le fichier binaire pour la première fois j'utilise quoi exactement comme fonction ou instruction .
merci

[koala01]

Ainsi que c'est indiqué dans la réponse de la FAQ sur laquelle j'ai fait pointer le lien de mon dernier message, pour ouvrir un fichier en mode "binaire", il "suffit" de donner la valeur std::ios_base::binary comme deuxième argument lors de l'ouverture du fichier...

Pour ouvrir un fichier en vue d'y écrire des informations, cela prend donc la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::ofstream ofs("nomDuFichier.dat", std::ios_base::binary);

et pour l'ouvrir en vue d'y récupérer les informations celle de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::ifstream ifs("nomDuFichier.dat", std::ios_base::binary);

Mais, surtout, je reste convaincu que tu pars dans une très mauvaise direction à vouloir gérer les choses à la manière que tu exposes.

Et je reste même convaincu qu'en t'organisant correctement, il n'y aurait aucun problème à devoir gérer plusieurs milliers d'étudiants dans une faculté, sans avoir besoin de recourir aux fichiers pour autre chose que... de les garder en mémoire entre deux utilisations de l'application.

[bahita]

salut
kaolo svp un fichier binaire accepte il des valeurs autre que 0/1 !! je vous ai dis des matrices de valeurs réelles donc le fichier n'est pas de type binaire !!!!.
merci

[Médinoc]

Un "fichier binaire", ça accepte tout sauf des pointeurs.

Au sujet des zéros et des uns, n'oublie pas que même un nombre représenté en virgule flottante, au fond, reste une suite de zéros et de uns!

[koala01]

Il faut bien comprendre que strictement TOUT est représenté sous forme binaire, en informatique.

En effet, bien qu'il dispose de grande possibilités, un processeur est plus bête que ma plus jeune nièce dans le sens où il ne sait compter que de 0 à 1.

Si tu vois un "a" ou si tu rencontre la valeur 3.1415926, ce n'est que parce que les conventions d'affichages implique d'utiliser la base décimale ou une table de caractères particulière plutôt que la représentation binaire des valeurs.

De ce fait, quelle que soit la valeur représentée (un caractère, une valeur entière ou un réel quelle qu'en soit la précision) est d'office représentée par un groupe de bits, regroupés en vue d'obtenir une plage de valeurs suffisantes, et dépendant de l'architecture de l'ordinateur.

Le fait d'écrire des valeurs binaires et non des caractères n'aura comme seul résultat que la représentation à l'intérieur du fichier sera différente de celle que tu obtiendrait avec un fichier texte, mais permet de s'assurer que l'ensemble des donnée utilisera systématiquement une taille clairement définie.

Cela revient, en simplifiant au possible, à dire au programme:

n'essaye pas de convertir ces valeurs suivant les conventions habituelles mais contente toi de prendre ces valeurs comme elles viennent

Ainsi, si tu veux écrire dans un fichier texte la valeur "12" (douze), il te faudrait... 2 caractères pour représenter cette valeur, et il en faudra trois si tu veux écrire (sous forme de texte) une valeur supérieure ou égale à 100, et plus encore si tu veux écrire des valeurs supérieures.

Mais, si l'on considère qu'un caractère est composé de 8 bits (comme c'est souvent le cas), il est possible de représenter n'importe quelle valeur entre 0 et 255 avec seulement ... 1 caractère qui, si on devais l'écrire en binaire prendrait la forme de 01111011.

De la même manière, nous avons la certitude que n'importe quelle valeur reconnue comme étant de type réel (considérons un double pour l'exemple) pourra être représentée en utilisant un nombre donné de bits (et même de caractères), parce que la taille du type double est clairement définie (tu peux l'obtenir avec l'opérateur sizeof() ) pour ton compilateur particulier.

Dés lors, tu peux envisager de placer 25 doubles à la suite dans le fichiers et d'y accéder de manière directe.

Il te "suffit" "sauter" à la position n*sizeof(double) (ou n représente le double que tu veux atteindre) en partant du début du fichier

Mais je le répète encore une fois, mon avis personnel est qu'il est pour la plupart du temps (et du fait des ressources dont disposent les ordinateurs actuels) pas utile de se contraindre aux problèmes que peuvent poser l'utilisation de fichier binaire dans ton cas...

Au fait, c'est koala (tu sais bien: le marsupial placide qui mange de l'eucalyptus ) et non kaolo

[Emmanuel Deloget]

Quand on dit "fichier binaire", on parle de la représentation des données - pas du type de donnée qui peuvent être stockées - et le nom du format (binaire) est en fait en directe opposition au nom du format utilisé pour parler des fichiers qui sont lisibles par un être humain - les fichiers "texte".

Pour simplifier, un fichier binaire est fait pour être lu par un programme tandis qu'un fichier texte est plutôt fait pour être lu par un humain.

Les deux peuvent contenir exactement les même données (y compris des nombres flottants). Seul l'encodage change. En format texte, les informations sont directement assimilable par un cerveau humain. Le nombre 12.6757 est représenté par la chaine de caractère "12.6757". En format binaire, le même nombre est encodé avec sa représentation machine - celle que le processeur comprends. Il s'agira dans ce cas d'un flottant IEEE de 32 bits (ou plus, selon la précision souhaitée) qui sera stocké dans le fichier sous une forme certes incompréhensible par un humain, mais beaucoup plus pratique pour un ordinateur.

L'un des avantages de cette méthode est que le fichier est souvent plus court: 12.6757 nécessite 7 octets pour le stockage, tandis que le flottant de 32 bits sous-jacent peut être stocké en 4 octets.

La taille du fichier est plus stable: la taille de l'enregistrement ne dépends plus de la valeur stockée mais du type de la valeur stockée. En texte, 458740.1896 et 12.6757 nécessite respectivement 12 et 7 octets pour être stockés. En format binaire, seul le type de donnée compte - chacune de ces valeurs nécessite 4 octets, point final.

Enfin, la lecture est souvent plus rapide, car elle se passe d'une étape d'interprétation - pour lire un fichier texte et le comprendre, le processeur a besoin de convertir les chaînes de caractère dans un type de donnée qu'il peut interpréter.

Le problème évident est qu'il faut systématiquement passer par un programme afin de pouvoir lire les données et les modifier.

normalement c'est clair

Si c'est clair dans ta tête, alors c'est nécessairement clair pour nous. Par chance, j'ai passé mon diplôme de mind-reading avec option "telepthy and telekinesis" au Percifal Institude of Paranormal Science la semaine dernière, je l'ai eu avec mention. En ce moment, tu est en train de penser "mais de quoi il parle là?".

[JolyLoic]

Formellement, il y a très peu de différence entre un fichier binaire et un fichier texte en C++ (la façon dont les fins de lignes sont gérées, c'est à peu près tout je crois...).

Ensuite, il y a le fait de faire des entrées/sorties formatées (les opérateurs <<) ou non formatées (les fonctions read/write).

[drcd]

Comme l'a demandé koala01, quelle est la taille des matrices?
Decrit nous un peu plus ton projet.

Si les matrices sont petites, tu peux envisager de les mettre dans un fichier texte. Sinon, comme tout le monde te l'a conseillé, utilise les fichiers binaires c'est mieux pour les perfs.

Sinon tu peux voir du coté de la serialisation, il y a un super tuto qui vient de sortir à ce sujet.

Et aller encore une idée, soyons fou, tu peux utiliser une base de donnée si tes matrices sont de taille fixe lol.

Pour ce qui est des fichiers binaires, tu m'as demandé du code en MP.
Le voici, il vient de la FAQ, tu aurais pu chercher.

Créer 2 fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
template<typename T>
std::ostream& write(std::ostream& os, const T& value)
{
    return os.write(reinterpret_cast<const char*>(&value), sizeof(T));
}
 
template<typename T>
std::istream & read(std::istream& is, T& value)
{
    return is.read(reinterpret_cast<char*>(&value), sizeof(T));
}

Voila le code pour une matrice d'entier 3x3, en supposant que tu as représenté tes matrice sous forme d'un tableau à 2 dimension.

Maintenant le code de la manipulation de fichier binaire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
#include <fstream>
#include <iostream>
#include <string>
 
#using namespace std;
 
...
 
//Declaration de la matrice
int matrice[3][3];
 
//Initialisation pour l'exemple
for(int i=0;i<3;i++)
{
    for(int j=0;j<3;j++)
    {
        matrice[i][j]=i+j+1;
    }
}
 
//Voila à quoi ressemble la matrice
//1 2 3
//4 5 6
//7 8 9
 
//Sauvegarde dans un fichier binaire de la matrice
//Creation du fichier
std::ofstream FileOut("matrice1.dat", std::ios_base::binary);
 
string strMatrice;
for(int i=0;i<3;i++)
{
    for(int j=0;j<3;j++)
    {
        strMatrice+=matrice[i][j];
        strMatrice+=";";
    }
}
 
//strMatrice=1;2;3;4;5;6;7;8;9;
 
//Sauvegarde de la matrice dans le fichier
write(FileOut, strMatrice);
FileOut.close();
 
strMatrice=" ";
 
//Chargement de la matrice à partir du fichier dans strMatrice
std::ifstream FileIn("matrice.dat", std::ios_base::binary);
read(FileIn, strMatrice);
FileIn.close();
 
//strMatrice=1;2;3;4;5;6;7;8;9;
 
int matrice2[3][3];
for(int i=0;i<3;i++)
{
    for(int j=0;j<3;j++)
    {
        strMatrice.substr(i+j,1);
    }
}
 
//matrice2=
//1 2 3
//4 5 6
//7 8 9
 
Pour l'acces direct, tu peux faire une matrice= un fichier. A toi de bien nommer tes noms de fichiers.
...