Uma das facilidades das quais estou tirando proveito hoje é o App::cpanminus do Miyagawa. Esse aplicativo foi criado para facilitar a instalação de módulos em ambientes com restrições de recursos, portanto ele não possui muitas dependências e tem um baixo footprint.

Em alguns posts antigos eu mostrei como configurar o aplicativo cpan, instalar módulos no home do usuário e criar um mini mirror local com CPAN::mini, então como aquecimento para o Equinócio que se aproxima eu vou atualizar esses tutoriais tornando os posts anteriores obsoletos.

Para contextualizar os novos leitores vamos a um rápido overview das ferramentas abordadas:

• cpanm e cpanm: são aplicativos que automatizam a instalação de módulos Perl publicados no repositório www.cpan.org.
• www.cpan.org: É o repositório de módulos Perl onde podemos encontrar (hoje) cerca de 89768 módulos escritos por cerca de 8734 autores, para as mais diversas finalidades. Frequentemente alternamos o significado da palavra cpan entre “o repositório da web” e o “aplicativo de instalação de módulos”.
• local::lib: é um módulo (ou biblioteca) que facilita a instalação de outros módulos em diretórios que não os da instalação padrão, o que é útil quando você não possui privilégios administrativos e precisa de alguns módulos extras.
• CPAN::Mini: é outro módulo que permite a criação de um mini repositório local com a última versão de cada módulo do cpan. Isso é muito útil quando você precisa instalar módulos em um ambiente que não possui acesso à internet.

Mão na massa

Bom o primeiro passo agora, ao invés de configurar o aplicativo cpan é baixar e instalar o cpanm. Quando essa etapa é feita em conjunto com o sudo, o cpanm é instalando na árvore padrão de instalação do Perl. Para instalar no seu home basta executar:

curl -L http://cpanmin.us | perl - App::cpanminus

Entretanto isso ainda não configurou o seu ambiente. O cpanm foi instalado em $HOME/perl5/bin, mas seu $PATH, as variáveis de ambiente e o local::lib ainda não estão prontas.

Para instalar o módulo local::lib faça:

$HOME/perl5/bin/cpanm local::lib

Especificar o caminho completo é necessário porque ainda não adicionamos o diretório de instalação local na variável de ambiente $PATH. Para fazer isso executamos:

echo 'eval $(perl -I$HOME/perl5/lib/perl5 -Mlocal::lib)' >> ~/.bashrc

Nota: No Mac o arquivo é o .profile ao invés do .bashrc.

Isso faz com que a cada login, o ambiente pergunte ao módulo local::lib onde estão os outros módulos. Note que desta vez não precisamos exportar a variável PERL_MM_USE_DEFAULT porque o cpanm resolve as dependências de uma forma um pouco mais esperta que o seu irmão mais velho.

Para finalizar esta etapa, feche o terminal e abra novamente para carregar as variáveis ou execute:

. ~/.bashrc

Agora, se você quiser configurar o mini repositório, os passos são os mesmos:

1. Instalar o módulo CPAN::Mini;
2. Criar o arquivo de configuração para ele;
3. Executar o comando minicpan;

A instalação pode ser feita com o comando:

cpanm CPAN::Mini

O arquivo de configuração (~/.minicpanrc) pode ser criado com o conteúdo:

local: ~/minicpan
remote: http://www.cpan.org

Daí é só executar o comando minicpan e esperar o repositório ser baixado (aproximadamente 1.5 GB).

Para que o cpanm aponte para o repositório local você deve invocá-lo passando com o seguinte parâmetro extra:

cpanm --mirror ~/minicpan --mirror-only

Ou para maior conveniência criar um alias:

echo "alias cpanmm='cpanm --mirror ~/minicpan --mirror-only'" >> ~/.bashrc

Após recarregar o .bashrc você terá disponíveis os comandos cpanm que baixa os módulos diretamente da internet e o cpanmm que instala os módulos a partir do seu repositório local.

Não se esqueça de executar o comando minicpan pelo menos uma vez por semana para manter o seu repositório local atualizado.

Referências:

• Eden Cardim
• App::cpanminus
• cpan.org
• local::lib
• CPAN::Mini

Nesta sexta feira aconteceu a última aula do curso de férias de 20hs que eu e alguns amigos ministramos na FEI sobre introdução ao Linux. Gostaria de registrar mais uma vez nosso agradecimento por todo o apoio que recebemos da instituição, representada pelo Professor Plínio.

O curso foi carinhosamente redefinido durante a semana como “Uma caótica e divertida introdução ao mundo Linux”, pois ao invés de nos focarmos em memorização de comandinhos, tentamos mostrar aos alunos como se virar sozinhos, habituando-os a usar o manual e deixando-os confortáveis o suficiente para experimentar.

A temática foi mais ou menos no estilo de “O que acontece se eu apertar esse botão vermelho?”, onde até mesmo os instrutores faziam coisas erradas para utilizar isso como gancho para o tópico seguinte.

No primeiro dia falamos para os alunos que eles não precisavam de um curso com especialistas para que pudessem explorar o sistema, então a frase mais usada foi “Não sei. Vamos procurar no man?”, seguida de uma ajudinha sobre como localizar e entender o manual corretamente.

Nesse formato, interagimos sobre manuais, comandos básicos, organização do sistema de arquivos, permissões, pipes, descritores de arquivos, redirecionamento de E/S, particioamento entre outros tópicos, sempre focando nas dúvidas dos alunos, ao invés de no programa do curso, mostrando que eles poderiam destrinchar um determinado assunto tão profundamente quanto quisessem.

Naturalmente, acabamos não tendo tempo de entrar em vários assuntos, mas os tópicos que não abordamos, ou os termos mais específicos eram deixados no quadro para que eles anotassem e pesquisassem por conta própria, sempre tomando o cuidado de dar uma direção, de forma que eles não ficassem perdidos ou com tudo mastigado.

Na quata feira, abordamos a instalação do Linux, tomando como exemplo o Ubuntu. Até mesmo um pendrive que corrompeu algumas ISOs serviu de gancho para falarmos de checksum. Em pouco tempo eles já estavam configurando o sistema sozinhos, atualizando e instalando pacotes sem que precisássemos interferir muito.

A quinta feira foi o dia mais audacioso para um curso introdutório. Focando nas necessidades dos alunos, abordamos ferramentas de desenvolvimento e debug. Demos uma visão geral das etapas de compilação, mostramos como as macros são pre-processadas, como é gerado código objeto e como os objetos são linkados. Falamos brevemente sobre cpp, gcc, ld, gdb, nm, objdump, e sobre como as bibliotecas são criadas, sem assustar com os comandos, focando nos conceitos por trás de tudo.

Embora esse seja um tópico razoavelmente avançado, mostramos para os alunos que eles tinham plenas condições de entender o que estava acontecendo e se aprofundarem no assunto caso quisessem. Mostramos que existe e deixamos por conta da curiosidade de cada um.

A moda

Na sexta feira trouxemos um questionamento sobre a humanidade das pessoas que operam as máquinas e sobre como a tecnologia pode ser prejudicial para elas. Tentamos fazer os alunos questionarem-se sobre o porquê de terem escolhido essa carreira.

A esse bate papo seguiu-se uma sessão de perguntas sobre mercado onde foi perguntado quais tecnologias deveriam ser aprendidas para se destacar no mercado. Foi levantada a questão do conhecimento motivado pelo produto, sendo que a visão do mercado é que devemos buscar o conhecimento somente se motivados por um problema ou criação de produtos.

Infelizmente, não tivemos tempo suficiente para uma discussão mais abrangente, mas neste ponto, a opinião dos instrutores diverge da opinião do mercado.

Todos sabemos que a necessidade motiva. Não discordamos disto. O que não aceitamos é que a busca pelo conhecimento seja podada pela existência ou não de uma determinada necessidade.

Quando estamos sujeitos às modas do mercado estamos sempre um passo atrás do que está acontecendo. Alguém determinou que a tecnologia X é o estado da arte da computação e só nos resta correr feito loucos para continuar fazendo parte do rebanho. Nós nos tornamos escravos. Seres passivos, reativos.

E sem liberdade de pensamento, sem sentimentos, sem criatividade, nós perdemos aquilo que nos faz humanos. Nós nos tornamos máquinas.

Querem um exemplo?

