人妻精品久久无码区,99久久无码一区人妻,性做久久久久久久久浪潮

个�h��译Beyond the C++ Standard Library -2

chenchen — Sat, 31 Dec 2005 09:23:00 GMT

shared_ptr
Header: "boost/shared_ptr.hpp"

几乎全部有效�E�序都需要一些引用记�?reference-counted)形式的智能指�?�q�些只能指针使我们不再需要自己写复杂的逻辑来控制被�׃�n对象的生命期.当引用记数降�?,没有对象对这个被�׃�n对象感兴��?所以它自动delete.引用记数��指针被分�c�Mؓ侵入式和非��R入式.�c�L��式提供一个确定的功能函数或者数据成员来��理引用记数.那意味着设计�c�d��有预见性的可以与��R入式,引用记数��指针�c?或者改�q�型共同工作.非��R入式,引用记数��指针不需要管理�Q何类�?引用记数��指针假设内存的所有权与存储他们的指针相关�?在没有智能指针帮助下使用�׃�n对象的问题是必须有�h最�l�delete�׃�n内存.谁做,何时�?没有引用记数��指针,一个外部的生命期管理必��d��加于被管理的内存,它典型的表达了所有权集合之间存在很强的互�怾�附关�p?那样妨碍了可重用性和增加了复杂度.

被管理的�c�L��许有一个属性��它能成�ؓ一个优�U�的候选来和引用记数智能指针一起��?比如,事实�?它复制开销很大,或者它表示需要被多个实例�׃�n,合理的共享所有权.�q�有的情况不存在一个明��的�׃�n资源拥有�?应用引用记数��指针佉K��要在对象间分享一个共享资源成为可�?同样在标准库中��没有危险和没有泄露的条�g下存储对象指针成为可�?��其面对异常时或者当从容器中�U�除元素�?当你在容器中存储指针�?你能得到多态的优势,效率改良(如果复制需要很大花费的�?,�q�具备存储多个相同对象的能力,兌��容器的专门检�?

在你有理由�ƈ军_��使用引用记数��指针�?怎样选择使用侵入式还是非侵入式的设计?非��R入式
几乎��L��较好的选择因�ؓ它的一般适用�?对现存代码媄响少,灉|��.你可以��用非侵入�?引用记数��指针寚w��些你希望保持不变的类.通常的方法是改编一个类来和侵入式的一起工�?引用记数��指针是从引用记数基类�z��出来�?乍一看它的变化或�怼�随着更多的开销.但是臛_��,它增加了�怺�依存关系和加��Z��可重用�?它同样增加了对象大小,或在一些范围内限制了可用�?

一个shared_ptr可以由原生指�?另一个shared_ptr,一个std::auto_ptr,或者一个boost::weak_ptr创徏.它同样可以传递第二个实参到shared_ptr的constructor,当做释放�?
它会被最后调用来释放被共享资�?�q�是非常有用的对于管理那些不是通过new分配和delete销毁的资源(我们�E�后��看��C��些创建用户释放者的例子).shared_ptr被创建后,它会被像普通指针一��L��使用,没有被明��删除的情况下回昄��异常.

�q�是shared_ptr的一个部分纲�?最重要的成员和自由函数被列出来,随后��简短的讨论.

namespace boost {

template class shared_ptr {
public:
template explicit shared_ptr(Y* p);
template shared_ptr(Y* p,D d);

~shared_ptr();

    shared_ptr(const shared_ptr & r);
    template explicit
      shared_ptr(const weak_ptr& r);
    template explicit shared_ptr(std::auto_ptr& r);

shared_ptr& operator=(const shared_ptr& r);

    void reset();

    T& operator*() const;
    T* operator->() const;
    T* get() const;

bool unique() const;
long use_count() const;

operator unspecified-bool-type() const;

void swap(shared_ptr& b);
};

template
shared_ptr static_pointer_cast(const shared_ptr& r);
}

Members

template explicit shared_ptr(Y* p);

�q�个constructor接管参数指针p的所有权.失参p必须是一个有效的Y的指�?创徏后引用记数被设�ؓ1.仅当constructor为std::bad_alloc时抛出异�?它仅在引用记数没分配真种不太可能的情况下发生).

