C++-Grundkenntnisse erlernen – dieser Zeiger, statische Mitglieder, konstante Mitgliedsfunktionen

1. Dieser Zeiger

1. Übersetzung eines C++-Programms in ein C-Programm

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. Funktion dieses Zeigers: Dies kann direkt in nicht statischen Memberfunktionen verwendet werden um den Zeiger darzustellen. Zeiger auf das Objekt, auf das die Funktion einwirkt.

3. Dieser Zeiger und die statische Mitgliedsfunktion: Die statische Mitgliedsfunktion wirkt nicht speziell auf ein bestimmtes Objekt, daher kann dieser Zeiger nicht in einem statischen Objekt verwendet werden Mitgliedsfunktion

2 , Statische Mitglieder

• Statische Mitglieder: Mitglieder mit dem Schlüsselwort static vor der Beschreibung.

• Jedes Objekt verfügt über eine eigene Kopie gewöhnlicher Mitgliedsvariablen, während statische Mitgliedsvariablen insgesamt nur eine Kopie haben, die von allen Objekten gemeinsam genutzt wird. Der Operator sizeof berechnet keine statischen Mitgliedsvariablen.

• Gewöhnliche Mitgliedsfunktionen müssen speziell auf ein Objekt einwirken, während statische Mitgliedsfunktionen nicht speziell auf ein Objekt einwirken und auf sie zugegriffen werden kann, ohne das Objekt zu übergeben.

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

1. Methoden für den Zugriff auf statische Mitglieder:

• Klassenname::Mitgliedsname CRectangle::PrintTotal();

• Objektname.Membername CRectangle r; r.PrintTotal();

• Pointer->Membername CRectangle * p = &r; PrintTotal();

• Reference.Member name CRectangle & ref = r; int n = ref.nTotalNumber;

2 🎜>

• Statische Mitgliedsvariablen sind im Wesentlichen globale Variablen. Auch wenn ein Objekt nicht existiert, müssen die statischen Mitgliedsvariablen der Klasse dennoch vorhanden sein

• definiert Die statischen Mitgliedsvariablen werden einmalig in der Klassendatei beschrieben oder initialisiert. Andernfalls kann die Kompilierung erfolgreich sein, die Verknüpfung jedoch nicht

• In statischen Mitgliedsfunktionen kann nicht auf nicht statische Mitgliedsvariablen zugegriffen werden und nicht statische Mitgliedsfunktionen können nicht aufgerufen werden

3. Mitgliedsobjekte und geschlossene Klassen

1. Eine Klasse mit Mitgliedsobjekten wird als umschließende Klasse bezeichnet.

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;
}

Wenn die Die CCar-Klasse definiert keinen Konstruktor. Die folgende Anweisung verursacht einen Kompilierungsfehler: CCar car; da der Compiler nicht versteht, wie car.tyre initialisiert werden soll. Bei der Initialisierung von car.engine gibt es kein Problem. Verwenden Sie einfach den Standardkonstruktor. Jede Anweisung, die ein geschlossenes Klassenobjekt generiert, muss dem Compiler mitteilen, wie die Mitgliedsobjekte im Objekt initialisiert werden. Die spezifische Methode ist: über die Initialisierungsliste des Konstruktors der geschlossenen Klasse.

2. Ausführungsreihenfolge von Konstruktoren und Destruktoren geschlossener Klassen

• Wenn ein geschlossenes Klassenobjekt generiert wird, werden zuerst die Konstruktoren aller Objektmitglieder ausgeführt und dann der Abschluss Der Klassenkonstruktor wird ausgeführt.

• Die Reihenfolge der Konstruktoraufrufe der Objektmitglieder stimmt mit der Reihenfolge überein, in der die Objektmitglieder in der Klasse deklariert werden, unabhängig von der Reihenfolge, in der sie in der Elementinitialisierungsliste erscheinen.

• Wenn das Objekt der geschlossenen Klasse stirbt, wird zuerst der Destruktor der geschlossenen Klasse und dann der Destruktor des Mitgliedsobjekts ausgeführt. Die Reihenfolge ist das Gegenteil der Aufrufreihenfolge des Konstruktors.

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

4. Freunde

1. Freunde werden in zwei Arten unterteilt: Freundesfunktionen und Freundesklassen

(1) Freundesfunktion: Der Freund Die Funktion einer Klasse kann auf die privaten Mitglieder der Klasse zugreifen

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;
}

(2) Freundklasse: Wenn A eine Freundklasse von B ist, kann die Mitgliedsfunktion von A auf die privaten Mitglieder von B zugreifen. Die Beziehung zwischen Mitglieder und Freundesklassen können nicht übertragen oder geerbt werden

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

5. Konstante Mitgliedsfunktionen

1 Funktion: Wenn Sie nicht möchten, dass der Wert eines Objekts geändert wird, definieren Sie dies Objekt können Sie das Schlüsselwort const

• vor dem Objekt hinzufügen. Sie können das Schlüsselwort const nach der Beschreibung der Mitgliedsfunktion der Klasse hinzufügen, und die Mitgliedsfunktion wird zu einer konstanten Mitgliedsfunktion .

• Der Wert des Attributs kann nicht innerhalb einer konstanten Mitgliedsfunktion geändert werden, noch kann eine nicht konstante Mitgliedsfunktion aufgerufen werden

• Beim Definieren eine konstante Mitgliedsfunktion und Deklaration eines konstanten Mitglieds Das Schlüsselwort const sollte in Funktionen verwendet werden

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

2. Überladung von konstanten Mitgliedsfunktionen: Zwei Funktionen haben den gleichen Namen und die gleiche Parameterliste, aber eine ist const und das andere nicht Variablenstatus, auch in einer in const-Funktion.

(2) Anwendung: Wenn die Mitgliedsfunktion einer Klasse den Status des Objekts nicht ändert, wird sie im Allgemeinen als const deklariert. Manchmal ist es jedoch erforderlich, einige Datenelemente in einer const-Funktion zu ändern, die nichts mit dem Klassenstatus zu tun haben. Anschließend sollten diese Datenelemente mit veränderbar geändert werden.

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

Verwandte Empfehlungen:

Die Verwendung von statischen und konstanten C++-Mitgliedern

Zusammenfassung der C++-Überprüfungspunkte: Fünf statische Mitgliedsvariablen und Mitgliederfunktion

Das obige ist der detaillierte Inhalt vonC++-Grundkenntnisse erlernen – dieser Zeiger, statische Mitglieder, konstante Mitgliedsfunktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!