Na década de 90, a moda do mercado era Delphi. Toda vez que um aluno perguntava o que deveria aprender para entrar no mercado, a resposta era: Delphi. Porque Delphi era utilizado em muitas empresas, porque a maioria das vagas em aberto eram para programadores Delphi, etc. Assim, uma massa enorme de pessoas foi estimulada a aprender uma ferramenta, sem se preocupar com base algorítmica, lógica, estrutura ou estilo. Grande parte tornou-se mão de obra barata e dispensável.

Quando os ventos do mercado sopraram em uma outra direção, quem não estava realmente preparado foi varrido do mapa.

Depois vieram o Java, o .NET, o Ruby, entre outros.

Então você está dizendo que essas linguagens são ruins? Definitivamente não, e esse nem é o foco. A sacada é que mesmo nessas linguagens da moda, poucas pessoas estão realmente preparadas e bem posicionadas, enquanto a maioria é só mão de obra substituível e barata.

O que faz um profissional ser bem sucedido é sua capacidade de resolver problemas, e não quantas ferramentas ele sabe manipular.

É claro que quanto mais ferramentas à sua disposição, mais fácil tende a ser o seu trabalho, mas isso só é verdade se você possuir base o suficiente para escolher qual ferramenta se aplica e qual não se aplica. Essa talvez seja a melhor medida de competência.

Voltando ao questionamento anterior, se você só buscar o conhecimento quando houver uma necessidade, você provavelmente não terá à sua disposição conteúdo suficiente para fazer uma boa escolha quando precisar. Na verdade a escolha já terá sido feita por outra pessoa e só te restará a opção de acatar e seguir, depois é claro de correr atrás para aprender o que outra pessoa decidiu que é melhor para você.

Non Dvcor Dvco

Quando alguém me pergunta o que deve aprender para entrar no mercado de trabalho, em sempre me lembro da frase que está na bandeira da cidade de São Paulo: Não sou conduzido, conduzo.

Então eu digo que a pergunta está invertida. Está tudo errado e essa falácia é vendida com pompa e circunstância. Você não tem que aprender nada para agradar ao mercado, na verdade o que você tem que fazer é deixar o mercado querendo ter você, te desejando.

Se você fica sempre preocupado com o que os outros querem que você faça, você estará sempre um passo atrás, buscando algo que não é o que você deseja, e que assim que o vento mudar pode se tornar inútil.

Pergunte ao invés disso quais as características que você precisa desenvolver para se tornar um profissional desejado. A resposta é simples. Seja excelente. Escolha aquilo que mais lhe dá prazer e dedique-se com afinco. Prepare-se, busque embasamento, não se prenda a ferramentas e comandos, procure conhecer o que está em torno do que você está fazendo. Seja curioso, pergunte. Aprenda a ser um hacker no verdadeiro sentido da palavra.

Quando você parar de se preocupar com o que está na moda você vai perceber que há vagas que não conseguem ser preenchidas por empurradores de rato.

Busque sempre o conhecimento, mesmo que sem uma aplicação óbvia, pois as grandes invenções da humanidade só foram possíveis depois de integrar idéias muitas vezes não relacionadas. Há sempre mais de uma ciência por trás de tudo que você toca.

Explore com paixão o máximo de suas habilidades, que o sucesso será uma mera cosequência.

Apêndice

Especialmente mas não exclusivamente para os alunos do curso, deixo alguns links interessantes:

• How To Become A Hacker
• How To Ask Questions The Smart Way
• The UNIX System
• GNU Operating System
• The MINIX 3 Operating System
• Free BSD
• Linux Kernel
• Bash
• KornShell
• The Linux Documentation Project
• Advanced Bash-Scripting Guide
• Program Library HOWTO
• Guia Foca GNU/Linux
• Fedora Brasil
• Ubuntu-BR
• Slackware
• GCC
• Perl
• XFree86
• Xorg
• Compiz
• Git

Online desde 26/10/1995, com 17365 módulos escritos por 7930 autores (até o momento da escrita deste post), o CPAN é o repositório oficial de módulos Perl. Nele podemos encontrar muitas vezes, centenas de módulos prontos para várias tarefas. Essa é uma das facilidades que fazem os programadores Perl serem tão eficientes.

No entanto, a dependência de uma conexão à internet para a instalação de novos módulos, é por vezes um empecilho para a utilização desta poderosa ferramenta. Mas como em Perl sempre há mais de uma forma de se fazer, neste post mostraremos como criar um mini-mirror do cpan para ser utilizado em ambientes onde uma conexão com a internet nem sempre é possível.

Depois de configurar o aplicativo cpan para instalar módulos localmente com a local::lib, o primeiro passo para configurar o mirror é instalar e configurar o módulo CPAN::Mini e seus aplicativos.

Existem várias formas de se configurar o minicpan. A que eu mais uso é a que é feita através de um arquivo de configuração chamado .minicpanrc que deve ser criado no diretório home do usuário. Ele possui somente duas linhas conforme abaixo:

1
2

local: ~/minicpan
remote: http://www.cpan.org

A primeira linha indica em qual diretório ficarão os arquivos do mirror, enquanto a segunda indica de onde as informações sobre os pacotes serão baixadas.

Feito isso, podemos instalar o módulo CPAN::Mini com o comando:

1

user@host:~$ cpan CPAN::Mini

Depois de instalar o módulo, executamos o comando minicpan que vai sincronizar o repositório indicado no ‘remote’ do .minicpanrc com o repositório na internet. Esta parte pode demorar entre alguns minutos e várias horas, dependendo da velocidade do seu link.

1
2
3
4
5
6
7

user@host-perl:~$ minicpan
authors/01mailrc.txt.gz ... updated
modules/02packages.details.txt.gz ... updated
modules/03modlist.data.gz ... updated
authors/id/A/AA/AAYARS/Devel-Ladybug-0.406.tar.gz ... updated
authors/id/A/AA/AAYARS/CHECKSUMS ... updated
...

A última etapa é configurar o aplicativo cpan para utilizar o nosso mirror local como primeira opção de download. Isso é feito pelo próprio prompt do cpan:

1

cpan> o conf urllist unshift file:///home/blabos/minicpan

Onde /home/blabos é o diretório home do usuário, no meu caso, blabos; e minicpan é o diretório que configuramos na opção ‘local’ do .minicpanrc.

Com esses passo simples, conseguimos construir um mini-mirror do cpan para ser utilizado em ambientes com pouco ou nenhum acesso à internet. Adicionalmente, para replicar o mirror em outras máquinas, basta copiar o diretório minicpan e adicioná-lo como opção de download para o comando cpan (última etapa descrita anteriormente).

Meus sinceros agradecimentos ao edenc que primeiro me falou a respeito do minicpan, ao Randal Schwartz que escreveu o script original do minicpan e ao Ricardo SIGNES que transformou o script do Randal em um módulo.

Se quiser saber mais a respeito, dê uma olhada no artigo original do Randal ou na documentação online do módulo.

O CVS foi o primeiro sistema de controle de versão com o qual trabalhei. Não sei se era pela minha inexperiência, mas ele sempre foi mais uma pedra no sapato que uma ferramenta de trabalho.

Quando conheci o Subversion fiquei espantado:

“Nossa! É possível tirar um snapshot do repositório inteiro. Uau!”

A parte chata era que ainda como o CVS, precisava de um servidor para onde mandar os meus commits. Assim quando eu estava sem conexão ou sem servidor, simplesmente não era possível fazer os commits, a menos é claro que eu mantivesse uma cópia do reositório na sua máquina e gerenciasse toda essa bagunça.

Quando ouvi falar do git, não fiquei muito entusiasmado, mas depois do primeiro uso:

“Caceta, eu não preciso de um servidor pra enviar commits!”

Eu não vou entrar das funcionalidades do git aqui, até porque esse não é o objetivo do post. Para quem quiser estudar o git há farta documentação na internet e no site do git e há um livro bem legal disponível sob Creative Commons chamado Pro Git.

Há alguns meses eu também conheci o github, um site source-forge-like onde você pode hospedar seus projetos versionados com git, interagir com outros desenvolvedores e muito mais.

Para quem vive no mundo unix, trabalhar com o github é trivial. É so cadastrar um usuário, gerar uma chave SSH e começar a postar código.

Agora se você compartilha da triste sina dos pouco afortunados que ainda não se libertaram do windows, utilizar o github é … trivial também!

Para tanto é necessário que se instale o Cygwin. O Cygwin é uma ferramenta bem bacana que automatiza a instalação de aplicativos tipicamente unix no windows.

