timer
timer
- 毫秒级别的精度。
- <boost/timer.hpp>
- using namespace boost;
|
1 2 3 4 5 6 7 8 9 10 11 |
// 开始计时 timer t; // 可度量的最大时间，小时为单位 t.elapsed_max(); // 可度量的最小时间，秒为单位 t.elapsed_min(); // 已经流逝的时间 t.elapsed(); |
progress_timer
- 派生自timer。
- 会在析构时自动输出流逝的时间。
- <boost/progress.hpp>
- using namespace boost;
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
int main() { boost::progress_timer t; // do other things } void test() { { boost::progress_timer t; } // ... { boost::progress_timer t; } } |
|
1 2 3 4 5 6 7 |
// 重定向输出 stringstream ss; { boost::progress_timer t(ss); } std::cout << ss.str(); |
progress_display
- 在控制台显示程序的执行进度。
- <boost/progress.hpp>
- using namespace boost;
- 缺陷：无法把进度显示输出和程序的输出分离。
|
1 2 3 |
// 传入进度基数 std::vector<int> v(100); progress_display pd(v.size()); |
data_timer
- 格力高利历：支持从1400-01-01到9999-12-31。
special_values
- 枚举
- pos_infin
- neg_infin
- not_a_date_time
- min_date_time
- max_date_time
gregorian
- <boost/date_time/gregorian/gregorian.hpp>
- using namespace boost::gregorian;
posix_time
- <boost/date_time/posix_time/posix_time.hpp>
- using namespace boost::posix_time;
date
- 以天为单位表示时间。
- to_simple_string
- YYYY-mmm-DD
- to_iso_string
- YYYYMMDD
- to_iso_extended_string
- YYYY-mmm-DD
- to_tm
- date_from_tm
|
1 2 3 4 5 6 7 8 9 10 |
// 无效的 date d1; date d2(2020,Jan, 1); date d3(2020, 1, 1); date d4(d2); date d5 = from_string("1993-10-05"); date d6(from_string("1993-10-05")); date d7 = from_undelimited_string("20011118"); |
day_clock
- local_day()返回当天的本地日期。
- universal_day()返回当天的UTC日期。
|
1 2 |
day_clock::local_day(); day_clock::universal_day(); |
date_period
- 日期周期。
time_duration
- 时间长度。
ptime
- 处理时间。
内存管理
RAII机制
- 在类的构造函数里申请资源，然后使用，最终在析构函数中释放资源。
智能指针
- 智能指针可以在退出作用域时-不管是正常流程离开还是因异常离开，总调用delete来析构在堆上动态分配的对象。
auto_ptr
- 接受new操作符或对象工厂创建出的对象指针作为参数，代理原始指针。
- 当退出作用域或发生异常时，C++语言会保证auto_ptr对象销毁，调用析构函数，使用delete操作符删除原始指针并释放资源。
- 缺陷
- 不要使用auto_ptr指向基本数据类型的对象。
- 不要使两个auto_ptr指向同一个对象。
- 不要使用auto_ptr对象保存动态分配数组的指针。
- 不要将auto_ptr对象存储在容器中。
因为auto_ptr的复制和赋值具有破坏性，不满足容器要求。（赋值或复制后，两个对象必须具有相同值）
scoped_ptr
-
include <boost/smart_ptr.hpp>
- 一个类似auto_ptr和unique_ptr的智能指针，保证了new操作符在堆上分配的动态对象在任何时候都能被正确删除。
- 但是，一旦scoped_ptr获取了对象的管理权，我们无法再从它那里取回来。不允许拷贝和赋值。
- 如果一个类持有scoped_ptr的成员变量，那么它也会是不可拷贝和赋值的。
|
1 |
scoped_ptr<string> sp(new string("test")); |
scoped_array
shared_ptr
概述
- 和scoped_ptr一样包装了new操作符在堆上分配的对象，但它实现的是引用计数型的智能指针，可以自由拷贝和赋值，当引用计数为0的时候，才删除被包装的动态分配的对象。
- shared_ptr的reset的作用是对引用计数减1，除非引用计数为0，否则不会发生删除操作。
- unique在shared_ptr是指针的唯一所有者时返回true，和use_count相比，更快，更可靠。
- shared_ptr提供了基本的线程安全保证，集被多个线程安全读取，但对其他的访问形式是未定义的。
- make_shared
- shared_ptr
能够存储void型的指针，而void\型的指针，可以指向任意类型，因此，shared_ptr 就像一个泛型的指针容器一样，拥有容纳任意类型的能力。
应用
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
// 桥接 class sample { public: sample(); void print(); private: class impl; shared_ptr<impl> p_; }; class sample::impl { public: void print() { std::cout << "impl print" << std::endl; } }; sample::sample() : p_(new impl) {} void sample::print() { p_->print(); } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
// 工厂 class abstract { public: void f() = 0; void g() = 0; protected: virtual ~abstract() = default; }; class impl : public abstract { public: impl() = default; virtual ~impl() = default; public: void f() override { std::cout << "class impl f()" << std::endl; } void g() override { std::cout << "class impl g()" << std::endl; } }; shared_ptr<abstract> create() { return make_shared<impl>(); } int main() { auto p = create(); p->f(); p->g(); } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
// 定制删除器 class socket_t {...}; socket_t* open_socket() { return new socket_t(); } void close_socket(socket_t* s) { // ... } socket_t * s = open_socket(); shared_ptr<socket_t> p(s, close_socket); |
|
1 2 3 4 5 6 7 8 9 10 |
// 高级定制删除器 void any_func(void* p) { // do something } int main() { // 退出作用域时，将指向any_func. shared_ptr<void> p(nullptr, any_func); } |
shared_array
weak_ptr
概述
- weak_ptr是为了配合shared_ptr而引入的一种智能指针，它更像是个shared_ptr的助手而不是智能指针，因为它不具备普遍指针的行为。
- weak_ptr可以从一个shared_ptr或另一个weak_ptr对象构造，获得资源的观测权。它的构造不会引起指针引用计数的增加。析构也不会减少引用计数的值。
- 不过可以通过它的lock函数从被观测的shared_ptr获得一个shared_ptr对象，把弱关系转变为强关系，从而操作资源。
当expired为true的时候，lock获得的是一个存储空指针的shared_ptr。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
shared_ptr<int> sp(new int(10)); assert(sp.use_count() == 1); weak_ptr<int> wp(sp); assert(wp.user_count() == 1); // 判断weak_ptr观察的对象是否失效 if (!wp.expired()) { shared_ptr<int> sp2 = wp.lock(); *sp2 = 100; assert(wp.use_count() == 2); } // sp2析构，引用计数变为1 assert(wp.use_count() == 1); sp.reset(); // shared_ptr失效 assert(wp.expired()); assert(!wp.lock()); // 空指针 |
intrusive_ptr
- 另外一种引用技术型智能指针。
- 不直接管理引用计数，而是通过intrusive_ptr_add_ref来增加引用计数，通过intrusive_ptr_release来减少引用计数来简介管理。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
struct counted_data { int count_ = 0; // ... }; void intrusive_ptr_add_ref(counted_data* p) { ++p->count_; } void intrusive_ptr_release(counted_data* p) { if (--p->count_ == 0) { delete p; } } |
pool
概述
- 内存池预先分配了一块大的内存空间，然后就可以在其中使用某种算法高效快速的自定制内存分配。
- pool库在需要大量地考虑分配/释放小对象时很有效率，而且完全不需要考虑delete。
简单的pool
- 构造传一个size_t的requested_size指示每次分配内存块的大小（不是内存池的大小）。
- malloc分配内存块。
- ordered_malloc在分配内存的同时合并空闲块链表。
- release_memory让内存池释放所有未被分配的内存。
- purge_memory强制释放pool所持有的所有内存，不管内存是否在被使用。
- 只能作为普通数据类型的内存池。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
int main() { pool<> pl(sizeof(int)); // 必须把void*转成需要的类型 int *p = static_cast<int*>(pl.malloc()); assert(pl.is_from(p)); pl.free(p); for (int i = 0; i < 100; ++i) { pl.ordered_malloc(10); } } |
object_pool
- object_pool是用于类实例（对象）的内存池。会在析构时对所有已经分配的内存块调用析构函数。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
struct test_class { public: int a, b, c; test_class(int x = 1, int y = 2, int z = 3) : a(x), b(y), c(z) {} }; int main() { object_pool<test_class> pl; auto p = pl.malloc(); assert(pl.is_from(p)); p = pl.construct(7, 8, 9); object_pool<string> pls; for (int i = 0; i < 10; ++i) { string* ps = pls.construct("test"); std::cout << *ps << std::endl; } } |
singleton_pool
|
1 2 3 4 5 6 7 |
struct pool_tag {}; typedef singleton_pool<pool_tag, sizeof(int)> spl; int main() { int* p = (int*)spl::malloc(); spl::release_memory(); } |
pool_alloc
- 提供两个可用于标准容器模板参数的内存分配器。
- pool_alloc
- fast_pool_allocator
- 当内存分配失败时会抛出std::bad_alloc异常。
|
1 2 |
vector<int, pool_allocator<int>> v; v.push_back(10); |
本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！
你可能也喜欢
- ♥ C++程序高级调试与优化_第一篇07/20
- ♥ STL_queue06/07
- ♥ 包管理器：设计与实现09/18
- ♥ C++_函数模板、类模板、特化、模板元编程、SFINAE、概念06/22
- ♥ C++_多态、类型转换、数据段、BSS段、类型视图06/21
- ♥ Effective C++_第三篇07/01