C++中this指針用法示例詳解

更新時間：2024年09月11日 09:01:57 作者：敲代碼的奧豆

在C++編程中this指針是每個非靜態(tài)成員函數的隱含參數,指向調用對象的地址,它用于區(qū)分同一個類的不同實例,并訪問成員變量和成員函數,這篇文章主要介紹了C++中this指針用法的相關資料,需要的朋友可以參考下

一、this指針

• Date類中有 Init 與 Print 兩個成員函數，函數體中沒有關于不同對象的區(qū)分，那當d1調用Init和 Print函數時，該函數是如何知道應該訪問的是d1對象還是d2對象呢？那么這里就要看到C++給了一個隱含的this指針解決這里的問題

• 編譯器編譯后，類的成員函數默認都會在形參第?個位置，增加?個當前類類型的指針，叫做this 指針，比如Date類的Init的真實原型為， void Init(Date* const this, int year, int month, int day)

• 類的成員函數中訪問成員變量，本質都是通過this指針訪問的，如Init函數中給_year賦值， this- >_year = year;

• C++規(guī)定不能在實參和形參的位置顯示的寫this指針(編譯時編譯器會處理)，但是可以在函數體內顯示使用this指針。

class Date
{
public:
 void Init(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 void Print()
{
 cout << _year << "/" << _month << "/" << _day << endl;
 }
private:
 // 這?只是聲明，沒有開空間 
 int _year;
 int _month;
 int _day;
};

運行下面兩串代碼，會發(fā)現兩個代碼雖然只差了一行代碼，結果卻差別很大

#include<iostream>
using namespace std;
class A
{
public:
 void Print()
 {
 cout << "A::Print()" << endl;
 }
private:
 int _a;
};
int main()
{
 A* p = nullptr;
 p->Print();
 return 0;
}

#include<iostream>
using namespace std;
class A
{
public:
 void Print()
 {
 cout << "A::Print()" << endl;
 cout << _a << endl;
 }
private:
 int _a;
};
int main()
{
 A* p = nullptr;
 p->Print();
 return 0;
}

這里先說結果，第一串代碼能正常運行，第二串代碼會運行崩潰，第一串代碼在調用了p->Print時這個函數，但是并沒有對p這個空指針進行解引用，所以第一串代碼能夠正常運行，而第二串代碼，再調用print函數之后，里面的_a實際是this->_a，對p進行了解引用，而p是空指針，而對于空指針的訪問只有在運行時才會發(fā)生，編譯器在編譯階段不會發(fā)現，所以不會程序報錯，會在運行時崩潰。

在C++中，this指針是一個隱含的指向當前對象的指針，它不是由程序員分配的，而是編譯器自動創(chuàng)建并插入到每個成員函數的隱式參數列表中的，this指針位于函數調用幀的局部變量區(qū)，通常稱為?？臻g，用于存儲函數執(zhí)行時需要的臨時數據和指向自身對象的數據，當函數被調用時，this 指針會被初始化為指向調用它的對象實例，這對于訪問類的私有成員變量特別有，this 永遠不會為空，除非是在靜態(tài)成員函數或者非成員函數中，這時沒有特定的對象關聯。

二、C++和C語言實現Stack對比

面向對象三大特性：封裝、繼承、多態(tài)，下面的對比我們可以初步了解?下封裝，通過下面兩份代碼對比，我們發(fā)現C++實現Stack形態(tài)上還是發(fā)生了挺多的變化，底層和邏輯上沒啥變化。

C實現stack代碼

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int STDataType;
typedef struct Stack
{
 STDataType* a;
 int top;
 int capacity;
}ST;
void STInit(ST* ps)
{
 assert(ps);
 ps->a = NULL;
 ps->top = 0;
 ps->capacity = 0;
}
void STDestroy(ST* ps)
{
 assert(ps);
 free(ps->a);
 ps->a = NULL;
 ps->top = ps->capacity = 0;
}
void STPush(ST* ps, STDataType x)
{
 assert(ps);
if (ps->top == ps->capacity)
 {
 int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
 STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * 
sizeof(STDataType));
 if (tmp == NULL)
 {
 perror("realloc fail");
 return;
 }
 ps->a = tmp;
 ps->capacity = newcapacity;
 }
 ps->a[ps->top] = x;
 ps->top++;
}
bool STEmpty(ST* ps)
{
 assert(ps);
 return ps->top == 0;
}
void STPop(ST* ps)
{
 assert(ps);
 assert(!STEmpty(ps));
 ps->top--;
}
STDataType STTop(ST* ps)
{
 assert(ps);
 assert(!STEmpty(ps));
 return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
 assert(ps);
return ps->top;
}
int main()
{
 ST s;
 STInit(&s);
 STPush(&s, 1);
 STPush(&s, 2);
 STPush(&s, 3);
 STPush(&s, 4);
 while (!STEmpty(&s))
 {
 printf("%d\n", STTop(&s));
 STPop(&s);
 }
 STDestroy(&s);
 return 0;
}

C++實現stack代碼

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
 // 成員函數 
 void Init(int n = 4)
 {
 _a = (STDataType*)malloc(sizeof(STDataType) * n);
 if (nullptr == _a)
 {
 perror("malloc申請空間失敗");
 return;
 }
 _capacity = n;
 _top = 0;
 }
void Push(STDataType x)
 {
 if (_top == _capacity)
 {
 int newcapacity = _capacity * 2;
 STDataType* tmp = (STDataType*)realloc(_a, newcapacity * 
sizeof(STDataType));
 if (tmp == NULL)
 {
 perror("realloc fail");
 return;
 }
 _a = tmp;
 _capacity = newcapacity;
 }
 _a[_top++] = x;
 }
 void Pop()
 {
 assert(_top > 0);
 --_top;
 }
 bool Empty()
 {
 return _top == 0;
 }
 int Top()
 {
 assert(_top > 0);
 return _a[_top - 1];
 }
 void Destroy()
 {
 free(_a);
 _a = nullptr;
 _top = _capacity = 0;
 }
private:
// 成員變量 
 STDataType* _a;
 size_t _capacity;
 size_t _top;
};
int main()
{
 Stack s;
 s.Init();
 s.Push(1);
 s.Push(2);
 s.Push(3);
 s.Push(4);
 while (!s.Empty())
 {
 printf("%d\n", s.Top());
 s.Pop();
 }
 s.Destroy();
 return 0;
}

• C++中數據和函數都放到了類里面，通過訪問限定符進行了限制，不能再隨意通過對象直接修改數據，這是C++封裝的一種體現，這個是最重要的變化，這里的封裝的本質是一種更嚴格規(guī)范的管理，避免出現亂訪問修改的問題，當然封裝不僅僅是這樣的，我們后面還需要不斷的去學習。

• C++中有一些相對方便的語法，比如 Init 給的缺省參數會方便很多，成員函數每次不需要傳對象地址，因為this指針隱含的傳遞了，方便了很多，使用類型不再需要typedef用類名就很方便。