c++标准库第四章一般概念

一、以前的头文件扩展名很多，包括.h, .hpp, .hxx，现在不需要扩展名：#include

二、#include也适用于C标准头文件，但必须采用前缀符合c，如：

#include 对应之前的

#include 对应之前的

三、以下namespace嵌套于std内：

1、std::rel_ops

2、std::chrono

3、std::placeholders

4、std::regex_constants

5、std::this_thread

四、使用c++标准库命名空间：

1、直接指定标识符 std::cout <<

2、使用using declaration using std::cout; cout <<

3、使用using directive using namespace std; cout <<,应该避免使用这种方式

五、 exception

------------logic_error

------------------------domain_error

------------------------invalid_argument

------------------------length_error

------------------------out_of_range

------------------------future_error

------------runtime_error

---------------------------system_error

---------------------------range_error

---------------------------overflow_error

---------------------------underflow_error

------------bad_cast

------------bad_typeid

------------bad_exception

------------bad_alloc

------------bad_weak_ptr

------------bad_function_call

六、针对语言支持二设计的异常类，此类异常用以支撑某些语言特性

1、bad_cast: 运行期间，当一个reference身上的“动态类型转换”失败时，dynamic_cast会抛出bad_cast异常

2、bad_typeid： 运行期类型辨识过程中，如果交给typeid操作符的实参是0或者空指针，typeid操作符会抛出bad_typeid异常

3、bad_exception： bad_exception异常被用来处理非预期的异常，可以由unexpected()抛出

七、针对逻辑错误而设计的异常类，所谓逻辑错误就是可以在程序中避免的错误

1、invalid_argument：表示无效实参

2、length_error：指出某个行为“可能超越最大容许大小”

3、out_of_range：指出实参值“不在预期范围内”

4、domain_error：指出领域范畴内错误

5、future_error：指出当使用非同步系统调用时发生的逻辑错误

八、针对运行期错误而设计的异常类，用来指出不在程序作用域内且不容易避免的错误

1、range_error：指出内部计算时发生区间错误

2、overflow_error：指出算术运算发生上溢

3、underflow_error： 指出算术运算发生下溢

4、system_error：指出因底层操作系统而发生的错误

5、bad_alloc：只要全局操作符new失败，bad_alloc就会被抛出，除非用new的nothrow版本

6、bad_weak_ptr： 当根据一个shared pointer 创建出一个weak_pointer的操作失败，bad_weak_ptr会被抛出

7、bad_function_call：当一个function外覆物被调用但其实没有目标时，bad_function_call会被抛出

九、针对标准库的IO库，有一个特别的异常类ios_base::failure。此类异常可能会在stream由于发生错误或遇上end-of-file而改变其状态时抛出

十、异常头文件

1、#include classes exception和bad_exception

2、#include logic error和runtime error

3、#include system error

4、#include out of memory

5、#include IO

6、#include async error和future error

7、#include bad_cast和bad_typeid

十一、所有标准异常都提供what()，某些异常类还提供code()。what()返回一个以null结束的byte string

十二、错误码：用来封装错误码值。错误状态：一种提供“错误描述的可移植性抽象层

十三、c++标准库为错误码和错误状态提供了两种不同的类型： class std::error_code, class std::error_condition

1、std::error::invalid_argument

2、std::future_error::no_state

十四、class std::system_error, class std::ios_base::failure, class std::_future_error都提供了额外的非虚成员函数code(),返回一个std::error_code对象

十五、c++标准库提供了一个将异常存储于类型为exception_ptr的对象中

1、current_exception()会返回excepton_ptr对象，指向当前正被处理的异常，该异常会保持有效，直到没有exception_ptr指向它

2、rethrow_exception(exptr)会重新抛出那个被存储的异常

十六、callable object（可被调用的对象）

1、一个函数

2、一个指向成员函数的指针

3、一个函数对象

4、一个lambda

十七、并发和多线程一般性规范：