O processo de instalação é bem simples. Baixe o Cygwin direto do seu site e execute com um duplo clique (duh!!!).

Há várias opções de personalização. Eu utilizei as opções default, até chegar na tela onde se configura qual o repositório de onde o instalador vai baixar os pacotes. Aqui uma ressalva: alguns repositórios são mais rápidos que outros. Faça seus testes. Eu utilizei o http://cygwin.cibermirror.org.

Depois na tela de seleção de pacotes, vá na aba Devel e selecione os pacotes do git.

Na aba Net, selecione os pacotes do openssh.

Next, next, finish.

A partir daqui, supondo que você já tenha um usuário cadastrado no github, falta configurar as chaves de acesso. As chaves são mecanismos de segurança utilizadas pelo servidor para que ele tenha certeza que você é você mesmo. Se você ainda não tem um usuário cadastrado no github, cadastre-se for free.

Para criar a chave basta seguir os passos do tutorial que tem no próprio github e gerar a chave. Vá em Account Settings e depois em SSH Public Keys. Há um link pequeno Need help with public keys?. O tutorial está um pouco desatualizado em relação às telas que ele mostra, mas ainda está completamente funcional.

Resumindo, abra o terminal do Cygwin que você acabou de instalar, digite ssh-keygen -t rsa -C “seu_email@vai_aqui.com”, conforme mostra a figura, substituindo seu_email@vai_aqui.com pelo seu email, naturalmente, responda às perguntas e digite uma senha. Essa senha pode ser uma frase longa (recomendado) ou pode ser vazia. Ela será requisitada toda vez que você for sincronizar dados com o github.

Você precisa agora enviar para o github a chave pública. Para isso abra o arquivo da chave pública – normalmente .ssh/id_rsa.pub – com o notepad, copie o texto e cole no formulário do github. Mas preste atenção, você precisa envia a chave pública. Há um .pub no final do arquivo. A chave privada – sem o .pub no final – não deve nunca se posta em público.

Pronto agora você é capaz de enviar código para a sua conta no github.

Atente para o detalhe que nos seus projetos há uma url pública e uma url somente sua.

E bom social coding para você também.

Instalar módulos do CPAN em máquinas onde você não tem permissão de root é muito simples. Utilizando o módulo local::lib do próprio CPAN, você pode criar uma instalação local na qual os módulos são instalados no seu próprio home.

Configurando o cpan

Para isso, basta chamar um terminal e digitar o comando cpan. Ele vai mostrar uma pequena mensagem de apresentação e perguntar se você gostaria de deixá-lo configurar tudo automaticamente. Para a maioria dos casos a configuração automática é suficiente, no entanto eu vou configurar algumas opções por mim mesmo, então vou responder ‘no’.

Would you like me to configure as much as possible automatically? [yes] no

A primeira opção que eu vou responder diferente da default é a que define a política de pré-requisitos (<prerequisites_policy>). Ela define o que o cpan deve fazer ao se deparar com um módulo que possui um dependência. O default é ‘ask’ (perguntar).

Policy on building prerequisites (follow, ask or ignore)? [ask] follow

Eu vou modificar para ‘follow’ (seguir). Assim, quando o cpan encontrar um módulo que possui alguma dependência, ao invés de me perguntar, ele vai tentar instalá-la automaticamente. Isso é extremamente útil durante instalações longas com uma árvore de dependências grande como a do Catalyst.

Policy on installing 'build_requires' modules (yes, no, ask/yes,
ask/no)? [ask/yes] yes

Na sequência vem a pergunta sobre a instalação de dependências de build dos módulos. Eu vou alterar de ‘ask/yes’ para ‘yes’ para que as dependências de build também sejam instaladas. O default era perguntar e sugerir sim como resposta.

A seguir vem uma sequência de perguntas sobre ferramentas que o cpan normalmente usa. Eu aproveito esse momento para checar se alguma está faltando e então instalá-la.

Where is your bzip2 program? [/bin/bzip2]
 
Where is your gzip program? [/bin/gzip]

Várias opções depois, a próxima que eu modifico é o charset default de ISO-8859-1 para UTF-8.

The next option deals with the charset (aka character set) your
terminal supports. In general, CPAN is English speaking territory, so
the charset does not matter much but some CPAN have names that are
outside the ASCII range. If your terminal supports UTF-8, you should
say no to the next question. If it expects ISO-8859-1 (also known as
LATIN1) then you should say yes. If it supports neither, your answer
does not matter because you will not be able to read the names of some
authors anyway. If you answer no, names will be output in UTF-8.
 
Your terminal expects ISO-8859-1 (yes/no)? [yes] no

O cpan vai te perguntar se ele pode se conectar à internet para baixar a lista de repositórios. Ele é bem educado quanto às coisas que ele precisa fazer, por isso estamos configurando opções que o deixem mais independente. Responda yes e aguarde ele baixar a lista de servidores.

Depois de se comunicar com os servidores default, ele te pergunta sobre quais repositórios você quer configurar em três etapas. Primeiro pergunta o continente, depois o país e por último o próprio repositório. É possível escolher mais de uma opção simultaneamente. Eu escolhi para continentes América do Sul e América do Norte, para países Brasil, Chile e Estados Unidos e por último alguns repositórios em cada país. Fique à vontade para escolher quantos e quais quiser.

Pronto. Agora você está no shell do cpan.

Instalando o módulo local::lib

O próximo passo é instalar e configurar o módulo local::lib. Para isso digite no shell do cpan o comando:

cpan[1]> look local::lib

Isso vai fazer com o que o cpan baixe o módulo mas não instale-o automaticamente. Ao invés disso ele vai abrir um novo shell no diretório local onde ele desempacotou o módulo local::lib.

Neste shell, faça o bootstrap com os seguintes comandos:

catalyst@spectro:~/.cpan/build/local-lib-1.004003-UyX2wf$ perl Makefile.PL \
--bootstrap && make test && make install

Por último mas não menos importante é preciso exportar algumas variáveis de ambiente. Para isso saia do shell atual (Ctrl+D), saia do shell do cpan (bye ou quit) e execute no bash o seguinte comando:

echo 'eval $(perl -I$HOME/perl5/lib/perl5 -Mlocal::lib)' >>~/.bashrc

Isso vai adicionar os comandos que exportam as variáveis de ambiente ao final do seu arquivo .bashrc, e então a cada login elas serão automaticamente exportadas.

Force a re-execução do seu bashrc ou faça logout e login novamente

catalyst@spectro:~$ . ~/.bashrc

Certifique-se que as variáveis de ambiente foram configuradas ou coisas estranhas podem acontecer. Entenda por “coisas estranhas” qualquer coisa diferente do funcionamento correto. Algumas podem ser realmente bizarras.

catalyst@spectro:~$ env | grep perl
PERL5LIB=/home/catalyst/perl5/lib/perl5:/home/catalyst/perl5/lib/perl5...
MODULEBUILDRC=/home/catalyst/perl5/.modulebuildrc
PATH=/home/catalyst/perl5/bin:/usr/local/bin:/usr/bin:/bin:/usr/games
PERL_MM_OPT=INSTALL_BASE=/home/catalyst/perl5
catalyst@spectro:~$

Retocando a maquiagem

Agora, antes de começar a instalar módulos, é uma boa atualizar o próprio módulo CPAN.pm. Atente para as maiúsculas e minúsculas.

catalyst@spectro:~$ cpan CPAN
...
Installing /home/catalyst/perl5/bin/cpan
Writing /home/catalyst/perl5/lib/perl5/i486-linux-gnu-thread-multi/auto...
Appending installation info to /home/catalyst/perl5/lib/perl5/i486-linux...
  ANDK/CPAN-1.9402.tar.gz
  /usr/bin/make install  -- OK
Warning (usually harmless): 'YAML' not installed, will not store persist...
catalyst@spectro:~$

Depois da instalação da nova versão do CPAN.pm, note que ele está avisando que o módulo YAML não está instalado. Para deixar tudo redondinho vamos intalá-lo também.

catalyst@spectro:~$ cpan YAML
...
Writing /home/catalyst/perl5/lib/perl5/i486-linux-gnu-thread-multi/auto/Y...
Appending installation info to /home/catalyst/perl5/lib/perl5/i486-linux...
  INGY/YAML-0.68.tar.gz
  /usr/bin/make install  -- OK
CPAN: YAML loaded ok (v0.68)
Going to read 1 yaml file from /home/catalyst/.cpan/build/
DONE
Restored the state of none (in 0.0265 secs)
catalyst@spectro:~$

