系列文章目录

---

---

前言

暂不考虑支持多线程
常用STL的简单实现，主要内容百行左右完成，意在理解STL的原理

---

● 智能指针模板

SharedPtr

#include <assert.h>
#include <atomic>template <class T>
class SharedPtr
{
public:typedef T element_type;explicit SharedPtr(T* ptr = nullptr) : m_ref(nullptr){if (ptr)  m_ref = new reftype(ptr);}template <class Deleter>explicit SharedPtr(T* ptr, Deleter d) : m_ref(nullptr){if (ptr) m_ref = new reftye_with_deleter<Deleter>(ptr, d);}SharedPtr(const SharedPtr& tocopy){Acquire(tocopy.m_ref);}~SharedPtr(){Release();}SharedPtr& operator=(const SharedPtr& tocopy){if (this != &tocopy){Release();Acquire(tocopy.m_ref);}return *this;}SharedPtr& operator=(T* ptr){if (get() != ptr){Release();if (ptr) m_ref = new reftype(ptr);}return *this;}T* get() const{return m_ref ? m_ref->m_ptr : nullptr;}void reset(T* ptr = nullptr){Release();if (ptr) m_ref = new reftype(ptr);}template <class Deleter>void reset(T* ptr, Deleter d){Release();if (ptr) m_ref = new reftye_with_deleter<Deleter>(ptr, d);}bool unique() const { return m_ref ? m_ref->m_count == 1 : true; }long use_count() const { return m_ref ? m_ref->m_count.load() : 0; }// test for pointer validity: defining conversion to unspecified_bool_type// and not more obvious bool to avoid implicit conversions to integer typestypedef T*(SharedPtr<T>::*unspecified_bool_type)() const;operator unspecified_bool_type() const{if (m_ref && m_ref->m_ptr) return &SharedPtr<T>::get;else nullptr;}T& operator*() const{assert(m_ref && m_ref->m_ptr);return *( m_ref->m_ptr);}T* operator->() const{assert(m_ref && m_ref->m_ptr);return m_ref->m_ptr;}private:struct reftype{reftype(T* ptr) : m_ptr(ptr), m_count(1) {}virtual ~reftype() {}virtual void delete_ptr() { delete m_ptr; }T*              m_ptr;std::atomic_int m_count;};template <class Deleter>struct reftye_with_deleter: public reftype{reftye_with_deleter(T* ptr, Deleter d) : reftype(ptr), m_deleter(d) {}virtual void delete_ptr() override{m_deleter(this->m_ptr);}Deleter m_deleter;};reftype* m_ref;void Acquire(reftype* ref){m_ref = ref;if (ref) ref->m_count.fetch_add(1);}void Release(){if (m_ref){if (! --m_ref->m_count ){m_ref->delete_ptr();delete m_ref;}m_ref = nullptr;}}
};template <class T, class U>
bool operator==(const SharedPtr<T>& a, const SharedPtr<U>& b)
{return a.get() == b.get();
}
template <class T, class U>
bool operator!=(const SharedPtr<T>& a, const SharedPtr<U>& b)
{return a.get() != b.get();
}//------------------------------------------------------------------------------
#include <iostream>
#include <stdio.h>
class TestSt
{
public:char buf[1024];char bux[4096];
public:TestSt() { printf("   const %p\n", this);};~TestSt(){printf("~TestSt: %p\n", this);}
};int main()
{std::atomic_int at;SharedPtr<TestSt> p_st(new TestSt());SharedPtr<TestSt> p_st2(p_st);SharedPtr<TestSt> p_st3(new TestSt());p_st3 = p_st2;std::cout << p_st.use_count() << " " << p_st2.use_count() << " " << p_st3.use_count() << " " <<  std::endl;}

● Vector

auto p = new T[N]; 申请空间，为每个元素p[i]调用T的构造函数
delete[] p; 先为每个元素调用析构函数，释放空间

1. 简单版本

new (m_values+i) T(val); 和 m_values[i] = val并不等价
当value_type包含虚函数时后者不能正确处理虚函数表指针，而前者却可以。这或许也是C和C++不兼容的证据？

如图所示，new (m_values+i) T(val)可以正确处理虚表指针，而m_values[i] = val的_vptr.TestSt = 0x0

#include <stdlib.h>
#include <algorithm>template <class T>
class Vector
{
private:T* m_values;size_t m_size, m_capacity;public:typedef T value_type;typedef T* iterator;Vector(): m_values(nullptr), m_size(0), m_capacity(0) {}~Vector(){for (size_t i = 0; i < m_size; i++){m_values[i].~T();}free(m_values);m_values = nullptr;m_size = m_capacity = 0;}Vector(size_t n, const T& val): m_values(nullptr), m_size(n),m_capacity(n){m_values =  (T*)malloc(sizeof(T) * m_capacity);for (size_t i = 0; i < n; i++){new (m_values+i) T(val);}}Vector(const Vector<T>& tocopy){m_values =  (T*)malloc(sizeof(T) * tocopy.m_capacity);m_size = tocopy.m_size;m_capacity = tocopy.m_capacity;for (size_t i = 0; i < m_size; i++){new (m_values+i) T(tocopy.m_values[i]);}}Vector<T>& operator=(const Vector<T>& tocopy){if (&tocopy == this) return *this;Vector<T> tmp(tocopy);std::swap(m_values, tmp.m_values);std::swap(m_size, tmp.m_size);std::swap(m_capacity, tmp.m_capacity);return *this;}value_type& operator[](size_t idx){return m_values[idx];}void push_back(const T& val){if (m_size + 1 > m_capacity){m_capacity = m_capacity ? 2*m_capacity : 1;T* tmp = (T*)malloc(sizeof(T) * m_capacity);for (size_t i = 0; i < m_size; i++){new (tmp+i) T(m_values[i]);m_values[i].~T();}free(m_values);m_values = tmp;}new (m_values+m_size) T(val);++m_size;}void pop_back(){--m_size;m_values[m_size].~T();}void clear(){for (size_t i = 0; i < m_size; i++){m_values[i].~T();}m_size = 0;}size_t size() { return m_size; }iterator begin(){return m_values;}iterator end(){return m_values + m_size;}
};

2. X

---

总结