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.

Achei legal que a maioria delas estava relacionada com o conteúdo do blog, ou com assuntos sobre os quais eu poderia ter escrito. No entanto, algumas delas chamaram a atenção por sua peculiaridade e quantidade.

Como bom blog sobrenatural, atraimos a atenção de diversas pessoas procurando saber como desenvolver sua telepatia e premonição. Outras, buscavam uma forma de se livrar da telepatia.

Exercitando nosso lado ortográfico, demos dicas a todos os ávidos leitores que procuravam como conseguir uma redação de vinte linhas prontinha. E olha que nós realmente ensinamos isso!

Alguns exemplos foram cuidadosamente analisados e respondidos por nossa equipe:

xixi no cinema

Normalmente é causado por excesso de refrigerantes, mas se precisar mesmo, use o banheiro.

vocabulário maloqueiro

É nóis na fita mano! Cê é meu truta! Tá ligado?

ubuntu+não sei que aconteceu com o meu teclado+caracteres estranhos

Verifique se está sóbrio ou se foi sequestrado por algum alienígena. Se tudo falhar esqueça o teclado e avance logo para o mouse.

como usar telepatia

De preferência com moderação.

bruce lee foi uma farsa?

Segundo Chuck Norris, sim.

chame que eu choro junto

Duas Carpideiras pelo preço de uma…

como conseguir que o open office corrija ortografia?

F7

como fazer para ter uma premonição?

Barbada: É só enganar a morte, oras.

como me livrar da telepatia

Se não sair com um banho, tente dois…

como passar fibra ótica embaixo de pontes

Com cuidado.

fiz engenharia e agora?

Sempre há tempo para se arrepender

o que significa o numero 3 invertido

A letra E

significado de ficamos barrados

Algo assim

palavras parecidas festa

Testa esta, besta!

quero uma mochila de graça

Eu também!!!

objetos baixados onde ponho?

Na encruzilhada?

E por hoje é só pessoal!

No longínquo janeiro de 2008 eu fiz um dos primeiros posts do blog, comentando um post do Fábio Telles e arriscando algumas opiniões sobre suporte e custos do software livre. Naquela época o próprio Fábio fez uma crítica um pouco contundente, mas que eu gostei bastante.

Recentemente, esse post foi lido novamente e comentando, mas não foi um comentário qualquer, foi um super comentário que eu reproduzo abaixo, na íntegra:

Olha meu caro. Software Livre não dá dinheiro a ninguém, não fomenta negócio, não paga impostos, não produz fonte de riquezas, enfim, não tem nenhuma utilidade no mundo capitalista em que vivemos.

Eu acho que esta onda livre apenas usa o esforço de pessoas que não têm ideologias para fazer o trabalho de grandes empresas como IBM.

O que eu vejo é grandes empresas usando mão de obra gratuita para fazer o trabalho deles, e estão ganhando rios de dinheiro às custas de programadores recém formados que não tem bandeira nem religião, que acabam abraçando uma idéia mentirosa como esta filosofia open-source.

Resumindo: estão usando força de trabalho de pessoas ignorantes para atingir seus objetivos comerciais. E é uma pena que muita gente cai nessa.

Se software livre fosse o futuro o Linux não estaria na casa dos 1% dos monopolizadores dos desktops.

Uau!

Eu achei que comentar esse comentário junto com os inúmeros comentários do post original, faria essa troca de idéias passar batida, então, decidi fazer um breve post sobre ele.

Querido Nigel, agradeço profundamente por sua disposição e empenho ao comentar o post.

Você afirma que software livre não dá dinheiro a ninguém. Gostaria então que você me explicasse qual a mágica utilizada por mim para pagar as contas, o domínio e a hospedagem desse blog, onde você é bem vindo para comentar de graça! Oras, me conte qual a mágica, que assim acabaremos com a pobreza no mundo!

Você também afirma que não fomenta negócio e nem paga impostos. Caramba! Então o ISS, o COFINS, a Contribuição Social que a minha empresa paga não existem? O governo está me roubando? Esse tempo todo e eu não sabia que o serviço que presto era isento de impostos. Ainda bem que você me contou isso!

Veja só, eu e minha empresa socialista! Feio, feio feio! Blabos mau!

Essas empresas malvadas se aproveitando de programadores recém-formados, inexperientes, bocós e pobres!

Nigel, de acordo com o seu texto, você parece não saber muito bem sobre o que está falando. Eu não vou discorrer aqui sobre a inúmeras formas de se ganhar dinheiro com o software livre, nem o porquê de ele ser socialmente justo, mas te convido a conhecer de verdade a realidade do software livre para que você pare de repetir algo que aparentemente não compreende. Então eu posso de apresentar uns maltrapilhos que terão prazer te pagar uma boa cerveja proprietária com o não-dinheiro que ganhamos com software livre.

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.

Boa Memória

Imagem publicada com a devida autorização do esquecido

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).

 <prerequisites_policy>
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.

 <build_requires_install_policy>
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.

 <bzip2>
Where is your bzip2 program? [/bin/bzip2]
 
 <gzip>
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.
 
 <term_is_latin>
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.

O Gênio por trás dessa revolucionária idéia atende pela alcunha de Ankesh Kothari. Segundo ele, pedir para pessoas doarem dinheiro por uma razão específica é cerca de 200% mais eficaz do que um simples “Donate Money”. No meu caso, zero + 200% continua zero. No caso dele, acabou de ganhar 3 links e uma cerveja!

Por isso, se você gostou de algum post deste blog, junte-se à nossa campanha e Buy Me a Beer.