Connaissance de base de l'apprentissage du C++ : ce pointeur, les membres statiques, les fonctions membres constantes

1. ce pointeur

1. Traduction du programme C++ en programme C

class CCar {                          struct CCar {
    public:                                int price;
    int price;                        };
    void SetPrice(int p);             void SetPrice(struct CCar * this,int p){
};                                        this->price = p;
void CCar::SetPrice(int p){           }
    price = p; //this->price = p;
}                                     int main() {
int main(){                               struct CCar car;
    CCar car;                             SetPrice( & car,20000);
    car.SetPrice(20000);                  return 0;
    return 0;                         }
}

2. Fonction de ce pointeur : Celui-ci peut être utilisé directement en non statique. fonctions membres. Représente un pointeur pointant vers l'objet sur lequel la fonction agit

3. ce pointeur et fonctions membres statiques : les fonctions membres statiques n'agissent pas spécifiquement sur un certain objet, donc le pointeur this

2. Membres statiques

• Membres statiques : membres avec le mot-clé static devant la description.

• Chaque objet a sa propre copie des variables membres ordinaires, tandis que les variables membres statiques n'ont qu'une seule copie au total, partagée par tous les objets. L'opérateur sizeof ne calculera pas les variables membres statiques.

• Les fonctions membres ordinaires doivent agir spécifiquement sur un objet, tandis que les fonctions membres statiques n'agissent pas spécifiquement sur un objet et sont accessibles sans passer l'objet.

class CRectangle{
    private:
        int w, h;
        static int nTotalArea; // 静态成员变量
    public:
        CRectangle(int w_,int h_);
        ~CRectangle();
        static void PrintTotal(); // 静态成员函数
};

1. Méthodes pour accéder aux membres statiques :

• Nom de la classe ::Nom du membre CRectangle::PrintTotal();

• Nom de l'objet.Nom du membre CRectangle r; r.PrintTotal();

• Pointeur->Nom du membre CRectangle * p = &r; >PrintTotal();

• Référence.Nom du membre CRectangle & ref = r; int n = ref.nTotalNumber;

2. Questions :

• Les variables membres statiques sont essentiellement des variables globales. Même si un objet n'existe pas, les variables membres statiques de la classe existent toujours

Obligatoire Décrire ou initialiser les variables membres statiques une fois dans le fichier qui définit la classe. Sinon, la compilation peut réussir, mais la liaison ne peut pas réussir
Dans les fonctions membres statiques, les variables membres non statiques ne sont pas accessibles et les fonctions membres non statiques ne peuvent pas être appelées
3. Objets membres et classes fermées

Définition : Une classe avec des objets membres est appelée une classe englobante

Dans l'exemple ci-dessus, si la classe CCar ne définit pas de constructeur, alors l'instruction suivante provoquera une erreur de compilation : CCar car; car le compilateur ne comprend pas comment car.tyre doit être initialisé. Il n'y a aucun problème avec l'initialisation de car.engine, utilisez simplement le constructeur par défaut. Toute instruction qui génère un objet de classe fermée doit permettre au compilateur de comprendre comment les objets membres de l'objet sont initialisés. La méthode spécifique est : via la liste d'initialisation du constructeur de la classe fermée.

class CTyre{             // 轮胎类
    private:
        int radius;      // 半径
        int width;       // 宽度
    public:
        CTyre(int r,int w):radius(r),width(w) { }
};
class CEngine{           // 引擎类
};
class CCar {             // 汽车类
    private:
        int price;       // 价格
        CTyre tyre;
        CEngine engine;
    public:
        CCar(int p,int tr,int tw );
};
CCar::CCar(int p,int tr,int w):price(p),tyre(tr, w){};
int main(){
    CCar car(20000,17,225);
    return 0;
}

2. Ordre d'exécution des constructeurs et destructeurs de classe fermée

Lorsqu'un objet de classe fermée est généré, les constructeurs de tous les membres de l'objet sont exécutés en premier, puis la fermeture est exécuté Constructeur de classe.
L'ordre d'appel du constructeur des membres de l'objet est cohérent avec l'ordre dans lequel les membres de l'objet sont déclarés dans la classe, quel que soit l'ordre dans lequel ils apparaissent dans la liste d'initialisation des membres.
Lorsque l'objet de la classe fermée meurt, le destructeur de la classe fermée est exécuté en premier, puis le destructeur de l'objet membre est exécuté. L'ordre est l'opposé de l'ordre d'appel du constructeur.

