Métodos Const (no começo e no fim do método)

[Lucas Pereira Caixeta]

Galera, tudo bem com todos?

Seguinte, andei pesquisando sobre métodos const e no meu trabalho mesmo apareceu uma dúvida. Me explicaram mas gostaria de saber de vocês uma opinião.. e enfim:

const char* foo() const;

Nesse método temos o const no início e no fim. 
O do fim sei que não deixa o método mudar os atributos do objeto que entrou no método. Mas e esse primeiro? Em que casos devo mais usar?

Agradeço pacas a ajuda no entendimento disso (que pode parecer simples à muitos).
No mais, ótima semana!

Att.
Lucas Pereira Caixeta

[Ivo Calado]

O primeiro vai servir para você impedir que o método retornado seja alterado no decorrer da execução. Neste exemplo que você mostrou a variável retornada, isto é, const char* será tratata como uma constante pelo restante do fluxo.


[]'s

2010/3/15 Lucas Pereira Caixeta <lpc...@gmail.com>

--
Antes de enviar um e-mail para o grupo leia:
http://www.ccppbrasil.org/wiki/Lista:AntesdePerguntar
--~--~---------~--~----~---------------------------------~----------~--~----~
[&] Colabore com a Pesquisa de Preferência de Conteúdo
para Eventos do Grupo C & C++ Brasil:
http://www.surveymonkey.com/s/GBBGTXN
------~----~-------~---~---~---~---~----------------~------------~---------~
[&] C & C++ Brasil - http://www.ccppbrasil.org/
Para sair dessa lista, envie um e-mail para ccppbrasil-...@googlegroups.com
Para mais opções, visite http://groups.google.com/group/ccppbrasil
--~--~---------~--~----~--~-~--~---~----~-----------------~--~----------~
Emprego & carreira: vag...@ccppbrasil.org
http://groups.google.com/group/dev-guys?hl=en

--
Ivo Augusto Andrade Rocha Calado
PhD candidate in Electrical Engineering
Embedded Systems and Pervasive Computing Lab - http://embedded.ufcg.edu.br
Electrical Engineering Department - http://dee.ufcg.edu.br/
Electrical Engineering and Informatics Center - http://www.ceei.ufcg.edu.br
Federal University of Campina Grande - http://www.ufcg.edu.br

PGP: 0xD7C3860A pgp.mit.edu
Putt's Law:
      Technology is dominated by two types of people:
              Those who understand what they do not manage.
              Those who manage what they do not understand.

There are 11 types of people in the world: Those who understand binary, those who do not understand and those who think they understand.

[Murilo Adriano Vasconcelos]

O primeiro significa que o tipo que a função foo() retorna é um ponteiro para char somente leitura. Ou seja é um ponteiro pra char que você não pode alterar o valor apontado por ele.

--

Antes de enviar um e-mail para o grupo leia:
http://www.ccppbrasil.org/wiki/Lista:AntesdePerguntar
--~--~---------~--~----~---------------------------------~----------~--~----~
[&] Colabore com a Pesquisa de Preferência de Conteúdo
para Eventos do Grupo C & C++ Brasil:
http://www.surveymonkey.com/s/GBBGTXN
------~----~-------~---~---~---~---~----------------~------------~---------~
[&] C & C++ Brasil - http://www.ccppbrasil.org/
Para sair dessa lista, envie um e-mail para ccppbrasil-...@googlegroups.com
Para mais opções, visite http://groups.google.com/group/ccppbrasil
--~--~---------~--~----~--~-~--~---~----~-----------------~--~----------~
Emprego & carreira: vag...@ccppbrasil.org
http://groups.google.com/group/dev-guys?hl=en

--
Murilo Adriano Vasconcelos
Ciência da Computação INF-UFG
Universidade Federal de Goiás
http://murilo.wordpress.com

[Gianni]

O que vem antes do nome do método é o tipo.  Logo, o método foo() retorna um 'const char*', ou seja, um ponteiro para um char, cujo conteúdo não pode ser modificado.  Se ao invés disso, eu quisesse retornar um ponteiro que poderia ser alterado, faria: 'char* foo() const;'  ou então, um ponteiro const para um int:  'const int* foo() const;'