Agora sim. Vamos dar uma conferida onde foi parar o módulo YAML recém instalado:

catalyst@spectro:~$ ls ~/perl5/lib/perl5
CPAN  CPAN.pm  i486-linux-gnu-thread-multi  local  Test  YAML  YAML.pm
catalyst@spectro:~$

Ele foi instalado dentro de uma árvore de diretórios criada no home do usuário corrente. Tudo isso sem pedir a senha de root uma única vez.

Conclusão

Instalar módulos do CPAN localmente sem precisar de senha de root é muito fácil. Isso é extremamente útil em máquinas onde você tem apenas permissão de usuário comum, como em servidores de hospedagem.

Uma outra vantagem é que para levar os mesmos módulos para outra máquina (com a mesma arquitetura) basta copiar o diretório perl5 que você acabou de criar, já que todos os módulos estão instalados dentro dele, bem como adicionar o comando que exporta as variáveis de ambiente na máquina destino. Isso também é bastante útil quando você tem um servidor de hospedagem que não te dá acesso a um shell.

Links (in)úteis

• Módulo local::lib
• Módulo CPAN.pm

Relembrando Arrays

Um array, ou matriz, ou ainda um arranjo, é uma abstração matemática utilizada para representar um conjunto de dados homogêneos, ou seja do mesmo tipo (int, float, etc). Essa abstração é organizada em formato de tabela, com linhas e colunas. Cada elemento na matriz possui coordenadas únicas (linha e coluna), de forma que um dado elemento E(i,j) representa o único elemento na posição “linha i”, “coluna j”.

A sintaxe de declaração de matrizes segue abaixo:

// Matrizes unidimensionais ou vetores
int     ivet[10];               // 10 elementos, do 0 ao 9
char    cvet[23];               // 23 elementos, do 0 ao 22
 
// Matrizes bidimensionais
int     imat[2][3];             // 2 linhas (0 a 1) e 3 colunas (0 a 2)
double  dmat[10][2];            // 10 linhas (0 a 9) e 2 colunas (0 a 1)

Cada elemento da matriz é independente dos demais e pode ser acessado conforme a sintaxe abaixo:

int ivet[10];
int imat[3][4];
 
// Alterando o quarto elemento do vetor ivet.
// Lembre-se que começa-se a contar a partir do elemento zero
ivet[3] = 13;
 
// Lendo o segundo elemento do vetor ivet
int num = ivet[1];
 
// Alterando o elemento da primeira linha, segunda coluna de imat
imat[0][1] = 42;
 
// Lendo o elemento na terceira linha, quarta coluna de imat
int foo = imat[2][3];

Neste post não vamos discutir a fundo matrizes, vamos apenas investigar a relação entre matrizes e ponteiros de uma forma bastante intuitiva.

Tamanhos de matrizes

Dado que uma matriz é uma abstração que comporta vários valores de um mesmo tipo, qual o tamanho dela? Quanto espaço ele ocupa na memória?

Considere o código abaixo:

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

int     ivet[10];
char    cvet[13];
double  dvet[20];
 
char    cmat[3][4];
int     imat[5][4];
 
cout << "sizeof(int)     = " << sizeof(int) << endl;
cout << "sizeof(char)    = " << sizeof(char) << endl;
cout << "sizeof(double)  = " << sizeof(double) << endl;
 
cout << "sizeof(ivet)    = " << sizeof(ivet) << endl;
cout << "sizeof(cvet)    = " << sizeof(cvet) << endl;
cout << "sizeof(dvet)    = " << sizeof(dvet) << endl;
cout << "sizeof(cmat)    = " << sizeof(cmat) << endl;
cout << "sizeof(imat)    = " << sizeof(imat) << endl;

O resultado é bastante razoável. O Espaço ocupado por uma matriz é igual ao número de elementos multiplicado pelo tamanho do tipo do elemento (linhas x colunas x sizeof(tipo)). Ora, se cada elemento é independente, supõe-se que cada um ocupe um lugar separado na memória, caso contrário um elemento sobrescreveria outro. Sendo assim, será que cada elemento possui seu próprio endereço de memória?

Matrizes e endereços de memória

Para facilitar, vamos então analisar os possíveis endereços de uma matriz de caracteres, cujo tamanho de um dado único é 1 byte:

15
16
17
18
19
20
21
22
23
24
25
26
27
28

const int max = 5;
char cvet[max] = {'A', 'B', 'C', 'D', 'E'};
 
// Mostrando o índices, valores e endereços dos dados.
printf("Índice\tValor\tEndereço do elemento\n");
for (int i = 0; i < max; i++) {
    printf("%d\t%c\t%p\n", i, cvet[i], &cvet[i]);
}
 
// Mostrando o endereço da própria matriz
printf("Endereço da matriz: %p\n", &cvet);
 
// Mostrando o endereço da própria matriz denovo
printf("Endereço da matriz: %p\n", cvet);

Os endereços dos elementos são sequenciais, ou seja, cada elemento é armazenado ao lado do anterior. Adicionalmente existem dois fatos ainda mais interessantes:

1. O endereço do array (&cvet), mostrado na linha 25, é o mesmo do primeiro elemento do array;
2. A própria variável cvet pode ser interpretada como um ponteiro, como é mostrado na linha 28;

Em C++, um array comum é um bloco contíguo de memória cujo nome pode ser interpretado (cast) como um ponteiro que aponta para o seu primeiro elemento. Adicionalmente é válido fazer um ponteiro apontar para um array desde que o ponteiro destino seja para o mesmo tipo que o tipo dos elementos do array. Durante a atrubuição de um array a um ponteiro, o compilador faz uma conversão implícita de tipos. O ponteiro destino passa a ser interpretado como um ponteiro para a área de memória ocupada pelo array.

Uma das consequências não tão óbvias é que durante o cast implícito, é perdida a informação de que aquela área de memória era um array. Portanto é perdida a informação do tamanho do array. Do ponto de vista do ponteiro, ele está apontando para o começo de um bloco arbitrário de memória, de um tamanho também arbitrário. Sair de um array e ir para um ponteiro significa ir de uma abstração mais restritiva e mais alto nível, para um abstração menos restritiva e mais baixo nível.

Por outro lado tentar atribuir um ponteiro a um array gera um erro de compilação por tipos incompatíveis. Um array é um bloco de memória de n dados (bytes), já um ponteiro possui apenas um dado, um endereço. O compilador não tem como saber de antemão se um ponteiro aponta para uma área de 1, 2 ou 200 bytes.

15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

const int max = 300;
char cvet[max];
char* pc = 0;
 
printf("\nAntes da atribuição\n");
printf("cvet = %p\n", cvet);
printf("pc   = %p\n", pc);
printf("sizeof(cvet) = %lu\n", sizeof(cvet));
printf("sizeof(pc)   = %lu\n", sizeof(pc));
 
pc = cvet;
 
printf("\nDepois da atribuição\n");
printf("cvet = %p\n", cvet);
printf("pc   = %p\n", pc);
printf("sizeof(cvet) = %lu\n", sizeof(cvet));
printf("sizeof(pc)   = %lu\n", sizeof(pc));

Note que antes da atribuição (linha 25) o ponteiro pc. está nulo, pois foi inicializado assim. Já os tamanhos indicam que o array possui 300 bytes e o ponteiro apenas 8 (minha máquina é um amd 64). Após a atribuição ambos passam a “apontar” para a mesma área de memória, porém os tamanhos não mudam. Houve um cast implicito de char[300] para char*, e nessa brincadeira o ponteiro pc não tem como saber o tamanho da área de memória para o qual ele aponta. Já o array cvet continua sabendo direitinho o que ele é, sem nenhuma crise existencial.

Aritmética de ponteiros – Vulgo, e daí?

Ora, mas se eu sei que os dados numa matriz estão dispostos lado a lado, eu posso utilizar um ponteiro que vai pulando para o endereço ao lado e acessando o elemento seguinte. O nome disso é aritimética de ponteiros.

15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

const int max = 6; 
char cvet[max] = {'B','L','A','B','O','S'};
 
char* pc = cvet;
 
for (int i = 0; i < max; i++) {
    printf("%c", *(pc + i));
}
printf("\n");
 
for (int i = 0; i < max; i++) {
    printf("%c", *pc++);
}
printf("\n");
 
 
// Agora com inteiros
int ivet[max] = {1, 2, 3, 4, 5, 6};
int* pi = ivet;
 
