Const colocação para parar a edição do ponteiro de dados com boost shared_ptr

Question

Assim, a Wikipedia me diz (corretamente creio) que para parar a edição dos dados de um ponteiro e o ponteiro em si que eu deveria fazer isso:

void function(int const * const var)

É este o mesmo que esta função:

void function(const int * const var)

E, nesse caso, por que é permitido?Porque eu sei que você não pode fazer isso porque a duplicação de const erro de compilação:

void function(const int const * const var)

Essencialmente eu quero fazer o mesmo com um impulso ponteiro.Eu iria fazer isso:

void function(const boost::shared_ptr<int> const var)

E como isso afetaria minha capacidade para fazer um loop através dizer partilhada com um ponteiro para um vetor?Eu poderia fazer isso com o que guarda:

void function(const boost::shared_ptr<std::vector<int>> const var)
{
    for (unsigned int i = 0; i < var->size(); ++i)
    {
        std::cout << var[i];
    }
}

Particularidades:Depois que Brian resposta

Então, se eu criar um ponteiro como este:

boost::shared_ptr<vector<int>> lala

E eu uso essa função:

function (const boost::shared_ptr<std::vector<const int>> var)

será que funciona?

Answer 1

Sim, int const * const var é o mesmo que const int * const var.Você pode colocar const antes ou depois de o tipo modifica, por "razões históricas".Ver http://www.stroustrup.com/bs_faq2.html#constplacement

Para um ponteiro inteligente objeto, você na verdade não pode fazer

const boost::shared_ptr<int> const

porque tanto consts modificar o mesmo tipo.Em vez disso, você deseja

const boost::shared_ptr<const int>

O primeiro const impede que o ponteiro se de ser modificado (i.e., reatribuída ao ponto a outro int) e o const no modelo de parâmetro indica o objeto da operator* para devolver um const int&, o que impede a modificação do int apontou.

Isso não impede iteração através de um vetor ou de qualquer outro recipiente, da forma que você descreveu, pela mesma razão por que você ainda pode iterar sobre uma const vetor normalmente.

Editar em resposta à pergunta editar:

Isso funciona:

void f(const boost::shared_ptr<const std::vector<int> > var);
// ...
boost::shared_ptr<vector<int> > lala;
f(lala);

O primeiro const o parâmetro não afeta a passagem de parâmetro em tudo;ele diz apenas que a função em si não modificar o parâmetro.A razão pela qual podemos adicionar um const no parâmetro do modelo é que um boost::shared_ptr<T> pode ser inicializado a partir de boost:shared_ptr<U> onde T e U não são necessariamente do mesmo tipo, como U* implicitamente conversível T*.Se T é o mesmo que U exceto com maior cv-qualificação, como no presente caso, a conversão é possível.

Não fazer std::vector<const int>.Eu estou bastante certo de que não é legal.(Pelo menos eu recebi várias telas de erros de compilação cada vez que eu tentei.)

Answer 2

const antes ou após o int é o mesmo então:

int const * var

e

const int * var

são o mesmo e significa o valor apontado não pode ser alterado

const após o * significa que o ponteiro não pode ser transferido.

Se eu entendi corretamente, você gostaria de fazer o vetor constante.Se for esse o caso, a sintaxe seria:

void function(const boost::shared_ptr<const std::vector<int>>& var)

O smart ponteiro é passado por constante de referência porque é mais barato do que passar o ponteiro inteligente por o valor e tem o mesmo efeito.O objeto apontado pelo ponteiro inteligente é imutável, declarando o tipo que aponta para const.

Answer 3

Você já corretamente fundamentado, que const shared_ptr<Foo> não faz Foo um objeto const.Esta "brecha" é descrito em taxas.Em vez disso, você precisará alterar o tipo de ponteiro armazenado por boost::shared_ptr.Isso pode ser feito no modelo de argumento em si:

void function(const boost::shared_ptr<const std::vector<int>>& var)

boost::shared_ptr tem uma cópia-construtor que permite uma constante do tipo a ser copiado a partir de um não-const-type.O oposto não deve ser possível.

Answer 4

Antes, ou depois?

Abaixo, duas linhas são semanticamente equivalentes, ambos declarar um ponteiro cujo valor não pode ser alterado, que refere-se a um int que não pode ser alterado.

int const * const p1 = ...; 
const int * const p2 = ...;

O const palavras-chave liga-se a tudo o que está directamente para a esquerda, a menos que não há nada à esquerda, caso em que será abraço tudo o que existe no direito.

---

Mais const, o melhor?

 typedef boost::shared_ptr<int> shared_int_ptr;

 const shared_int_ptr const p3; // ill-formed

Acima typedef é dada para torná-lo mais fácil de ver que boost::shared_ptr<int> é um nome único, e, portanto, não podemos adicionar const em ambos os lados;duplicados consts são (como você citou) não é legal C++.

Apenas a aplicação de um não seria suficiente, desde que faria o wrapper const, mas não o objeto interno que ele está se referindo a (o int).

Anteriormente, escreveu que boost::shared_ptr deve ser disposto ao redor de um int, mas desde que nós queremos fazer moldado tipo de const, bem..vamos resumir o shared_ptr em torno do que queremos:

void func (const boost::shared_ptr<const int> foo);

Acima func não é capaz de modificar foo, nem o int referido por foo.