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

  1. #1
    Membre actif

    Homme Profil pro
    Technicien maintenance
    Inscrit en
    février 2012
    Messages
    50
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : février 2012
    Messages : 50
    Points : 213
    Points
    213

    Par défaut Pointeur de structure en argument

    Bonjour,

    Je coince sur un probleme d'écriture.
    J'ai ecris du code suivant ,
    Main.c :
    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
     
    #include <....//mes include systeme
    .....
    typedef struct {
               tile_t date
               .........
              .......
    } Mesures;
     
    #include "....."//mes include locaux
     
    int affOLED(Mesure *);
     
    int main(int argc, char** argv) 
    {
        ......//des definitions
       Mesures Mes;
    .........  // du code
     
     
    AffOled(&Mes);
     
    .........//du code
     
     
    }
     
    int AffOled(Mesures *Mes)
    {
    	struct tm ld;
    	ld= *localtime(&Mes->date);
     
         ......//du code
     
    }
    Cela fonctionne très bien.

    Maintenant , comme le code de la fonction AffOLED() devient très important, je désire mettre cette fonction dans un fichier .c séparé.

    J'ai donc écris un AffOLED.c ,

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
    #.......//include systeme
    #include "Affiche.h"
     
    int AfficheOled(Mesures *Mes)
    {
    	char LaDate[50];
    	struct tm *ld;
     
    	ld= localtime(& (Mes->date));
    .........................
     
    }
    Puis j'ai créé un .h comme suit :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    #ifndef __AFFICHE
    #define __AFFICHE
     
    extern Mesures *;
     
    extern int AfficheOled(Mesures *);
     
    #endif
    j'ai rajouter #include "Affiche.h" dans le main.c

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    typedef struct{
        } Mesures;
     
    #include "Affiche.h"
     
    int main(...)
    {
    ....
    }


    Et la, plus rien ne vas......

    J'ai essayer avec diverses versions du .h,
    extern struct Mesures *Mes;
    extern typedef Mesures *Mes;
    extern typedef struct Mesures *Mes;



    mais je crois surtout que je n'ai pas encore bien assimilé les pointeurs, les typedef, et autre subtilités du multi fichier en C
    Si quelqu'un avait une idée, ou une correction.....
    Pour info ce code est ecrit en C sous linux rasbian avec l'éditeur geany.
    Un grand merci pour m'allumer la lumière

    Michel

  2. #2
    Expert éminent sénior
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    septembre 2005
    Messages
    26 964
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2005
    Messages : 26 964
    Points : 39 977
    Points
    39 977

    Par défaut

    Le problème, c'est que tu n'as pas créé de type struct Mesures: Tu as seulement créé un type Mesures pour lequel tu ne peux pas utiliser de déclaration anticipée.
    Ceci se corrige facilement:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    //MonHeaderPartagé.h
     
    struct Mesures;
    typedef struct Mesures Mesures;
     
    int AfficheOled(Mesures const*);
    Mesures* Mesurer();
    void DetruireMesures(Mesures*);
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    //MonImplémentation.h
    #include <time.h>
     
    struct Mesures {
               time_t date
               .........
              .......
    };
    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
    //MonImplémentation.c
    #include "MonHeaderPartagé.h"
    #include "MonImplémentation.h"
     
    int AfficheOled(Mesures const* Mes)
    {
    	char LaDate[50];
    	struct tm *ld;
     
    	ld= localtime(& (Mes->date));
    	.........................
    	return .....;
    }
     
    Mesures* Mesurer()
    {
    	Mesures* ret = malloc(sizeof *ret);
    	if(ret != NULL) {
    		.........
    	}
    	return ret;
    }
     
    void DetruireMesures(Mesures*p)
    {
    	free(p);
    }
    Le truc à garder à l'esprit, c'est que toutes les fonctions qui font directement appel au contenu de la structure Mesures (comme AfficheOled()) ont besoin d'avoir accès à sa définition complète.
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  3. #3
    Expert éminent
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    2 972
    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 972
    Points : 6 602
    Points
    6 602

    Par défaut

    extern Mesures *; -> ne sert à rien

    extern int AfficheOled(Mesures *); -> une fonction/ procédure est toujours externe en C

    Tu touches aux déclarations partielles

    En gros, dans ton entête Affiche.h, le compilateur n'a pas besoin de la définition de ta structure puisque c'est un pointeur.
    Par contre dans tes sources Affiche.c et main.c, il faut la définition : et donc un #include "one_mesure.h".

    Le plus simple, c'est de mettre un #include "one_mesure.h" dans ton entête Affiche.h, et laisser le reste se faire naturellement


    one_mesure.h :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #ifndef ONE_MESURE_H
    #define ONE_MESURE_H
     
    #include ... // <- comme time.h
     
     
    typedef struct s_mesure {
        tile_t date
     
    //  ...
    } t_mesure;
     
     
    #endif // ONE_MESURE_H

    Édit : Attention au code de @Médinoc il a oublié les include guards (<- lien wiki en anglais)

  4. #4
    Membre actif

    Homme Profil pro
    Technicien maintenance
    Inscrit en
    février 2012
    Messages
    50
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : février 2012
    Messages : 50
    Points : 213
    Points
    213

    Par défaut

    Bonjour Medinoc et Foetus,

    Merci pour les réponses rapides...

    Si j'ai bien compris :

    je cree un fichier .h qui contient les definitions de mes structures (et de mes variable globale ??)
    Soit :

    MesVariable.h
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     
    #ifndef  __MESVAR
    #define __MESVAR
    #include <time.h>// pour l'utilisation du time_t
     struct Mesures
     {
         time_t date
         double mes1
    ........
    } ;
     
    double calcul  //autre variable globale
    .......
    #endif
    Et ce fichier je l'inclus dans chaqu'un des .c ou .h où les variables/structure sont utilisée, comme variable ou comme pointeurs.
    Pour ensuite dans les .c déclarer les variables/structure utilisée

    AffOLED.h
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    #ifndef  __AFFICHE
    #define __AFFICHE
    #include "MesVariable.h"
    .........
    typedef struct Mesures Mes;
     
    int AffOLED(Mesure const*);
     
    #endif
    AffOLED.c
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    #include <...>
    #include "AfffOLED.h"
     
    int AffOLED(Mesures const *Mes)
    {
    ......   
      Mes->mes1++;
    ......
    }
    et pour finir , dans

    main.c
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     
    #include<.....>
    #include "MesVariables.h"
    #include "AffOLED.h"
     
    int main()
    {
       Mesures MesNow;  
    .............
     
       AffOLED(&MesNow);
    .....
     
    }
    Est ce que là je m'approche ???

    Pourquoi est ce que dan sla declaration de la fonction AffOLED (Mesures const *Mes) je dois mettre le pointeur sur la structure en const ???
    cela n'aurais pas fonctionner avec ffOLED (Mesures *Mes) et evidemmentadapter la definition dans le AffOLED.h ?

    Là je n'ai pas la possibilité de tester le code sinon cela serai fait avant de vous repondre.

    Merci

    Michel

  5. #5
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    7 343
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 7 343
    Points : 20 904
    Points
    20 904
    Billets dans le blog
    1

    Par défaut

    Bonjour
    Citation Envoyé par michel.semal Voir le message
    je cree un fichier .h qui contient les definitions de mes structures (et de mes variable globale ??)
    Est ce que là je m'approche ???
    Oui c'est bon (enfin sauf pour l'utilisation de ces globales "de faignasse" "de confort")...

    Citation Envoyé par michel.semal Voir le message
    Pourquoi est ce que dan sla declaration de la fonction AffOLED (Mesures const *Mes) je dois mettre le pointeur sur la structure en const ???
    C'est pour éviter de modifier accidentellement le pointeur. Evidemment ça fonctionne aussi sans ça.
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  6. #6
    Membre actif

    Homme Profil pro
    Technicien maintenance
    Inscrit en
    février 2012
    Messages
    50
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : février 2012
    Messages : 50
    Points : 213
    Points
    213

    Par défaut

    Merci Sve@r.

    Oui c'est bon (enfin sauf pour l'utilisation de ces globales "de faignasse" "de confort")...
    Mais pourtant quand je lis des posts, je trouve que l'on parle partout qu'un bon devellopeur etait un fainéant.....

    Pour les variables globales, c'est plus une question de rethorique que vraiment utilisé. Mais la remarque ci dessus reste valable

    Pour la seconde remarque sur la defnition de la const*, je mettrais cela en pratique dès mon retour du taf;
    A relire le post je me ppose encore des questions mais je verrai en essayant de comprendre.

    Merci beaucoup à tous


    Michel

  7. #7
    Expert éminent sénior
    Avatar de koala01
    Homme Profil pro
    Consultant informatique
    Inscrit en
    octobre 2004
    Messages
    11 176
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : Belgique

    Informations professionnelles :
    Activité : Consultant informatique

    Informations forums :
    Inscription : octobre 2004
    Messages : 11 176
    Points : 27 582
    Points
    27 582

    Par défaut

    Salut,
    Citation Envoyé par michel.semal Voir le message
    Mais pourtant quand je lis des posts, je trouve que l'on parle partout qu'un bon devellopeur etait un fainéant.....
    C'est en effet ce qu'on lit souvent

    On oublie juste de préciser qu'un bon développeur est un développeur fainéant ... qui sait quand ne pas l'être

    Les variables globales créent souvent beaucoup plus de problème que ce qu'elle n'apportent de solution, ce qui nous donne une excellente raison de ne pas nous laisser aller à notre "fainéantise naturelle", car elle finira tôt ou tard par nous retomber dessus, et par nous occasionner beaucoup plus de travail que si nous avions décidé dés le départ de ne pas y souscrire
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  8. #8
    Expert éminent
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    2 972
    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 972
    Points : 6 602
    Points
    6 602

    Par défaut

    Citation Envoyé par michel.semal Voir le message
    Est ce que là je m'approche ???
    2-3 petites choses

    Ton typedef tu peux directement le faire lors de la définition de ta structure, dans ton entête MesVariable.h. Regarde mon entête one_mesure.h.

    Tu n'as pas besoin d'inclure MesVariable.h dans ton main.h, puisque l'entête AffOLED.h l'a déjà fait.

    Je ne suis pas fan du fait de mélanger la structure avec les variables globales. Fait un fichier spécifique global.h, parce que sinon c'est le meilleur moyen de mettre des variables globales n'importe où. Et c'est d'ailleurs leur gros problème : tu ne pas contrôler à 100% leurs modifications si ton code devient important.


    Après pour ne pas avoir de variables globales , je peux te parler d'injection de dépendance, d'interface, de singleton, ... mais bon cela sera pour plus tard vu que tu galères à faire 2 include et 1 structure.

  9. #9
    Membre actif

    Homme Profil pro
    Technicien maintenance
    Inscrit en
    février 2012
    Messages
    50
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : février 2012
    Messages : 50
    Points : 213
    Points
    213

    Par défaut

    bonjour à tous,
    Citation Envoyé par foetus Voir le message
    2-3 petites choses
    Merci pour ces petites choses. C'est comme cela que je progresse le plus.

    J'ai cherché sur internet et dans les forums, mais je n'ai rien trouver de clair sur les structure, pointeur, fonction et multifichier.
    Sur chacun indépendament oui, parfois deux par deux mais pas sur les quatre ensemble.(ou du moins j'ai pas compris)

    Donc, un fichier .h pour les defintion de structure (avec le typedef et sans les variable globales d'ailleur je n'en ai pas)
    Inclure ce fichier la ou il est necessaire.
    Dans la même idée, on pourrait cree un fichier include.h qui regrouperait tous les ' #include<>' ?
    On inclurai ce fichier dans chaque .c.


    Citation Envoyé par foetus Voir le message
    Après pour ne pas avoir de variables globales , je peux te parler d'injection de dépendance, d'interface, de singleton, ...
    Je vais me pencher sur la question........

    Merci a tous pour votre aide.

    Michel

  10. #10
    Expert éminent
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    2 972
    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 972
    Points : 6 602
    Points
    6 602

    Par défaut

    Citation Envoyé par michel.semal Voir le message
    Dans la même idée, on pourrait cree un fichier include.h qui regrouperait tous les ' #include<>' ?
    On inclurai ce fichier dans chaque .c.
    Ce que tu as du mal à comprendre, c'est qu'à chaque fois tu fais un #include, tu vas avoir une copie intégrale du fichier inclus (qui va remplacer la commande préprocesseur)
    C'est pour cela que 1) tout le monde dit que c'est archaïque 2) il faut mettre les include guards pour ne pas avoir de définitions dupliquées

    Tout cela pour te dire , qu'il faut faire le moins d'#include afin de gagner du temps à la compilation - mais cela tu vas vite le comprendre avec un projet assez important
    Donc faire une entête de brutasse oui mais

    D'ailleurs pour ta culture, faire une entête de brutasse cela s'appelle une entête précompilée (precompiled header, lien wiki en anglais) qui existe depuis 1998 dans Visual.
    L'idée : on met dans une entête toutes les entêtes qui sont sensées ne presque jamais être modifiées, on compile le tout et ce fichier binaire est inclus lors de l'édition des liens : cela permet de gagner du temps de compilation.

  11. #11
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    7 343
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 7 343
    Points : 20 904
    Points
    20 904
    Billets dans le blog
    1

    Par défaut

    Citation Envoyé par foetus Voir le message
    Tu n'as pas besoin d'inclure MesVariable.h dans ton main.h, puisque l'entête AffOLED.h l'a déjà fait.
    Ah, moi justement j'aurais dit le contraire. Je suis en effet partisan du "j'inclus ce dont j'ai besoin sans me préoccuper si un autre include ne le fait pas déjà". Et comme je suis protégé par les include guard...
    Hypothèse: j'ai besoin de "trucA" et "trucB", j'inclus alors "includeA" et "includeB" (toi tu inclus juste "includeA" car tu sais qu'il inclus automatiquement "includeB"). Mais le jour où je n'ai plus besoin de "trucA", je supprime "includeA" et mon code continue à compiler vu que "includeB" est toujours là. Alors que chez-toi, en supprimant "includeA" ton code ne compile plus...
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  12. #12
    Membre éprouvé Avatar de edgarjacobs
    Homme Profil pro
    Développeur informatique
    Inscrit en
    mai 2011
    Messages
    400
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : Belgique

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : mai 2011
    Messages : 400
    Points : 924
    Points
    924

    Par défaut

    J'en fais autant. Je ne suis pas sensé savoir quel include fait quel include, qui lui-même fait des include, etc. Donc je mets en include dans un .c tout ce dont il a besoin pour compiler correctement.

  13. #13
    Expert éminent
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    2 972
    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 972
    Points : 6 602
    Points
    6 602

    Par défaut

    @Sve@r tu as tout fait raison

    C'est comme je te le disais il y a quelque temps en arrière : il faut compartimenter/ faire des interfaces.

    Dans ce cas : les sources maStruct.h, AffOLED.h et AffOLED.c sont toutes liées. Et tu as le main.

    Donc, pour moi c'est normal que maStruct.h, il n'y a que la source AffOLED.X qui s'en occupe. C'est la notion d'encapsulation de la POO (programmation orientée objet).

    Le main n'a pas à se préoccuper à inclure les fonctions (AffOLED.h), la structure (maStruct.h) et "je-ne-sais-pas-quoi". Elle inclue seulement l'interface "AffOLED"

    Parce qu'on peut te rétorquer le fait inverse : si pour un raison X, la source/ interface "AffOLED" n'a plu besoin de la structure, et bien tu vas avoir un include mort dans le main qui te bouffera du temps à la compilation.

    Et pour cela, tu compileras toujours, mais si le temps de compilation de ton projet explose tu vas perdre du temps à trouver tous les include qui ne servent à rien

  14. #14
    Membre actif

    Homme Profil pro
    Technicien maintenance
    Inscrit en
    février 2012
    Messages
    50
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : février 2012
    Messages : 50
    Points : 213
    Points
    213

    Par défaut

    Bonjour

    Le sujet est passionnant, je trouve que le débat est motivant.

    Pour ajouter une (petite) pierre à l'edifice, je dirait ceci:

    Le programme en question est desftiné a remplir la structure (les données).
    Donc le main.c a besoins de le definition de la structure (MesVariable.h)
    Pour obtenir ces données le main .c utilise d'autre fonctions (.c) qui elles retournes une valeur.
    Le main.c depose les valeur de retour des fonction dans la structure

    la affOLED.c elle affiche les données de la structure sur un display OLED.
    Donc dette fonction a besoin de la definition de la structure(MesVariable.h)

    En suivant ce qui c'est dit précedement, dans e cas d'espèce, Il vaut mieux faire un include de MesVaraible.h dans tous les .c qui auront besoins d'acceder a cette structure,
    L'affichage vers un ecran
    La mise en fichier des données,
    La validation (mesures cohérente ou non)
    ......

    Tandis que si la structure n'est utilisée que pour afficher les donnée (mais d'ou viennent-elles?) on n'en a besoisn que dans AffOLED.c.

    Pour parler du projet, compiler l'executable sous linux fait 139K avec les bibliothèque pour l'OLED et WiringPi.
    Donc la compilation lorsque tout vas bien (que j'ai retirer mes mouffles) ne met pas 1seconde. (en fait un peur plus longtemps lorsque je recompile la partie OLED.


    Citation Envoyé par foetus Voir le message
    @Sve@r tu as tout fait raison
    Donc, pour moi c'est normal que maStruct.h, il n'y a que la source AffOLED.X qui s'en occupe.(programmation orientée objet).
    Donc vu mon projet, et que d'autres fonctions que main et AffOLED ont besoin de cette structure, je la laisse aussi dans le main.c (et là ou elle sera utilisée)

    Par contre la remarque est judicieuse pour d'autre cas.
    n'étant pas programmeur professionnel, mes projet dépassent rarement le Mb compilés.
    Donc je n'ai jamais rencontrer de projet qui mettent du temps à compiler....



    Citation Envoyé par foetus Voir le message
    C'est la notion d'encapsulation de la POO
    Comme M Jourdain , "Je fais de la prose sans le savoir" Yes!! mais c'est un autre débat...


    Je reste assidument à l’écoute de vos remarques, commentaires et enseignements.

    Michel

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

Discussions similaires

  1. Réponses: 2
    Dernier message: 23/03/2018, 16h08
  2. lire pointeur sur structure en argument
    Par Linu6 dans le forum C
    Réponses: 3
    Dernier message: 23/09/2007, 00h53
  3. Réponses: 7
    Dernier message: 08/04/2006, 12h18
  4. Pointeurs et structures...
    Par vinzzzz dans le forum C
    Réponses: 13
    Dernier message: 18/01/2006, 11h37
  5. probleme avec pointeurs de structures
    Par remi77 dans le forum C
    Réponses: 2
    Dernier message: 20/10/2003, 13h19

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