for (int i = 0; i < max; i++) {
    printf("%p = %d\n", pi, *pi++);
}
printf("\n");
 
// Em duas dimensões
char cmat[2][3] = {{'B','L','A'},{'B','O','S'}};
char* ppc;
 
ppc = (char*)cmat;
 
for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 3; j++) {
        printf("%c", *(ppc + 3*i+j));
    }
    printf("\n");
}
printf("\n");

Na linha 18 o ponteiro pc passa a pontar para o array cvet, e consequentemente para o seu primeiro elemento, o caracter ‘B’. Na linha 21 o conteúdo de pc, que é o endereço onde foi armazenado o caracter ‘B’, é incrementado de i e em seguida de-referenciado. Na primeira passada o valor de i é zero, portanto é dereferenciado para o valor ‘B’. Nos passos seguintes, o endereço seguinte vai sendo de-referenciado para os outros caracteres armazenados no array original. É mais ou menos isso que internamente o compilador faz quando você utiliza a sintaxe cvet[i]. A abstração de array te dá uma forma mais amigável de tratar áreas contíguas de memória do que *(pc + i).

Mas se a abstração de array é mais simples, pra que utilizar aritmética de ponteiros?

Uma das respostas está a linha 26. Ela faz a mesma coisa que a linha 21, porém um pouco mais rápido. Na sintaxe da linha 21, ou de forma semelhante, na sintaxe de array, o acesso a um dado qualquer pode ser resumido de forma bem grosseira nos comandos:

1. Tome o endereço base do array;
2. Adicione ao endereço o valor do índice;
3. De-referencie este novo endereço;

Já com aritmética de ponteiro ficaria assim:

1. De-referencie este endereço;

O comando incremento (ou a conta feita com endereços) não vou contar porque é parte do loop, embora i++; seja mais rápido que a = b + c;. Agora imagine esse pequeno ganho de 66% aplicado em uma área de dados de 1 MB. Serão mais de 2 milhões de comandos a menos!

A técnica de utilizar um ponteiro para manipular uma área arbitrária de memória é utilizada geralmente em programação de baixo nível (mais próximo da máquina), manipulação de buffers e strings, entre outros truques sujos. Nas entranhas dos computadores, operações que varrem extensas áreas de memória, frequentemente são realizadas com aritimética de ponteiros. Nesse nível, Darwin reina supremo e só os mais preparados sobrevivem. A partir daqui a linguagem começa a dar um poder que só os puros de coração conseguem compreender.

Uma observação importante é que entre as linhas 31 e 38 a experiência é repetida com inteiros. Note que como os inteiros possuem 4 bytes, os incrementos são automaticamente feitos de 4 em 4 bytes, e não de 1 em 1, ou seja o incremento é automaticamente calculado para sizeof(tipo). Incrementar um ponteiro significa acessar a próxima área de memória semelhante ao dado atual, e não apenas o próximo endereço. Como o tamanho de um char é um byte, quando incremetamos um ponteiro para char, avançamos apenas 1 byte. Se incrementarmos um ponteiro para double, avançaremos 8 bytes, e assim por diante.

Outra observação é que uma matriz bidimensional pode ser “linearizada” conforme é mostrado nas linhas 40 a 52. Isso é útil, quando aplicável, para aproveitar melhor o cache do processador, por exemplo.

void*, o Pansexual dos ponteiros

Anteriormente eu disse que só era possível atribuir um array a um ponteiro que fosse para o mesmo tipo que os dados do array. Eu menti descaramente! O motivo, é que para alguém que desistiu do post antes deste tópico, é mais seguro acreditar que não pode !

Existem duas exceções à regra. A primeira é quando há uma conversão explícita de tipos e o ponteiro destino “acha” que está apontando para o tipo certo. Um exemplo está na linha 44 do código anterior.

A segunda é o caso dos ponteiros para void. Um ponteiro para void é um ponteiro que não faz exigências quanto ao tipo de dados que está na área de memória para o qual ele aponta. Ele é um ponteiro pra uma área genérica de memória, algo bem baixo nível.

Para utilizar um dado apontado por um ponteiro para void, antes de de-referenciá-lo, é preciso fazer um cast explícito para algum tipo válido, pois se um int* é de-referenciado para int e um char* é de-referenciado para char, adivinhe para que é de-referenciado um void*?

15
16
17
18
19
20
21
22
23
24
25
26
27

const int max = 6; 
char cvet[max] = {'B','L','A','B','O','S'};
 
void* pv = cvet;
 
// Erro de compilação.
//*pv
// Quanto vale sizeof(void)?
 
for (int i = 0; i < max; i++) {
    printf("%c", *(((char*)pv) + i));
}
printf("\n");

Ponteiro para void são utilizados quando precisa-se apontar para uma área genérica de memória sem ter controle/conhecimento do tipo de dados que essa área contém, ou em funções que não podem fazer suposições sobre os tipos de seus parâmetros, como é o caso da API da lib pthreads (link arbitrário).

Encerrando

Quanto mais nos aprofundamos nos tópicos sobre ponteiros, mais próximos da máquina ficamos. Boa parte do poder das linguagens C e C++ provém daí, e boa parte dos problemas também. A complexidade vai aumentando e os riscos também. Para muitos é aí que mora a diversão!

Links

• arrays.zip (todos os fontes do post);
• Ponteiros no cplusplus.com
• Ponteiros no blabos.org
• Referências no blabos.org
• O Culpado

Guardadas as devidas proporções, vamos aos fatos. Faculdade técnica, aula de humanas. Não poderia haver combinação mais explosiva. 60% da nota do semestre viria de um seminário sobre parte do livro Gestão à Brasileira. Trabalho em grupo. Grupo de 8 pessoas. Además, já que a gestão é à brasileira, o prazo para confecção do trabalho também o é. Ok, tá certo que tivemos um adiamento de uma semana por motivos de força maior, mas uma semana a mais em um prazo irrisório, continua irrisório. Mas somos brasileiros e não desistimos nunca!

Eu sou um cara relativamente sortudo, de forma que pude escolher trabalhar com mais 7 pessoas de extrema competência. Tanto é que em todas as fases do projeto trabalho, todos estavam efetivamente envolvidos e produzindo, o que é mais incrível.

Nesta fase apareceram os primeiros telepatas. Seres superiores capazes de fazer o trabalho sem terem lido o texto base, apenas pegando as idéias telepaticamente dos que leram. Os telepatas restantes surgiram na hora de fazer os slides da apresentação, pois fizemos em pedaços meticulosamente encaixáveis, telepaticamente, óbvio!

Mas pessoas diferentes tem necessidades diferentes. Com 8 pessoas trabalhando em partes separadas, cada um utilizou sua suite Office® preferida (2000, 2003, 2007…). Só mesmo um trouxa inventou de usar aquela porcaria do Open Office, aquela merda.

Eis que para a surpresa de todos (inclusive do trouxa que vos fala), certa suite de escritório proprietária mostrou-se incompatível consigo mesma. Como assim Bial? Calma que o tio explica. Primeiramente a versão da SOP (suite office proprietária) onde faríamos a apresentação, especulava-se ser a 2000 (eu não fui conferir). Segundamente, eu não sei por que, eu não sei como e eu não me importo, quando tentávamos salvar na SOP 2007 um conjunto de slides no formato SOP 2003 dava uma merda federal. Era fonte preta que ficava branca, era tamanho de fonte que mudava e não me pergunte, eu não entendo do assunto, os slides com imagens e textos eram transformados em imagens.

Até aí tudo bem (pelo menos pra mim que não tive que refazer slide). Montaram uma operação de guerra com pacotes instaláveis via pendrive, cds e tudo mais.

Quarta feira tensa. Organicamente muito ruim pra mim. Meu dia foi começar a ficar suportável depois das 13:00hs. O que sobrou de mim, repassava o texto, fazia resumos e torcia para chegar inteiro até o momento da apresentação. Meu dia de vidente. Levo note, não levo note? Vou levar o Eee. Maldito peso extra! Outro vidente levou seu note com software proprietário. Os outros confiaram na operação de guerra com tripla redundância: CD, pendrive com SOP instalável e MP4.

Eis que aos 45 do segundo tempo descobrimos que a besta que vos fala replicou 3 textos em um slide. Vamos alterar, moleza! Infelizmente a vesão da SOP do outro vidente era mais recente que versão dos arquivos. Putz, o que é mesmo interoperabilidade? E INTRAoperabilidade? E Retrocompatibilidade? Que pena, pelo visto as SOPs em questão desconhecem todos esses conceitos. Resultado: Fodeu. Não me pergunte como, texto foi salvo como imagem, fonte trocou de cor e o escambau.