Resumindo: o 1o const se refere ao retorno da função.

[Leandro Santos de Lima]

Humm...pelo que eu li tenho a impressão que é menos...

const char* foo() const quer dizer:

um método de uma classe que não altera o estado da classe, ou seja, os membros dela ( último const). Já o primeiro const diz que temos um ponteiro, alterável - leia-se não const, para um objeto const do tipo char. Se quisessemos um ponteiro const seria:

const char* const foo() const...

Me corrijam se estiver enganado.

Att.,

Leandro Lima

2010/3/15 Gianni <nasus....@gmail.com>

[Gianni]

Eu não disse que o ponteiro não pode ser alterado, eu disse que o conteúdo do ponteiro não pode.  Admito que não é a descrição mais clara que existe, então prometo que na próxima vez eu falarei inequivocamente de que é o valor apontado pelo ponteiro que, por convenção, será inalterável até que a morte, ou um const_cast, os separe.

[Leandro Santos de Lima]

Opa, não havia reparado que era isso que esperava dizer. Só falei mesmo por que aprendi recentemente e achei quer era algo pouco observado o fato de const não servir para o ponteiro e sim para o objeto. 

Abraço

Leandro

2010/3/15 Gianni <nasus....@gmail.com>

[Thiago Adams]

> Opa, não havia reparado que era isso que esperava dizer. Só falei mesmo por
> que aprendi recentemente e achei quer era algo pouco observado o fato de
> const não servir para o ponteiro e sim para o objeto.

O const pode servir para ambos.

}
struct X
{
//retorna um ponteiro const para um char const
const char* const f() const
{
return "x";
}
};

{
X x;
//declara um ponteiro const para um char const
const char * const c = x.f();
}

[Gianni]

On Mar 16, 2010, at 9:09 AM, Thiago Adams wrote:

>> Opa, não havia reparado que era isso que esperava dizer. Só falei mesmo por
>> que aprendi recentemente e achei quer era algo pouco observado o fato de
>> const não servir para o ponteiro e sim para o objeto.
>
> O const pode servir para ambos.

Foi justamente o que ele havia dito.

[Adriano dos Santos Fernandes]

On 16/03/2010 09:09, Thiago Adams wrote:
>> Opa, n�o havia reparado que era isso que esperava dizer. S� falei mesmo por

>> que aprendi recentemente e achei quer era algo pouco observado o fato de

>> const n�o servir para o ponteiro e sim para o objeto.

>>
> O const pode servir para ambos.
>
> }
> struct X
> {
> //retorna um ponteiro const para um char const
> const char* const f() const
>

Mas esse segundo const n�o faz sentido neste caso (tipo de retorno),
pois n�o � uma vari�vel.

Eu n�o gosto muito de usar const em vari�veis locais e par�metros quando
a atribui��o n�o � um valor literal. Sobre par�metros, pior ainda, pois
detalhes de implementa��o s�o transferidos para o prot�tipo da fun��o em
alguns compiladores:
http://asfernandes.blogspot.com/2009/08/buggy-const.html

Adriano

[Gianni]

On Mar 16, 2010, at 9:25 AM, Adriano dos Santos Fernandes wrote:

On 16/03/2010 09:09, Thiago Adams wrote:

Opa, não havia reparado que era isso que esperava dizer. Só falei mesmo por

que aprendi recentemente e achei quer era algo pouco observado o fato de

const não servir para o ponteiro e sim para o objeto.

    

O const pode servir para ambos.

}

struct X

{

  //retorna um ponteiro const para um char const

