La mémoire d'un logiciel/ programme

[Rockleader]

Bonjour à tous chers amis programmeurs, je viens vous expliquer ma démarche.

Mon père est actuellement en charge d'une caserne de pompier, il doit donc gérer tout un tas d'information. Et, il est pas suer douer avec les logiciels d'excel va t-on dire.

J'aimerais donc lui créer pour son anniversaire un logiciel (c'est un bien grand mot, parlons plutôt de programme pour l'instant) qui lui permettrait de gérer la plupart des informations utiles que je n'ai pas encore identifier.

Un premier problème s'ouvre à es yeux, en effet dans tous les programmes que l'on m'a fait faire en cours, on utilise toujours la mémoire à court terme d'un pc, c'est à dire que quand on stocke des données dans des variables, et que l'on ferme le programme, les données sont définitivement perdues. Donc comment faire en sorte dans un programme de pouvoir "sauvegarder" les données que va entrer un utilisateur, sans parler d'information de style interface graphique etc etc, ne serait ce qu'en restant dans la console de windows ou linux où le programme s’exécute.


Je préois de faire ça en ADA étant le seul langage que je maîtrise assez pour le moment, mais peut être n'est ce pas possible à ce niveau là.

[fatal_error]

slt,

tu écris dans un fichier pour sauvegarder, et tu lis le fichier pour mettre en mémoire dans ton programme

[Rockleader]

slt,

tu écris dans un fichier pour sauvegarder, et tu lis le fichier pour mettre en mémoire dans ton programme

Ouai d'accord ça c'est ce qu'il fut faire dans la théorie, mais en pratique, ça se code comment ça =)

[fatal_error]

par exemple :

Code: Tout sélectionner

//##writing the file
// L is a list of objects to save (caserne, caserne, preferences)
// fileName is the file to save settings
for all objects in L as objectToSave do
 objectToSave.save(fileName); //each object will happen its content to the file
done

exemple de contenu de fichier:

Code: Tout sélectionner

caserne
  5 (nb de personnes)
  paris (ville)
caserne
  3
  marseille
preferences
  popupEnabled=true
  ...

un objet caserne contient : un nombre de personnes et une ville

Code: Tout sélectionner

//##reading the file
while not end of fileName do
 typeOfObjectToConstruct = fileName.readLine()
 if(typeOfObjectToConstruct  == caserne)
   constructCaserne(fileName)
 else if (typeOfObjectToConstruct == preferences)
   constructPreferences(fileName)
done

ou constructCaserne avance le curseur du fichier jusqu'au prochain type d'objet (tout en lisant le fichier pour construire caserne)

[Rockleader]

Bon, je suis pas sûr d'avoir tout compris vu que c'est du C, mais je pense avoir saisi la démarche; en version ADA ça donnerait par exemple.

Code: Tout sélectionner

NB_MAX:constant Integer := 200;
Type TabCaserne is array In Integer 1..NB_MAX of String;
monTab:TabCaserne;
nbEff :Integer;
nom:String;
   begin

get(nbEff); -- ce sera le nbre de pompier
for k in 1..nbEff loop
   put("Nom du pompier :");
   get(nom);
   monTab(k) := nom;
end loop;
-- donc en gros ici dans parler des spécificités en ada du type string que je contournerai, j'enregistre dans une case de mon tableau chaque nom de pompier de la caserne. C'est ce qui correspondrait en réalité à la première utilisation du programme. Par la suite, je désire que toutes ces informations soit à nouveau accessible.


Donc, pour faire en sorte de sauvegarder tous les noms qui ont été stocker dans le tableau, il faudrait que je fasse quelque chose du genre:

Code: Tout sélectionner

for all case in monTab as object to save loop
   objectToSave.save(filename);
end loop;


