double Div(int a, int b) {
  if (b == 0) throw "Zero Div";//抛出一个字符串常量
  cout << "要是异常抛出, 自我及其一下全部腰斩, 不会执行" << endl;
  return (double)a / (double)b;
}
int main() {
  try {
    cout << Div(4, 0) << endl;
  }
  catch (int errid) {
    //捕获错误码整形进行处理
    cout << "错误编号: " << errid << endl;
  }
  catch (const char* msg) {
    cout << "错误信息" << msg << endl;
  }
  cout << "异常处理结束了, 继续向后执行呀, 除非异常处理进行了中断" << endl;
  return 0;
}

class MyException {
public:
  MyException(int errid, string errmsg) 
    : _errid(errid)
    , _errmsg(errmsg) 
  {}
  const string& what() const noexcept {
    return _errmsg;
  }
  int GetErrid() const noexcept {
    return _errid;
  }
private:
  int _errid;
  string _errmsg;
};

class Test {
public:
  Test() {
    //default ctor 
  } 
  ~Test() {
    cout << "dtor" << endl;
  }
};
int main() {
  try {
    //Test t;   栈区对象肯定没问题的
    Test* pt = new Test;//堆区呢？
    throw 1;
        delete pt;   //会怎样??? 不会执行, 内存泄漏
  }
  catch (int errid) {
    cout << "我会不会调用析构???" << endl;
    cout << errid << endl;
  }
  return 0;
}

double Div(int a, int b) {
  if (b == 0) {
    throw MyException(0, "Zero Div");
  }
  return (double)a / (double)b;
}
void func() {
 // 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
 // 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再
 // 重新抛出去。
  int* arr = new int[4]{ 0 };
  try{
    int a, b;
    cout << "请输入被除数和除数: " << endl;
    cin >> a >> b;
    cout << Div(a, b) << endl;
  }
  catch (...) { //我仅仅处理内存, 至于信息等等继续抛出去其他函数处理    
    cout << "delete[]" << endl;
    delete[] arr;
    throw;//继续往外抛出
  }
}
int main() {
  try {
    func();
  }
  catch (const MyException& e) {
    cout << "错误信息: " << e.what() << endl;
  }
  return 0;
}

class MyException {
public:
  MyException(int errid, string errmsg)
    : _errid(errid)
    , _errmsg(errmsg)
  {}
  virtual string what() const noexcept {
    return _errmsg;
  }
  virtual int GetErrid() const noexcept {
    return _errid;
  }
protected:
  int _errid;
  string _errmsg;
};
//继承的子类
class SqlException : public MyException {
public:
  SqlException(int errid = 0, const char* msg = "") 
    : MyException(errid, msg)
  {}
  virtual string what() const noexcept {
    string tmp("SqlException: ");
    tmp += _errmsg;
    return tmp;
  }
};
class CacheException : public MyException {
public:
  CacheException(int errid = 0, const char* msg = "")
    : MyException(errid, msg)
  {}
  virtual string what() const noexcept {
    string tmp("CacheException: ");
    tmp += _errmsg;
    return tmp;
  }
};
class HttpServerException : public MyException {
public:
  HttpServerException(int errid = 0, const char* msg = "")
    : MyException(errid, msg)
  {}
  virtual string what() const noexcept {
    string tmp("HttpServerException: ");
    tmp += _errmsg;
    return tmp;
  }
};

namespace tyj {
  template<class T>
  class unique_ptr {
  public:
    unique_ptr(T* ptr = nullptr)
      : _ptr(ptr)
    {}
    ~unique_ptr() {
      if (_ptr)
        delete _ptr;
    }
    T& operator*() {
      return *_ptr;
    }
    T* operator->() {
      return _ptr;
    }
  private:
    T* _ptr;
    unique_ptr(unique_ptr<T>& up) = delete; //禁止掉构造函数
    unique_ptr<T>& operator=(unique_ptr<T>& up) = delete;//禁止掉复制重载
  };
}

namespace tyj {
  template <class T>
  class shared_ptr {
  public:
    shared_ptr(T* ptr = nullptr) 
      : _ptr(ptr)
      , _pmtx(new mutex)
      , _pRefCount(new int(1))
    {}
    ~shared_ptr() {
      Release();    //释放资源
    }
    //增加引用计数, 赋值拷贝
    shared_ptr(const shared_ptr<T>& sp)
      : _ptr(sp._ptr)
      , _pRefCount(sp._pRefCount)
      , _pmtx(sp._pmtx) {
      AddRefCount();//增加引用计数
    }
    shared_ptr<T>& operator=(shared_ptr<T>& sp) {
      if (this != &sp) {
        Release();//先释放可能持有的资源
        _ptr = sp._ptr;
        _pmtx = sp._pmtx;
        _pRefCount = sp._pRefCount;
        AddRefCount();//增加引用计数
      }
      return *this;
    }
    int UseCount() { 
      return *_pRefCount; 
    }
    T* Get() {
      return _ptr;
    }
    T& operator*() {
      return *_ptr;
    }
    T* operator->() {
      return _ptr;
    }
  private:
    void AddRefCount() {//增加引用计数
      _pmtx->lock();
      ++(*_pRefCount);
      _pmtx->unlock();
    }
    void Release() {//释放资源, 减去一次引用计数
      bool deleteFlag = 0;//判断是否需要释放资源, 真正的delete
      _pmtx->lock();
      if (--(*_pRefCount) == 0) {
        delete _ptr;
        delete _pRefCount;
        deleteFlag = 1;
      }
      _pmtx->unlock();
      if (deleteFlag) {
        delete _pmtx;//最后释放锁
      }
    }
  private:
    T* _ptr;//指向管理资源的指针
    int* _pRefCount;//引用计数指针
    mutex* _pmtx;//互斥锁
  };
}