matriz_compartilhada
Shared_array é semelhante a shared_ptr. Ele envolve o array dinâmico alocado pelo operador new[] no heap. Ele também usa o mecanismo de contagem de referência para fornecer um proxy para o array dinâmico, que pode existir por muito tempo no ciclo de vida de o programa e não será liberado até que não haja referência.Memória.
resumo da aula
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); //交换指针
};
A interface e a função de shared_array são quase as mesmas de shared_ptr, a principal diferença é:
1) O ponteiro p aceito pelo construtor deve ser o resultado de new[], não o resultado de new expression
2) A sobrecarga do operador Operator[] é fornecido, você pode acessar elementos com subscritos como arrays comuns
3) Não há *、->sobrecarga de operador, porque shared_array não contém um ponteiro comum
4) O destruidor usa delete[] para liberar recursos em vez de excluir.
uso
shared_array é como uma combinação de shared_ptr e scoped_array - tem as vantagens de shared_ptr e as desvantagens de scoped_array. A maioria das discussões sobre shared_ptr e scoped_array são adequadas para isso, então não vou explicar em detalhes aqui, mas apenas dar um pequeno exemplo:
#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); //离开作用域,自动删除动态数组
}
Além disso, tenha cuidado ao usar o operador sobrecarregado shared_array [], shared_array não fornece verificação de intervalo para índices de array e usar índices que excedem o tamanho dinâmico do array ou índices negativos levará a um comportamento indefinido horrível.
Shared_array tem recursos limitados. Na maioria dos casos, pode ser substituído por shared_ptr<std::vector>ou std::vector<shared_ptr>. Essas duas soluções têm melhor segurança e mais flexibilidade, e o preço pago é quase insignificante.
exemplo de código
#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);
}