J'ai essayé de traduire ça du C à l'Ada mais je suis pas du tout sur que ce soit une syntaxe correcte.
TU me diras le meilleur moyen c'est encore de tester, mais je voudrais pas faire trop de bêtises quand même sur la mémoire de mon pc si je me trompe quelque part.
Il me faudrait donc aussi prévoir une option en sécurité pour effacer le contenu enregistré d'un tableau et de recommencer le programme au début.

[Dlzlogic]

Bonjour Rockleader,
Je ne cherche en aucun cas à tempérer vos ardeurs, mais vous vous attaquez à un problème assez compliqué. De plus, vous raisonnez en "langage" et non en "algorithme", et c'est une erreur.
Ce qu'a écrit fatal_error n'est pas du C.

A mon avis vous devriez étudier plusieurs points
- types de données : permanentes (ex personnel - matériel) et évolutives ( missions, incidents)
- méthode de mise à jour (création, modification, suppression)
- opérations à effectuer (requête, organisation)
- etc.
Pour l'instant, ce n'est que du texte en français.

Pour chaque tâche à effectuer par le programme, il faut faire une analyse qui comporte une phase "début" (les données disponibles, y compris les informations sur la tâche à effectuer), une phase "traitement" qui doit pouvoir s'écrire sous forme d'algorithme (cases, flèches, tests, fichiers etc.) et une phase "fin" (le résultat, le stockage, les vérifications).

Si j'ai bien compris ce que j'ai lu, l'ADA est enseigné dans un but pédagogique. En effet sa syntaxe convient très bien à l'apprentissage. Par contre je crois qu'il est assez peu probable que vous utilisiez ce langage dans un contexte professionnel.Je suppose que les membres confrontés de près ou de loin à l'apprentissage de l'informatique expliqueront cela bien mieux que moi.

[Rockleader]

Je sais bien sur que je ne vais pas retrouver de l'ADA dans mon milieu professionnel ou du moins ce sera très improbable, mais là ça n'a rien de professionnel ce que je veux réaliser. C'est autant pour faire un cadeau que pour me motiver à apprendre de nouveau trucs.


Je vois bien que c'est complexe mais je ne vois pas vraiment par où attaquer ce morceaux. Je pense avoir saisit la façon dont on procède algorithmiquement, mais cela il faut le coder, et cette partie là je ne l'ai bien sur pas aborder en cours, pourtant c'est quand même un truc important.

Simple exemple, des capteurs qui vont enregistrer des données météo, heureusement qu'ils peuvent enregistré, parce que sinon il faudrait que quelqun surveille les données du capteur 24 h sur 24.
Donc il y a bien un moyen pour faire ça.


Peut être que je grille certaines étapes de l'apprentissage de la programmation en parlant de cela, si c'est le cas, ça serait sympa e me dire quel bout aller voir avant^^

[Sylviel]

Je suis assez d'accord avec le principe général : pour sauvegarder des données en dur on écrit un fichier, qu'on va lire ensuite. Pour cela il faut regarder la section entrée/sortie d'un tutoriel du langage que tu veux utiliser. Il y a parfois des fonctions déjà faite qui te simplifie la vie.

A propos de ADA je n'en ai entendu parler que deux fois :
- une fois par un informaticien professionnel disant que si le compilo ADA avait été gratuit ce serait le langage dominant aujourd'hui. Ou du moins il aurait pris la place du C.
- une autre à la BNP car c'est leur langage de programmation (au niveau banque de marché au moins).

[Rockleader]

Voici le code contenu dans pack entrées_sorties du langage ADA:

Code: Tout sélectionner