1、一般而言，多个线程共享同一个程序库对象而其中至少一个线程改动该对象时，可能导致不明确行为

2、某个线程的对象构造期间，另一个线程使用了该对象，会导致不明确行为。析构同理

3、STL容器和容器适配器并发的只读访问时允许的。并发处理同一个容器的不同元素也时可以的

4、对标准stream进行格式化输入和输出的并发处理时可能的

5、atexit()和at_quick_exit()的并发调用是同步的

6、默认分配器的所偶成员函数，除了析构函数，其并发处理都被同步

十八、c++标准库在许多地方采用特殊对象处理内存的分配和归还，这个对象称为allocator(分配器)。Allocator表现出一种特殊内存模型，被当成一种用来把“内存需求”转换为“内存低级调用”的抽象层。如果在相同事件采用多个不同的allocator对象，便可以在同一个程序中采用不同的内存模型

 

// 以前的头文件扩展名很多，包括.h, .hpp, .hxx，现在不需要扩展名
#include 
//#include也适用于C标准头文件，但必须采用前缀符合c，如：
//#include  对应之前的
//#include  对应之前的
//以下namespace嵌套于std内
//std::rel_ops
//std::chrono
//std::placeholders
//std::regex_constants
//std::this_thread
#include 
#include 
#include 

//使用c++标准库：
//1、直接指定标识符 std::cout <<
//2 、使用using declaration  using std::cout; cout << 
//3、使用using directive using namespace std; cout <<,应该避免使用这种方式
using namespace std;

// exception
//------------logic_error
//------------------------domain_error
//------------------------invalid_argument
//------------------------length_error
//------------------------out_of_range
//------------------------future_error
//------------runtime_error
//---------------------------system_error
//---------------------------range_error
//---------------------------overflow_error
//---------------------------underflow_error
//------------bad_cast
//------------bad_typeid
//------------bad_exception
//------------bad_alloc
//------------bad_weak_ptr
//------------bad_function_call
//针对语言支持二设计的异常类，此类异常用以支撑某些语言特性
//1、bad_cast: 运行期间，当一个reference身上的“动态类型转换”失败时，dynamic_cast会抛出bad_cast异常
//2、bad_typeid： 运行期类型辨识过程中，如果交给typeid操作符的实参是0或者空指针，typeid操作符会抛出bad_typeid异常
//3、bad_exception： bad_exception异常被用来处理非预期的异常，可以由unexpected()抛出
//针对逻辑错误而设计的异常类，所谓逻辑错误就是可以在程序中避免的错误
//1、invalid_argument：表示无效实参
//2、length_error：指出某个行为“可能超越最大容许大小”
//3、out_of_range：指出实参值“不在预期范围内”
//4、domain_error：指出领域范畴内错误
//5、future_error：指出当使用非同步系统调用时发生的逻辑错误
//针对运行期错误而设计的异常类，用来指出不在程序作用域内且不容易避免的错误
//1、range_error：指出内部计算时发生区间错误
//2、overflow_error：指出算术运算发生上溢
//3、underflow_error： 指出算术运算发生下溢
//4、system_error：指出因底层操作系统而发生的错误
//5、bad_alloc：只要全局操作符new失败，bad_alloc就会被抛出，除非用new的nothrow版本
//6、bad_weak_ptr： 当根据一个shared pointer 创建出一个weak_pointer的操作失败，bad_weak_ptr会被抛出
//7、bad_function_call：当一个function外覆物被调用但其实没有目标时，bad_function_call会被抛出
//针对标准库的IO库，有一个特别的异常类ios_base::failure。此类异常可能会在stream由于发生错误或遇上end-of-file而改变其状态时抛出
//异常头文件
//#include  classes exception和bad_exception
//#include  logic error和runtime error
//#include  system error
//#include  out of memory
//#include  IO
//#include  async error和future error
//#include  bad_cast和bad_typeid
//所有标准异常都提供what()，某些异常类还提供code()。what()返回一个以null结束的byte string
//错误码：用来封装错误码值
//错误状态：一种提供“错误描述的可移植性抽象层
//c++标准库为错误码和错误状态提供了两种不同的类型： class std::error_code, class std::error_condition
//1、std::error::invalid_argument
//2、std::future_error::no_state
//class std::system_error, class std::ios_base::failure, class std::_future_error都提供了额外的非虚成员函数code(),返回一个std::error_code对象
/*class system_error : public runtime_error
{
public:
	virtual const char* what() const noexcept;
	const error_code& code() const noexcept;
};
class error_code
{
public:
	const error_category& category() const noexcept;
	int value() const noexcept;
	string message() noexcept; // 会返回一个相应信息，通常时what()为所有异常产生的信息的一部分
	explicit operator bool() const noexcept; // 返回是否有个错误码被设置
	error_condition default_error_conditon() const noexcept;
};
class error_conditon
{
public:
	const error_category& category() const noexcept;
	int value() const noexcept;
	string message() noexcept;
	explicit operator bool() const noexcept;
};
class error_category
{
public:
	virtual const char* name() const noexcept = 0; // 返回分类名称
	virtual string message(int ev) const = 0; // 返回相应信息
	virtual error_conditon default_error_condition(int ev) const noexcept; // 返回默认错误状态
};*/
//const error_category& generic_category() noexcept;  system_error
//const error_category& system_category() noexcept;  system_error
//const error_category& iostream_category() noexcept;  ios
//const error_category& future_category() noexcept;  future