  const char* const f() const

  

Mas esse segundo const não faz sentido neste caso (tipo de retorno), pois não é uma variável.

Eu não gosto muito de usar const em variáveis locais e parâmetros quando a atribuição não é um valor literal. Sobre parâmetros, pior ainda, pois detalhes de implementação são transferidos para o protótipo da função em alguns compiladores: http://asfernandes.blogspot.com/2009/08/buggy-const.html

Só um detalhe que eu vi, é que esse tempo todo nós estavamos falando de 'const char* foo() const;'  que não é C++ válido, pois isso é a declaração de uma função 'não-membro'.  'const' dessa forma no final só vale para função membro.  Para funções simples, é preciso colocar um __attribute__((const)) na delcaração dela, mas isso que dizer algo ligeiramente diferente do const em membros.  Aliás, o __attribute__((pure)) está mais próximo do bar::foo() const;

http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html

[P.]

Leandro Santos de Lima wrote:

> Opa, não havia reparado que era isso que esperava dizer. Só falei mesmo por
> que aprendi recentemente e achei quer era algo pouco observado o fato de
> const não servir para o ponteiro e sim para o objeto.

Um uso mais claro da sintaxe seria:

char const * foo () const

onde a leitura de

char const *

deve ser feita da direita pra esquerda: tipo ponteiro para tipo
constante de char.
Quando o const ocorre no início:

const char *

entende-se que significa o mesmo que a construção acima.

É possível qualificar o próprio ponteiro como const; um ponteiro é um
objeto, afinal.
A seguinte construção:

char * const

significa: tipo constante de ponteiro para tipo char.

--
P.

[Adriano dos Santos Fernandes]

On 16/03/2010 09:45, Gianni wrote:
> S� um detalhe que eu vi, � que esse tempo todo n�s estavamos falando
> de 'const char* foo() const;' que n�o � C++ v�lido, pois isso � a
> declara��o de uma fun��o 'n�o-membro'.
Bom, ningu�m colocou um arquivo fonte inteiro, s� o trecho da
declara��o, ent�o fica impl�cito que estava se falando de m�todos
n�o-est�ticos. :-)

S� outra observa��o sobre o const (atributo da fun��o). Se voc� tem na
sua classe um membro "int* p", o const n�o deixar� alterar p, mas *p
poder� ser alterado.

Para *p n�o ser alter�vel (e isso � independente do const final do
m�todo), dever� ser declarado como "const int* p".

Adriano

[P.]

Adriano dos Santos Fernandes wrote:

A construção:

const int * p

é equivalente a:

int const * p

onde p permanece mutável.

Se você deseja tornar p imutável, deve escrever:

int * const p

--
P.

[Adriano dos Santos Fernandes]

Claro, exceto em métodos const.

> Se você deseja tornar p imutável, deve escrever:
>
> int * const p
>

Só faltou dizer que aí (caso p seja membro de uma classe) deverá ser
inicializado no construtor (após os dois pontos) e não poderá ser
atualizado, mesmo em métodos não-const.

Acho que agora já falamos tudo sobre const, não? :-)

Adriano

[Gianni]

Faltou explicar const_cast e membros mutable. :-D

class Foo
{
private:
mutable int bar;
int BAR;

public:
const int* foo() const
{
bar++;
return &bar;
}

int FOO() const
{
return const_cast<Foo*>(this)->BAR++;
}
};

Isso me lembra uma histórinha:

A foo walked into a bar and said: "Hello World!!!"

[P.]

Adriano dos Santos Fernandes wrote:

> > A construção:
> >
> > const int * p
> >
> > é equivalente a:
> >
> > int const * p
> >
> > onde p permanece mutável.
> >
>
> Claro, exceto em métodos const.

O fato de o nome p ser ou não ser qualificado como const é
independente da existência ou não de métodos qualificados como const.
p é não-const, simplesmente.

Qualificar uma função com const no final:

bar::foo () const

é equivalente ao seguinte, onde this está explícito:

bar::foo ( bar const * this )

i.e. o qualificador const do método se aplica à variável this, apenas.

--
P.

[Thiago Silva]

2010/3/16 P. <pedro....@member.fsf.org>:

> Qualificar uma função com const no final:
>
>   bar::foo () const
>
> é equivalente ao seguinte, onde this está explícito:
>
>  bar::foo ( bar const * this )
>
> i.e. o qualificador const do método se aplica à variável this, apenas.
>

sendo pedante em relação ao "equivalente":

bar::foo ( bar const * const this )

--
Thiago Silva
Computer Science
M.Sc. Candidate at Federal University of Pernambuco
jabber/gtalk: tsi...@jabber-br.org
http://blog.sourcecraft.info

[Thiago Adams]

> Eu n o gosto muito de usar const em vari veis locais e par metros quando
> a atribui o n o um valor literal. Sobre par metros, pior ainda, pois
> detalhes de implementa o s o transferidos para o prot tipo da fun o em
> alguns compiladores:http://asfernandes.blogspot.com/2009/08/buggy-const.html

