最近2018中文字幕在日韩欧美国产成人片_国产日韩精品一区二区在线_在线观看成年美女黄网色视频_国产精品一区三区五区_国产精彩刺激乱对白_看黄色黄大色黄片免费_人人超碰自拍cao_国产高清av在线_亚洲精品电影av_日韩美女尤物视频网站

估計(jì)大家面試過(guò)程中應(yīng)該都會(huì)被問(wèn)到C++11的shared_ptr是如何實(shí)現(xiàn)的，大家應(yīng)該都能答出來(lái)引用計(jì)數(shù)的概念，但是如果要讓你手寫(xiě)一個(gè)shared_ptr，你能寫(xiě)出來(lái)嗎?

創(chuàng)新互聯(lián)公司長(zhǎng)期為超過(guò)千家客戶提供的網(wǎng)站建設(shè)服務(wù)，團(tuán)隊(duì)從業(yè)經(jīng)驗(yàn)10年，關(guān)注不同地域、不同群體，并針對(duì)不同對(duì)象提供差異化的產(chǎn)品和服務(wù)；打造開(kāi)放共贏平臺(tái)，與合作伙伴共同營(yíng)造健康的互聯(lián)網(wǎng)生態(tài)環(huán)境。為洮南企業(yè)提供專(zhuān)業(yè)的網(wǎng)站設(shè)計(jì)、成都做網(wǎng)站，洮南網(wǎng)站改版等技術(shù)服務(wù)。擁有10年豐富建站經(jīng)驗(yàn)和眾多成功案例,為您定制開(kāi)發(fā)。

最近，我寫(xiě)了一個(gè)簡(jiǎn)單的shared_ptr，在這里分享一波。

首先定義一個(gè)主管引用計(jì)數(shù)的類(lèi)：

class SharedCount {
   public:
    SharedCount() : count_{1} {}

    void add() { ++count_; }

    void minus() { --count_; }

    int get() const { return count_; }

   private:
    std::atomic count_;
};

然后就是SharedPtr類(lèi)，首先在構(gòu)造函數(shù)中創(chuàng)建SharedCount的對(duì)象：

template 
class SharedPtr {
   public:
    SharedPtr(T* ptr) : ptr_{ptr}, ref_count_{new SharedCount} {}

    SharedPtr() : ptr_{nullptr}, ref_count_{new SharedCount} {}

   private:
    T* ptr_;
    SharedCount* ref_count_;
};

通過(guò)構(gòu)造函數(shù)創(chuàng)建出來(lái)的SharedPtr引用計(jì)數(shù)肯定是1，那析構(gòu)函數(shù)怎么實(shí)現(xiàn)?無(wú)非就是將引用計(jì)數(shù)減1，如果引用計(jì)數(shù)最終減到0，則釋放所有指針：

template 
class SharedPtr {
   public:
    ~SharedPtr() { clean(); }

   private:
    void clean() {
        if (ref_count_) {
            ref_count_->minus();
            if (ref_count_->get() == 0) {
                if (ptr_) delete ptr_;
                delete ref_count_;
            }
        }
    }
};

然后就是智能指針的關(guān)鍵部分，即在拷貝構(gòu)造和拷貝賦值的時(shí)候?qū)⒁糜?jì)數(shù)+1：

template 
class SharedPtr {
   public:
    SharedPtr(const SharedPtr& p) {
        this->ptr_ = p.ptr_;
        this->ref_count_ = p.ref_count_;
        ref_count_->add();
    }

    SharedPtr& operator=(const SharedPtr& p) {
        clean();
        this->ptr_ = p.ptr_;
        this->ref_count_ = p.ref_count_;
        ref_count_->add();
        return *this;
    }
};

處理了拷貝語(yǔ)義，還需要處理移動(dòng)語(yǔ)義，即實(shí)現(xiàn)移動(dòng)構(gòu)造和移動(dòng)賦值函數(shù)：

template 
class SharedPtr {
   public:
    SharedPtr(SharedPtr&& p) {
        this->ptr_ = p.ptr_;
        this->ref_count_ = p.ref_count_;
        p.ptr_ = nullptr;
        p.ref_count_ = nullptr;
    }

    SharedPtr& operator=(SharedPtr&& p) {
        clean();
        this->ptr_ = p.ptr_;
        this->ref_count_ = p.ref_count_;
        p.ptr_ = nullptr;
        p.ref_count_ = nullptr;
        return *this;
    }
};

在移動(dòng)語(yǔ)義中，引用計(jì)數(shù)保持不變，同時(shí)清空原參數(shù)中的指針。

關(guān)于共享指針，到這里基本邏輯都已經(jīng)實(shí)現(xiàn)完成，但還需要補(bǔ)充獲取裸指針、獲取引用計(jì)數(shù)等接口：

這樣一個(gè)完整的智能指針大體已經(jīng)實(shí)現(xiàn)完成，運(yùn)行一下看看：