Já quase conformados com a idéia de ter que reformatar todo o trabalho em 15 min, resolvi abrir o arquivo em formato proprietário com aquela bosta de Open Office. Resultado: Milagre! O Open Office conseguiu recuperar boa parte do trabalho. Daí, 3 ou 4 ajustes e os slides estavam corrigidos. Só tinha um pequeno problema. A máquina onde faríamos a apresentação não entendia ODF, e salvar no formato da SOP destruía a formatação. Ah Eee, você tem saída VGA! Despluga, pluga, nada. Reboot plugado e tã-dãm! Simplesmente funciona. Eee plugado no projetor e funcionando.

Moral da história: Open Office + Eee = Trabalho apresentado, nota garantida. Até o próximo semestre (nesta matéria).

Não me pergunte porque foi tão difícil dominar uma suite office. Não me interessa. Eu não quero ler um manual de 6000 páginas pra poder fazer um conjunto de slides simples, somente com texto e imagens, sem efeitos. Não é isso que os defensores do software proprietário bradam? Que simplesmente funciona? Que o Open Office é uma merda? Ok, pode até ser, mas pelo menos é uma merda que fede, que faz que se propõe a fazer. Não me interessa qual versão roda na faculdade ou na sua casa. Eu quero poder compartilhar arquivos sem surpresas com meus 7 colegas de grupo, cada um com o software que melhor lhe servir. Eu quero interoperabilidade. Não me interessa se o Open Office não é a borboleta coloria faiscante sueca que você quer. Eu quero que simplesmente funcione. Que seja simples. Que seja intuitivo. Que eu não precise perder tempo refatorando slide. Tempo esse que eu poderia estar estudando Cálculo, Grafos ou o que mais fosse.

Não me interessa se você me chamar de burro por não conseguir fazer slide em suite sofisticada. Eu não quero ter que reservar uma área do meu cérebro para descobrir como usar um software de fazer slide, pra aula de humanas (com o devido respeito). Eu quero gastar meu cérebro entendendo como se comporta uma derivada parcial com n variáveis num espaço de m dimensões, pra entender e argumentar quando um livro de cálculo trás curvas de níveis desenhadas ao contrário. Eu quero gastar meu cérebro entendendo que apesar de uma referência existir e ocupar memória, um operador nunca opera sobre ela.

Não faço Ciência da Computação pra aprender a ser operador de planilha ou arrastador de caixinha colorida.

Creio que devemos umas cervejas ao pessoal do Open Office pelo excelente trabalho de engenharia reversa sobre formatos proprietários. Você poderiam dar umas aulas para o pessoal de certa empresa de software, pra que eles aprendam a ser mais compatíveis com eles mesmos. A partir de hoje vocês ganharam por tempo indeterminado um banner (feio que dói) no blog, na faixa.

Ao pessoal do grupo meus sinceros agradecimentos por um trabalho bem feito e bem apresentado. É sempre uma honra poder trabalhar com os melhores.

Uma referência é um nome alternativo para um objeto, um alias. Aliás, quem diz isso não sou eu, mas o próprio Bjarne Stroustrup, lá pelo tópico 5.5 do seu livro, cujo conteúdo é tão bom que só fui reparar hoje que na capa tem uma onda quebrando em forma de C. Gostei dessa capa!

Declarando Referências

Uma referência para um determinado tipo é declarada acrescentando-se o caracter & (ê comercial ou ampersand) após o nome do tipo da referência. Note que da mesma forma que na declaração de ponteiros, estamos tratando o & como um caracter de notação e não um operador. Não há um operador de declaração de ponteiros ou referências. É apenas uma notação da linguagem. Dado um tipo T, a expressão T& significa Referência para T. Por exemplo:

// Declara uma variável inteira original.
// Também poderia ser char, float, etc.
int i;
 
// Declaram referências para a variável i.
// Todas as formas são equivalentes, mas preferimos a primeira.
// Note que os tipos das referências tem que ser os mesmos
// que os das variáveis referenciadas.
int& ra     = i;
int &rb     = i;
int & rc    = i;
 
// Diferentemente de ponteiros, a linha abaixo gera um
// erro de compilação. Você saberia dizer por quê?
int &r1, &r2;

Embora em C++ as referências lembrem um pouco os ponteiros, eles são bem diferentes. Ao contrário do que acontece com ponteiros, uma referência precisa ser inicializada durante sua declaração. Tentar declarar uma referência sem inicializá-la gera um erro em tempo de compilação, ou seja, o compilador vai cuspir na sua cara “Perdeu playboy, perdeu!”. A única exceção a essa regra é para referências declaradas como extern, pois elas serão inicializadas em algum outro ponto do programa, mas isso é outro papo.

Se você tentar trapacear declarando uma referência extern sem inicializá-la o compilador não vai reclamar. Se ela nunca for utilizada, ok. Se o compilador for esperto e notar que ela não será utilizada, pode até removê-la da lista de símbolos. Mas se ela for utilizada em qualquer parte do programa, o linker vai rir da sua cara gargalhando “undefined reference to ‘nome_da_variavel’”. Portanto faça as coisas direitinho. Declarou uma referência? Então iniclalize-a. extern? Tem certeza que sabe o que está fazendo?

A lógica por trás disso é que uma referência foi planejada para ser um nome para alguma coisa. Se você não a inicializar, ela não será nome para nada, então não faz sentido. Um detalhe muito importante é que inicializar uma referência não é atribuir um valor a ela. Como o prório Bjarne diz, nenhum operador opera sobre referências, ou seja, não há como atribuir, somar, subtrair, etc com uma referência. Como uma referência é um apelido para um objeto, cada operador atua nese objeto, e não na referência. Uma vez inicializada, uma referência sempre referenciará o mesmo objeto.

A primeira armadilha com referências, assim como ponteiros está na questão do tamanho. Enquanto o tamanho de um ponteiro (e de outras estruturas de dados) pode ser obtido com o operador sizeof, o tamanho de uma referência não pode ser obtido por técnicas convencionais, já que ao aplicar o operador sizeof em uma referência, estamos na verdade, aplicando o operador no objeto ao qual ela se referencia, conforme vimos no parágrafo anterior.

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

char    c;
int     i;
double  d;
 
char&   rc = c;
int&    ri = i;
double& rd = d;
 
// O operador sizeof diz o tamanho do tipo do seu argumento.
cout << "Size of char:    " << sizeof(c) << " bytes" << endl;
cout << "Size of int:     " << sizeof(i) << " bytes" << endl;
cout << "Size of double:  " << sizeof(d) << " bytes" << endl;
 
cout << endl;
 
cout << "Size of char&:   " << sizeof(rc) << " bytes" << endl;
cout << "Size of int&:    " << sizeof(ri) << " bytes" << endl;
cout << "Size of double&: " << sizeof(rd) << " bytes" << endl;

As técnicas para obter os tamanhos das referências fogem ao escopo deste texto, mas pretendo falar sobre elas futuramente. Por hora, vou apenas dizer sem demonstrar que, quando aplicável, o tamanho de uma referência é idêntico ao tamanho de um ponteiro.

A parte boa da história é que frequentemente os tamanhos de ponteiros e referências são bem menos relevantes que os tamanhos dos objetos apontados ou referenciados. Eu particularmente, nunca precisei utilizar essa informação, mas para o desenvolvimento em arquiteturas diferentes ou para sistemas embarcados, isso já se torna mais interessante.

Utilizando Referências

O uso de referências já é bem mais simples que o de ponteiros, pois não são necessários operadores de extração de endereços ou de de-referenciação. Variáveis referências são utilizadas como variáveis comuns, lembrando que uma operação feita numa referência sempre afeta o objeto referenciado.

17
18
19
20
21
22
23
24
25
26
27
28
29
30

int x, y;
int& rx = x;
int& ry = y;
 
x = 13;
y = 10;
 
rx = 42;    // A atribuição é automaticamente aplicada em x.
ry++;       // O incremento é automaticamente aplicado em y.
 
cout << "x:  " << x << endl;    // Valor de x.
cout << "y:  " << y << endl;    // Valor de y.
cout << "rx: " << rx << endl;   // Valor de rx == x.
cout << "ry: " << ry << endl;   // Valor de ry == y.

