特微网站首页制作网站费用

一、异常处理手段

• 抛出异常：throw 异常

  • 作用：让调用者看见这个异常，如果调用者不理睬，就让调用者的调用者看见

• 接住异常: try {可能异常的code} catch(异常类型) {处理方式}

  • 异常类型：一般为const &，防止copy;

  • 如果 不确定异常类型，也可以用catch(...){处理方式}，并且在catch中仍可用throw；继续抛

二、标准异常类

• 都继承于 exception 这个基类
• 异常的类型：
  • bad_alloc
  • logic_error 
    • length_error
    • out_of_range (stl容器调用at)
    • domain_error
    • invalid_argument
  • runtime_error
    • range_error
    • overflow_error
    • underflow_error
  • bad_cast
• catch(...)一般写在异常类型的最后

例子：

#include <iostream>
#include <vector>void strcpy(char *dest, const char *source)
{if (!dest || !source)throw std::invalid_argument("Null Pointers pass to strcpy.");while (*source)*dest++ = *source;*dest = '\0';
}template <typename T>
class Array
{
public:Array(std::size_t n)try : m_size(n), m_data(new T[n]){}catch (const std::bad_alloc &ba){std::cout << "No enough memory." << std::endl;throw;}private:size_t m_size;int *m_data;
};int main()
{char *dest = nullptr;const char *source = "hello";try{strcpy(dest, source);}catch (const std::invalid_argument &e){std::cout << "invalid_argument" << std::endl;std::cout << e.what() << std::endl;}catch (...){std::cout << "catch" << std::endl;}return 0;
}

三、栈展开

栈展开作用: 销毁局部变量

四、构造函数try-catch

template <typename T>
class Array
{
public:Array(std::size_t n)try : m_size(n), m_data(new T[n])  //写法比较特殊{}catch (const std::bad_alloc &ba){std::cout << "No enough memory." << std::endl;throw;}private:size_t m_size;int *m_data;
};

五、异常安全保证

1. 不抛异常(Nothrow guarantee)：保证不抛出异常
2. 强异常安全保证(Strong guarantee)：抛出异常程序状态不变
3. 弱异常安全保证(Weak guarantee)：状态改变，但在有效状态

六、不抛出异常 noexcept 关键字可以让编译器进行更好的优化

• 如果函数声明了noexcept, 但还是抛出了一场，调用栈可能开解(直接崩溃)
  • note：移动构造 和 移动赋值 不声明为noexcept，比那一期是不敢用的
• noexcept的两种特殊用法：
  • noexcept(bool) : 相当于开关noexcept的作用，noexcept(true) = noexcept(bool);
  • noexcept(noexcept(std::swap(thing,other.thing))) : 这个noexcept是一个表达式。根据内部函数是够抛异常决定返回true/false

七、copy&swap

#include <vector>
#include <string>
#include <iostream>// class Buffer
// {
// private:
//     unsigned char *_buf;
//     int _capacity;
//     int _length;// public:
//     explicit Buffer(int capacity) : _capacity(capacity), _length(0)
//     {
//         std::cout << "Buffer(int capacity)" << std::endl;
//         // throw std::invalid_argument("=====");
//         _buf = capacity == 0 ? nullptr : new unsigned char[capacity]{};
//     }//     ~Buffer()
//     {
//         std::cout << "~Buffer()" << std::endl;
//         delete[] _buf;
//     }//     Buffer(const Buffer &buffer)
//     {
//         std::cout << "Buffer(const Buffer &buffer)" << std::endl;
//         this->_capacity = buffer._capacity;
//         this->_length = buffer._length;
//         // throw std::invalid_argument("=====");
//         this->_buf = new unsigned char[buffer._capacity];
//         std::copy(buffer._buf, buffer._buf + buffer._capacity, this->_buf);
//     }//     Buffer(Buffer &&buffer) noexcept
//     {
//         std::cout << "Buffer(Buffer &&buffer)" << std::endl;
//         this->_capacity = buffer._capacity;
//         this->_length = buffer._length;
//         this->_buf = buffer._buf;//         buffer._buf = nullptr;
//         buffer._capacity = 0;
//         buffer._length = 0;
//     }//     Buffer &operator=(const Buffer &buffer)
//     {
//         std::cout << "Buffer &operator=(const Buffer &buffer)" << std::endl;
//         if (this != &buffer)
//         {
//             this->_capacity = buffer._capacity;
//             this->_length = buffer._length;
//             delete[] this->_buf;
//             throw std::invalid_argument("....");
//             this->_buf = new unsigned char[buffer._capacity];
//             std::copy(buffer._buf, buffer._buf + buffer._capacity, this->_buf);
//         }
//         return *this;
//     }//     Buffer &operator=(Buffer &&buffer) noexcept
//     {
//         std::cout << "Buffer &operator=(Buffer &&buffer)" << std::endl;
//         if (this != &buffer)
//         {
//             this->_capacity = buffer._capacity;
//             this->_length = buffer._length;
//             delete[] this->_buf;
//             this->_buf = buffer._buf;//             buffer._buf = nullptr;
//             buffer._capacity = 0;
//             buffer._length = 0;
//         }
//         return *this;
//     }//     bool write(unsigned char value) noexcept
//     {
//         if (_length == _capacity)
//             return false;
//         _buf[_length++] = value;
//         return true;
//     }
// };class Buffer
{
private:unsigned char *_buf;int _capacity;int _length;public:explicit Buffer(int capacity) : _capacity(capacity), _length(0){_buf = capacity == 0 ? nullptr : new unsigned char[capacity];}~Buffer(){delete[] _buf;}friend void swap(Buffer &lhs, Buffer &rhs);Buffer(const Buffer &buffer) : _capacity(buffer._capacity),_length(buffer._length),_buf(_capacity == 0 ? nullptr : new unsigned char[_capacity]){std::copy(buffer._buf, buffer._buf + buffer._capacity, this->_buf);}Buffer(Buffer &&buffer) noexcept : Buffer(0){swap(buffer, *this);}Buffer &operator=(Buffer buffer) // 会做一次拷贝构造/移动构造，根据传入参数类型确定{swap(buffer, *this);return *this;}bool write(unsigned char value) noexcept{if (_length == _capacity)return false;_buf[_length++] = value;return true;}
};void swap(Buffer &lhs, Buffer &rhs)
{using std::swap;swap(lhs._buf, rhs._buf);swap(lhs._capacity, rhs._capacity);swap(lhs._length, rhs._length);
}class BitMap
{
public:explicit BitMap(size_t size) : _buffer(size) {}static void Swap(BitMap &lhs, BitMap &rhs){using std::swap;swap(lhs._buffer, rhs._buffer);}private:Buffer _buffer;
};int main()
{int *a = nullptr;Buffer buffer(10);buffer.write(52);buffer.write(37);Buffer buffer1(20);buffer1.write(20);buffer1.write(111);swap(buffer, buffer1);// try// {//     buffer1 = buffer;// }// catch (...)// {//     std::cout << "error" << std::endl;// }// buffer.write(52);// buffer.write(37);// Buffer buffer1(20);// buffer1.write(20);// buffer1.write(111);// try// {//     buffer1 = buffer;// }// catch (...)// {//     std::cout << "error" << std::endl;// }// std::cout << "over" << std::endl;
}// Buffer buffer = Buffer(10);
// buffer = Buffer(16);