struct A { A() { std::cout << "A() \n"; } ~A() { std::cout << "~A() \n"; }};void test_simple_shared() { A* a = new A; SharedPtr ptr(a); { std::cout << ptr.use_count() << std::endl; SharedPtr b = ptr; std::cout << ptr.use_count() << std::endl; SharedPtr c = ptr; std::cout << ptr.use_count() << std::endl; SharedPtr d = std::move(b); std::cout << ptr.use_count() << std::endl; } std::cout << ptr.use_count() << std::endl;}int main() { test_simple_shared(); }

結(jié)果為：

template 
class SharedPtr {
   public:
    int use_count() { return ref_count_->get(); }

    T* get() const { return ptr_; }

    T* operator->() const { return ptr_; }

    T& operator*() const { return *ptr_; }

    operator bool() const { return ptr_; }

   private:
    T* ptr_;
    SharedCount* ref_count_;
};

基本的shared_ptr完成后，再來(lái)寫(xiě)點(diǎn)有意思的，不知道大家有沒(méi)有用過(guò)這幾個(gè)指針轉(zhuǎn)換函數(shù)：

struct A {
    A() { std::cout << "A() \n"; }
    ~A() { std::cout << "~A() \n"; }
};

void test_simple_shared() {
    A* a = new A;
    SharedPtr ptr(a);
    {
        std::cout << ptr.use_count() << std::endl;
        SharedPtr b = ptr;
        std::cout << ptr.use_count() << std::endl;
        SharedPtr c = ptr;
        std::cout << ptr.use_count() << std::endl;
        SharedPtr d = std::move(b);
        std::cout << ptr.use_count() << std::endl;
    }
    std::cout << ptr.use_count() << std::endl;
}

int main() { test_simple_shared(); }

結(jié)果為：

A()
1
2
3
3
1
~A()

template
std::shared_ptr static_pointer_cast(const std::shared_ptr& r) noexcept;

template
std::shared_ptr const_pointer_cast(const std::shared_ptr& r) noexcept;

template
std::shared_ptr dynamic_pointer_cast(const std::shared_ptr& r) noexcept;

template
std::shared_ptr reinterpret_pointer_cast(const std::shared_ptr& r) noexcept;

template 
class SharedPtr {
   public:
   private:
    template 
    SharedPtr(const SharedPtr& p, T* ptr) {
        this->ptr_ = ptr;
        this->ref_count_ = p.ref_count_;
        ref_count_->add();
    }

    T* ptr_;
    SharedCount* ref_count_;
};

template 
SharedPtr static_pointer_cast(const SharedPtr& p) {
    T* ptr = static_cast(p.get());
    return SharedPtr(p, ptr);
}

template 
class SharedPtr {
   public:
    template 
    friend class SharedPtr;
};

template 
class SharedPtr {
   public:
    template 
    friend class SharedPtr;

    template 
    friend SharedPtr static_pointer_cast(const SharedPtr& p);

   private:
    template 
    SharedPtr(const SharedPtr& p, T* ptr) {
        this->ptr_ = ptr;
        this->ref_count_ = p.ref_count_;
        ref_count_->add();
    }

    T* ptr_;
    SharedCount* ref_count_;
};

template 
SharedPtr static_pointer_cast(const SharedPtr& p) {
    T* ptr = static_cast(p.get());
    return SharedPtr(p, ptr);
}

struct A {
    A() { std::cout << "A() \n"; }
    ~A() { std::cout << "~A() \n"; }
};

struct B : A {
    B() { std::cout << "B() \n"; }
    ~B() { std::cout << "~B() \n"; }
};

void test_cast_shared() {
    B* a = new B;
    SharedPtr ptr(a);
    {
        std::cout << ptr.use_count() << std::endl;
        SharedPtr b = static_pointer_cast(ptr);
        std::cout << ptr.use_count() << std::endl;
        SharedPtr c = ptr;
        std::cout << ptr.use_count() << std::endl;
        SharedPtr d = ptr;
        std::cout << ptr.use_count() << std::endl;
    }
    std::cout << ptr.use_count() << std::endl;
}

int main() { test_cast_shared(); }

A()
B()
1
2
3
4
1
~B()
~A()

template 
class UniquePtr {
   public:
    UniquePtr(T* ptr) : ptr_{ptr} {}

    UniquePtr() : ptr_{nullptr} {}

    UniquePtr(const UniquePtr& p) = delete;
    UniquePtr& operator=(const UniquePtr& p) = delete;

    UniquePtr(UniquePtr&& p) {
        this->ptr_ = p.ptr_;
        p.ptr_ = nullptr;
    }

    UniquePtr& operator=(UniquePtr&& p) {
        clean();
        this->ptr_ = p.ptr_;
        p.ptr_ = nullptr;
        return *this;
    }

    T* get() const { return ptr_; }

    T* operator->() const { return ptr_; }

    T& operator*() const { return *ptr_; }

    operator bool() const { return ptr_; }

    ~UniquePtr() { clean(); }

   private:
    void clean() {
        if (ptr_) delete ptr_;
    }

    T* ptr_;
};

template 
class UniquePtr {
   public:
    UniquePtr(const UniquePtr& p) = delete;
    UniquePtr& operator=(const UniquePtr& p) = delete;
};