Initialisation variable erreur dans une classe

Résolu
xkill2005 Messages postés 20 Date d'inscription lundi 14 décembre 2020 Statut Membre Dernière intervention 19 février 2021 - Modifié le 26 déc. 2020 à 11:54
Dalfab Messages postés 706 Date d'inscription dimanche 7 février 2016 Statut Membre Dernière intervention 2 novembre 2023 - 25 déc. 2020 à 10:25
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

Dalfab Messages postés 706 Date d'inscription dimanche 7 février 2016 Statut Membre Dernière intervention 2 novembre 2023 11
24 déc. 2020 à 16:58
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.
0
xkill2005 Messages postés 20 Date d'inscription lundi 14 décembre 2020 Statut Membre Dernière intervention 19 février 2021
Modifié le 26 déc. 2020 à 11:55
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;
}
0
xkill2005 Messages postés 20 Date d'inscription lundi 14 décembre 2020 Statut Membre Dernière intervention 19 février 2021
Modifié le 24 déc. 2020 à 23:49
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 

}

0
xkill2005 Messages postés 20 Date d'inscription lundi 14 décembre 2020 Statut Membre Dernière intervention 19 février 2021
Modifié le 25 déc. 2020 à 09:12
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
}


0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Dalfab Messages postés 706 Date d'inscription dimanche 7 février 2016 Statut Membre Dernière intervention 2 novembre 2023 11
Modifié le 25 déc. 2020 à 10:32
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
0
Rejoignez-nous