template shared_ptr(Y* p,D d);

此constructor有俩个参�?�W�一个是shared_ptr接管所有权的资�?�W�二个是负责释放资源的对象当shared_ptr被销�?被存储的资源被传递给对象以d(p).p的有效值取决于d.如果reference counter不能被分�?shared_ptr抛出std::bad_alloc�c�d��的异�?

shared_ptr(const shared_ptr& r);

在r中被存储资源通过创徏shared_ptr对象被分�?reference count�?.�q�个copy constructor不抛出异�?

template explicit shared_ptr(const weak_ptr& r);

从weak_ptr(在本章后面介�l?创徏一个shared_ptr.它��weak_ptr��h��thread-safe的用�?因�ؓ被共享资源的reference count��通过weak_ptr的参数自�?weak_ptr不会影响被共享资源的reference count).如果weak_ptr是空的话(r.use_count()==0),shared_ptr抛出bad_weak_ptr�c�d��的异�?

template shared_ptr(std::auto_ptr& r);

�q�个construction从auto_ptr接过r存储对象的所有权通过存储一个指针副本�ƈ释放原auto_ptr.创徏后reference count�?.代表r,当然,耗尽内存的情况下,reference counter无法分配��抛出std::bad_alloc

~shared_ptr();

shared_ptr的destructor减少reference count 1.如果count�?,被指资源delete.delete指针��通过调用operator delete或者��用用��h��供的释放者对象来销�?此对象将被存储的指针作�ؓ它的唯一参数调用.destructor不抛出异�?

shared_ptr& operator=(const shared_ptr& r);

copy assignment operator�׃�nr中的资源�q�停止共享当前被�׃�n的资�?此copy assignment operator不抛出异�?/P>

void reset();

此函数被用于停止�׃�n被存储指针的所有权.被共享资源的reference count�?.

T& operator*() const;

此operator�q�回一个被存储指针所指向对象的引�?如果指针为null,operator*��D��未定义行�?此operator不抛出异�?/P>

T* operator->() const;

此operator�q�回被存储的指针.同operator*一起��smart pointer看�v来想普通指�?此operator不抛出异�?/P>

T* get() const;

get function是检查被存储指针是否为null的首选方�?在null情�Ş下operator* and operator->��D��为定义行�?.注意它同样可以测试一个shared_ptr是否包含一个有效指针通过使用暗式Boolean�c�d��转换.此function不抛出异�?

bool unique() const;

此函数返回true当shared_ptr是被存储指针的唯一拥有�?否则,�q�回false.unique不抛出异�?

long use_count() const;

此函数返回指针的reference count.在调试用途中��其有用,因�ؓ他能被用来获得reference count的简短信息在执行�E�序的关键点�?保守的��用它.��Z��使一些shared_ptr的接口可以执�?计算reference count也许有很大开销甚至是不可能�?此函��C��抛出异常.

operator unspecified-bool-type() const;

