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

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

Nach dem Login kopieren

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

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

• 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说明的函数（常量方法）

Nach dem Login kopieren

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

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!