4. Amis

class CTyre {
    public:
        CTyre() { cout << "CTyre contructor" << endl; }
        ~CTyre() { cout << "CTyre destructor" << endl; }
};
class CEngine {
    public:
        CEngine() { cout << "CEngine contructor" << endl; }
        ~CEngine() { cout << "CEngine destructor" << endl; }
};
class CCar {
    private:
        CEngine engine;
        CTyre tyre;
    public:
        CCar( ) { cout << “CCar contructor” << endl; }
        ~CCar() { cout << "CCar destructor" << endl; }
};
int main(){
    CCar car;
    return 0;
}
//输出结果：
CEngine contructor
CTyre contructor
CCar contructor
CCar destructor
CTyre destructor
CEngine destructor

1. Les amis sont divisés en deux types : les fonctions d'ami et les classes d'ami

(1) Fonction d'ami : La fonction ami d'une classe peut accéder aux membres privés de la classe

(2) Classe ami : Si A est une classe amie de B, alors la fonction membre de A peut accéder aux membres privés de B, la relation entre les classes amies ne peut pas être transférée ou héritée

class CCar ;     //提前声明 CCar 类，以便后面的CDriver 类使用
class CDriver{
    public:
    void ModifyCar( CCar * pCar) ;         // 改装汽车
};
class CCar{
    private:
        int price;
        friend int MostExpensiveCar( CCar cars[], int total); // 声明友元
        friend void CDriver::ModifyCar(CCar * pCar);     // 声明友元，可包括构造、析构函数
};
void CDriver::ModifyCar( CCar * pCar){
    pCar->price += 1000;                        // 汽车改装后价值增加
}
int MostExpensiveCar( CCar cars[],int total){   // 求最贵汽车的价格                           
    int tmpMax = -1;
    for( int i = 0;i < total; ++i )
    if( cars[i].price > tmpMax)
    tmpMax = cars[i].price;
    return tmpMax;
}

5. Fonctions membres constantes

class B{
    friend class A;      // 声明A为友元类
};

1. Fonction : Si vous ne souhaitez pas que la valeur d'un objet soit modifiée, vous pouvez ajouter le mot-clé const

devant l'objet lors de sa définition. Vous pouvez ajouter le mot-clé const après la description de la fonction membre de la classe, et la fonction membre devient un membre constant. fonction.
La valeur de l'attribut ne peut pas être modifiée à l'intérieur d'une fonction membre constante, et une fonction membre non const ne peut pas non plus être appelée
Lors de la définition une fonction membre constante et déclaration d'un membre constant Le mot clé const doit être utilisé dans les fonctions

2. Surcharge des fonctions membres constantes : deux fonctions ont le même nom et la même liste de paramètres, mais l'un est const et l'autre ne l'est pas, compté comme surcharge

class Sample {
    private :
        int value;
    public:
        Sample() { }
        void SetValue() {  }
};
const Sample Obj;  //  常量对象
Obj.SetValue ();   //错误，常量对象只能使用构造函数、析构函数和有const说明的函数（常量方法）

3. Variables membres mutables :

(1) Fonction : mutable est défini au-delà des contraintes de const. Variables modifiées par mutable will. être toujours dans un état mutable, même si dans une fonction const.

(2) Application : Si la fonction membre d'une classe ne change pas l'état de l'objet, elle est généralement déclarée comme const. Cependant, parfois, il est nécessaire de modifier certaines données membres qui n'ont rien à voir avec l'état de la classe dans une fonction const, alors ces données membres doivent être modifiées avec mutable.

Recommandations associées :

class CTest{
    public:
        bool GetData() const{
            m_n1++;
            return m_b2;
        }
    private:
        mutable int m_n1;
        bool m_b2;
};

L'utilisation de membres statiques et de membres constants en C++

Résumé des points de révision C++ : Cinq variables membres statiques et fonctions membres

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!