一、類和物件、this指標
OOP語言的四大特征是什么？
- 抽象
- 封裝、隱藏
- 繼承
- 多型
類體內實作的方法會自動處理為inline函式，
類物件的記憶體大小之和成員變數有關
類在記憶體上需要對齊，是為了減輕cup在記憶體上的io次數
查看類物件的大小的指令：cl className.cpp /d1reportSingleClassLayout類名
一個類可以定義無數個物件，每個物件都有自己的成員變數，但是他們共享一套成員方法，
有一個問題：Q1:類中的成員方法是怎么知道要處理哪個物件的資訊的？
A1:在呼叫成員方法的時候會在引數串列里隱式的給定物件記憶體的地址，如下所示：
類的成員方法一經編譯，所有方法引數都會加一個this指標，接收呼叫該方法的物件的地址，即下圖中的CGoods *this
二、掌握建構式和解構式
定義一個SeqStack類：
class SeqStack
{
public:
SeqStack(int size = 10) :_top(-1), _size(size) {
_pstack = new int[size];
}
~SeqStack() {
cout << this << "~SeqStack()" << endl;
delete[] _pstack;
_pstack = nullptr;
}
void push(int val) {
if (full()) {
resize();
}
_pstack[++_top] = val;
}
void pop() {
if (empty()) {
return;
}
--_top;
}
int top() {
return _pstack[_top];
}
bool empty() { return _top == -1; }
bool full() { return _top == _size-1; }
private:
int* _pstack;
int _top;
int _size;
void resize() {
int* ptmp = new int[_size * 2];
for (int i = 0; i < _size; i++) {
ptmp[i] = _pstack[i];
}
delete[] _pstack;
_pstack = ptmp;
_size *= 2;
}
};
/**
運行程序
*/
int main() {
SeqStack sq1;
for (int i = 0; i < 15; i++) {
sq1.push(rand() % 100);
}
while (!sq1.empty()) {
cout << sq1.top() << " ";
sq1.pop();
}
return 0;
}
三、掌握物件的深拷貝和淺拷貝
.data段的物件是程式啟動的時候構造的，程式結束的時候析構的
heap堆上物件是new的時候構造的，delete的時候析構的
stack堆疊上的物件是在呼叫函式的時候構造的，執行完函式時析構的
如果物件占用外部資源，淺拷貝就會出現問題：會導致一個物件指向的記憶體釋放，從而造成另一個物件中的指標成為野指標，所以就要對這樣的物件進行深拷貝，在新的物件中重新開辟一塊空間，使兩者互不干涉，
注意：在面向物件中，要避免使用memcpy進行拷貝，因為物件的記憶體占用不確定，會因為物件中保存指標而造成淺拷貝，需要拷貝的時候只能用for回圈逐一拷貝，
深拷貝：
SeqStack& operator=(const SeqStack& src) {
cout << "operator=" << endl;
//防止自賦值
if (this == &src) {
return *this;
}
delete[] _pstack;//需要釋放掉自身占用的外部資源
_pstack = new int[src._size];
for (int i = 0; i <= src._top; i++) {
_pstack[i] = src._pstack[i];
}
_top = src._top;
_size = src._size;
return *this;
}
SeqStack(const SeqStack& src) {
cout << this << "SeqStack(const SeqStack& src)" << endl;
_pstack = new int[src._size];
for (int i = 0; i <= src._top; i++) {
_pstack[i] = src._pstack[i];
}
_top = src._top;
_size = src._size;
}
四、類和物件應用實踐
類Queue：
#pragma once
class CirQueue
{
public:
CirQueue(int size = 10) {
_pQue = new int[size];
_front = _rear = 0;
_size = size;
}
CirQueue(const CirQueue& src) {
_size = src._size;
_front = src._front;
_rear = src._rear;
_pQue = new int[_size];
for (int i = _front; i != _rear; i = (i + 1) % _size) {
_pQue[i] = src._pQue[i];
}
}
~CirQueue() {
delete[] _pQue;
_pQue = nullptr;
}
CirQueue& operator=(const CirQueue& src) {
if (this == &src) {
return *this;
}
delete[] _pQue;//需要釋放掉自身占用的外部資源
_size = src._size;
_front = src._front;
_rear = src._rear;
_pQue = new int[_size];
for (int i = _front; i != _rear; i = (i + 1) % _size) {
_pQue[i++] = src._pQue[i];
}
return *this;
}
void push(int val) {
if (full()) {
resize();
}
_pQue[_rear] = val;
_rear = (_rear + 1) % _size;
}
void pop() {
if (empty()) {
return;
}
_front = (_front + 1) % _size;
}
int front() {
return _pQue[_front];
}
bool full() {
return (_rear + 1) % _size == _front;
}
bool empty () {
return _front == _rear;
}
private:
int* _pQue;
int _front;
int _rear;
int _size;
void resize() {
int* ptmp = new int[_size * 2];
int index = 0;
for (int i = _front; i != _rear; i=(i+1)%_size) {
ptmp[index++] = _pQue[i];
}
delete[] _pQue;
_pQue = ptmp;
_front = 0;
_rear = index;
_size *= 2;
}
};
類String：
#pragma once
#include <algorithm>
class String
{
public:
String(const char* str = nullptr) {
if (str != nullptr) {
_pChar = new char[strlen(str) + 1];
strcpy(_pChar, str);
}
else {
_pChar = new char[1];
*_pChar = '\0';
}
}
String(const String& str) {
_pChar = new char[strlen(str._pChar)+1];
strcpy(_pChar, str._pChar);
}
~String() {
delete[] _pChar;
_pChar = nullptr;
}
String& operator=(const String& str) {
if (this == &str) {
return *this;
}
delete[] _pChar;//需要釋放掉自身占用的外部資源
_pChar = new char[strlen(str._pChar) + 1];
strcpy(_pChar, str._pChar);
return *this;
}
private:
char* _pChar;
};
五、掌握建構式的初始化串列
初始化串列和寫在構造體里有什么區別：
初始化串列會直接定義并且賦值；放在構造體里會先執行定義操作，在對定義好的物件賦值，
物件變數是按照定義的順序賦值的，與建構式中初始化串列的順序無關，上圖中的ma是0xCCCCCCCC，mb是10，ma未賦值，
六、掌握類的各種成員方法及其區別
普通成員方法和常成員方法，是可以多載的，常成員方法可以在物件宣告為const的時候呼叫，
物件宣告為const的時候，呼叫成員方法是通過const物件的指標呼叫的，而普通的成員方法默認生成的是普通的指標物件，不能直接賦值，
只要是只讀操作的成員方法，一律實作成const常成員方法
三種成員方法：
七、指向類成員的指標
class Test {
public:
void func() { cout << "call Test::func" << endl; }
static void static_func() { cout << "call Test::static_func" << endl; }
int ma;
static int mb;
};
int Test::mb=0;
int main() {
Test t1;
Test *t2 = new Test();//在堆上生成物件，并用指標指向
//使用指標呼叫類成員方法(前面要加類的作用域Test::)
void (Test:: * pfunc)() = &Test::func;
(t1.*pfunc)();
(t2->*pfunc)();
//定義指向static的類成員方法
void(*pfunc1)() = &Test::static_func;
(*pfunc1)();
//使用指標指向類成員變數，前面要加類的作用域Test::
int Test::* p = &Test::ma;
t1.*p = 20;
cout << t1.*p << endl;
t2->*p = 30;
cout << t2->*p << endl;
int* p1 = &Test::mb;
*p1 = 40;
cout << *p1 << endl;
delete t2;
return 0;
}
輸出為：
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/476449.html
標籤：C++