IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Caml Discussion :

Fonction qui d'argument une chaîne de caractère renverrait l'objet qu'elle désigne


Sujet :

Caml

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre régulier
    Étudiant
    Inscrit en
    Juillet 2010
    Messages
    102
    Détails du profil
    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juillet 2010
    Messages : 102
    Points : 110
    Points
    110
    Par défaut Fonction qui d'argument une chaîne de caractère renverrait l'objet qu'elle désigne
    Bonjour !

    Cela fait plusieurs fois que je suis confronté à un problème assez embêtant en Caml Light : Je ne connais pas de fonction permettant de passer de la chaîne de caractère représentant le nom d'un objet à cet objet !

    Il s'agirait donc d'une fonction de string dans 'a qui d'argument une chaîne de caractère renverrait l'objet dont le nom est la chaîne de caractère.

    Par exemple, admettons que cette fonction s'appelle read_string. On pourrait alors avoir la session suivante :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    #read_string;;
    - : string -> 'a = <fun>
     
    #let objet=[1;2;3];;
    objet : int list = [1; 2; 3]
     
    #read_string "objet";;
    - : int list = [1; 2; 3]
    Une telle fonction serait très pratique notamment pour faire de l'interactif (mais aussi pour plein d'autres choses).

    Pour l'instant, à chaque fois que j'en ai eu besoin j'ai utilisé des match exhaustifs du genre :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    #let ersatz x = match x with
              "objet_1" -> objet_1
            | "objet_2" -> objet_2
                       (...)
            | "objet_n" -> objet_n;;
    ersatz : string -> 'a = <fun>
    Sauf que là j'ai un peu plus d'un demi-millier d'objets à traiter donc même si je pourrais me démerder pour faire une fonction qui affiche le code servant à faire mon match exhaustif, ça fait un peu c***. Pis je me dis que ça pourra toujours servir dans le futur.

    Voilà, je résume :

    - Existe-t-il une telle fonction ?
    - Le cas non-échéant [lol], pourrait-on la programmer en Caml ?
    - Le cas contraire [c'est mieux] y aurait-il de la programmer en C ou je sais pas quoi puis de l'ajouter au fonctions Caml ?

    - Si aucun des cas précédents ne s'est présenté, y aurait-il moyen de contourner le problème ? Dans le cas présent, j'utilise du read_line pour faire de "l'interactif", un truc qui fasse que par exemple on lance un outil de recherche de mots et on peut directement taper le mot et appuyer sur entrée au lieu de devoir se farcir #rechercher "mot";; à chaque fois. Par exemple, rechercher étant une fonction de recherche dans une base de donnée, on pourrait avoir :

    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
    let read () = 
    	print_string(">");
    	read_line();;
    read : unit -> string = <fun>
     
    exception stop;;
    Exception stop defined.
     
    let search strng =
    	if strng = "quit"
    	then raise stop
    	else rechercher strng;;
    search : string -> unit = <fun>
     
    let outil_de_recherche () = 
    	print_string("Go");
            print_newline();
    	try	while true 
    		do
    			search (read ())
    		done
    	with stop -> print_string("Stop");;
    outil_de_recherche : unit -> unit = <fun>
    Ce qui permet d'obtenir le résultat escompté. Seulement, ceci est possible car on a :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    rechercher : string -> unit = <fun>
    Mais admettons que rechercher soit de int list dans unit, ça ne marcherait pas. C'est dommage, non ? Alors, comment faire ?

  2. #2
    Membre éprouvé
    Profil pro
    Inscrit en
    Avril 2007
    Messages
    832
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2007
    Messages : 832
    Points : 1 104
    Points
    1 104
    Par défaut
    Une telle fonctionnalité n'existe pas en Caml.. et heureusement !
    Elle encouragerait les gens à faire n'importe quoi (comme les variables variables de PHP), et d'ailleurs le code que tu donnes est un assez bon exemple.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    let ersatz x = match x with
              "objet_1" -> objet_1
            | "objet_2" -> objet_2
                       (...)
            | "objet_n" -> objet_n;;
    Si tu as des objets de 1 à n, il faut les stocker dans... un tableau !
    Il faut donc plutôt utiliser du code comme :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    let ersatz nom = Scanf.sscanf nom "objet_%d" (fun i -> tableau_objets.(i))
    Si tu as des choses plus sophistiquées (par exemple une liste d'objets avec nom dans un jeu ou quoi), fais-toi une structure de données où tu stockes le nom de chaque objet avec ses caractéristiques, et utilise ensuite une table associative (par exemple une table de hachage) nom->objet.

  3. #3
    Membre éprouvé
    Avatar de Cacophrene
    Homme Profil pro
    Biologiste
    Inscrit en
    Janvier 2009
    Messages
    535
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Royaume-Uni

    Informations professionnelles :
    Activité : Biologiste

    Informations forums :
    Inscription : Janvier 2009
    Messages : 535
    Points : 1 125
    Points
    1 125
    Par défaut
    Bonjour,

    Je vais même plus loin que bluestorm : non seulement ce n'est pas une fonctionnalité souhaitable, parce qu'elle peut facilement conduire à des programmes incorrects, mais une fonction qui renvoie une valeur de type quelconque à partir d'un argument de type fixé n'est pas vraiment typée. Regarde dans la bibliothèque standard : quelles sont les fonctions qui ont ce genre de signature ? En OCaml il y a notamment exit et les fonctions qui lèvent des exceptions (invalid_arg, failwith, raise)... ce n'est pas pour rien.

    Cordialement,
    Cacophrène

  4. #4
    Membre régulier
    Étudiant
    Inscrit en
    Juillet 2010
    Messages
    102
    Détails du profil
    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juillet 2010
    Messages : 102
    Points : 110
    Points
    110
    Par défaut
    Citation Envoyé par bluestorm Voir le message
    Il faut donc plutôt utiliser du code comme :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    let ersatz nom = Scanf.sscanf nom "objet_%d" (fun i -> tableau_objets.(i))
    Si tu as des choses plus sophistiquées (par exemple une liste d'objets avec nom dans un jeu ou quoi), fais-toi une structure de données où tu stockes le nom de chaque objet avec ses caractéristiques, et utilise ensuite une table associative (par exemple une table de hachage) nom->objet.
    Ah, merci beaucoup ! Je pense que c'est ça qu'il me faut (seulement je ne connais pas les fonctions que tu utilise : je connais seulement les fonctions de bases qui servent à mettre en place de petits algorithmes [et non à faire de vrai programmes, on a même jamais prononcé le mot "compilation"] qu'on voit en prépa).

    Sinon mes objets sont déjà stockés dans un tableau. En gros à l'heure actuelle ils ressemblent à ça :

    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
    let Unexistant = {indice = 0; nom = ""; voisins = []; ligne = ""} and
    Les_Courtilles = {indice = 1; nom = "Les Courtilles"; voisins = [2]; ligne = "la ligne 13"} and
    Les_Agnettes = {indice = 2; nom = "Les Agnettes"; voisins = [1;9]; ligne = "la ligne 13"} and
    Carrefour_Pleyel = {indice = 3; nom = "Carrefour Pleyel"; voisins = [4;22]; ligne = "la ligne 13"} and
    St_Denis_Porte_de_Paris = {indice = 4; nom = "Saint-Denis - Porte de Paris"; voisins = [5;3]; ligne = "la ligne 13"} and
    Basilique_de_St_Denis = {indice = 5; nom = "Basilique de St-Denis"; voisins = [4;6]; ligne = "la ligne 13"} and
    St_Denis_Universite = {indice = 6; nom = "St-Denis - Université"; voisins = [5]; ligne = "la ligne 13"} and
    Pont_de_Levallois_Becon = {indice = 7; nom = "Pont de Levallois Bécon"; voisins = [8]; ligne = "la ligne 3"} and
    Anatole_France = {indice = 8; nom = "Anatole France"; voisins = [7;20]; ligne = "la ligne 3"} and
    Gabriel_Peri = {indice = 9; nom = "Gabriel Péri"; voisins = [2;10]; ligne = "la ligne 13"} and
    Mairie_de_Clichy = {indice = 10; nom = "Mairie de Clichy"; voisins = [9;11]; ligne = "la ligne 13"} and
    G11 = {indice = 11; nom = ""; voisins = [10;21;14]; ligne = "la ligne 13"} and
    W12 = {indice = 12; nom = ""; voisins = [65;17]; ligne = "walk"} and
    Porte_de_Champerret = {indice = 13; nom = "Porte de Champerret"; voisins = [20;19]; ligne = "la ligne 3"} and
    Porte_de_Clichy = {indice = 14; nom = "Porte de Clichy"; voisins = [11;16]; ligne = "changement"} and
    G15 = {indice = 15; nom = ""; voisins = [606;16]; ligne = "le RER C"} and
    G16 = {indice = 16; nom = ""; voisins = [15;14]; ligne = ""} and
    W17 = {indice = 17; nom = ""; voisins = [12;18]; ligne = "walk"} and
    W18 = {indice = 18; nom = ""; voisins = [17;34]; ligne = "walk"} and
    (...)
    et j'en ai 620 que je stocke dans un gros tableau (via deux gros tableaux que je fusionne en un seul, parce que mon implémentation de Caml Light ne me permet pas de définir un tableau à l'aide de plus de 4082 caractères, or comme mes noms sont bêtement lourds, ça monte vite ). Ca donne un truc du genre :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    let Paris = [|Unexistant; Les_Courtilles; Les_Agnettes; Carrefour_Pleyel; St_Denis_Porte_de_Paris; Basilique_de_St_Denis; (...)
    Je ne sais pas si ce stockage des données est optimal mais aux vues des objets qui m'ont étés présentés en cours, ça m'a semblé être le cas. (Pour le nom des objets, je reconnais qu'il est bêtement compliqué et je pense que je vais le simplifier)

    Je pourrais faire une fonction qui balaie le tableau à la recherche d'un élément dont le nom serait identique (c'est d'ailleurs comme ça que j'avais fait au début - pour l'indice aussi d'ailleurs : je balayais le tableau en incrémentant un compteur jusqu'à ce que je tombe sur la bonne station - seulement je me suis dit que c'était pas top pour la complexité, et c'est pour ça que je vous posais la question. Ceci dit si je devais faire comme ça ça serait pas un vrai problème puisque je ne dois le faire qu'une fois au début de l'algorithme (ensuite je ne travaille qu'avec les indices des stations - d'où la nécessité de passer de l'indice d'une station à la liste de ces voisins et inversement en temps unitaire)

    utilise ensuite une table associative (par exemple une table de hachage) nom->objet.
    Est-ce que tu pourrais développer un peu ? Je suis débutant et on m'a jamais parlé de ça. Il y a un bon nombre des termes que tu utilise dont j'ai jamais entendu parler en cours d'info (table associative, table de hachage...)

    En tous cas encore merci pour vos réponses rapides les gars, c'est super sympa et en plus ça fait plaisir de voir qu'on peut se faire aider en Caml ! (je pensais que c'était pas utilisé du tout et que j'arriverais jamais à trouver des gens voulant bien m'aider)

  5. #5
    Membre éprouvé
    Profil pro
    Inscrit en
    Avril 2007
    Messages
    832
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2007
    Messages : 832
    Points : 1 104
    Points
    1 104
    Par défaut
    Il y a plusieurs structures de données qui font des "tables associatives" : c'est un nom général que j'utilise pour parler des structures qui associent des valeurs à d'autres valeurs ("clés"). Un tableau est une table associative dont les clés sont toujours des entiers (de 0 à N-1).

    En Caml, tu as aussi les tables de hachage ( pour Caml Light, http://caml.inria.fr/pub/docs/manual.../node15.8.html ) et les "maps", basées sur des arbres équilibrés ( pour Caml Light, http://caml.inria.fr/pub/docs/manual...node15.10.html ).

    Tu n'as pas vraiment besoin de savoir comment c'est fait dedans. L'idée d'une table de hachage est un peu compliquée, mais en gros on s'arrange pour attribuer un "numéro" à chaque clé, pour pouvoir stocker ça dans des tableaux. On peut avoir des tables de hachages indexées par tout type qu'on sait "hacher" (produire un numéro), typiquement les chaînes de caractères (la façon précise dont on calcule le numéro est compliquée). La complexité est en O(1) (amorti) pour l'accès, l'ajout, la suppression, etc.
    Pour "Map", on utilise des arbres équilibrés, en gros une structure de donnée bien faite qui trie les éléments (donc, un petit peu comme dans un tableau trié, recherche dichotomique en O(log n)), où on peut en plus ajouter et retirer des éléments en O(log n), ce qui en pratique est en général aussi rapide qu'une table de hachage.


    Deux remarques :
    - si tu fais un programme sérieux, Objective Caml peut être plus adapté que Caml Light (le module Scanf que j'ai utilisé dans mon premier post n'existe pas en Caml Light, il faudra parser le nom à la main).
    - si tu utilises des ensembles de données relativement gros, et que tu veux des requêtes un peu puissantes dessus, il vaut mieux utiliser une base de données à part; il y a des interfaces entre Objective Caml et les principales bases de données (SQLite, MySQL, PostgreSQL...).

  6. #6
    Membre habitué
    Profil pro
    Inscrit en
    Avril 2009
    Messages
    128
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2009
    Messages : 128
    Points : 146
    Points
    146
    Par défaut
    Bonjour,

    Personnellement je t'aurais recommandé d'utiliser une liste-associative. C'est une structure de donnée qui offre des performances moindres par rapport aux autres type de table-associative, mais pour des programmes simples ne nécessitant pas de performance particulière c'est plus simple et aussi efficace. Pas besoin d'utiliser un basooka pour tuer une mouche

    ça te donnerait donc quelque chose comme cela :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    let my_assoc_list = [
      ("les Courtilles", Les_Courtilles);
      ("les Agnettes", Les_Agnettes);
      ("Carrefour Pleyel", Carrefour_Pleyel);
      ("St Denis Porte de Paris", St_Denis_Porte_de_Paris);
      (* etc ... *)
    ]
    et pour récupérer un élément à partir de son nom on fait comme ceci avec OCaml (tu traduiras pour caml light) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    let this = List.assoc "les Agnettes" my_assoc_list
    même si la liste en question contient un million d'éléments le temps d'accès d'un élément ne sera pas perceptible pour un humain.

    sinon tu parlais de l'indice des stations, avec les listes-associatives ou les tables de hachage les clés d'accès peuvent très bien être autre chose qu'un string, comme un int ou autre chose.

    Citation Envoyé par drunkskater Voir le message
    Est-ce que tu pourrais développer un peu ? Je suis débutant et on m'a jamais parlé de ça. Il y a un bon nombre des termes que tu utilise dont j'ai jamais entendu parler en cours d'info (table associative, table de hachage...)
    la qualité des article wikipedia est variable selon les domaines, mais dans le domaine de l'informatique les articles sont de très bonne qualité, tu peux t'y référer sans soucis,
    http://fr.wikipedia.org/wiki/Tableau_associatif
    http://fr.wikipedia.org/wiki/Table_de_hachage
    http://fr.wikipedia.org/wiki/Arbre_équilibré

    Citation Envoyé par drunkskater Voir le message
    En tous cas encore merci pour vos réponses rapides les gars, c'est super sympa et en plus ça fait plaisir de voir qu'on peut se faire aider en Caml ! (je pensais que c'était pas utilisé du tout et que j'arriverais jamais à trouver des gens voulant bien m'aider)
    la communauté ocaml (car il n'y a pas de communauté caml light) est effectivement un très petite communauté, mais elle est dynamique et réactive !

  7. #7
    Membre régulier
    Étudiant
    Inscrit en
    Juillet 2010
    Messages
    102
    Détails du profil
    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juillet 2010
    Messages : 102
    Points : 110
    Points
    110
    Par défaut
    re-bonjour !

    Alors tout d'abord merci beaucoup bluestorm et adtunum pour vos réponses ! Je m'excuse de ne pas avoir pu répondre plus tôt, mais bon, qui dit vacances dit pas d'Internet (une excellente chose au demeurant), d'où mon retard.

    @ bluestorm :

    Merci pour toutes ces précisions, je vais essayer de me renseigner un peu plus sur ces "maps", ça a l'air intéressant.

    Sinon mon programme n'est pas sérieux du tout, en fait il s'agit d'un programme qui trouve des itinéraires entre deux stations de métro du réseau parisien en tenant compte de certaines contraintes. Pas de quoi fouetter un chat, ça s'inscrivait comme petite illustration "concrète" dans un "pseudo-TIPE" sur la théorie des graphes (problème du voyageur de commerce, etc...). Le truc est inintéressant au possible vu qu'il s'agit d'une recherche exhaustive, mais ça m'a permis de me familiariser un peu avec le langage Caml. Puis le temps passant j'ai rajouté quelques outils, et là je me dis que maintenant que j'ai modélisé tout le réseau ça serait dommage de ne pas s'en servir, c'est pourquoi je voudrais améliorer un peu le truc, histoire d'en faire un truc utilisable.

    Mais je pense que je vais quand même le traduire en OCaml parce que j'ai des problèmes de compilation avec CamlLight...

    @ adtunum :

    Merci pour tes précisions (et pour tes liens !). Pour la liste-associative, j'ai tendance à ne pas aimer ce genre de truc parce qu'on m'a traumatisé en cours d'info avec le fait que la complexité devait être optimale (même pas le droit d'utiliser des fonctions du genre "list_length" ou des trucs du genre quand ça faciliterait pourtant bien la tâche ), mais c'est vrai que dans mon cas ça conviendrait aussi bien !

    Sinon j'ai un "petit problème" : dans la suite, si l'utilisateur tape "Chatelet" ou "châtelet" au lieu de "Châtelet", ça va planter. Je voudrais éviter ça.

    Je pensais donc faire une fonction qui transforme "Châtelet" et toutes les autres variantes en "chatelet", et qui compare ensuite les chaînes de caractères obtenues.

    Pour ça, je me disais qu'il allait falloir que d'une façon ou d'une autre j'identifie "A" et "à" à "a". J'ai pour ce faire plusieurs idées mais je ne sais pas si elles sont bonnes. je m'était dis que je pourrais par exemple faire un tableau ou une liste du type [("a","a");("A";"a");("à","a");("b","b");("B";"b") ... ], et ensuite on balaie la liste en jusqu'à trouver l'élément correspondant dans le premier élément d'un couple, et à ce moment on renvoit le deuxième élément de ce couple. A moins qu'il n'y ait certaines opérations sur les codes ASCII qui permettent de virer des majuscules ou des accents facilement ?

  8. #8
    Membre éprouvé
    Profil pro
    Inscrit en
    Avril 2007
    Messages
    832
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2007
    Messages : 832
    Points : 1 104
    Points
    1 104
    Par défaut
    Ta méthode est bonne, à part qu'il vaut mieux utiliser un tableau ou une table associative (accès arbitraire en temps constant ou quasi-constant) qu'une liste associative.

    Honnêtement, je pense que pour le coup, on peut utiliser une "bonne solution" avec une bonne complexité. Passer d'une liste associative à autre chose c'est essentiellement simplissime, il faut changer un peu le code de construction de la structure (sachant qu'on peut facilement écrire un convertisseur liste -> structure), et remplacer les appels à List.assoc par des appels à Hashtbl.get ou Map.get. C'est essentiellement la même interface.

    Je comprends l'intérêt de favoriser la simplicité plutôt que la complexité quand la complexité optimale demande un effort de programmation supplémentaire. Ici, tout est déjà tout cuit, donc ça ne change pas grand chose.


    Edit : j'ai retrouvé le code suivant dans mes caves. Ça pourrait t'intéresser.

    Code ocaml : 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
    (* liste_filtre renvoie un graphe (une liste de couples) représentant la fonction filtre
       "triviaux" désigne le sous-graphe correspondant à l'indentité ([('a', 'a'); ('b', 'b')...]),
       et à la conversion majuscule_minuscule ([('A', 'a'); ...])
    *)
    let liste_filtre =
      let triviaux =
        let trivial c = [(c, c); (Char.uppercase c, c)] in
        let rec lettres = function
          0 -> ['a']
        | n -> Char.chr (n + Char.code 'a') :: lettres (n - 1)
        in
        List.flatten (List.map trivial (lettres 25))
      in
      let accentue lettre = List.map (fun accent -> (accent, lettre)) in
      let points = List.map (fun point -> (point, '.')) in
      let espaces = List.map (fun espace -> (espace, ' ')) in
      triviaux
      @ accentue 'a' ['á'; 'à'; 'À'; 'â'; 'Â'; 'ä'; 'Ä'; 'Æ']
      @ accentue 'e' ['é'; 'É'; 'è'; 'È'; 'ê'; 'Ê'; 'ë'; 'Ë']
      @ accentue 'i' ['í'; 'Í'; 'î'; 'Î'; 'ï'; 'Ï']
      @ accentue 'o' ['ó'; 'ô'; 'ö'; 'ò'; 'õ'; 'Ô']
      @ accentue 'u' ['ú'; 'ù'; 'û'; 'ü'; 'Ù'; 'Ú'; 'Ü'; 'Û']
      @ accentue 'y' ['ÿ']
      @ accentue 'c' ['ç'; 'Ç']
      @ accentue 'n' ['ñ']
      @ points ['.'; ';'; ':'; '?'; '!'; '¿'; '¡'; ',']
      @ espaces [' '; '-'; '('; ')'; '"'; '\''; '@'; '*'; '\n'; '\t'; '\r';
    	     '«'; '»'; '<'; '>'; '{'; '}'; '_'; '/'; '\\'; '['; ']'; '%'; '&';
    	     '´'; '`'; '^'; 'º'; 'æ'; '°'; '+'; '¨'; '$'; '=';
    	     '0'; '1'; '2'; '3'; '4'; '5'; '6'; '7'; '8'; '9'; '¹'; '²'; '³'
    	    ]
     
    let rec assoc clé = function
      [] -> raise Not_found
    | (c, valeur) :: _ when c = clé -> valeur
    | _ :: queue -> assoc clé queue
     
    (* filtre met en place un cache pour ne pas utiliser la fonction assoc (linéaire) à chaque fois :
       le filtrage est en temps constant *)
    let filtre =
      let cache = Array.init 256
        (fun i ->
           try assoc (Char.chr i) liste_filtre
           with Not_found -> ' ')
      in
      fun c -> cache.(Char.code c)
     
    let traiter_mot mot =
      for i = 0 to String.length mot - 1 do
        mot.[i] <- filtre mot.[i]
      done

Discussions similaires

  1. Problème avec une chaîne de caractère en argument de fonction
    Par R3v3n4nt dans le forum Interfaces Graphiques
    Réponses: 0
    Dernier message: 09/03/2013, 13h10
  2. Réponses: 8
    Dernier message: 12/02/2013, 01h08
  3. [PowerShell] Récupérer une chaîne de caractères dans un objet WMI
    Par Zipper963 dans le forum Scripts/Batch
    Réponses: 5
    Dernier message: 15/01/2013, 10h00
  4. Réponses: 3
    Dernier message: 12/12/2008, 10h47
  5. Réponses: 5
    Dernier message: 14/06/2008, 23h06

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo