Java面向對象(二) 五、方法 5.1 方法的重載(overload) 定義:在同一個類中,允許定義多個相同名字的方法,只要參數列表(參數類型或者參數個數)是不同的。 判斷是否為方法重載: (1)同一個類,同樣的方法名,不同的參數列表! (2)與方法修飾符、方法返回值、形參名、方法體無關! pub ...
1 smart pointer 思想
個人認為smart pointer實際上就是一個對原始指針類型的一個封裝類,並對外提供了-> 和 * 兩種操作,使得其能夠表現出原始指針的操作行為。
要理解smart pointer思想首先要瞭解一個概念RAII(Resource Acquisition Is Initialization), 直譯為資源獲取即初始化,核心理念為在對象創建時分配資源,而在對象銷毀時釋放資源.
根據RAII理念,如果對象創建在棧(stack)上,由於棧上的對象在銷毀是會自動調用析構函數,因此僅僅需要在構造函數內完成資源分配,而在析構函數內完成資源釋放,此時程式員就不需要自己關心資源的釋放問題。
但當對象創建在自由存儲區(free store)上時,例如:
class Fruit {
public:
Fruit(std::string name = "fruit", int num = 1) :name_{ name }, num_{ num }{}
~Fruit(){ cout << "destroy fruit" << endl;}
std::string name_;
int num_;
};
int main(){
Fruit* intPtr{new Fruit};//memory leak
return 0;
}
此時系統僅僅能回收在棧上1創建的指針intPtr所占據的資源,對於指針所指向的動態分配的記憶體空間並不會自動調用析構函數進行資源釋放,此時如果程式員不主動調用 delete 進行資源釋放則會產生記憶體泄漏。
那麼如何讓創建在自由存儲區的對象也能夠自動地釋放資源,而不需要程式員自己手動釋放資源呢?智能指針給出了一種非常巧妙的解決思路,它將一個原本定義在自由存儲區的對象封裝進了一個創建在棧上的資源管理對象中,由這個資源管理對象在自己的析構函數中釋放定義在自由存儲區上的對象所占據的資源。這使得程式員只需要利用資源管理對象接管在自由存儲區上動態創建的對象資源,利用棧對象的生存機制能夠實現資源的自動釋放而不需要自己手動delete 對象資源。例如:
template <typename T>
class ResourceManager {
public:
ResourceManager(T* ptr) :ptr_{ ptr } {}
~ResourceManager() {
cout << "delete arr in free store" << endl;
delete ptr_;
}
private:
T* ptr_;
};
void AutoManage(){
ResourceManager fruit{ new Fruit};
}
int main(){
AutoManage();//delete arr in free store
system("pause");
//cout << fruit->name_ << " " << (*fruit).num_ << endl;//fruit 1
return 0;
}
在AutoManage()函數中動態分配一個Fruit對象,並將其封裝進ResourceManager資源管理類中,當程式離開函數AutoManage()時,由於ResourceManager是一個定義在棧上的對象,程式會自動調用析構函數~ResourceManager()進行對象銷毀操,此時由於ResourceManager在析構函數中進行了Fruit資源的釋放,因此不會發生記憶體泄漏問題,一次不需要程式員手動釋放資源的自動記憶體管理過程完美完成。
以上僅僅完成了動態分配的資源的自動回收功能,要使得ResourceManager資源管理類能夠像Fruit*指針一樣操作Fruit對象的成員,還需要對外提供***** 以及->兩種指針操作:
template <typename T>
class ResourceManager {
public:
ResourceManager(T* ptr) :ptr_{ ptr } {}
~ResourceManager() {
cout << "delete arr in free store" << endl;
delete ptr_;
}
T*& operator->() {return ptr_;}
T& operator*() { return *ptr_; }
private:
T* ptr_;
};
void AutoManage(){
ResourceManager fruit{ new Fruit};
}
int main(){
AutoManage();//delete arr in free store
system("pause");
cout << fruit->name_ << " " << (*fruit).num_ << endl;//fruit 1
return 0;
}
此時可以利用ResourceManager提供的***** 以及->操作符直接操作原始Fruit* 指針,使得ResourceManager對象就像一個真實的指向Fruit對象的Fruit* 指針。
2 unique_ptr 思想
unique_ptr作為最常用的智能指針,它提供了對資源的獨占式管理,即對資源的唯一所有權(sole ownership), 這就要求unique_ptr是一個不可複製的對象。每一個unique_ptr對象都有義務對其管理的資源進行釋放。但unique_ptr 並不限制移動(move)操作所導致的所有權轉移。最後不要忘記unique_ptr作為一個智能指針概念,它必須能夠自動管理動態分配的對象資源,並且提供對對象資源的指針操作。概括一下,unique_ptr要求:
- 不可複製
- 能夠移動
- 自動記憶體管理
- 指針操作
template<typename T>
class UniquePtr {
public:
UniquePtr(T* ptr):ptr_{ptr}{}
~UniquePtr() {
cout << "delete unique resource in free store" << endl;
delete ptr_;//釋放資源
}
UniquePtr(const UniquePtr&) = delete;//禁用拷貝構造
UniquePtr& operator=(const UniquePtr&) = delete;//禁用拷貝複製
UniquePtr(UniquePtr&& object) {//移動構造
cout << "move construct" << endl;
ptr_ = object.ptr_;
object.ptr_ = nullptr;
}
UniquePtr& operator=(UniquePtr&& object) {//移動賦值
cout << "move assign" << endl;
ptr_ = object.ptr_;
object.ptr_ = nullptr;
return *this;
}
T*& operator->() { return ptr_; }//->
T& operator*() { return *ptr_; }//*
private:
T* ptr_;
};
template <typename T>
void ChangeOwnership(UniquePtr<T> move) {
UniquePtr<T> newOwner{ nullptr };
newOwner = std::move(move);
}
int main(){
UniquePtr uniquePtr{new Fruit};
ChangeOwnership(std::move(uniquePtr));
//ChangeOwnership(uniquePtr);//compile error! deny copy construction
//UniquePtr uniquePtr1 = uniquePtr;//compile error! deny copy construction
//UniquePtr<Fruit> uniquePtr2{nullptr};
//uniquePtr2 = uniquePtr;//compile error! deny copy assignment
system("pause");
return 0;
}
可以看到即使程式員沒有自動釋放創建在自由存儲區上的對象,通過UniquePtr也能自動進行釋放。同時UniquePtr無法進行拷貝,保證了UniquePtr對資源所有權的獨占性,而通過std::move() 以及移動構造/賦值函數,UniquePtr能夠將對資源的所有權轉移給其他UniquePtr對象。基本簡易得實現了一個std::unique_ptr智能指針。
3 shared_ptr 思想
shared_ptr作為另一個常用的智能指針,它和unique_ptr智能指針的理念有著很大的不同,它提供了對資源共用管理,即對資源所有權的共用(shared ownership),這就要求shared_ptr必須是一個可複製的對象。但是由於shared_ptr對象有很多個,而具體的對象資源只有一個這就要求所有共用對象資源的shared_ptrs指針中最終只能有一個shared_ptr能夠釋放對象資源。因此shared_ptr引入了引用計數(reference counting)機制:多個shared_ptrs對象共用一個引用計數變數,通過引用計數記錄當前對對象資源被引用的次數,僅當引用計數為0,也就是出當前shared_ptr對象外沒有其他shared_ptr對象再共用當前對象資源時,當前shared_ptr對象才能夠釋放持有的對象資源。
顯然根據引用計數(reference counting)機制,釋放對象資源的shared_ptr對象必然是最後一個持有對象資源的shared_ptr,這就很好得解決了另一個非常常見的記憶體問題:重覆刪除(double deletion)。最後概括一下,shared_ptr要求:
- 可複製
- 共用引用計數
- 自動記憶體管理
- 指針操作
template <typename T>
class SharedPtr {
public:
SharedPtr(T* ptr) :ptr_{ ptr }, count_{ new unsigned int{} } {}
~SharedPtr() {
if (*count_ == 0) {//引用計數==0,釋放資源
cout << "delete shared resource in free store" << endl;
delete ptr_;
delete count_;
}
else//引用計數不為0,引用計數-1
--(*count_);
}
SharedPtr(const SharedPtr& object) :ptr_{ object.ptr_ }{//拷貝構造 引用+1
count_ = object.count_;
++(*count_);
}
SharedPtr& operator=(const SharedPtr& object) {//拷貝賦值 引用+1
ptr_ = object.ptr_;
count_ = object.count_;
++(*count_);
return *this;
}
unsigned int GetReferenceCount() { return *count_; }//輸出當前資源引用個數
T*& operator->() { return ptr_; }//->
T& operator*() { return *ptr_; }//*
private:
T* ptr_;
unsigned int* count_;//reference counting
};
template <typename T>
void ShareOwnership(SharedPtr<T> copy) {
cout << copy.GetReferenceCount() << endl;
};
int main(){
SharedPtr sharedPtr1{new Fruit};
SharedPtr sharedPtr2{ sharedPtr1 };
SharedPtr<Fruit> sharedPtr3{ nullptr };
sharedPtr3 = sharedPtr2;
ShareOwnership(sharedPtr3);
system("pause");
return 0;
}
可以看到即使程式中存在多個shared_ptr對象,共用的Fruit對象資源也只會被釋放一次。函數ShareOwnership()中的引用輸出為3,這是因為:首先sharedPtr1持有了一個Fruit對象資源,初始化引用為0;其次sharedPtr2,sharedPtr3通過拷貝sharedPtr1的方式共用了Fruit對象資源,這使得引用0+2=2;最後將sharedPtr3拷貝至函數ShareOwnership()的參數copy中時又使得Fruit對象資源的共用者+1,最終使得引用計數2+1=3;
最後補充一點,對於Fruit對象資源的共用,儘量採用直接拷貝shared_ptr對象的方式進行。如果利用原始Fruit* 指針創建新的shared_ptr對象,則很容易產生 重覆刪除(double deletion)問題:
auto sharedPtr{ std::make_shared<Fruit>("apple",2) };
//sharedPtr.get()返回Fruit對象的原始指針Fruit*
std::shared_ptr<Fruit> sharedPtr1{sharedPtr.get() };//cause double deletion
這是因為sharedPtr,sharedPtr1互相不知道對方的存在,都認為只有自己持有Fruit對象,導致兩個shared_ptr的引用計數均為0,當程式走出作用範圍後sharedPtr,sharedPtr1都會嘗試釋放Fruit對象,產生重覆刪除(double deletion).