Initialisation variable erreur dans une classe [Résolu]

Signaler
Messages postés
20
Date d'inscription
lundi 14 décembre 2020
Statut
Membre
Dernière intervention
3 janvier 2021
-
Messages postés
520
Date d'inscription
dimanche 7 février 2016
Statut
Membre
Dernière intervention
3 janvier 2021
-
Bonjour, ma variable vie dans la méthode n'est pas déclarer alors que je l'ai déclarer dans mon constructeur ? et mon personnage maxence mon debogueur marque impossible de déclarrer mon personage::personage() dans mon main() ?

#include <iostream>
#include <string>
using namespace std;

class Personage
{
public:
    void dega(int puissance)
    {
        vie = vie - puissance;
    }
private:
    Personage()
    {
        int vie = 100;
        int magie = 100;
    }
};

int main()
{
     Personage maxence;
}

5 réponses

Messages postés
520
Date d'inscription
dimanche 7 février 2016
Statut
Membre
Dernière intervention
3 janvier 2021
4
Bonjour,

Tu l'as écrit :
vie
et
magie
sont déclarées dans le constructeur et donc n'existent que pendant la fonction de construction. Si tu souhaites que tes variables aient la même durée de vie qu'un
Personnage
, il faut les déclarer dans la structure
Personnage
.
Tu ne peux pas créer un Personnage dans
main()
car tu as mis le constructeur dans la zone
private
. Donc seul un
Personnage
peut créer un
Personnage
! Peut-être que mettre le constructeur dans la zone
public
serait préférable.
Messages postés
20
Date d'inscription
lundi 14 décembre 2020
Statut
Membre
Dernière intervention
3 janvier 2021

comment initialiser des variables qui sont dans private en mettant le constructeur dans public mes variable seront forcement public dans ce cas la ?


class Personage
{
public: 
   Personage()    //construteur sans variable dedans
  {
  }

    void dega(int puissance)
    {
        vie = vie - puissance;
    }
private:
        int vie = 100;                //variable a initialiser avec le constructeur mais en private
        int magie = 100;
};

int main()
{
     Personage maxence;
}
Messages postés
20
Date d'inscription
lundi 14 décembre 2020
Statut
Membre
Dernière intervention
3 janvier 2021

réponse résolu mais quelle différence entre les 2 dynamiques ?




class Personage
{
public:
 
   Personage();     // personage(ALL)  le construteur initialise  tout les types int,char,double
   personage(int,int);  //recherche la fonction exterieur avec 2 int a quelle moment les int private dynamique ce crée ?

    void dega(int puissance)
    {
        vie = vie - puissance;
    }



private:
 
        int vie = 100;                //definie en static 
        int magie = 100;
//*******************************************************************************    
        int vie ;                         //definie en dynamique
        int magie ;
};




personage::personage(int vie,int magie)
{

//code modife variable private dynamique
}




int main()
{
 
personage maxence;     //static    l'objet prendra le constructeur ALL initialisation static
    
Personage maxence(100,100);    //dynamique    l'objet prendra le constructeur 2 int initialisation dynamique définit en paramètre

personage *maxence = new personage(100,100);       //dynamique    l'objet prendra le constructeur 2 int  quelle est la différence  des 2 dynamiques 

}

Messages postés
20
Date d'inscription
lundi 14 décembre 2020
Statut
Membre
Dernière intervention
3 janvier 2021

constructeur dynamique ?


#include <iostream>
#include <string>
using namespace std;

class personage
{
    
    public:

        
        personage(int,int);         //le construteur fait un overflow controler dans la class en fonction
       

        void affiche();


        void dega(int puissance)    //les fonction et les if et les tableaux fonctionne dans le public
        {
            vie = vie - puissance;
            cout << "vous prenez tand de dega : " << puissance << endl;
            cout << "niveau de vie : " << vie << endl << "voulez-vous de la potion magique ? oui : o non: n : " << endl;
            cin >> cache;
            if (cache[0] == 'o')
            {
                vie = vie + magie;
                cout << "niveau de vie : " << vie << endl;
            }
        }
      


        

    private:

        char cache[1];
        int vie;
        int magie;

    

};

personage::personage(int vie,int magie)        //les fonctions en dehors de la class avec un pointeur personage::personage elles sont apeller par la fonction dans le public et passe en dehors du public pour lire les arguments dans le .ccp
{
    this->vie = vie;
    this->magie = magie;
}

void personage::affiche()
{
    cout << vie << endl;
    cout << magie << endl;
}




int main()
{

    personage maxence(100,100);                   //constructeur dynamique ? personage maxence(int var, int var)
    maxence.affiche();
    maxence.dega(5);

    personage*thomas = new personage(80,80);      //constructeur dynamique
    (*thomas).affiche();
    maxence.affiche();

    cout << "les deux objets prend 2 case en memoire" << endl;   
    cout << thomas << endl;                      //adresse de l'obet sans *
    cout << &maxence;                            //adresse de l'objet avec  & 
                                                                       //donc il y a bien 6variable donc 3 variables  virtuelles  alouées  au niveau code source  et 3 physique ecrit en code source donc au final au niveau de la ram il y a 6 bits pour une var = 1 bits dans  2 case memoires  2 objet différent
}


Messages postés
520
Date d'inscription
dimanche 7 février 2016
Statut
Membre
Dernière intervention
3 janvier 2021
4
Bonjour,

Attention au vocabulaire. Une variable peut être:
-
static 
: elle existe pendant toute la durée du programme.
- globale : idem
static
.
- automatique : c'est le cas le plus fréquent. Donc dans une fonction, elle est créée au point de déclaration, elle disparait à la fin du bloc dans lequel elle est déclarée.
- membre : Dans une classe, elle est créée juste avant l'appel au constructeur de la classe, elle disparaît juste après l'appel au destructeur de la classe.
- dynamique : est créée dans un espace appelé le "tas", et est détruite "quand on en a plus besoin". Le pire moyen d'allouer sur le "tas", c'est d'utiliser
new 
car il faut utiliser
delete 
pour détruire la variable, et on risque fort de se gourrer. Sinon il faut utiliser des objets qui s'occupent de ça pour nous. Par exemple
std::vector<>
ou un "smart pointer" comme
std::unique_ptr<>
.

Dans tous les cas, le constructeur sera appelé au moment de la construction, et le destructeur sera appelé immédiatement avant la destruction.

class personage {    
   public:
      personage(int vie, int magie) : vie_{vie}, magie_{magie} {
        // magie_ et vie_ ont été initialisées avant
      }
      void  affiche()const {
         std::cout << "vie: " << vie_ << "magie: " << magie << std::endl;
      }

      static personnage  perso1; // déclaration membre static
   private:
      int  vie_;    // variable membre
      int  magie_;
};
personnage  personnage::perso1(11,11); // définition membre static

personnage  perso2( 12, 12 );  // global

int main()  {

   static personnage  perso3(13,13); // static est créé avant d'entrer dans main
   personnage  perso4(14,14); // automatique
   auto  pperso5 = std::make_unique<personnage>( 15, 15 ); // dynamique pperso5 est propriétaire d'un personnage

   personnage::perso1.affiche();
   perso2.affiche();
   perso3.affiche();
   perso4.affiche();
   pperso5->affiche();
} // à cet instant disparaissent pperso5 et perso4,
//   et comme pperso5 est propriétaire d'un personnage celui-ci disparaît avec lui.
// à la fin du programme disparaissent perso3, perso2 et personnage::perso1