Por que usar indireção múltipla?
156 views
Skip to first unread message
NewWave
Feb 21, 2012, 8:34:17 AM2/21/12
to ccppbrasil
Olá, amigos!
Podem me dar alguma luz sobre por que eu usaria indireção múltipla?
Não estou enxergando a necessidade.
Obrigado.
Podem me dar alguma luz sobre por que eu usaria indireção múltipla?
Não estou enxergando a necessidade.
Obrigado.
Murilo Adriano Vasconcelos
Feb 22, 2012, 12:10:46 PM2/22/12
to ccppb...@googlegroups.com
Você pode alterar, em uma função por exemplo, a posição em que um ponteiro aponta:
--
Murilo Adriano Vasconcelos
Tipo* a = something;
func(&a);
void func(Tipo** a)
{
if (!*a) {
*a = new Tipo();
}
}
--
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
Renan Greinert
Feb 22, 2012, 12:10:39 PM2/22/12
to ccppb...@googlegroups.com
Você tem sorte. Enquanto você não tiver que usar indireção múltipla você está livre de uma porrada de problemas.
Em C++, você raramente vai precisar disso. Em C, pelo menos dois níveis de ponteiros já é razoavelmente comum. Os exemplos mais clássicos são para manipular matrizes com tamanhos variáveis e criar funções que alocam memória para ponteiros passados por referência.
Exemplo:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void aloca( char** p)
{
*p = (char*)malloc(100);
}
int main(int argc,char **argv)
{
char* var;
aloca( &var );
strcpy(var, "hello world");
free(var);
return 0;
}
Como disse, é bom evitar essas coisas. Se estiver em C++ e puder utilizar STL, você raramente vai precisar disso.
Abraço,
Renan Greinert
http://renangreinert.blogspot.com/
Em C++, você raramente vai precisar disso. Em C, pelo menos dois níveis de ponteiros já é razoavelmente comum. Os exemplos mais clássicos são para manipular matrizes com tamanhos variáveis e criar funções que alocam memória para ponteiros passados por referência.
Exemplo:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void aloca( char** p)
{
*p = (char*)malloc(100);
}
int main(int argc,char **argv)
{
char* var;
aloca( &var );
strcpy(var, "hello world");
free(var);
return 0;
}
Como disse, é bom evitar essas coisas. Se estiver em C++ e puder utilizar STL, você raramente vai precisar disso.
Abraço,
Renan Greinert
http://renangreinert.blogspot.com/
2012/2/21 NewWave <je...@jent.com.br>
Infax
Feb 23, 2012, 8:50:30 AM2/23/12
to ccppbrasil
Outra ferramenta útil para evitar indireção múltipla no C++ é o
operador de alias (o '&' na recepção e não no envio de um parâmetro).
O operador de alias pode ser muito poderoso quando programando em C++
para usar "ponteiros" com sintaxe mais simples.
Outra conceito interessante é uma "rule of thumb" que diz que se você
está usando mais de dois níveis de indireção, provavelmente tem como
simplificar seu problema.
On Feb 22, 3:10 pm, Renan Greinert <renangue...@gmail.com> wrote:
> Você tem sorte. Enquanto você não tiver que usar indireção múltipla você
> está livre de uma porrada de problemas.
>
> Em C++, você raramente vai precisar disso. Em C, pelo menos dois níveis de
> ponteiros já é razoavelmente comum. Os exemplos mais clássicos são para
> manipular matrizes com tamanhos variáveis e criar funções que alocam
> memória para ponteiros passados por referência.
>
> Exemplo:
>
> #include <stdio.h>
> #include <string.h>
> #include <stdlib.h>
>
> void aloca( char** p)
> {
> *p = (char*)malloc(100);
>
> }
>
> int main(int argc,char **argv)
> {
> char* var;
> aloca( &var );
>
> strcpy(var, "hello world");
>
> free(var);
>
> return 0;
>
> }
>
> Como disse, é bom evitar essas coisas. Se estiver em C++ e puder utilizar
> STL, você raramente vai precisar disso.
>
> Abraço,
> Renan Greinert
>
> http://renangreinert.blogspot.com/
>
> 2012/2/21 NewWave <j...@jent.com.br>
> > Para mais opções, visitehttp://groups.google.com/group/ccppbrasil
> > --~--~---------~--~----~--~-~--~---~----~-----------------~--~----------~
> > Emprego & carreira: vaga...@ccppbrasil.org
> >http://groups.google.com/group/dev-guys?hl=en
operador de alias (o '&' na recepção e não no envio de um parâmetro).
O operador de alias pode ser muito poderoso quando programando em C++
para usar "ponteiros" com sintaxe mais simples.
Outra conceito interessante é uma "rule of thumb" que diz que se você
está usando mais de dois níveis de indireção, provavelmente tem como
simplificar seu problema.
On Feb 22, 3:10 pm, Renan Greinert <renangue...@gmail.com> wrote:
> Você tem sorte. Enquanto você não tiver que usar indireção múltipla você
> está livre de uma porrada de problemas.
>
> Em C++, você raramente vai precisar disso. Em C, pelo menos dois níveis de
> ponteiros já é razoavelmente comum. Os exemplos mais clássicos são para
> manipular matrizes com tamanhos variáveis e criar funções que alocam
> memória para ponteiros passados por referência.
>
> Exemplo:
>
> #include <stdio.h>
> #include <string.h>
> #include <stdlib.h>
>
> void aloca( char** p)
> {
> *p = (char*)malloc(100);
>
> }
>
> int main(int argc,char **argv)
> {
> char* var;
> aloca( &var );
>
> strcpy(var, "hello world");
>
> free(var);
>
> return 0;
>
> }
>
> Como disse, é bom evitar essas coisas. Se estiver em C++ e puder utilizar
> STL, você raramente vai precisar disso.
>
> Abraço,
> Renan Greinert
>
> http://renangreinert.blogspot.com/
>
>
>
>
>
>
>
>
> > Olá, amigos!
>
> > Podem me dar alguma luz sobre por que eu usaria indireção múltipla?
> > Não estou enxergando a necessidade.
>
> > Obrigado.
>
> > --
> > 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/
>
>
>
>
>
>
> > Olá, amigos!
>
> > Podem me dar alguma luz sobre por que eu usaria indireção múltipla?
> > Não estou enxergando a necessidade.
>
> > Obrigado.
>
> > --
> > 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
>
> > ------~----~-------~---~---~---~---~----------------~------------~---------~
> > Para mais opções, visitehttp://groups.google.com/group/ccppbrasil
> > --~--~---------~--~----~--~-~--~---~----~-----------------~--~----------~
> > Emprego & carreira: vaga...@ccppbrasil.org
> >http://groups.google.com/group/dev-guys?hl=en
Fabiano Vasconcelos
Feb 24, 2012, 10:46:20 AM2/24/12
to ccppb...@googlegroups.com
Em 23-02-2012 10:50, Infax escreveu:
Outra ferramenta útil para evitar indireção múltipla no C++ é o operador de alias (o '&' na recepção e não no envio de um parâmetro).
Infax, mas o operador & também está presente em C. Por que então
se usa indireção múltipla em C, então?
--
Fabiano Vasconcelos
Graduando em Análise de Sistemas em Redes de Computadores
Usando: Ubuntu 11.04, GNU GCC for Linux
IDE: NetBeans
Fortaleza - CE
Fabiano Vasconcelos
Graduando em Análise de Sistemas em Redes de Computadores
Usando: Ubuntu 11.04, GNU GCC for Linux
IDE: NetBeans
Fortaleza - CE
Renan Greinert
Feb 24, 2012, 11:22:10 AM2/24/12
to ccppb...@googlegroups.com
Em C, você não pode declarar uma variável como referência. Ou seja, isso:
void func( int& var );
Só funciona em C++.
void func( int& var );
Só funciona em C++.
2012/2/24 Fabiano Vasconcelos <fvasco...@gmail.com>
[&] C & C++ Brasil - http://www.ccppbrasil.org/
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
Felipe Magno de Almeida
Feb 24, 2012, 11:24:21 AM2/24/12
to ccppb...@googlegroups.com
2012/2/23 Infax <inf...@gmail.com>:
> Outra ferramenta útil para evitar indireção múltipla no C++ é o
> operador de alias (o '&' na recepção e não no envio de um parâmetro).
> Outra ferramenta útil para evitar indireção múltipla no C++ é o
> operador de alias (o '&' na recepção e não no envio de um parâmetro).
Em foo(X const& x) o & não é um operador.
> [&] 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
--
Felipe Magno de Almeida
P.
Feb 24, 2012, 1:36:47 PM2/24/12
to ccppb...@googlegroups.com
Em sexta-feira, 24 de fevereiro de 2012 13h46min20s UTC-2, NewWave (Fabiano Vasconcelos) escreveu:
Em 23-02-2012 10:50, Infax escreveu:Infax, mas o operador & também está presente em C. Por que então se usa indireção múltipla em C, então?Outra ferramenta útil para evitar indireção múltipla no C++ é o operador de alias (o '&' na recepção e não no envio de um parâmetro).
Ele disse "operador" mas é uso incorreto da linguagem; quis dizer "declarador".
O símbolo & é um operador nesta declaração:
int * i = & x;
mas é um declarador nesta:
int & i = x;
--
P.
Fabiano Vasconcelos
Feb 25, 2012, 1:26:06 PM2/25/12
to ccppb...@googlegroups.com
Em 22-02-2012 14:10, Murilo Adriano Vasconcelos escreveu:
Você pode alterar, em uma função por exemplo, a posição em que um ponteiro aponta:
Tipo* a = something;func(&a);
void func(Tipo** a){if (!*a) {*a = new Tipo();}}
Calma que eu ainda não examinei os operadores new e delete com
bastante atenção. :)
Infax
Feb 27, 2012, 12:21:00 PM2/27/12
to ccppbrasil
É isso mesmo. Eu errei ao usar a palavra "operador". Eu considero
bastante confuso isso dos símbolos "*" e "&" serem ao mesmo tempo
declaradores e operadores. Já cansei de explicar para colegas com
menos experiência em C++ que ao declarar uma variável "int* pi", o "*"
é uma propriedade de tipo da variável (pi é do tipo "ponteiro de
inteiro") e não uma operação "*" que se faz sobre pi. Muita gente
demora para se acostumar com isso, o fato de ser muito comum encontrar
declarações desse tipo na forma "int *pi" não ajuda.
Em C, há o /operador/ "&" para obter o endereço da variável sobre a
qual "&" opera. Em C++, existe esse operador, mas também há o /
declarador/ "&" que indica que uma variável "int& i" é uma referência
para alguma área de memória. Uma vantagem do "&" como "alias" é poder
fazer uso de uma variável passada por referência com a sintaxe de
acesso a membros de objeto ao invés de precisar usar a sintaxe de
acesso a membros de objetos de-referenciados.
Isto é, para:
class NumeroComplexo {
public:
int parteConcreta;
int parteAbstrata;
}
tanto:
void incrementa(NumeroComplexo* numeroComplexo){
numeroComplexo->parteConcreta += 1;
}
quanto:
void incrementa(NumeroComplexo& numeroComplexo){
numeroComplexo.parteConcreta += 1;
}
tem o mesmo resultado, mas é mais simples e agradável escrever
numeroComplexo.parteConcreta que numeroComplexo->parteConcreta.
Principalmente para quem está começando com o C++.
On Feb 25, 4:26 pm, Fabiano Vasconcelos <fvasconce...@gmail.com>
wrote:
> aten��o. :)
>
> *Fabiano Vasconcelos*
> _Graduando em An�lise de Sistemas em Redes de Computadores_
bastante confuso isso dos símbolos "*" e "&" serem ao mesmo tempo
declaradores e operadores. Já cansei de explicar para colegas com
menos experiência em C++ que ao declarar uma variável "int* pi", o "*"
é uma propriedade de tipo da variável (pi é do tipo "ponteiro de
inteiro") e não uma operação "*" que se faz sobre pi. Muita gente
demora para se acostumar com isso, o fato de ser muito comum encontrar
declarações desse tipo na forma "int *pi" não ajuda.
Em C, há o /operador/ "&" para obter o endereço da variável sobre a
qual "&" opera. Em C++, existe esse operador, mas também há o /
declarador/ "&" que indica que uma variável "int& i" é uma referência
para alguma área de memória. Uma vantagem do "&" como "alias" é poder
fazer uso de uma variável passada por referência com a sintaxe de
acesso a membros de objeto ao invés de precisar usar a sintaxe de
acesso a membros de objetos de-referenciados.
Isto é, para:
class NumeroComplexo {
public:
int parteConcreta;
int parteAbstrata;
}
tanto:
void incrementa(NumeroComplexo* numeroComplexo){
numeroComplexo->parteConcreta += 1;
}
quanto:
void incrementa(NumeroComplexo& numeroComplexo){
numeroComplexo.parteConcreta += 1;
}
tem o mesmo resultado, mas é mais simples e agradável escrever
numeroComplexo.parteConcreta que numeroComplexo->parteConcreta.
Principalmente para quem está começando com o C++.
On Feb 25, 4:26 pm, Fabiano Vasconcelos <fvasconce...@gmail.com>
wrote:
> Em 22-02-2012 14:10, Murilo Adriano Vasconcelos escreveu:
>
> > Voc� pode alterar, em uma fun��o por exemplo, a posi��o em que um
>
> > ponteiro aponta:
>
> > Tipo* a = something;
> > func(&a);
>
> > void func(Tipo** a)
> > {
> > if (!*a) {
> > *a = new Tipo();
> > }
> > }
>
> Calma que eu ainda n�o examinei os operadores new e delete com bastante
>
> > Tipo* a = something;
> > func(&a);
>
> > void func(Tipo** a)
> > {
> > if (!*a) {
> > *a = new Tipo();
> > }
> > }
>
> aten��o. :)
>
> *Fabiano Vasconcelos*
> _Graduando em An�lise de Sistemas em Redes de Computadores_
Reply all
Reply to author
Forward
0 new messages