Qual o problema de usar o const em variáveis locais?
Uso o const sempre que possível e variáveis locais são inicializadas
na declaração.

[Leandro Santos de Lima]

Não rapaz, 

Não há problema em usar em variáveis locais. Você só não pode usar o const em função pq este const no final da função quer dizer: "Prometo pelo código de honra dos escoteiros que não vou mexer nos membros da classe da qual sou membro." Se é função, não é membro de nada e portanto não faz sentido...exemplificando:

void foo() const é pau na certa;

Agora algo do tipo:

void Foo::fool() const  está ok.

Abraço,

Leandro

2010/3/16 Thiago Adams <thiago...@gmail.com>

[Murilo Adriano Vasconcelos]

class A

{

void foo() const {};

};

[Adriano dos Santos Fernandes]

> > detalhes de implementa o s o transferidos para o prot tipo da
> fun o em
> > alguns
> compiladores:http://asfernandes.blogspot.com/2009/08/buggy-const.html
>

> Qual o problema de usar o const em vari�veis locais?
> Uso o const sempre que poss�vel e vari�veis locais s�o inicializadas
> na declara��o.
>
N�o � que h� problema, � que na minha opini�o isso dificilmente tem
algum benef�cio pr�tico. Veja:
const int len = s.length();

Como nesse caso acima, v�rias "vari�veis" locais s�o constantes em
potencial. Isso implica (sendo consistente) ficar usando const pra todo
lado.

Se estivermos falando de objetos (que poder�o ser passados como "const
Tipo&" ou que ter�o estado e m�todos const" a� � outra situa��o.

Adriano

[Humberto Pereira]

2010/3/17 Adriano dos Santos Fernandes <adri...@gmail.com>:

>
>>    > detalhes de implementa o s o transferidos para o prot tipo da
>>    fun o em
>>    > alguns
>>    compiladores:http://asfernandes.blogspot.com/2009/08/buggy-const.html
>>

>>    Qual o problema de usar o const em variáveis locais?
>>    Uso o const sempre que possível e variáveis locais são inicializadas
>>    na declaração.
>>

> Não é que há problema, é que na minha opinião isso dificilmente tem algum
> benefício prático. Veja:

>    const int len = s.length();

const nao faz sentido para tipos primitivos, em lugar nenhum.

[]s
Humberto Pereira

[Adriano dos Santos Fernandes]

On 17/03/2010 11:36, Humberto Pereira wrote:
> 2010/3/17 Adriano dos Santos Fernandes<adri...@gmail.com>:
>
>>
>>> > detalhes de implementa o s o transferidos para o prot tipo da
>>> fun o em
>>> > alguns
>>> compiladores:http://asfernandes.blogspot.com/2009/08/buggy-const.html
>>>

>>> Qual o problema de usar o const em vari�veis locais?
>>> Uso o const sempre que poss�vel e vari�veis locais s�o inicializadas
>>> na declara��o.
>>>
>>>
>> N�o � que h� problema, � que na minha opini�o isso dificilmente tem algum

>> benef�cio pr�tico. Veja:

>> const int len = s.length();
>>
> const nao faz sentido para tipos primitivos, em lugar nenhum.
>

Claro que faz. Imagina vc sair alterando sem querer constantes usadas
para flags (bit masks) porque trocou um == por =.

Adriano

[Humberto Pereira]

2010/3/17 Adriano dos Santos Fernandes <adri...@gmail.com>:
> On 17/03/2010 11:36, Humberto Pereira wrote:
>>
>> 2010/3/17 Adriano dos Santos Fernandes<adri...@gmail.com>:
>>
>>>
>>>
>>>>
>>>>    >  detalhes de implementa o s o transferidos para o prot tipo da
>>>>    fun o em
>>>>    >  alguns
>>>>    compiladores:http://asfernandes.blogspot.com/2009/08/buggy-const.html
>>>>

>>>>    Qual o problema de usar o const em variáveis locais?
>>>>    Uso o const sempre que possível e variáveis locais são inicializadas
>>>>    na declaração.
>>>>
>>>>
>>>
>>> Não é que há problema, é que na minha opinião isso dificilmente tem algum

>>> benefício prático. Veja:

>>>    const int len = s.length();
>>>
>>
>> const nao faz sentido para tipos primitivos, em lugar nenhum.
>>
>
> Claro que faz. Imagina vc sair alterando sem querer constantes usadas para
> flags (bit masks) porque trocou um == por =.

Ok, nao fazem sentido no escopo da discussao, passagem de parametros,
retorno de funcao e variaveis locais.
:)

