tableau_partagé
Shared_array est similaire à shared_ptr. Il encapsule le tableau dynamique alloué par l'opérateur new[] sur le tas. Il utilise également le mécanisme de comptage de références pour fournir un proxy pour le tableau dynamique, qui peut exister pendant une longue période dans le cycle de vie de le programme et ne sera pas libéré tant qu'il n'y aura pas de référence.
résumé de la classe
template<class T>
class shared_array {
public:
explicit shared_array(T * p - 0); //构造函数
template<class D> shared_array(T * p, D d);
~shared_array(); //析构函数
shared_array(shared_array const & r); //拷贝构造函数
shared_array & operator=(shared_array const & r); //拷贝赋值
void reset(T * p = 0); //重置指针
template<class D> void reset(T* p, D d);
T & operator[](std::ptrdiff_t i) const() const; //重载操作符[]
T * get() const; //获得原始指针
bool unique() const; //是否唯一
long use_count() const; //引用计数
void swap(shared_array<T> & b); //交换指针
};
L'interface et la fonction de shared_array sont presque les mêmes que shared_ptr, la principale différence est :
1) Le pointeur p accepté par le constructeur doit être le résultat de new[], pas le résultat de new expression
2) La surcharge de l'opérateur Operator[] est fourni, vous pouvez accéder aux éléments avec des indices comme des tableaux ordinaires
3) Il n'y a pas *、->de surcharge d'opérateur, car shared_array ne contient pas de pointeur ordinaire
4) Le destructeur utilise delete[] pour libérer des ressources au lieu de supprimer.
usage
shared_array est comme une combinaison de shared_ptr et scoped_array - il présente à la fois les avantages de shared_ptr et les inconvénients de scoped_array. La plupart des discussions sur shared_ptr et scoped_array lui conviennent, je ne vais donc pas l'expliquer en détail ici, mais donner juste un petit exemple :
#include <boost/smart_ptr.hpp>
using namespace boost;
void case1()
{
int* arr = new int[100]; //一个动态数组
scoped_array<int> sa(p); //shared_array代理动态数组
assert(sa.unique()); //唯一持有指针
shared_array<int> sa2 = sa; //共享数组,引用计数增加
assert(sa2.use_count() == 2); //引用计数增加
sa[0] = 10; //可以使用operator[]访问元素
assert(sa2[0] == 10); //离开作用域,自动删除动态数组
}
De plus, soyez prudent lorsque vous utilisez l'opérateur surchargé shared_array [], shared_array ne fournit pas de vérification de plage pour les indices de tableau, et l'utilisation d'indices qui dépassent la taille du tableau dynamique ou d'indices négatifs entraînera un comportement indéfini horrible.
Shared_array a des capacités limitées. Dans la plupart des cas, il peut être remplacé par shared_ptr<std::vector>ou std::vector<shared_ptr>. Ces deux solutions ont une meilleure sécurité et plus de flexibilité, et le prix payé est presque négligeable.
exemple de code
#include <iostream>
using namespace std;
#include <boost/smart_ptr.hpp>
using namespace boost;
int main()
{
int* p = new int[100];
shared_array<int> sa(p);
assert(sa.unique());
shared_array<int> sa2 = sa;
assert(sa2.use_count() == 2);
sa[0] = 10;
assert(sa2[0] == 10);
}