le mie informazioni di contatto
Posta[email protected]
2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Sommario
2.1 Il concetto di istanziazione
4.Funzioni membro predefinite delle classi
4.5 Sovraccarico degli operatori
Formato di definizione della classe
class è la parola chiave che definisce la classe, Stack è il nome della classe e {} è il corpo della classe. Si noti che il punto e virgola alla fine della definizione non viene omesso. I contenuti nel corpo della classe sono chiamati membri della classe: le variabili nella classe sono chiamate attributi o variabili membro della classe sono chiamate metodi o funzioni membro della classe;
- //text.cpp
- #include<iostream>
- using namespace std;
-
- class Stack
- {
-
- //成员变量
- int* a;
- int top;
- int capacity;
- //成员函数
- void Push()
- {
-
- }
- void Pop()
- {
-
- }
- };//分号不能省略
- int main()
- {
-
-
- return 0;
- }
- //为区分成员变量,一般前面加_
- //成员变量
- int* _a;
- int _top;
- int _capacity;
C++ è un modo per implementare l'incapsulamento, utilizzando classi per combinare le proprietà e i metodi di un oggetto per rendere l'oggetto più completo e fornire selettivamente la sua interfaccia agli utenti esterni tramite diritti di accesso.
- //text.cpp
- #include<iostream>
- using namespace std;
-
- class Stack
- {
-
-
- ///
-
- void Push()
- {
-
- }
- //Push 没给限定符 class默认私有 private
- ///
- public:
- void Pop()
- {
-
- }
- int Swap()
- {
-
- }
- //Pop和Swap 被public修饰,直到下一个限定符出现之前都为公有
- ///
- protected:
- int add();
- //add 被public修饰,直到下一个限定符出现之前都为保护
- /// /
-
- private:
-
- int* _a;
- int _top;
- int _capacity;
- //成员变量被private修饰,直到}结束都为私有
- };
- int main()
- {
- Stack st;
- //公有可以访问
- st.Pop();
- st.Swap();
- //私有不可访问
- st._top;
-
-
-
- return 0;
- }
Note aggiuntive:
La classe definisce un nuovo ambito. Tutti i membri della classe rientrano nell'ambito della classe Quando si definiscono membri all'esterno della classe, è necessario utilizzare l'operatore ::scope per indicare a quale ambito della classe appartiene il membro.
Il dominio della classe influisce sulle regole di ricerca della compilazione. Se Init nel programma seguente non specifica il dominio della classe Stack, il compilatore tratterà Init come una funzione globale. Se non riesce a trovare membri come _top durante la compilazione, andrà a dominio di classe per trovarli.
- //text.cpp
- #include<iostream>
- using namespace std;
-
- class Stack
- {
-
-
- public:
- void Init(int x, int y);
-
- };
- void Stack::Init(int x, int y)
-
- {
- _top = x;
- _capacity = y;
- }
- int main()
- {
-
- return 0;
- }
Avviso:
- //text.cpp
- #include<iostream>
- using namespace std;
-
- class Stack
- {
-
- //声明
-
- int* _a;
- int _top;
- int _capacity;
-
- };
-
- int main()
- {
-
- Stack::_top = 2024;
- //编译器报错,_top只是声明,并未实例化
-
- return 0;
- }
-
- //text.cpp
- #include<iostream>
- using namespace std;
-
- class Stack
- {
-
-
- //声明
- int* _a;
- int _top;
- int _capacity;
-
- };
-
- int main()
- {
-
-
- Stack st;
- st._top=2024;
- //Stack实例化出st,系统已经给st分配内存了,可以存储数据,编译通过
-
- return 0;
- }
-
-
Regole di allineamento della memoria
- class A
- {
- public:
- void Print()
- {
- cout << _ch << endl;
- }
- private:
- char _ch;
-
- int _i;
- };
- //_ch 是一个字节,默认对齐数是4,最大对齐数是4,所以开辟4个字节用来存在_ch
- // _i是4个字节,默认对齐数是4,最大对齐数是4,所以开辟4个字节用来存储_i
- class B
- {
- public:
- void Print()
- {
- //。。。
- }
-
-
- };
- class B
- {
-
-
- };
- //B和C里面没有存储任何成员变量,只有一个函数,可成员函数不存对象里面
- // 按理来说是0,但是结构体怎么会没大小,为表示对象存在C++对这种规定大小为1,为了占位标识对象存在
Dopo la compilazione del compilatore, le funzioni membro della classe aggiungeranno per impostazione predefinita un puntatore alla classe corrente nella prima posizione del parametro formale, chiamato questo puntatore.
Ad esempio, il prototipo Init nella classe Date è void Init (Date * const this, int anno, int mese, int giorno) Quando si accede alle variabili membro nelle funzioni membro della classe, si accede all'essenza tramite il puntatore this. come _year nella funzione Init Assignment, this->_year=year
prototipo:
- class Date
- {
- void Print()
- {
-
- cout << _year << "n" << _month << "n" << _day << endl;
- }
- void Init( int year, int month,int day)
- {
- _year = year;
- _month = month;
- _day = day;
-
- }
-
- private:
- int _year;
- int _month;
- int _day;
-
- };
-
- Date d1;
- d1.Init(2024,7,10);
-
- d1.Print();
- Date d2;
-
- d2.Init(2024, 7, 9);
- d2.Print();
-
prototipo reale
- class Date
- {
- void Init(Date* const this,int year, int month,int day)
-
- {
- this->_year = year;
- this->_month = month;
- this->_day = day;
-
- }
- void Printf(Date* const this)
-
- {
-
- cout << this->_year << "n" <<this-> _month << "n" << this->_day << endl;
- }
- private:
- int _year;
- int _month;
- int _day;
-
- };
- Date d1;
- d1.Init(&d1,2024,7,10);
- d1.Print(&d1);
-
- Date d2;
- d2.Init(&d2,2024, 7, 9);
- d2.Print();
C++ stabilisce che non è consentito scrivere questo puntatore nella posizione dei parametri effettivi e dei parametri formali (il compilatore lo gestirà durante la compilazione), ma questo puntatore può essere utilizzato esplicitamente nel corpo della funzione. Questo puntatore non può essere modificato, ma il il contenuto indicato da questo puntatore può
questo puntatore è memorizzato nello stack
La funzione membro predefinita è una funzione membro che non è definita in modo esplicito dall'utente e viene generata automaticamente dal compilatore. È denominata funzione membro predefinita.
Il costruttore è una funzione membro speciale Va notato che sebbene il costruttore sia chiamato costruttore, il contenuto principale del costruttore non è quello di aprire spazio per creare oggetti (l'oggetto locale che usiamo solitamente è lo spazio che viene aperto quando. viene creato lo stack frame) ), ma l'oggetto viene inizializzato quando viene istanziata l'oggetto. L'essenza del costruttore è sostituire la funzione della funzione Init che abbiamo scritto prima nelle classi Stack e Date. La chiamata automatica del costruttore sostituisce perfettamente la funzione Init.
Caratteristiche del costruttore:
- class Date
- {public:
- //1.无参构造函数
- Date()
- {
- _year = 1;
- _month = 1;
- _day = 1;
- }
- //2.带参构造函数
- Date(int year, int month, int day)
- {
- _year = year;
- _month = month;
- _day = day;
- }
-
-
- //3.全缺省构造函数
- Date(int year = 1, int month = 1, int day = 1)
- {
- _year = year;
- _month = month;
- _day = day;
- }
- private:
- int _year;
- int _month;
- int _day;
-
- };
Il costruttore senza argomenti, il costruttore tutto predefinito e il costruttore generato dal compilatore per impostazione predefinita quando non scriviamo un costruttore sono tutti chiamati costruttori predefiniti. Ma solo uno di questi tre può esistere, non contemporaneamente. Sebbene il costruttore senza parametri e il costruttore completamente predefinito costituiscano un sovraccarico di funzioni, ci sarà ambiguità quando li si chiama.Si noti che non solo il costruttore predefinito è quello generato dal compilatore per impostazione predefinita, è il costruttore, il costruttore senza parametri e il costruttore predefinito completo è anche il costruttore predefinito. Per riassumere, può essere chiamato senza passare parametri.
Non lo scriviamo. Il costrutto generato dal compilatore per impostazione predefinita non ha requisiti per l'inizializzazione delle variabili membro di tipo integrate. Vale a dire, se è inizializzato o meno è incerto, dipende dal compilatore.
- //text.cpp
- #include<iostream>
- using namespace std;
- typedef int STDataType;
- class Stack
- {
- public:
- Stack(int n = 4)
- {
- _a = (STDataType*)malloc(sizeof(STDataType) * n);
- if (nullptr == _a)
- {
- perror("malloc申请失败");
- }
- _capacity = n;
- _top = 0;
- }
-
- private:
- STDataType* _a;
- size_t _capacity;
- size_t _top;
- };
- //两个Stack实现队列
- class MyQueue
- {
- private:
- int size;
- Stack pushst;
- Stack popst;
- };
-
- int main()
- {
-
- MyQueue my;
-
-
- return 0;
- }
-
Il C++ divide i tipi in tipi personalizzati e tipi incorporati (tipi di base). I tipi incorporati sono i tipi di dati nativi forniti dal linguaggio, come int/char/double/pointer, ecc. I tipi personalizzati sono tipi che definiamo noi stessi utilizzando parole chiave come class/struct.Il costruttore qui viene inizializzato automaticamente e VS inizializza anche la dimensione del tipo incorporato Diversi compilatori hanno valori di inizializzazione diversi e C++ non li specifica.
Per le variabili membro di tipo personalizzato, è necessario chiamare il costruttore predefinito di questa variabile membro per inizializzarla.Se questa variabile membro non ha un costruttore predefinito, verrà segnalato un errore. Se vogliamo inizializzare questa variabile membro, dobbiamo utilizzare un elenco di inizializzazione per risolverlo.
Riepilogo: nella maggior parte dei casi, dobbiamo implementare noi stessi il costruttore. In alcuni casi, è simile a MyQueue e quando Stack ha un costruttore predefinito, MyQueue può essere generato e utilizzato automaticamente.
- ~Stack()
- {
- free(_a);
- _a = nullptr;
- _top = _capacity = 0;
- }
Caratteristiche del distruttore:
1. Il nome del distruttore è preceduto dai caratteri~
2. Nessun parametro e nessun valore restituito (coerente con il costruttore)
3. Una classe può avere un solo distruttore.Se la definizione non viene visualizzata, il sistema genererà automaticamente un distruttore predefinito.
4. Al termine del ciclo di dichiarazione dell'oggetto, il sistema chiamerà automaticamente il distruttore.
5. Analogamente al costruttore, non scriviamo il distruttore generato automaticamente dal compilatore e non elaboriamo i membri di tipo incorporati. I membri di tipo personalizzato chiameranno altri distruttori.
6. Va inoltre notato che quando visualizziamo il distruttore, verrà chiamato anche il distruttore del membro di tipo personalizzato, il che significa che il distruttore del membro di tipo personalizzato verrà chiamato automaticamente indipendentemente dalla situazione.
- //text.cpp
- #include<iostream>
- using namespace std;
- typedef int STDataType;
- class Stack
- {
- public:
- Stack(int n = 4)
- {
- _a = (STDataType*)malloc(sizeof(STDataType) * n);
- if (nullptr == _a)
- {
- perror("malloc申请失败");
- }
- _capacity = n;
- _top = 0;
-
-
- }
-
- ~Stack()
- {
- free(_a);
- _a = nullptr;
- _top=_capacity=0;
- }
- private:
- STDataType* _a;
- size_t _capacity;
- size_t _top;
-
- };
- //两个Stack实现队列
- class MyQueue
- {public:
- //编译器默认生成MyQueue的构造函数调用了Stack的构造,完成了两个成员的初始化
- //编译器默认生成MyQueue的析构函数调用了Stack的析构,释放了Stack内部的资源
- //显示写析构也会调用Stack的析构
- ~MyQueue()
- {
- cout << "~MyQueue" << endl;
- }
- private:
-
- Stack pushst;
- Stack popst;
-
- };
-
-
- int main()
- {
-
- MyQueue my;
-
-
- return 0;
- }
Il distruttore in MyQueue non fa nulla, ma C++ stabilisce che verranno chiamati altri distruttori per liberare la memoria.
Se non vengono richieste risorse, non è necessario scrivere il distruttore e il distruttore predefinito generato dal compilatore può essere utilizzato direttamente, ad esempio Date. Se è possibile utilizzare il distruttore predefinito generato, non è necessario scrivere in modo esplicito il distruttore come MyQueue, ma esiste un'applicazione di risorse Durante la distruzione, assicurati di scrivere direttamente il distruttore, altrimenti causerà una perdita di risorse come Stack
-
-
- bool operator<(Date d1, Date d2)
- {
-
- }
- bool operator==(Date d1,Date d2)
- {
- return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
- }
- //text.cpp
- #include<iostream>
- using namespace std;
-
- class Date
- {
- public:
- Date(int year, int month, int day)
- {
- _year= year;
- _month = month;
- _day = day;
-
- }
-
-
-
- int _year;
- int _month;
- int _day;
-
- };
-
- bool operator<(Date d1, Date d2)
- {
-
- }
- bool operator==(Date d1,Date d2)
- {
- return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
- }
- int main()
- {
-
- Date d1(2024, 7, 10);
- Date d2(2024,7,9);
- //两种用法都可以
- d1 == d2;
- operator==(d1 , d2);
- return 0;
- }