[]s
Humberto Pereira

[Murilo Adriano Vasconcelos]

Não faz sentido o retorno de qualquer tipo que é retornado por valor ser const, já que modifcar a cópia não surtiria efeito no original.

Em 17 de março de 2010 11:39, Adriano dos Santos Fernandes <adri...@gmail.com> escreveu:

On 17/03/2010 11:36, Humberto Pereira wrote:

2010/3/17 Adriano dos Santos Fernandes<adri...@gmail.com>:
 

   >  detalhes de implementa o s o transferidos para o prot tipo da
   fun o em
   >  alguns
   compiladores:http://asfernandes.blogspot.com/2009/08/buggy-const.html

   Qual o problema de usar o const em variáveis locais?
   Uso o const sempre que possível e variáveis locais são inicializadas
   na declaração.

     

Não é que há problema, é que na minha opinião isso dificilmente tem algum

benefício prático. Veja:

   const int len = s.length();
   

const nao faz sentido para tipos primitivos, em lugar nenhum.
 

Claro que faz. Imagina vc sair alterando sem querer constantes usadas para flags (bit masks) porque trocou um == por =.


Adriano

--
Antes de enviar um e-mail para o grupo leia:                     http://www.ccppbrasil.org/wiki/Lista:AntesdePerguntar
--~--~---------~--~----~---------------------------------~----------~--~----~
[&] Colabore com a Pesquisa de Preferência de Conteúdo              para Eventos do Grupo C & C++ Brasil:
                      http://www.surveymonkey.com/s/GBBGTXN
------~----~-------~---~---~---~---~----------------~------------~---------~
[&] C & C++ Brasil - http://www.ccppbrasil.org/
Para sair dessa lista, envie um e-mail para ccppbrasil-...@googlegroups.com
Para mais opções, visite http://groups.google.com/group/ccppbrasil
--~--~---------~--~----~--~-~--~---~----~-----------------~--~----------~
Emprego & carreira:  vag...@ccppbrasil.org
http://groups.google.com/group/dev-guys?hl=en

[Thiago Adams]

On Mar 17, 11:47 am, Murilo Adriano Vasconcelos <murilo...@gmail.com>
wrote:

> Não faz sentido o retorno de qualquer tipo que é retornado por valor ser
> const, já que modifcar a cópia não surtiria efeito no original.

A vantagem de se usar const neste contexto:
ex:
const int size = obj.getsize();
é :

* Garantir que a variável não é alterada no escopo dela promovendo
segurança
* Facilitar o entendimento e a revisão de código (conceito somente
leitura)
* Obriga a inicialização na declaração

[Murilo Adriano Vasconcelos]

Eu disse que não tem sentido o tipo do retorno da função ser const. No seu caso você disse que a variável que recebe o retorno é const.

--
Antes de enviar um e-mail para o grupo leia:
                    http://www.ccppbrasil.org/wiki/Lista:AntesdePerguntar
--~--~---------~--~----~---------------------------------~----------~--~----~
[&] Colabore com a Pesquisa de Preferência de Conteúdo
             para Eventos do Grupo C & C++ Brasil:
                       http://www.surveymonkey.com/s/GBBGTXN
------~----~-------~---~---~---~---~----------------~------------~---------~
[&] C & C++ Brasil - http://www.ccppbrasil.org/
Para sair dessa lista, envie um e-mail para ccppbrasil-...@googlegroups.com
Para mais opções, visite http://groups.google.com/group/ccppbrasil
--~--~---------~--~----~--~-~--~---~----~-----------------~--~----------~
Emprego & carreira:  vag...@ccppbrasil.org
http://groups.google.com/group/dev-guys?hl=en

[Murilo Adriano Vasconcelos]

O que você citou faz muito sentido e acho uma boa prática utilizar.