12
votes

C ++: Accès aux méthodes et variables des parents

Dans quel sens dois-je accéder à cette méthode parente et la variable parent?

class Base
{
public:
    std::string mWords;
    Base() { mWords = "blahblahblah" }
};

class Foundation
{
public:
    Write( std::string text )
    {
        std::cout << text;
    }
};

class Child : public Base, public Foundation
{
    DoSomething()
    {
        this->Write( this->mWords );
        // or
        Foundation::Write( Base::mWords );
    }
};

c++ inheritance parent-child base-class

0 commentaires

3 Réponses :

0
votes

Je pense que c'est l'approche la plus courante: xxx

sauf si vous rencontrez une ambiguïté.

S'il y a une ambiguïté ou une observation parce que vous voulez quelque chose dans un (particulier) classe de base mais quelque chose dans une autre classe de base (ou cette classe) la masque, utilisez ensuite la base base :: nom syntaxe.

Si une variable locale est en train d'ombrir un de vos membres, Ensuite, utilisez ceci -> , bien que en général, vous devriez essayer d'éviter cette situation. (c.-à-d. Essayez d'éviter de nommer les sections locales de telle sorte que les membres de l'ombre)

Je suppose qu'un moyen de regarder qu'il serait d'utiliser le premier de ceux-ci qui fonctionne et fait ce que vous voulez: < ol>

nom

  this-> nom

  base :: nom



                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    Oui, je pourrais avoir à traiter avec ambiguïté ... Je vais clarifier dans mon message d'origine.


                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Comme il n'y a pas de conflit de nommage, utilisez simplement  écrire (MODS) . Utilisez les 2 autres si vous avez des variables locales qui conflit ou lorsque les noms sont cachés.                                 


                                                                    
                                    
                                    
                                        3 commentaires
                                        
                                                                                            
                                                    S'il y a un conflit, quelle méthode recommandez-vous que j'utilise?                                                
                                                
                                                                                            
                                                    Et que voulez-vous dire par "quand les noms sont cachés"?                                                
                                                
                                                                                            
                                                    Si c'est un conflit entre variables locales et variables de membre (par exemple, votre classe a une variable de membre  i , et votre méthode utilise également une variable locale  i ), utilisez  ceci . Si  A  déclare une fonction  f , et  b  hérite  a  et déclare  f  aussi et vous souhaitez appeler  A  'S  f  à partir de  B , puis utilisez  a :: f .                                                

                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    12
 votes
                                
                            
                            
                                
                                     Les deux syntaxes que vous utilisez dans votre code ( ceci -> ...  code> et des noms qualifiés) ne sont nécessaires que spécifiquement lorsqu'il y a une ambiguïté ou une autre question de recherche de noms, comme le cas de la cachette de nom, la base de gabarit Classe, etc. 
 Lorsqu'il n'y a pas d'ambiguïté ou d'autres problèmes, vous n'avez pas besoin de ces syntaxes. Tout ce dont vous avez besoin est un simple nom non qualifié, comme  écrire  code> dans votre exemple. Juste  écrire  code>, pas  this-> écrire  code> et non  fondation :: écrire  code>. La même chose s'applique à  Mwores  code>.  P> 
 I.e. Dans votre exemple spécifique, une ligne  écriture (mwores)  code> fonctionnera simplement bien.  p>  
 Pour illustrer ce qui précède, si votre  DOSMATHIGHT  code> était  MODS  CODE> Paramètre, comme dans  P> 
DoSomething(int mWords) {
  Write(Foundation::mWords);
}

                                

                                                                    
                                    
                                    
                                        0 commentaires