Utilizar uma referência é tão transparente para o programador, que ele nem precisa saber que é uma referência. Simplesmente usa como se fosse uma variável ordinária. Com minha imaginação limitada não vejo como alguém consiga ser excomungado por utilizar referências inadequadamente. Embora sempre tenha algum espírito de porco que consiga fazer merda com referências, é muito mais fácil levar rasteira de Saci ao manusear ponteiros.

Endereços e Referências

Do ponto de vista de Murphy, as referências são feias, chatas e bobas, pois existe pouca coisa potencialmente perigosa a se fazer com elas. Nem mesmo quanto a endereçamento há muitas surpresas (será?). Considere o código abaixo:

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

int a = 10;
int b = 13;
 
int& ra = a;
int& rb = b;
 
ra = 42;
rb = 7;
 
cout << "ra  = " << ra << endl;// O valor de ra == 42.
cout << "rb  = " << rb << endl;// O valor de rb == 7.
cout << "a   = " << a << endl; // O valor de a == ra == 42.
cout << "b   = " << b << endl; // O valor de b == rb == 7.
 
cout << "&a  = " << &a << endl; // O endereço de a.
cout << "&b  = " << &b << endl; // O endereço de b.
cout << "&ra = " << &ra << endl;// O endereço de ra == &a. 
cout << "&rb = " << &rb << endl;// O endereço de rb == &b.

Nas linhas 17 e 18 eu declaro duas variáveis inteiras (poderia ter feito esse exemplo com uma só…). Nas linhas 20 e 21 eu declaro duas referências, referenciando as duas variáveis anteriores. A partir desse momento as variáveis ra e rb são apenas apelidos para as variáveis a e b. Como vimos anteriormente, qualquer operador aplicado às referências, na verdade atua nos objetos referenciados, portanto cada par variável-referência possui sempre o mesmo valor.

A parte interessante a se notar é que os endereços das referências são exatamente os mesmo endereços das variáveis que elas referenciam, ao contrário dos ponteiros que tinham seus próprios endereços. Por quê? Porque você caiu na Pegadinha do Malandro. Lembra daquele papo de nenhum operador ser aplicável a uma referência? Pois bem, o & utilizado aqui é o operador “endereço de”, que também é aplicado diretamente nas variáveis originais e não nas referências. As mesmas técnicas ninja utilizadas para obter os tamanhos das referências são necessárias para se obter os endereços delas.

Novamente a parte divertida disso é que o mecanismo de referências foi planejado para ser o mais transparente possível para o programador. Tamanhos e endereços físicos de referências são informações irrelevantes do ponto de vista da programação “normal” em C++.

Diferenças e semelhanças entre Ponteiros e Referências

Tanto ponteiros como referências são mecanismos de indireção em C++, ou seja, são mecanismos utilizados para que a partir de um dado símbolo (variável) eu seja capaz de manipular outro objeto.

Os principais usos para ponteiros são geralmente relacionados com gerenciamento e manipulação dinâmica de memória, criação e destruição de objetos de formas e em momentos especiais, bem como “passagem de parâmetros por referência” (assim entre aspas mesmo). Já as referências são mais utilizadas em passagem por referência (por que será?) e sobrecarga de operadores.

Basicamente, tudo que podemos fazer com referências pode ser emulado com ponteiros. Já a recíprocra não é sempre verdadeira. A grande vantagem delas no entanto, é o fato de tornarem a indireção completamente transparente ao programador.

Uma alegoria interesante para ajudar a entender melhor as diferenças entre ponteiros e referências é o apelido. Por exemplo: Imagine que um pessoa, digamos, Carlos Caetano Bledorn Verri, seja a nossa variável original, o objeto. Dunga já é uma referência a Carlos Caetano Bledorn Verri, pois é um apelido para o mesmo objeto, são a mesma pessoa. Já a Mãe do Dunga (ou do Carlos Caetano Bledorn Verri, tanto faz), que é contantemente citada pela torcida, pode ser considerada um ponteiro para ele, pois dados determinados operadores de vocabulário, um elogio feito a ela, na verdade é indiretamente direcionado a ele.

Links

• referencias.zip (todos os fontes do post);
• 01-declaracao.cpp
• 02-tamanhos.cpp
• 03-utilizando.cpp
• 04-enderecos.cpp
• O Culpado

Cortesia do pessoal do charges.com.br

Maldito flash…

Bem, se você conseguiu ver até o final, então o plugin aguenta mesmo…

Ponteiro é um tipo especial de dado, cujas variáveis declaradas desse tipo podem apontar (ou não) para algum outro dado na memória. Uma variável do tipo ponteiro, guarda o endereço de um outra coisa na memória. Essa coisa pode ser alguma variável, constante, início de um conjunto de dados, uma função, entre outras.

Declarando Ponteiros

A declaração de um ponteiro é normalmente feita acrescentando-se um * antes do nome da variável. Uma notação muito utilizada cola o * ao nome do tipo para dizer simbolicamente que se está declarando um “ponteiro para o tipo”, ao invés de uma “variável ponteiro”, mas elas são equivalentes. Por exemplo:

// Ponteiro para um int.
int* ptr_num1;
 
// Ou assim.
int *ptr_num2;
 
// Ponteiro para um double.
double* ptr_double1;
 
// Ou assim.
double *ptr_double2;

Depois de declarado, o ponteiro existe, possui tamanho e consequentemente ocupa lugar na memória. O tamanho de um ponteiro geralmente é igual ao número de bits da máquina/sistema em questão, por exemplo 4 bytes num sistema 32 bits.

17
18
19
20
21
22
23
24
25
26
27
28
29
30

char    c, *pc;
int     i, *pi;
double  d, *pd;
 
// O operador sizeof diz o tamanho do tipo do seu argumento.
cout << "Size of char:    " << sizeof(c) << " bytes" << endl;
cout << "Size of int:     " << sizeof(i) << " bytes" << endl;
cout << "Size of double:  " << sizeof(d) << " bytes" << endl;
 
cout << endl;
 
cout << "Size of char*:   " << sizeof(pc) << " bytes" << endl;
cout << "Size of int*:    " << sizeof(pi) << " bytes" << endl;
cout << "Size of double*: " << sizeof(pd) << " bytes" << endl;

Utilizando Ponteiros

Após a sua declaração, o conteúdo de um ponteiro é um valor aleatório, lixo de memória, como qualquer variável. Para que ele seja útil precisamos atribuir algo a ele. Como um ponteiro guarda um endereço de memória, precisamos atribuir a ele um endereço válido.

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

int x, y;
int *px, *py;
 
x = 13;
y = 10;
 
px = &x;
py = &y;
 
*px = 42;
(*py)++;
 
cout << *px << endl;
cout << *py << endl;
cout << (*px) * (*py) << endl;

O operador & (ê comercial ou ampersand) antes do nome de uma variável significa “o endereço de”, até porque o seu nome é “endereço de”.

O que está à esquerda da igualdade tem que poder guardar exatamente o mesmo tipo do que estiver do outro lado da igualdade. Um ponteiro guarda um endereço. Portanto para atribuir um endereço a um ponteiro, neste caso, é preciso obter um endereço com o operador &.

Exceto nos caso em que há conversão implícita de tipos (como entre tipos numéricos), atribuir a uma variável algo com um tipo diferente do seu, causa um erro de compilação. Felizmente!!!

Depois que um ponteiro já apontar para um endereço válido, poderemos acessar o conteúdo desse endereço com o operador * (Asterisco), cujo nome formal é “operador de de-referência”.

Note que o asterisco em uma declaração significa “ponteiro para o tipo” e no contexto da leitura ou escrita do conteúdo de um ponteiro, significa “o conteúdo do endereço” ou “o conteúdo apontado por”. Também cuidado para não confundir com o símbolo para produto aritmético. Para não confundir, lembre-se daquela tabela enorme de precedência dos operadores, que você só passou o olho e deixou cair no esquecimento. Nela você vai encontrar que o operador de de-referência tem precedência sobre o operador de multiplicação. Feito isso você vai se lembrar que o operador de de-referência é avaliado ANTES do operador de multiplicação.

17
18
19
20
21
22
23
24
25
26
27
28
29
30

int a, b, c, *pa, *pb;
a = 2;
b = 3;
 
pa = &a;
pb = &b;
 
c = *pa * *pb;
c = *pa * * pb;
c = * pa * * pb;
c = *pa**pb;
c = (*pa) * (*pb);
 
