1. #1
    Membre du Club Avatar de Redgard
    Homme Profil pro
    x
    Inscrit en
    décembre 2014
    Messages
    90
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : x

    Informations forums :
    Inscription : décembre 2014
    Messages : 90
    Points : 60
    Points
    60

    Par défaut Absence d'une variable dans la sortie

    Bonjour à tous et merci de prendre le temps de me lire.

    Débutant en C, je réalise un petit programme prenant un verbe, extrayant sa racine puis le conjuguant au subjonctif.

    Or il semblerait que je rencontre un problème avec ma fonction VerbRacine qui ne renvoie pas comme j'ai prévu la racine du verbe. Je présume que c'est parce que je l'ai mal pensé, mais je n'arrive pas très bien à comprendre pourquoi... :s

    Si quelqu'un a une idée de ce qui cloche, je suis preneur.


    Bonne journée,
    Red'

    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
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
     
    #include <stdio.h>
    #include <stdlib.h> 
     
    #ifndef boolean
    #define boolean
    #define TRUE 1
    #define FALSE 0
    #endif // !boolean
     
     
     
    // ============================== FONCTIONS APPELEES =========================================
     
    // calcul la taille du verbe
    int SizeVerb(char verbe[]) {
    	int i = 0;
     
    	while (verbe[i] != '\0')
    	{
    		i++;
    	}
     
    	return i;
    }
     
    //crée la racine du verbe
    void VerbRacine(char verbSource[], char verbRacine[]) {
    	int i = 0;
    	int z = SizeVerb(verbSource) - 1;
     
    	//recopie le tableau en s'arrêtant 2 lettres avant la fin.
    	while (i < z)
    	{
    		verbSource[i] = verbRacine[i];
    		i++;
    	}
     
    	verbRacine[i] = '\0';
    }
     
     
    // ======================================== FONCTION MAIN ========================================
    int main() {
    	// demande le verbe
    	char reponse[30];
     
    	printf("Entrez un verbe du premier groupe: ");
    	scanf("%s", reponse);
     
    	//créer une racine
    	int longueur = SizeVerb(reponse);
    	char *repUtilisateur;
     
    	repUtilisateur = (char *)malloc((longueur + 1) * sizeof(char));
     
    	VerbRacine(reponse, repUtilisateur);
     
    	// imprime la conjugaison du verbe à l'écran.
    	char *pron[6];
     
    	pron[0] = "JE";
            pron[1] = "TU";
            pron[2] = "IL";
            pron[3] = "NOUS";
            pron[4] = "VOUS";
            pron[5] = "ILS";
     
    	char *term[6];
     
    	term[0] = "ASSE";
    	term[1] = "ASSES";
    	term[2] = "AT";
    	term[3] = "ASSIONS";
    	term[4] = "ASSIEZ";
    	term[5] = "ASSENT";
     
    	for (int i = 0; i < 6; i++)
    	{
    		printf("QUE %s %s%s \n", pron[i], repUtilisateur, term[i]);
    	}
     
    	free(repUtilisateur);
     
    	return 0;
    }

  2. #2
    Expert confirmé
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    2 423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : juillet 2013
    Messages : 2 423
    Points : 5 507
    Points
    5 507

    Par défaut

    L'erreur est ligne 35

    Sinon tu fais appel à 2 fois à ta fonction SizeVerb (ligne 52 et ligne 30 (appel à 57)) dont 1 qui ne sert à rien.
    Et tu pourrais faire le malloc dans la fonction VerbRacine

    Pourquoi n'utilises-tu pas strlen ?

  3. #3
    Membre du Club Avatar de Redgard
    Homme Profil pro
    x
    Inscrit en
    décembre 2014
    Messages
    90
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : x

    Informations forums :
    Inscription : décembre 2014
    Messages : 90
    Points : 60
    Points
    60

    Par défaut

    Dans?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    		verbSource[i] = verbRacine[i];
    Une autre personne vient de me le dire, je présumais que j'ai inversé. Mais concrètement, j'ai du le lire à haute voix pour que la faute m'apparaisse... dyslexie*

    D'ailleurs, cette personne m'a conseillé de préférer les char* aux char[] dans les paramètres des fonctions (en bref, utiliser les pointeurs). Tu confirmes? quelle intérêt?
    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
    //crée la racine du verbe
    void VerbRacine(char* verbSource, char* verbRacine) {
    	int i = 0;
    	int longueur = SizeVerb(verbSource);
     
            verbRacine = (char *)malloc(( longueur + 1) * sizeof(char));
     
    	//recopie le tableau en s'arrêtant 2 lettres avant la fin.
    	while (i < longueur - 2)
    	{
    		verbRacine[i] = verbSource[i];
    		i++;
    	}
            verbRacine[i] = '\0';
    ]
    Pour le malloc dans la fonction: je sais pas... peut être?
    Dans l'idée le premier, sert à déterminer la taille de la liste repUtilisateur, et le deuxième sert à interrompre prématurément la copie de la première liste dans la seconde, pour enlever la terminaison "-ER".
    J'ai un peu du mal à voir comment synthétiser les deux en un... est-ce que ça ne peut pas produire des problèmes, que je déclare la longueur de la liste dans la fonction? de même que la liste ne soit pas définit alors qu'elle est employé par une fonction?

    pour strlen:
    Je ne connais pas encore cette commande. il faut que je regarde la documentation.
    à son nom, je présume que ça veut dire "string lenght".
    Le compilateur utilisé par ma formation en ligne ne gère pas la bibliothèque string.h

    ... toujours le même problème. Ce qui donne:
    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
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
     
    #include <stdio.h>
    #include <stdlib.h> 
     
    #ifndef boolean
    #define boolean
    #define TRUE 1
    #define FALSE 0
    #endif // !boolean
     
     
     
    // ============================== FONCTIONS APPELEES =========================================
     
    // calcul la taille du verbe
    int SizeVerb(char verbe[]) {
    	int i = 0;
     
    	while (verbe[i] != '\0')
    	{
    		i++;
    	}
     
    	return i;
    }
     
    //crée la racine du verbe
    void VerbRacine(char *verbSource, char *verbRacine) {
    	int i = 0;
    	int longueur = SizeVerb(verbSource);
     
    	verbRacine = (char *)malloc((longueur + 1) * sizeof(char));
     
    	//recopie le tableau en s'arrêtant 2 lettres avant la fin.
    	while (i < longueur - 2)
    	{
    		verbRacine[i] = verbSource[i];
    		i++;
    	}
     
    	verbRacine[i] = '\0';
    }
     
     
    // ======================================== FONCTION MAIN ========================================
    int main() {
    	// demande le verbe
    	char reponse[30];
     
    	printf("Entrez un verbe du premier groupe: ");
    	scanf("%s", reponse);
     
    	//créer une racine
    	char *repUtilisateur;
     
    	VerbRacine(reponse, repUtilisateur);
     
    	// imprime la conjugaison du verbe à l'écran.
    	char *pron[6];
     
    	pron[0] = "JE";
        pron[1] = "TU";
        pron[2] = "IL";
        pron[3] = "NOUS";
        pron[4] = "VOUS";
        pron[5] = "ILS";
     
    	char *term[6];
     
    	term[0] = "ASSE";
    	term[1] = "ASSES";
    	term[2] = "AT";
    	term[3] = "ASSIONS";
    	term[4] = "ASSIEZ";
    	term[5] = "ASSENT";
     
    	for (int i = 0; i < 6; i++)
    	{
    		printf("QUE %s %s%s \n", pron[i], repUtilisateur, term[i]);
    	}
     
    	free(repUtilisateur);
     
    	return 0;
    }

  4. #4
    Membre expert
    Inscrit en
    mars 2005
    Messages
    1 301
    Détails du profil
    Informations forums :
    Inscription : mars 2005
    Messages : 1 301
    Points : 3 784
    Points
    3 784

    Par défaut

    Citation Envoyé par foetus Voir le message
    Et tu pourrais faire le malloc dans la fonction VerbRacine
    Question de point de vue sur la conception d'APIs. Perso j'évite de confier cette tâche à l'appelé quand c'est possible et je m'explique :

    • ça multiplie les responsabilités : on extrait un radical ou on gère la mémoire ? Faut choisir.
    • Cela force à inclure stdlib.h et c'est moins générique : j'avais peut-être un buffer déjà tout prêt, pas de bol !
    • C'est moins flexible : si je veux plutôt allouer mon buffer en statique ou sur la pile, pas de bol !
    • Cela force à faire de la gestion d'erreur au milieu du traitement : j'ai pas envie d'avoir à gérer une erreur d'allocation quand je suis en train de manipuler des chaînes.



    Citation Envoyé par Redgard Voir le message
    ... toujours le même problème.
    Cela ne fonctionne pas parce que tu as réalisé plusieurs modifications en même temps, qui ont introduit d'autres erreurs. Si tu avais simplement corrigé le défaut que foetus a mentionné, tu aurais constaté que ton programme fonctionne (à peu de choses près). Ne fais qu'une seule chose à la fois.


    Citation Envoyé par Redgard Voir le message
    D'ailleurs, cette personne m'a conseillé de préférer les char* aux char[] dans les paramètres des fonctions (en bref, utiliser les pointeurs). Tu confirmes? quelle intérêt?
    C'est surtout : quel intérêt de préférer l'autre notation ([]) ? Le compilateur interprètera de toute manière le paramètre comme un pointeur. Il n'y a pas d'avantage à utiliser cette notation, sauf à ne pas vouloir faire comme tout le monde. Personnellement je ne l'emploie qu'à un seul endroit et c'est uniquement par habitude / convention : int main(int argc, char *argv[]) { ... .

    Attention : ce que j'ai écrit ici n'est valable que pour les déclarations de paramètres de fonction ! Il y a bien une différence entre char s1[] = "string"; et char *s2 = "string";, par exemple.

    Ah, pense aussi à ajouter un const avant l'astérisque dans une déclaration pour préciser que le contenu d'une chaîne ne sera pas modifié par le code qui utilise la variable. Ici, la chaîne source n'est pas sensée être modifiée, déclare donc ta fonction comme ceci : void VerbRacine(const char *verbSource, char *verbRacine). Tu indiques ainsi au compilateur (et à tes relecteurs qui comprendront mieux le rôle de chaque paramètre !) qu'on ne doit pas accéder au contenu de verbSource en écriture. Ton erreur aurait ainsi pu être détectée à la compilation.


    Citation Envoyé par Redgard Voir le message
    pour strlen:
    Je ne connais pas encore cette commande. il faut que je regarde la documentation.
    à son nom, je présume que ça veut dire "string lenght".
    Tu as correctement deviné -> http://en.cppreference.com/w/c/string/byte/strlen (garde l'adresse de ce site sous le coude)

  5. #5
    Expert confirmé
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    2 423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : juillet 2013
    Messages : 2 423
    Points : 5 507
    Points
    5 507

    Par défaut

    Citation Envoyé par Matt_Houston Voir le message
    Question de point de vue sur la conception d'APIs. Perso j'évite de confier cette tâche à l'appelé quand c'est possible et je m'explique :

    • ça multiplie les responsabilités : on extrait un radical ou on gère la mémoire ? Faut choisir.
    • Cela force à inclure stdlib.h et c'est moins générique : j'avais peut-être un buffer déjà tout prêt, pas de bol !
    • C'est moins flexible : si je veux plutôt allouer mon buffer en statique ou sur la pile, pas de bol !
    • Cela force à faire de la gestion d'erreur au milieu du traitement : j'ai pas envie d'avoir à gérer une erreur d'allocation quand je suis en train de manipuler des chaînes.
    Tu as tout à fait raison sur certains points, mais cette fonction est là pour faire une copie [partielle] d'une chaîne de caractères : donc ce n'est pas déconnant que ce soit elle qui prenne la longueur de la source, initialise la destination en conséquence et fasse la copie.
    Surtout qu'ici, c'est une copie partielle, certes simple (avec un -2), mais tu sors de ta fonction de la logique propre à cette copie.
    Avec le verbe choir, tu dois retirer 3 lettres

    Tu parles de la gestion d'erreur. Mais que ce passe-t-il si la source est vide ? que se-passe-il si ta destination est nulle (dans le cas présent) ?
    En C, tu dois en permanence faire de la programmation [ultra] défensive : retour booléen [bien passé ou pas] + paramètre pointeur d'une énumération pour toutes les erreurs possibles.

    Sinon, pour les autres allocations, statique, dynamique, sur la pile : 1) ici on en gère une seule 2) tu peux passer en paramètre une énumération "type d'allocation" qui permet d'initialiser ou pas la destination
    Et ainsi, ce paramètre permet de faire une documentation adéquate de la fonction


    Et pour stdlib.h, je n'ai jamais eu de considération de la sorte : c'est la librairie standard, un malloc je pense doit être "cross-platform". Je ne vais pas modulariser mon programme pour avoir une [grosse ou petite] partie de mon programme sans aucun include

  6. #6
    Membre du Club Avatar de Redgard
    Homme Profil pro
    x
    Inscrit en
    décembre 2014
    Messages
    90
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : x

    Informations forums :
    Inscription : décembre 2014
    Messages : 90
    Points : 60
    Points
    60

    Par défaut

    Citation Envoyé par Matt_Houston Voir le message
    Question de point de vue sur la conception d'APIs. Perso j'évite de confier cette tâche à l'appelé quand c'est possible et je m'explique :

    • ça multiplie les responsabilités : on extrait un radical ou on gère la mémoire ? Faut choisir.
    • Cela force à inclure stdlib.h et c'est moins générique : j'avais peut-être un buffer déjà tout prêt, pas de bol !
    • C'est moins flexible : si je veux plutôt allouer mon buffer en statique ou sur la pile, pas de bol !
    • Cela force à faire de la gestion d'erreur au milieu du traitement : j'ai pas envie d'avoir à gérer une erreur d'allocation quand je suis en train de manipuler des chaînes.

    Je suis pas aussi loin, donc je comprends pas tout ^^'. va falloir que je fasse quelques recherche.
    Mais, dans une formation en ligne que j'ai suivis, le gars disait de limiter ses fonctions à un seul tâches qui peut être résumer en une seul phrase. Dans le cas contraire, c'est que tu veux en faire trop.


    Cela ne fonctionne pas parce que tu as réalisé plusieurs modifications en même temps, qui ont introduit d'autres erreurs. Si tu avais simplement corrigé le défaut que foetus a mentionné, tu aurais constaté que ton programme fonctionne (à peu de choses près). Ne fais qu'une seule chose à la fois.
    Je manque encore de méthodologie et de rigueur. j'essaie d'éviter ce genre de chose mais j'ai tendance à vouloir aller trop vite.

    Attention : ce que j'ai écrit ici n'est valable que pour les déclarations de paramètres de fonction ! Il y a bien une différence entre char s1[] = "string"; et char *s2 = "string";, par exemple.
    bah si je ne trompe pas, "s1" est une liste/array, tandis que "s2" est le pointeur. Parcontre va falloir que je continue à étudier ça parce que je vois pas toutes les nuances au niveau de ce qui se passe dans la ram.
    Pour s1, tu initialises une liste de caractères que tu remplis avec "string". en bref dans la mémoire, tu vas retrouvé un emplacement avec l'adresse de la liste et un autre contenant la chaine de caractère "string".
    Tandis qu'avec "s2", tu initialises un pointeur dont l'adresse pointe faire une liste/ array de caractères et là????

    Ah, pense aussi à ajouter un const avant l'astérisque dans une déclaration pour préciser que le contenu d'une chaîne ne sera pas modifié par le code qui utilise la variable. Ici, la chaîne source n'est pas sensée être modifiée, déclare donc ta fonction comme ceci : void VerbRacine(const char *verbSource, char *verbRacine). Tu indiques ainsi au compilateur (et à tes relecteurs qui comprendront mieux le rôle de chaque paramètre !) qu'on ne doit pas accéder au contenu de verbSource en écriture. Ton erreur aurait ainsi pu être détectée à la compilation.
    En fait l'intérêt de la constante, c'est de passer une zone de la mémoire en ROM (Read Only Memory)

    Tu as correctement deviné -> http://en.cppreference.com/w/c/string/byte/strlen (garde l'adresse de ce site sous le coude)
    Merci, je vais l'ajouter à ma liste; ça m'en fera deux. Quelqu'un m'avait donné celui là déjà http://www.cplusplus.com


    Le projet est restreint aux verbes du premier groupe. Maintenant, si je devais faire qu'il détecte les autres groupes, je rajouterai surement une fonction en if qui vérifie les 3 dernières lettres et les compare à différentes combinaison de caractères, pour déterminer si c'est un du 1, 2 ou 3 groupe.

    ___________________________________________________________________

    Je viens de faire le test en reprenant mon code original et en faisant quelques modification et effectivement ça marche .... parcontre je ne sais pas pourquoi :/
    Je vais devoir comparer.

    En tout cas merci pour votre aide et pour vos conseils

    Nom : C2.PNG