/*template 
void processCodeException(const T& e)
{
	auto c = e.code();
	cout << "- category: " << c.category().name() << endl;
	cout << "- value: " << c.value() << endl;
	cout << "- msg: " << c.message() << endl;
	cout << "- def category: " << c.default_error_condition().category().name() << endl;
	cout << "- def value: " << c.default_error_condition().value() << endl;
	cout << "- def msg: " << c.default_error_condition().message() << endl;
}

void processException() 
{
	try {
		throw;
	}
	catch (const ios_base::failure& e) {
		cout << "I/O exception: " << e.what() << endl;
		processCodeException(e);
	}
	catch (const system_error& e) {
		cout << "system exception: " << e.what() << endl;
		processCodeException(e);
	}
	catch (const future_error& e) {
		cout << "future exception: " << e.what() << endl;
		processCodeException(e);
	}
	catch (const bad_alloc& e) {
		cout << "bad_alloc exception: " << e.what() << endl;
	}
	catch (const exception& e) {
		cout << "exception: " << e.what() << endl;
	}
}*/
//c++标准库提供了一个将异常存储于类型为exception_ptr的对象中
//current_exception()会返回excepton_ptr对象，指向当前正被处理的异常，该异常会保持有效，直到没有exception_ptr指向它
//rethrow_exception(exptr)会重新抛出那个被存储的异常

// callable object（可被调用的对象）
//1、一个函数
//2、一个指向成员函数的指针
//3、一个函数对象
//4、一个lambda

//并发和多线程一般性规范：
//1、一般而言，多个线程共享同一个程序库对象而其中至少一个线程改动该对象时，可能导致不明确行为
//2、某个线程的对象构造期间，另一个线程使用了该对象，会导致不明确行为。析构同理
//3、STL容器和容器适配器并发的只读访问时允许的。并发处理同一个容器的不同元素也时可以的
//4、对标准stream进行格式化输入和输出的并发处理时可能的
//5、atexit()和at_quick_exit()的并发调用是同步的
//6、默认分配器的所偶成员函数，除了析构函数，其并发处理都被同步

//c++标准库在许多地方采用特殊对象处理内存的分配和归还，这个对象称为allocator(分配器)
//Allocator表现出一种特殊内存模型，被当成一种用来把“内存需求”转换为“内存低级调用”的抽象层
//如果在相同事件采用多个不同的allocator对象，便可以在同一个程序中采用不同的内存模型

int main()
{
	
	return 0;
}