-- ***********************
-- Prologue de compilation
-- ***********************
with TEXT_IO;
with IO_EXCEPTIONS;
-- **************************************
-- Specification du paquetage utilisateur
-- **************************************
package ENTREES_SORTIES is
--  ***********************************************************************
--  Ce paquetage contient un sous-ensemble des operations d'entrees sorties
--     L'utilisateur n'a pas a connaitre la notion de genericite
--     Seules quelques operations concernant
--    les entiers,
--    les flottants,
--    les booleens,
--    les caracteres et
--    les chaines de caracteres
--  sont fournies.
--     ainsi que les exceptions les plus importantes
--       concernant les entrees-sorties
--  ***********************************************************************
-- =========================================================
-- Definition des paquetages necessaires aux entrees-sorties
-- =========================================================
package INT_IO is new text_io.integer_io(integer);
package FLT_IO is new text_io.float_io(float);
package BOOL_IO is new text_io.enumeration_io(boolean);
-- =======================================
-- Renommage de certains types necessaires
-- =======================================
subtype   COUNT           is text_io.count;
subtype   POSITIVE_COUNT  is text_io.positive_count;
subtype   FIELD           is text_io.field;
subtype   NUMBER_BASE     is text_io.number_base;
subtype   TYPE_SET        is text_io.type_set;
-- =================================
-- Renommage de certaines exceptions
-- =================================
DATA_ERROR : exception renames IO_EXCEPTIONS.data_error;
END_ERROR   : exception renames IO_EXCEPTIONS.end_error;
-- ===============================
-- Operations exportees de TEXT_IO
-- ===============================
procedure GET (ITEM: out character)                        renames text_io.get;
procedure PUT (ITEM: in character)                         renames text_io.put;
procedure GET (ITEM: out string)                           renames text_io.get;
procedure PUT (ITEM: in string)                            renames text_io.put;
procedure GET_LINE (ITEM: out string; LAST: out natural) renames text_io.get_line;
procedure PUT_LINE (ITEM: in string)                       renames text_io.put_line;
procedure SKIP_LINE (SPACING : in POSITIVE_COUNT :=1)      renames text_io.skip_line;
procedure NEW_PAGE                                         renames text_io.new_page;
procedure SKIP_PAGE                                        renames text_io.skip_page;
procedure NEW_LINE (SPACING: IN POSITIVE_COUNT:=1)    renames text_io.new_line;
                                                     
procedure SET_COL (TO: in POSITIVE_COUNT)     renames text_io.set_col;
procedure SET_LINE(TO: in POSITIVE_COUNT)                  renames text_io.set_line;
function END_OF_LINE return boolean                      renames text_io.end_of_line;
function END_OF_FILE return boolean  renames text_io.end_of_file;

-- ============================
-- Entrees et sorties d'entiers
-- ============================
procedure GET (ITEM:   out integer;  WIDTH: in field:=0)
                                                              renames INT_IO.get;
             
procedure PUT (ITEM:   in integer;
                WIDTH: in field        := INT_IO.default_width;
                BASE:  in number_base := INT_IO.default_base) renames INT_IO.put;
-- ===============================
-- Entrees et sorties de flottants
-- ===============================
procedure GET (ITEM:   out float;
                WIDTH: in field :=  0)                        renames FLT_IO.get;
procedure PUT (ITEM:   in float;
                FORE:  in field :=  FLT_IO.default_fore;
                AFT:   in field :=  FLT_IO.default_aft;
                EXP:   in field :=  FLT_IO.default_exp)       renames FLT_IO.put;
-- ==============================
-- Entrees et sorties de booleens
-- ==============================
procedure GET (ITEM:   out boolean)                           renames BOOL_IO.get;
procedure PUT (ITEM: in boolean;
                WIDTH: in field     := BOOL_IO.default_width;
                SET:   in text_io.type_set := BOOL_IO.default_setting)
                                                              renames BOOL_IO. put;
end ENTREES_SORTIES;


Mais je ne pense pas qu'il y est ce que je cherche là dedans, ou alors je n'ai pas su le voir. Je vais continuer à chercher.

[fatal_error]

Je vois bien que c'est complexe mais je ne vois pas vraiment par où attaquer ce morceaux.

ben c'est trivial en fait.