Affichages : 55
Taille : 14,8 Ko

  7. #7
    Expert confirmé
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    2 423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : juillet 2013
    Messages : 2 423
    Points : 5 507
    Points
    5 507

    Par défaut

    Citation Envoyé par Redgard Voir le message
    Pour s1, tu initialises une liste de caractères que tu remplis avec "string". en bref dans la mémoire, tu vas retrouvé un emplacement avec l'adresse de la liste et un autre contenant la chaine de caractère "string".
    Tandis qu'avec "s2", tu initialises un pointeur dont l'adresse pointe faire une liste/ array de caractères et là????
    Non, c'est un truc avec lequel j'ai du mal aussi et qui est ultra-dépend du compilateur

    Lorsque tu fais ceci, en théorie, ta variable sera mise dans une mémoire "lecture seule".
    Donc avec :
    • un tableau, char s1[] = "string" tu ne pourras ni détruire ni étendre (realloc) ton tableau, et en théorie ni le modifier
    • un pointeur, char* s2 = "string", tu ne pourras ni détruire ni étendre (realloc) ta chaîne de caractères, mais tu pourras modifier les caractères de ta chaîne (parce que c'est le pointeur qui est constant, pas la chaîne).

  8. #8
    Membre expert
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    décembre 2015
    Messages
    750
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : décembre 2015
    Messages : 750
    Points : 3 750
    Points
    3 750

    Par défaut

    Citation Envoyé par foetus Voir le message
    • un tableau, char s1[] = "string" tu ne pourras ni détruire ni étendre (realloc) ton tableau, et en théorie ni le modifier
    • un pointeur, char* s2 = "string", tu ne pourras ni détruire ni étendre (realloc) ta chaîne de caractères, mais tu pourras modifier les caractères de ta chaîne (parce que c'est le pointeur qui est constant, pas la chaîne).
    Le premier est un tableau, il doit être en RAM et est modifiable; il y a donc copie d'un tableau en ROM vers un tableau en RAM à l'instanciation de la variable. On peut aussi écrire static const char s2[] = "string"; qui lui sera un tableau directement en ROM.
    Le second devrait s'écrire const char* s2 = "string"; le mot const reste facultatif en C (bien la chaine puisse être en ROM!), il est devenu obligatoire en C++.

  9. #9
    Membre expert
    Inscrit en
    mars 2005
    Messages
    1 301
    Détails du profil
    Informations forums :
    Inscription : mars 2005
    Messages : 1 301
    Points : 3 784
    Points
    3 784

    Par défaut

    Non mais en fait on s'en fout des chaînes littérales constantes ou pas.. C'était un exemple pour préciser que mon propos ne portait que dans le contexte des signatures de fonction.


    Citation Envoyé par Redgard Voir le message
    Je suis pas aussi loin, donc je comprends pas tout ^^'. va falloir que je fasse quelques recherche.
    Mais, dans une formation en ligne que j'ai suivis, le gars disait de limiter ses fonctions à un seul tâches qui peut être résumer en une seul phrase. Dans le cas contraire, c'est que tu veux en faire trop.
    Je rebondissais sur ce qu'écrivait foetus mais oui voilà, tu as saisi l'idée. Ça a à voir avec Unix et plus généralement le principe d'économie.


    Citation Envoyé par Redgard Voir le message
    En fait l'intérêt de la constante, c'est de passer une zone de la mémoire en ROM (Read Only Memory)
    Attention : dans le cas général le mot-clef const n'est qu'une indication destinée au compilateur qu'on ne compte pas modifier le contenu de la zone mémoire en question, ce qui peut lui permettre de traduire le code différemment. Il est toujours possible de ne pas respecter ce contrat (et possiblement s'exposer à des effets indésirables).


    Citation Envoyé par Redgard Voir le message
    Merci, je vais l'ajouter à ma liste; ça m'en fera deux. Quelqu'un m'avait donné celui là déjà http://www.cplusplus.com
    Certains diront qu'il s'agit encore d'une querelle de clochers mais je te déconseille cplusplus.com au profit de cppreference qui est plus complet, plus précis et plus exact (ainsi que plus joliment / sobrement formaté..). Ne serait-ce que parce que le premier ne traite que de C++ qui n'est pas ce qui nous intéresse ici.


    Citation Envoyé par Redgard Voir le message
    Le projet est restreint aux verbes du premier groupe.
    Et encore : essaie de conjuguer manger..



    Citation Envoyé par foetus Voir le message
    mais cette fonction est là pour faire une copie [partielle] d'une chaîne de caractères
    Réaliser une copie peut s'interpréter de différentes manières.


    Citation Envoyé par foetus Voir le message
    Tu parles de la gestion d'erreur. Mais que ce passe-t-il si la source est vide ? que se-passe-il si ta destination est nulle (dans le cas présent) ?
    Tu mets des assert et tu écris ta documentation correctement ! C'est à cela que servent les préconditions. Une fois les entrées validées - le plus tôt possible - il est inutile de traiter des cas qui ne peuvent pas se produire. Tu imagines si tu devais check errno après chaque memcpy ?


    Citation Envoyé par foetus Voir le message
    En C, tu dois en permanence faire de la programmation [ultra] défensive : retour booléen [bien passé ou pas] + paramètre pointeur d'une énumération pour toutes les erreurs possibles.
    Justement ! Moins tu fais de choses, moins tu as de cas d'erreur à prendre en compte. Encore une fois : il faut valider les entrées au plus tôt, ensuite déroule !


    Citation Envoyé par foetus Voir le message
    Sinon, pour les autres allocations, statique, dynamique, sur la pile : 1) ici on en gère une seule 2) tu peux passer en paramètre une énumération "type d'allocation" qui permet d'initialiser ou pas la destination
    Alors j'en reviens à mon premier argument : la multiplication des responsabilités. Keep it simple !

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 4
    Dernier message: 13/06/2007, 17h42
  2. Comment completer une variable dans une PROC
    Par Le Basque dans le forum MS SQL-Server
    Réponses: 2
    Dernier message: 20/09/2004, 17h18
  3. [langage] trouver une variable dans une autre
    Par BEAUJAULT dans le forum Langage
    Réponses: 2
    Dernier message: 19/08/2004, 15h04
  4. comment recuperer une variable dans flash
    Par krépuscul dans le forum Flash
    Réponses: 30
    Dernier message: 16/10/2003, 09h40
  5. Réponses: 13
    Dernier message: 14/06/2003, 22h15

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