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

C++ Discussion :

Que pensez-vous de ma classe tableau ?


Sujet :

C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre éprouvé
    Inscrit en
    Novembre 2006
    Messages
    1 073
    Détails du profil
    Informations forums :
    Inscription : Novembre 2006
    Messages : 1 073
    Par défaut Que pensez-vous de ma classe tableau ?
    J'ai fait une classe qui crée des listes chaines, sachant que l'élément de chaque chaîne est un tableau de double.

    J'aurais pu utiliser des conteneurs, mais j'ai voulu refaire moi-même ma propre classe. Je vois juste qu'il manque le destructeur.

    Mais qu'en penses-vous?

    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
    class Tableau{
    private:
    	double *tab;
        Tableau *prec;
     
    public:
    	static long nblignes;
    	static Tableau* GetPrec(Tableau*); 
    	void SetPrec(Tableau*); 
    	Tableau(double);
    	static double *GetTab(Tableau*);
    	static void FilTab(Tableau*,long,double);
    };
     
    long Tableau::nblignes=0;
     
    Tableau::Tableau(double name){
    	//Constructeur
    	double *Ttab=new double[Max_size+1];
    	Ttab[0]=name;
    	for(long i=1;i<=Max_size;i++){
    		Ttab[i]=0;
    	}
    	this->tab=Ttab;
    }
     
    double* Tableau::GetTab(Tableau* rang){
    	 //permet d'obtenir la ligne correspondant au rang 
         return rang->tab;
    }
     
     
    void Tableau::SetPrec(Tableau* rang){
    	 //permet de fixer la ligne précédente
         this->prec=rang;
    }
    Tableau* Tableau::GetPrec(Tableau* rang){
    	 //permet d'obtenir la ligne précédente
         return rang->prec;
    }
    void Add_line(double name,Tableau **p){
         Tableau *new_elements=new Tableau(name);//Création de la nouvelle ligne
         (*p)->nblignes++;  
         new_elements->SetPrec(*p);
         *p=new_elements;
    }
     
    double* Get_line(double quote,Tableau *p){
                  //Cherche la ligne correspondant à la quotatio
    	while(Tableau::GetTab(p)[0]!=quote){
    		p=Tableau::GetPrec(p);
    	}
    	return Tableau::GetTab(p);
     
    }
    void Tableau::FilTab(Tableau *rang,long k,double value){
        //permet de remplir les cases du tableau correspondant a "rang"
    	rang->tab[k]=value;
    }
     
    int Tab_Exists(double name,Tableau *p){
    	 long i=0;double o=0;int res;
    	 Tableau *q=NULL;
    	 q=p;
    	 while((i<p->nblignes)&&(Tableau::GetTab(q)[0]==name)){ // q=p->prec;
    	     q=Tableau::GetPrec(p);
          	 i=i+1;
    	 }
    	 if(i<p->nblignes){
               res=1;}
    	 else
    	 {res=0;}
         return res;
    }
     double View(Tableau *p)
     {       double *u=Tableau::GetTab(p);
             return u[0];
     }
    J'ai d'ailleurs une question. Je comprends ce que sont les mots cléfs statique pour des variables, mais a quoi servent ils pour des fonctions?

  2. #2
    Membre Expert
    Avatar de Goten
    Profil pro
    Inscrit en
    Juillet 2008
    Messages
    1 580
    Détails du profil
    Informations personnelles :
    Âge : 35
    Localisation : France

    Informations forums :
    Inscription : Juillet 2008
    Messages : 1 580
    Par défaut
    Tu utilises des mots clefs sans savoir à quoi ils servent?
    Sur une fonction membre ça permet d'appeller cette fonction sans avoir d'instances de la classe :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    struct foo{
         static void bar();
    };
     
    //..
     
    foo::bar();
    Sinon pour la liste chainée :
    En général ça se compose de deux structures : une maillon (contenant la donnée et un pointeur sur le maillon suivant) et la structure liste qui gère la collection de maillon .

  3. #3
    Expert éminent
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 644
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 644
    Par défaut
    Salut,

    De plus, la sémantique qui "colle" à la notion de tableau est de présenter... un nombre donné d'éléments contigus en mémoire...

    Le corolaire de cela est que l'accès à un élément donné du tableau est sensé se faire en... temps constant (on parle aussi "d'accès aléatoire"):cela ne demande normalement pas plus de temps d'accéder au 100eme élément du tableau au départ du premier que d'accéder au deuxième.

    Or, une liste chainée propose un accès... séquentiel, c'est à dire, que pour passer du premier élément au centième, il faudra parcourir les 99 éléments qui les séparent, alors que, pour passer du premier au deuxième, il "suffira" de passer à l'élément suivant.

    Heuu... comprend tu l'aberration qu'il peut y avoir à représenter un tableau sous la forme d'une liste chainée, fusse-t-elle pondérée par le fait que chaque maillon permet de représenter un certains nombre d'éléments
    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

  4. #4
    Membre éprouvé
    Inscrit en
    Novembre 2006
    Messages
    1 073
    Détails du profil
    Informations forums :
    Inscription : Novembre 2006
    Messages : 1 073
    Par défaut
    je vois ce que tu veux dire. En réalité, j'utilise un tableau dynamique qui doit ajouter des lignes en cours de route.
    Mais c'est clair que j'aurais pu faire plus simple. Mais cela m'a permis de réviser les classes!!

  5. #5
    Expert éminent
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 644
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 644
    Par défaut
    En fait, une classe Tableau aurait selon moi été proche de quelque chose comme
    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
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    class Tableau
    {
        public:
            /* par défaut, on prévoit 10 éléments contigus 
             * ( c'est limite fixée de manière tout à fait arbitraire :D)
             */
            Tableau():size_(10), nextpos_(0), ptr_(new int[10]){}
            /* mais on laisse la possibilité à l'utilisateur d'en prévoir un
             * nombre différent
             */
            Tableau(size_t s):size_(s),nextpos_(0),ptr_(new int[s]){}
            /* le constructeur par copie */
            Tableau(Tableau const & rhs):size_(rhs.size_),nextpos_(rhs.nextpos_),
                   ptr_(new int[rhs.size_])
            {
                memcopy(ptr_,rhs.ptr_,size_);
            }
            /* et l'opérateur d'affectation Il utilise le fait que nous passons 
             * le tableau à affecter sous forme de valeur, ce qui implique, 
             * de facto la copie.
             * Le principe mis en oeuvre est le copy 'n swap ;)
             */
            Tableau & operator = (Tableau t)
            {
                std::swap(size_,t.size_);
                std::swap(nextpos_,t.nextpos_);
                std::swap(ptr_,t.ptr_);
                return *this;
            }
            ~Tableau()
            {
                delete[] ptr_;
                ptr_=0;
            }
            /* on permet à l'utilisateur d'ajouter un élément en fin de tableau 
             */
            void push_back(int i)
            {
                /* en doublant chaque fois la taille du tableau si nous avons
                 * atteint la limite des éléments possibles, nous évitons
                 * de devoir le refaire à chaque insertion
                 */
                if(nextpos_==size_)
                    resize(size_*2);
                ptr_[nextpos_]=i;
                ++nextpos_;
            }
            /* on permet à l'utilisateur de retirer le dernier élément du tableau 
             */
            void pop_back()
            {
                --nextpos_;
            }
            /* on pourrait aussi lui permettre d'en rajouter en début de tableau,
             * voire d'insérer un élément entre deux éléments existants...
             * Je ne présente pas ces fonctionnalités
             */
            /* on permet à l'utilisateur d'accéder à une valeur grace à
             * l'opérateur []
             * sous la forme non constante
             */
           int & operator[](size_t index){return ptr_[index];}
           /* et sous la forme constante */
           int const & operator[](size_t index){return ptr_[index];}
           /* La fonction at fournit la même possibilité, mais avec un controle
            * de l'index demandé (lance une exception "Overflow" à définir
            * si l'index est hors des limites admises
            */
           int & at(size_t index)
           {
               if(index>=nextpos_)
                   throw Overflow();
               return ptr_[index];
           }
           int const & at() const
           {
               if(index>=nextpos_)
                   throw Overflow();
               return ptr_[index];
           } 
           /* cette fonction permet de redimensionner le tableau */
           void resize(size_t newsize)
           {
               /* trois possibilités s'offrent à nous:
                *     - soit on rajoute des éléments potentiels,
                *     - soit on redimensionne afin d'en retirer
                *     - soit on ne change pas la taille
                */
               /* si on ne change pas la taille, on ne fait simplement rien */
               if(newsize!=size_)
               {
                   /* il nous faut un tableau temporaire à la bonne taille */
                   int * temp=new int[newsize];
                   /* si la nouvelle taille est plus grande que le nombre
                    * d'éléments présents, nous copions nextpos_ elements
                    * du tableau d'origine vers le tableau temporaire
                    * la position suivante reste inchangée
                    */
                   if(newsize>nexpos_)
                   {
                       memncpy(temp,ptr_,nextpos_*sizeof(int));
                   }
                   /* sinon, nous copions newsize éléments du tableau d'origine
                    * vers le tableau temporaire et
                    * la position suivante prend la valeur de newsize
                    */
                  else
                  {
                       memncpy(temp,ptr_,newsize*sizeof(int));
                       nextpos_=newsize;
                  }
                  /* on termine en libérant la mémoire allouée au tableau 
                   * d'origine
                   */
                 delete [] ptr_;
                 /* en définissant la nouvelle taille
                  */
                 size_=newsize;
                 /* et en assignant le tableau temporaire au pointeur réel
                  */
                 ptr_=temp;
               }
           }
        private:
            size_t size_; // le nombre maximal d'éléments potentiel à 
                          // un instant T
            size_t nextpos_; // la position du prochain élément
            int * ptr_; // le pointeur vers le tableau dont la mémoire est
                        // allouée dynamiquement
    };
    Ce n'est, défintivement, qu'un exemple écrit vite fait... il est très certainement améliorable et adaptable
    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

  6. #6
    Membre éprouvé
    Inscrit en
    Novembre 2006
    Messages
    1 073
    Détails du profil
    Informations forums :
    Inscription : Novembre 2006
    Messages : 1 073
    Par défaut
    j'étudirai tous ca en détail.
    Une question me vient à l'esprit en voyant tout ca,
    pourquoi utiliser:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
      size_t size_; // le nombre maximal d'éléments potentiel à 
                          // un instant T
            size_t nextpos_; // la position du prochain élément
    et non pas par ex

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     long size_; // le nombre maximal d'éléments potentiel à 
                          // un instant T
            long nextpos_; // la position du prochain élément
    Comme moi je l'aurais fait?

Discussions similaires

  1. que pensez-vous de ma classe?
    Par noctua dans le forum C++
    Réponses: 4
    Dernier message: 18/08/2011, 20h37
  2. que pensez vous de ma classe Matrice?
    Par deubelte dans le forum C++
    Réponses: 9
    Dernier message: 29/05/2008, 14h16
  3. Que pensez-vous des générateurs de doc PHP ?
    Par Nonothehobbit dans le forum EDI, CMS, Outils, Scripts et API
    Réponses: 64
    Dernier message: 10/07/2007, 10h17
  4. Que pensez vous du nouveau kernel 2.6 ?
    Par GLDavid dans le forum Administration système
    Réponses: 58
    Dernier message: 02/08/2004, 15h45
  5. Que pensez vous du mariage ASP Flash?
    Par tyma dans le forum Flash
    Réponses: 4
    Dernier message: 09/07/2003, 15h00

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