cout << "Valor da Pegadinha: " << c << endl;

Assim quando aquela prova de algoritmos te perguntar o que faz qualquer uma das últimas 5 linhas do exemplo, você vai dizer que ela multiplica os conteúdos apontados por pa e pb. Não vai mais precisar pegar DP por causa disso! E de quebra na vida real, se você realmente precisar fazer isso, você vai salvar suas 4 gerações passadas e as 5 futuras da excomunhão, se escolher usar a última linha.

Tudo que é possível fazer com uma variável comum é possível fazer com o conteúdo apontado por um ponteiro, seja leitura ou escrita (a menos é claro que o ponteiro seja const, mas isso é outro papo…).

Endereços e Ponteiros

Tomemos como exemplo o código abaixo:

18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

int a, b;
int *pa, *pb;
 
printf("Antes de qualquer atribuição:\n");
 
printf("&a  = %p\n", &a); // Endereço válido dado pelo SO.
printf("&b  = %p\n", &b); // Endereço válido dado pelo SO.
printf("&pa = %p\n", &pa);// Endereço válido dado pelo SO.
printf("&pb = %p\n", &pb);// Endereço válido dado pelo SO.
 
printf("\n");
 
printf("a   = %d\n", a);  // Conteúdo não inicializado (aleatório).
printf("b   = %d\n", b);  // Conteúdo não inicializado (aleatório).
printf("pa  = %p\n", pa); // Conteúdo não inicializado (aleatório).
printf("pb  = %p\n", pb); // Conteúdo não inicializado (aleatório).
 
// Tente descomentar as linhas abaixo, recompilar e rodar.
//printf("*pa  = %d\n", *pa); // O que será (*aleatório)?
//printf("*pb  = %d\n", *pb); // O que será (*aleatório)?
 
printf("\nApós as inicializações dos ponteiros:\n");
 
pa = &a;
pb = &b;
 
printf("&a  = %p\n", &a); // Mesmo endereço válido dado pelo SO.
printf("&b  = %p\n", &b); // Mesmo endereço válido dado pelo SO.
printf("&pa = %p\n", &pa);// Mesmo endereço válido dado pelo SO.
printf("&pb = %p\n", &pb);// Mesmo endereço válido dado pelo SO.
 
printf("\n");
 
printf("a   = %d\n", a);  // Conteúdo não inicializado (aleatório).
printf("b   = %d\n", b);  // Conteúdo não inicializado (aleatório).
printf("pa  = %p\n", pa); // Conteúdo inicializado (&a).
printf("pb  = %p\n", pb); // Conteúdo inicializado (&b).
 
printf("*pa = %d\n", *pa);// Conteúdo apontado por pa (*pa == a).
printf("*pb = %d\n", *pb);// Conteúdo apontado por pb (*pb == b).
 
printf("\nApós as inicializações dos inteiros:\n");
 
a = 10;
b = 13;
 
printf("&a  = %p\n", &a); // Mesmo endereço válido dado pelo SO.
printf("&b  = %p\n", &b); // Mesmo endereço válido dado pelo SO.
printf("&pa = %p\n", &pa);// Mesmo endereço válido dado pelo SO.
printf("&pb = %p\n", &pb);// Mesmo endereço válido dado pelo SO.
 
printf("\n");
 
printf("a   = %d\n", a);  // Conteúdo inicializado (10).
printf("b   = %d\n", b);  // Conteúdo inicializado (13).
printf("pa  = %p\n", pa); // Conteúdo inicializado (&a).
printf("pb  = %p\n", pb); // Conteúdo inicializado (&b).
 
printf("*pa = %d\n", *pa);// Conteúdo apontado por pa (*pa == a == 10).
printf("*pb = %d\n", *pb);// Conteúdo apontado por pb (*pb == b == 13).
 
printf("\nAlterando os valores através dos ponteiros:\n");
 
*pa = 7;
*pb = 42;
 
printf("&a  = %p\n", &a); // Mesmo endereço válido dado pelo SO.
printf("&b  = %p\n", &b); // Mesmo endereço válido dado pelo SO.
printf("&pa = %p\n", &pa);// Mesmo endereço válido dado pelo SO.
printf("&pb = %p\n", &pb);// Mesmo endereço válido dado pelo SO.
 
printf("\n");
 
printf("a   = %d\n", a);  // Conteúdo inicializado (a == *pa ==  7).
printf("b   = %d\n", b);  // Conteúdo inicializado (b == *pb == 42).
printf("pa  = %p\n", pa); // Conteúdo inicializado (&a).
printf("pb  = %p\n", pb); // Conteúdo inicializado (&b).
 
printf("*pa = %d\n", *pa);// Conteúdo apontado por pa ( 7).
printf("*pb = %d\n", *pb);// Conteúdo apontado por pb (42).

As linhas 18 e 19 declaram respectivamnete dois inteiros e dois ponteiros para inteiros.

As linhas 23 a 26 mostram os endereços das minhas variáveis. Esses endereços foram dados pelo sistema operacional e são fixos enquanto essas variáveis existirem. Uma variável não muda de endereço durante a execução do programa, mas pode mudar entre uma execução e outra. Quem define qual é esse endereço é o sistema operacional no momento da execução do programa. O compilador só sabe que serão necessários x bytes para cada variável, e qual a interpretação (tipo) que o programa vai dar a esse espaço.

As linhas 30 a 33 mostram os conteúdos dessas variáveis, que ainda não foram inicializadas. É lixo, o último valor que alguém (não sei quem) colocou naqueles lugares da memória do computador e que agora pertencem às minhas variáveis.

Note que não é seguro descomentar as linhas 36 e 37 pois elas tentam acessar os conteúdos apontados por pa e pb, que ainda não foram inicializados. Durante essa tentativa, o programa vai tentar interpretar aqueles valores de lixo aleatório como se fossem endereços de variáveis int válidos. Dependendo do compilador, do SO utilizado e da sua sorte, pode ser algo inofensivo ou não. O certo é que o resultado dessas linhas é imprevisível e fonte certa de problemas.

Nas linhas 41 e 42 os ponteiros são inicializados com os endereços das variáveis inteiras a e b. A partir daí os prints são repetidos.

Veja que os endereços dos ponteiros não mudam, o que já era esperado. O que mudam são os seus conteúdos. As variáveis pa e pb recebem os endereços de a e b respectivamente. Note que o conteúdo dos ponteiros é exatamente o valor do endereço das variáveis a e b que foram dados pelo SO no início do programa. Confira com os prints anteriores. O conteúdo apontado por pa e pb é o mesmo conteúdo de a e b, que ainda não foram inicializados, ou seja, lixo. Porém, diferentemente da etapa anterior, agora os ponteiros apontam para endereços válidos (os endereços de a e b) e ainda que os conteúdos de a e b sejam lixo de memória, os ponteiros agora apontam para variáveis que já foram alocadas.

Nas linhas 61 e 62 as variáveis inteiras são inicializadas com os valores 10 e 13, e os prints repetidos denovo.

Desta vez os coteúdos de a e b não são mais lixo. São valores devidamente conhecidos. Note que não há nenhuma alteração no endereçamento das variáveis em relação às etapas anteriores, apenas nos valores.

Veja também que depois que a e b foram inicializados, o conteúdo apontado por pa e pb também foram alterados automaticamente. Isto acontece justamente porque pa e pb apontam para as mesmas áreas de memória utilizadas pelas variáveis pa e pb. Isso significa que o conteúdo apontado por um ponteiro pode ser modificado alterando-se o conteúdo das variáveis originais apontadas por ele. E finalmente as linhas 81 a 97 mostram que o inverso também vale, ou seja, alterando-se o conteúdo apontado por um ponteiro, altera-se automaticamente o conteúdo das variáveis originais apontadas por eles.

É mais fácil entender isso pensando nas frases em português do que olhando para o código.

Por enquanto…

Este foi o básico da operação com ponteiros. Ainda existem coisas interessantes para serem vistas, como ponteiros para funções, por exemplo, mas isso já é considerado um tópico mais avançado. Na sequência desta série, que está planejada para 4 posts, veremos referências, diferenças e semelhanças entre ponteiros e referências e por último ponteiros para funções.

Links

• ponteiros.zip (todos os fontes do post);
• 01-declaracao.cpp
• 02-tamanhos.cpp
• 03-utilizando.cpp
• 04-pegadinha.cpp
• 05-enderecos.cpp
• Ponteiros no cplusplus.com
• O Culpado