Commence par sauvegarder un vulgaire nombre, puis le lire.
Puis plusieurs nombres...
puis un nombre et un string...

aprs je sais pas si l'ADA permet de faire de la POO, mais tu vois l'idée qu'on veut ptet déléguer à l'objet la possibilité de se sérialiser/désérialiser.

[nodjim]

Attention tout de même. Il n'est pas certain que toutes les informations à collecter doivent forcément se trouver dans une même base de données. ça dépend beaucoup de ce que l'on veut faire. Cette analyse préalable des besoins est primordiale avant tout montage logiciel. Il faut savoir ce que l'on veut collecter, savoir de quel type d'informations on a besoin de requérir, sans en oublier une seule.
Les tableurs genre Excel savent gérer pas mal de choses. On a bien entendu avec eux la possibilité de créer des pages d'accueil avec des boutons de requête, et ils savent bien sûr faire des calculs, c'est leur raison d'être.
Sinon, pour le traitement de l'information, ACCESS est bien plus performant mais plus difficile à apprivoiser...

[fatal_error]

ACCESS est bien plus performant

ben voyons!

[Rockleader]

Sans rentrer dans les nombre incalculable de données que je pourrais avoir à mémoriser.

Si j'ai mon programme qui doit fonctionner bêtement comme ça.


Première utilisation:

"Entrez un nombre :" 55
"Vous avez entré le nombre 55"

Actuellement si je ferme mon programme, ça recommencera et il demandera à nouveau l'information.

Hors, moi ce que j'aimerais; c'est que lors de la seconde utilisation, on est simplement :
" Vous avez entré le nombre 55"

Je pense que si je comprend ne serait ce que comment sauvegarder ce "55" c'est gagné pour le reste.
Même quitte à ce que la seconde utilisation ne m'affiche que 55 pour le moment sans la phrase, car comme je l'ai dis l'utilisation des string en ada est un peu particulière.


Bref, simplement, comment je devrais faire pour "sauvegarder" ce nombre.

Ensuite le lire ne devrait pas pour un problème, mais c'est l'étape sauvegarder ou si j'ai bien compris le principe, l'écrire dans un autre fichier. Après je sais comment l'utilisez ou du moins je pense savoir, mais je n'ai toujours pas bien saisi comment on le sauvegardait.

[fatal_error]

1)

mais je n'ai toujours pas bien saisi comment on le sauvegardait.

pour le sauvegarder tu écris dans un fichier.

2 )

Pour écrire dans un fichier

google+ ecrire fichier ada

Si tu bloques sur 1, arrêtes la programmation et demandes toi à quoi sert un fichier.

Si tu bloques sur 2, cherches en anglais.

[Rockleader]

Pour utiliser des fichiers texte, il faut utiliser text_io, c'est à dire commencer le programme avec
With Text_Io;.
Le type des fichiers s'appelle file_type. On peut déclarer des variables avec ce type, de même que des paramètres de fonction et procédure.

Pour créer un nouveau fichier, il faut utiliser la procédure create qui prend 4 paramètres:

une variable de type file_type.
un mode qui doit être out_file.
un nom de fichier de type string.
une chaîne de caractères qui doit être la chaîne vide "".

S'il existait déjà un fichier avec le même nom, il serait détruit.
Pour ouvrir un fichier qui existe, on utilise open qui prend les mêmes paramètres que create, sauf que le mode peut être out_file pour un fichier en écriture ou in_file pour un fichier en lecture.

Pour fermer un fichier, on utilise la procédure close qui prend un seul paramètre de type file_type.

Pour écrire ou lire dans un fichier texte, on utilise les procédures put et get avec 2 paramètres:

le fichier dans lequel on veut lire ou écrire (de type file_type).
ce qu'on veut lire ou écrire.

.....................................................


Je pense que c’est plus ou moins l'information que je cherchais, source : http://roizot.dominique.free.fr/prog/ada/fichier-texte.htm