它暗式�{换�ؓ一个类�?unspecified-bool-type,使用Boolean来测试一个smart pointer成�ؓ可能.如果当前存储一个有效指针则为true,否则,则�ؓfalse.此�{换函数返回的�c�d��是�ؓ规定�?使用bool作�ؓ�q�回�c�d��允�怸�些无意义的操�?代表性的,使用safe bool idiom来实�?的确是一个漂亮的办法来确保仅当适当的逻辑��试才能被��?此函��C��抛出异常.

void swap(shared_ptr& b);

它有时方便的交换俩个shared_ptrs的内�?swap函数交换被存储的指针(和它们的reference counts).此函��C��抛出异常.

Free Functions

template
shared_ptr static_pointer_cast(const shared_ptr& r);

执行一个static_cast从被存储的指针到shared_ptr,我们可以��查指针然后�{换它,但是我们不能存储它在另外一个shared_ptr�?新的shared_ptr��认为它是指针关联的资源的第一个管理�?它可以被补救通过static_pointer_cast.使用�q�个函数��保指针剩余的reference count不变�?static_pointer_cast不抛出异�?

Usage

shared_ptr解决的主要问题是在正��是旉��delete被多个用户共享的资源.�q�里有个直观的例�?
有俩个classes, A和B,�׃�n一个int实例.使用boost::shared_ptr,你需要包�?boost/shared_ptr.hpp".

#include "boost/shared_ptr.hpp"
#include

class A {
boost::shared_ptr no_;
public:
A(boost::shared_ptr no) : no_(no) {}
void value(int i) {
*no_=i;
}
};

class B {
boost::shared_ptr no_;
public:
B(boost::shared_ptr no) : no_(no) {}
int value() const {
return *no_;
}
};

int main() {
    boost::shared_ptr temp(new int(14));
    A a(temp);
    B b(temp);
    a.value(28);
    assert(b.value()==28);
}

classes A和B都存储一个shared_ptr.当创造A和B的实例时,shared_ptr temp被传递进了他们的constructor.�q�以为着�q�三个shared_ptr,a,b,和temp现在引用一个共同的int实例.我们用指针达��C��分��n一个int的目�?A和B��计��出它应该在何时被delete.在本例中,reference count�?直到main的结�?所有的shared_ptr跛_��作用�?减少count知道�?,允许最后一个smart pointers来delete�׃�n的int.

chenchen 2005-12-31 17:23 发表评论

个�h��译Beyond the C++ Standard Library

chenchen — Fri, 30 Dec 2005 12:43:00 GMT

scoped_array

Header : `"boost/scoped_array.hpp"`

`对于使用动态分配的数祖来说vector�l�常是我们最好的选择.但是有俩个情况��用普通数�l�更为妥�?`

`1:优化,vector带来�q�大的开销在体�U�和速度�?`

`2:表达的意�?使用长度固定的数�l?/TT>`

动态数�l�暴露出和普通指针一��L��危险,伴随着调用delete操作�W�来代替delete[]操作�W�的错误, 我在很多地方看到�q�这个错�?只一个就不敢惌��,何况应用的如此广泛在容器�cȝ��所有权�? scoped_array用于数组�c�M��scoped_ptr作用于单个对象的指针,它delete内存,不同之处是scoped_array 使用操作�W�delete[]. scoped_array是一个单独类而不是scoped_ptr的特化是因�ؓ使用metaprogramming技术来分别单个对象的指针和数组指针是不可能�? 不管如何努力的去区别,没有人发��C��个可靠的�Ҏ��来实�?因�ؓ数组�c�d��太容易退化到指针�c�d��q�不带有

`��M��c�d��转化信息来说明它到底指像的是什么类�?�l�果你有责�Q采用scoped_array而不�?TT>scoped_ptr,`

`��像你必��M��用delete[] operator而不是delete operator.优势是scoped_array帮你处理delete,`

`�q�且提醒你它处理的是数组,原生指针却做不到此点.`

`scoped_array和scoped_ptr和相�?不同的是它提供operator[]来模仿原生数�l? scoped_array优于原始,动态分配数�l�之一.它管理动态数�l�的生命�?与scoped_ptr如何��理所指向对象的生命期�c�M��,虽然如此,但很多情况下,std::vector却更可取,因�ؓ它更灉|��,更强�? 当你需要固定长度的数组,使用scoped_array而不�?/FONT>std::vector.`

chenchen 2005-12-30 20:43 发表评论

chenchen — Wed, 28 Dec 2005 05:35:00 GMT

class subtractive_rng : public unary_function {
private:
unsigned int _M_table[55];
size_t _M_index1;
size_t _M_index2;
public:
unsigned int operator()(unsigned int __limit) {
    _M_index1 = (_M_index1 + 1) % 55;
    _M_index2 = (_M_index2 + 1) % 55;
    _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
    return _M_table[_M_index1] % __limit;
}

void _M_initialize(unsigned int __seed)
{
    unsigned int __k = 1;
    _M_table[54] = __seed;
    size_t __i;
    for (__i = 0; __i < 54; __i++) {
        size_t __ii = (21 * (__i + 1) % 55) - 1;
        _M_table[__ii] = __k;
        __k = __seed - __k;
        __seed = _M_table[__ii];
    }
    for (int __loop = 0; __loop < 4; __loop++) {
        for (__i = 0; __i < 55; __i++)
            _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
    }
    _M_index1 = 0;
    _M_index2 = 31;
}

subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
subtractive_rng() { _M_initialize(161803398u); }
};

chenchen 2005-12-28 13:35 发表评论

stl 函数对象

chenchen — Tue, 27 Dec 2005 13:14:00 GMT

template
struct _Identity : public unary_function<_Tp,_Tp> {
const _Tp& operator()(const _Tp& __x) const { return __x; }
};

template struct identity : public _Identity<_Tp> {};

//验证模板参数是不是一个函数对象类�?BR>
template
struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> {
const typename _Pair::first_type& operator()(const _Pair& __x) const {
return __x.first;
}
};

template
struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type>
{
const typename _Pair::second_type& operator()(const _Pair& __x) const {
return __x.second;
}
};

template struct select1st : public _Select1st<_Pair> {};
template struct select2nd : public _Select2nd<_Pair> {};

//忽略模板参数为pair�c�d��所包含的相应参�?�W�一个参数和�W�二个参�?

template
struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {
_Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }
};

template
struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {
_Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
};

template
struct project1st : public _Project1st<_Arg1, _Arg2> {};

template
struct project2nd : public _Project2nd<_Arg1, _Arg2> {};

//忽略调用�q�算�W�时相应的参�?/P>

template
struct _Constant_void_fun {
typedef _Result result_type;
result_type _M_val;

_Constant_void_fun(const result_type& __v) : _M_val(__v) {}
const result_type& operator() const { return _M_val; }
};

template
struct _Constant_unary_fun {
typedef _Argument argument_type;
typedef _Result result_type;
result_type _M_val;

_Constant_unary_fun(const result_type& __v) : _M_val(__v) {}
const result_type& operator()(const _Argument&) const { return _M_val; }
};

template
struct _Constant_binary_fun {
typedef _Arg1 first_argument_type;
typedef _Arg2 second_argument_type;
typedef _Result result_type;
_Result _M_val;

_Constant_binary_fun(const _Result& __v) : _M_val(__v) {}
const result_type& operator()(const _Arg1&, const _Arg2&) const {
return _M_val;
}
};

//�q�回一个普通变量的const副本,无论参数��Z��,只返回同一个值的函数对象

template
struct constant_void_fun : public _Constant_void_fun<_Result> {
constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {}
};

template class _Argument __STL_DEPENDENT_DEFAULT_TMPL(_Result)>
struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument>
{
constant_unary_fun(const _Result& __v)
: _Constant_unary_fun<_Result, _Argument>(__v) {}
};

template           class _Arg1 __STL_DEPENDENT_DEFAULT_TMPL(_Result),
          class _Arg2 __STL_DEPENDENT_DEFAULT_TMPL(_Arg1)>
struct constant_binary_fun
: public _Constant_binary_fun<_Result, _Arg1, _Arg2>
{
constant_binary_fun(const _Result& __v)
    : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
};

//__STL_DEPENDENT_DEFAULT_TMPL 是一个宏�Q�意思是如果�~�译器不支持默认模板参数�Q�则使用上一�U�模板参�?BR>
template
inline constant_void_fun<_Result> constant0(const _Result& __val)
{
return constant_void_fun<_Result>(__val);
}

template
inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val)
{
return constant_unary_fun<_Result,_Result>(__val);
}

template
inline constant_binary_fun<_Result,_Result,_Result>
constant2(const _Result& __val)
{
return constant_binary_fun<_Result,_Result,_Result>(__val);
}

//函数�q�回一个只�q�回帔R��和输入参数无关的函数对象

chenchen 2005-12-27 21:14 发表评论

人妻精品久久无码区,99久久无码一区人妻,性做久久久久久久久浪潮

个�h��译Beyond the C++ Standard Library -2

个�h��译Beyond the C++ Standard Library

scoped_array

Header : `"boost/scoped_array.hpp"`

`对于使用动态分配的数祖来说vector�l�常是我们最好的选择.但是有俩个情况��用普通数�l�更为妥�?`

`1:优化,vector带来�q�大的开销在体�U�和速度�?`

`2:表达的意�?使用长度固定的数�l?/TT>`

`动态数�l�暴露出和普通指针一��L��危险,伴随着调用delete操作�W�来代替delete[]操作�W�的错误,`

`我在很多地方看到�q�这个错�?只一个就不敢惌��,何况应用的如此广泛在容器�cȝ��所有权�?`

`scoped_array用于数组�c�M��scoped_ptr作用于单个对象的指针,它delete内存,不同之处是scoped_array`

`使用操作�W�delete[].`

`scoped_array是一个单独类而不是scoped_ptr的特化是因�ؓ使用metaprogramming技术来分别单个对象`

`的指针和数组指针是不可能�?`

`不管如何努力的去区别,没有人发��C��个可靠的�Ҏ��来实�?因�ؓ数组�c�d��太容易退化到指针�c�d��q�不带有`

`��M��c�d��转化信息来说明它到底指像的是什么类�?�l�果你有责�Q采用scoped_array而不�?TT>scoped_ptr,`

`��像你必��M��用delete[] operator而不是delete operator.优势是scoped_array帮你处理delete,`

`�q�且提醒你它处理的是数组,原生指针却做不到此点.`

stl 函数对象

人妻精品久久无码区,99久久无码一区人妻,性做久久久久久久久浪潮

个�h���译Beyond the C++ Standard Library -2

个�h���译Beyond the C++ Standard Library

scoped_array

Header : "boost/scoped_array.hpp"

对于使用动态分配的数祖来说vector�l�常是我们最好的选择.但是有俩个情况��用普通数�l�更为妥�?

1:优化,vector带来�q�大的开销在体�U�和速度�?

2:表达的意�?使用长度固定的数�l?/TT>

动态数�l�暴露出和普通指针一��L��危险,伴随着调用delete操作�W�来代替delete[]操作�W�的错误,

我在很多地方看到�q�这个错�?只一个就不敢惌���,何况应用的如此广泛在容器�cȝ��所有权�?

scoped_array用于数组�c�M��scoped_ptr作用于单个对象的指针,它delete内存,不同之处是scoped_array

使用操作�W�delete[].

scoped_array是一个单独类而不是scoped_ptr的特化是因�ؓ使用metaprogramming技术来分别单个对象

的指针和数组指针是不可能�?

不管如何努力的去区别,没有人发��C��个可靠的�Ҏ��来实�?因�ؓ数组�c�d��太容易退化到指针�c�d���q�不带有

��M���c�d��转化信息来说明它到底指像的是什么类�?�l�果你有责�Q采用scoped_array而不�?TT>scoped_ptr,

���像你必���M��用delete[] operator而不是delete operator.优势是scoped_array帮你处理delete,

�q�且提醒你它处理的是数组,原生指针却做不到此点.

stl 函数对象

个�h��译Beyond the C++ Standard Library -2

个�h��译Beyond the C++ Standard Library

Header : `"boost/scoped_array.hpp"`

`对于使用动态分配的数祖来说vector�l�常是我们最好的选择.但是有俩个情况��用普通数�l�更为妥�?`

`1:优化,vector带来�q�大的开销在体�U�和速度�?`

`2:表达的意�?使用长度固定的数�l?/TT>`

`动态数�l�暴露出和普通指针一��L��危险,伴随着调用delete操作�W�来代替delete[]操作�W�的错误,`

`我在很多地方看到�q�这个错�?只一个就不敢惌��,何况应用的如此广泛在容器�cȝ��所有权�?`

`scoped_array用于数组�c�M��scoped_ptr作用于单个对象的指针,它delete内存,不同之处是scoped_array`

`使用操作�W�delete[].`

`scoped_array是一个单独类而不是scoped_ptr的特化是因�ؓ使用metaprogramming技术来分别单个对象`

`的指针和数组指针是不可能�?`

`不管如何努力的去区别,没有人发��C��个可靠的�Ҏ��来实�?因�ؓ数组�c�d��太容易退化到指针�c�d��q�不带有`

`��M��c�d��转化信息来说明它到底指像的是什么类�?�l�果你有责�Q采用scoped_array而不�?TT>scoped_ptr,`

`��像你必��M��用delete[] operator而不是delete operator.优势是scoped_array帮你处理delete,`

`�q�且提醒你它处理的是数组,原生指针却做不到此点.`