Je vais essayer de faire des test.



Là petit Hors-Sujet de mes souvenirs d'il y a 4-5 ans lorsque j'avais voulu commencer à apprendre le C.
Est ce que ce n'est pas une utilisation des pointeurs en C permettant de sauvegarder des données ? Je me souviens que j'avais décroché à ce moment là parce que je n'avais pas vraiment compris à quoi ça servait.

[Dlzlogic]

Bonjour Reckleader,

Là petit Hors-Sujet de mes souvenirs d'il y a 4-5 ans lorsque j'avais voulu commencer à apprendre le C.
Est ce que ce n'est pas une utilisation des pointeurs en C permettant de sauvegarder des données ? Je me souviens que j'avais décroché à ce moment là parce que je n'avais pas vraiment compris à quoi ça servait.

Non, il n'y a aucun rapport entre les pointeurs du C et les entrées-sortie, dans n'importe quel langage.
La notion de pointeur est strictement rattaché au langage. On peut très bien faire un gros programme en C sans rien savoir des pointeurs. Par contre, il est difficile d'imaginer de faire un programme même petit, sans rien savoir des entrées-sorties et des fichiers.
Quand vous tapez "Enter" après avoir tapé "55", vous faites une entrée. Quand l'écran vous affiche "Vous avez entré 55", vous faites une sortie. Vous utilisez pour cela un fichier stdin et un fichier stdout toujours prévus, mais généralement sous-entendus.
Quand vous voulez "Lire des données" existantes, au lieu d'utiliser stdin (c'est à dire le clavier), il faut nommer le fichier qui contient ces données puis les lire. C'est exactement comme si pour taper votre nombre vous allier prendre un livre de compte dans une bibliothèque, l'ouvrir à la bonne page et taper le chiffre de la bonne ligne. Il me parait indispensable de bien comprendre cela avant de chercher la syntaxe qui permet de le faire.

Il est aussi indispensable de distinguer les fichier séquentiels simples des bases de données. En disant cela, je rejoins ce qu'à dit nodjim.

[fatal_error]

fopen et fclose manipulent quand même des pointeurs de fichiers...

[Dlzlogic]

fopen et fclose manipulent quand même des pointeurs de fichiers...

Ben oui, naturellement, mais il est vrai que si on fait une lecture, avoir une petite notion des pointeurs n'est pas inutile si on veut comprendre ce genre de code :

Code: Tout sélectionner

char texte[32];
float ValFloat;
int Nombre;
FILE *lec=fopen("Fichier.txt","rt");
char ligne[80];
fgets(ligne,79,lec);
sscanf(ligne,"%s %f %d", texte, &ValFloat, &Nombre);


Bien sûr, un observateur attentif aura remarqué que le nom de variable "texte" est encadré par 2 virgules, alors que les 2 autres noms de variables sont précédées du caractère '&'.
Donc, pour le comprendre, à mon avis, il suffit de savoir qu'ils existent, savoir reconnaitre la syntaxe, mais pas beaucoup plus.
Mais je ne voudrais pas que l'on traduise de mon propos que les pointeurs ne servent à rien, ou qu'il est inutile de comprendre à quoi ils servent, ce qu'ils représentent etc.

[Steviae]

ADA permet l'usage de la POO en structures et s'étudie aussi en avancées.

Je sais bien sur que je ne vais pas retrouver de l'ADA dans mon milieu professionnel ou du moins ce sera très improbable, mais là ça n'a rien de professionnel ce que je veux réaliser. C'est autant pour faire un cadeau que pour me motiver à apprendre de nouveau trucs.

[Valentin03]

Bonjour tous,
Access est payant, il me semble ?
J'utilise: DBworx (free) Prise en main pas évidente, mais pratique et bon fonctionnement.

http://www.commentcamarche.net/download/telecharger-34058068-dbworx

ça peut servir.... à+