Access Violation

Antivirus....

2006-09-20T00:27:00.000-03:00

Novo post no meu outro blog..

Novo blog....

2006-09-06T20:36:00.001-03:00

Vista RC1

2006-09-04T13:46:00.000-03:00

Não é nenhuma novidade mas aqui vai...

A Microsoft liberou (para Testers) o Windows Vista RC 1 (build 5600). Analistas esperam que a Microsoft libere esta versão para o público em geral em 07/09.

Aqui você encontra outra review sobre o RC1.

SerialWizard : Frames

2006-07-27T21:29:00.000-03:00

No post anterior comecei a falar sobre o SerialWizard e suas funcionalidades.

Um dos elementos apresentados foi uma "janela" chamada "Frames". Mas o que é um frame? Este conceito é muito usado na área de comunicação de dados, neste caso específico de comunicação via porta serial. Um frame é um conjunto de dados com início e fim bem definidos.

Por exemplo em comunicação de dados via porta serial frames são delimitados por caracteres de controle como STX e ETX.

Um dos principais recursos do SerialWizard é ser capaz de carregar um arquivo com a definição de um frame e, a medida que os dados são recebidos e/ou enviados, separar os diversos elementos (fields) deste frame.

Este arquivo (XML) possui a seguinte sintaxe:

Created with colorer-take5 library. Type 'xml'

<?xml version="1.0" encoding="ISO-8859-1"?>
<protocol>
<frame>
<stx />

<len length='2' encoding='int/hex-string'/>
<payload length='[len]'>

   <signature length='4' /> <!-- <signature value='xxx'  /> not supported -->

   <command length='3' mapping='commands'/>
   <status length='1' mapping='status'/>

   <data />
</payload>
<etx/>
<lrc length='1' />

</frame>

<commands>
<item value='001' description='Command 1' />

<item value='002' description='Command 2' />
</commands>

<status>
<item value='004' description='status 004' />

<item value='008' description='status 008' />
</status>

</protocol>

Neste exemplo definimos um "frame" com o seguinte formato:

Primeiro campo é o caracter de controle STX

O segundo campo (Len) possui 2 bytes de tamanho e representa um número inteiro em uma string hexadecimal (por exemplo "12" ou 18 em decimal).

O próximo campo (payload) possui len bytes de tamanho (ou seja, se o valor do campo len for "15" (em hexa) então este campo possui 21 bytes) e possi os seguintes subcampos:

signature, com 4 bytes
command, com 3 bytes
status, com 1 byte
e data com len - 4 - 3- 1 bytes.

Caracter de controle ETX
LRC com 1 byte.

Abaixo apresentamos a janela principal do programa após a carga de dados formatados segundo o frame acima:

Observe que a janela "frames" foi populada com a estrutura exata do frame. Além disso podemos selecionar os dados relativos ao campo do frame clicando no respectivo checkbox na janela frames (observe o campo data).

No próximo post farei uma breve explicação sobre os elementos que definem um frame.

Abraços.

Adriano

SerialWizard for dummies :)

2006-07-25T00:32:00.000-03:00

Como comentei no último post, vou descrever melhor as funcionalidades do SerialWizard; abaixo segue um screenshot da tela principal do programa.

Nesta figura podemos observar alguns elementos:

Data window.
Frames window.
Detail window.

os quais descreverei individualmente:

Data Window

Este é a janela mais simples de se entender. A mesma apresenta os dados (em hexadecimal) enviados/recebidos pela porta serial ou dados carregados de um arquivo. Nela podemos selecionar dados, navegar pelos mesmos (com as teclas de navegação) além de realizar buscas (básicas na versão corrente).

Esta janela é dividida em duas "sub-janelas": uma para apresentar os dados em hexadecimal e outra para apresentar os dados como strings. Observe que ao selecionar um (ou mais bytes) em uma destas "sub-janelas" os bytes correspondentes na outra também serão selecionados.

Frames

Esta janela apresenta uma visão mais estruturada dos dados visualizados na janela data; em outras palavras nesta janela temos uma visão dos diversos campos (fields) que compõe um buffer. Este recurso é útil para analizarmos protocolos pois nos permite visualizar mais rapidamente os diversos campos do mesmo.

Para que este recurso esteja habiltiado é necessário que o programa conheça a estrutura do protocolo (saiba fazer parse do protocolo). Em um próximo post veremos como "ensinar" o programa a fazer parse de um protocolo.

Observe que ao selecionarmos um (ou mais) campo(s) (através do checkbox da treeview) os dados correspondentes serão selecionados.

Details

A janela details possui duas tabs: Details e Commands.

A primeira apresenta os dados selecionados em um (ou mais) formato(s) selecionado(s) (levando-se em consideração os respectivos tamanhos dos tipos de dado). Por exemplo se Signed16 estiver marcado e dois ou mais bytes (16 ou mais bits) estiverem selecionados o valor correspondente aos dados selecionados convertidos para um número sinalizado de 16 bits será apresentado.

A segunda tab (commands) é utilizada para enviar dados pela porta serial.

Novo aplicativo...

2006-07-24T20:27:00.000-03:00

A algum tempo atraz eu comecei a trabalhar em uma empresa de desenvolvimento que depende muito de comunicação com dispositivos através da porta serial (RS232) e tive contato com um programa desenvolvido internamente (acredito que pela matriz) que permitia o envio de dados pela serial; ainda que semelhante ao HyperTerminal do Windows, este programa adicionava algumas características interessantes:

Cálculo automático de LRC.
Tratamento de dados no formato hexadecimal

Apesar destes recursos notei alguns problemas com o mesmo:

Bugs: O programa possuía vários erros e eu não tinha acesso ao código fonte.
Recursos não implementados

Somado a estas questões havia o fato de eu procurar algo interessante para desenvolver usando a plataforma Dot Net; assim decidi implementar um aplicativo com as seguintes funcionalidades:

Visualização de dados no formato Hexadecimal
Envio de dados pela porta serial com suporte a cálculo automático de LRC e tratamento de dados hexadecimal
Parse de "frames", ou seja, dado um buffer contendo um frame separar os vários campos deste frame

Assim nasceu o SerialWizard (sei lá porque este nome).

Neste final de semana liberei a primeira versão (ainda em alpha e com vários bugs e funcionalidades ainda não implementadas). no sourceforge. Na medida do possível implementarei novas funcionalidades e corrigirei bugs no mesmo.

Ao longo dos próximos posts irei descrever as principais funcionalidades do programa; mas não espere por isso! Baixe o mesmo e comece a brincar agora mesmo! :)

Abraços.

Adriano

O que há de errado com este código?

2006-07-12T21:29:00.000-03:00

Mais um post da série o que há de errado com este código!

Created with colorer-take5 library. Type 'csharp'

0: using System;
1: using System.Windows.Forms;
2: using System.Threading;
3:
4: namespace TestWinForm
5: {
6:     public partial class TestCallBackFromDiferentThread : Form
7:     {
8:         private System.Threading.Thread workerThread;
9:
10:         public TestCallBackFromDiferentThread()
11:         {
12:             InitializeComponent();
13:         }
14:
15:         private void button1_Click(object sender, EventArgs e)
16:         {
17:             ThreadStart ts = new ThreadStart(AddNewLine);
18:             workerThread = new Thread(ts);
19:             workerThread.Start();
20:         }
21:
22:         private void AddNewLine()
23:         {
24:             listBox1.Items.Add(textBox1.Text);
25:         }
26:     }
27: }

Bom, a resposta eu posto depois!

Adriano

Gravando CDs for dummys

2006-07-03T07:21:00.000-03:00

Hoje de manhã eu precisava gravar um CD antes de ir para o trabalho; para ganhar tempo liguei o micro e fui tomar café; como o Windows Vista é muito humilde e se instalou como minha primeira opção de SO quando acabei de tomar café e fui gravar o tal CD o Windows Vista é que tinha sido carregado (ao invés do Windows XP).

Eu pensei comigo: ok, vamos ver como ele se comporta com relação a gravação de CDs. Abri a porta do gravador de CDs, coloquei um CD regravável (já com conteúdo) e depois de algum tempo apareceu a a seguinte janela:

Eu pensei: ótimo. como pode-se ver ele já reconheceu que se trata de uma mídia regravável e me deu a opção de "apagá-lo"; e esta foi exatamente meu próximo passo.

Ao final do processo me foi apresentada o seguinte dialog:

Muito estranho um dialog com um botão "finish" e o texto "to close this windows click finish", não ?

Espero que seja apenas um "lapso" (afinal de contas se trata de um produto beta).

Mas o pior de tudo é que o CD não foi "apagado" e também não consegui gravar nada nele (pelo Windows Vista).

Solução: reiniciei com o Windows XP e utilizei o CDBurnerXP Pro. Ai sim, consegui gravar meu CD.

Cool!

2006-06-22T20:24:00.000-03:00

Hoje encontrei vários posts interessantes que pretendo compartilhar.

O primeiro assunto que encontrei foi a implementação de transações pelo SO (no caso o Windows Vista).

Até onde eu sei o tão falado "Transactional File System" 
havia sido removido desta primeira versão,
mas pelo que entendi do post acima me parece que algum suporte 
já foi adicionado! E o melhor, funciona!
Pelo menos os testes simples que realizei.

Hoje de manhã, com mais tempo, procurei melhor sobre o assunto e encontrei o link original. Realmente o Transactional NTFS (ou TxF para os íntimos :) já está presente no Vista Beta 2!

Ao lado você observa o help de um programa de linha de comando que acompanha o Vista Beta 2 chamado Transaction. Como podemos ver temos a opção de iniciar uma nova transação, fazer o "commit" ou cancelar (Rollback) de uma transação em andamento. Uma vez criada a transação, qualquer operação com o sistema de arquivos parece fazer parte desta transação. Podemos observar este comportamento criando uma nova transação e a seguir criar e/ou apagar arquivos. Notamos que estas operações se completam apenas quando finalizamos a transação (Commit).

Na imagem à direita, utilizei o comando "transaction /start" para iniciar uma nova transação; a seuir, criei um novo arquivo (copy con teste.txt), que pode ser observado na imagem abaixo.

Note que no console em que o arquivo foi criado o mesmo é listado normalmente (uma vez que estamos na mesma transação que o criou!).

O próximo passo foi abrir outro console e verificar se o arquivo aparece para o mesmo ou não. Observei que o arquivo não foi listado (mas como parece que o blogger impõe limites de imagens em um post não consigui incluir a imagem :(. amanhã eu tento novamente). De qualquer forma acredite em mim; o arquivo só apareceu no segundo console (e no Windows Explorer e para todos os demais aplicativos que não fazem parte da transação) após a mesma ser finalizada com sucesso (transaction /commit). Outra coisa interessante é que após ter realizado o commit criei uma nova transação e apaguei o arquivo. Antes de fazer o commit novamente carreguei o Windows Explorer e tentei renomear o arquivo; o mesmo gerou um erro informando que o arquivo estava reservado por outra transação!.

Depois encontrei este post! Cool, o Windows Vista (Beta 2) já suporta redimensionamento de partições!

Nesta imagem podemos ver as opções (Expand/Shrink) (na partição ativa :))

Nem precisa perguntar se eu testei ou não ;). A resposta é não! Não quero arriscar perder dados de outras partições (como não tenho um segundo computador para testes instalei o Windows Vista no meu computador onde tenho todos os meus dados mesmo ;)

O último post que incluo fala um pouco sobre o SP1 do Visual Studio 2005 (mais especificamente do compilador C++).

Que Linux nada!! :)

2006-06-19T10:37:00.000-03:00

Você já viu este SO? Muito interessante.. mesmo não tendo realizado nenhum teste me pareceu bem interessante!

Adriano

Win32 <--> BLC (.Net)

2006-06-10T11:55:00.000-03:00

Hoje eu estava procurando um assundo no site do msdn library e encontrei este artigo sobre como mapear funções da Win32 para as respectivas classes/métodos da Base Class Library do .Net.

O mesmo é de 1/2004 mas ainda deve ser interessante :)

Deus os abençoe.

Adriano

Links...

2006-06-06T19:36:00.000-03:00

Aqueles que estão acostumados com SOs Unix Like certamente já conhecem este conceito, mas poucos usuários do Windows sabem que o NTFS (desde o Windows NT 4.0), suporta o conceito de hardlinks, que nada mais são que várias entradas de diretório que apontam para o mesmo arquivo (Note que este conceito aplica-se apenas a arquivos).

Utilizando-se este recurso é possível fazer com que um arquivo possa "estar" em dois (ou mais) diretórios ao mesmo tempo :).

Vejam o exemplo:

Arquivo: c:\temp\teste.txt
Hardlink: c:\dados\teste.txt

Neste exemplo é possível com que dois arquivos aparentemente distintos representem o mesmo arquivo.

Você pode estar se perguntando: "E porque eu usaría isto?". Para simplificar o gerenciamento de arquivos.

Por exemplo, em alguns projetos meus, necessito que um arquivo (digamos arquivo.txt) se encontre em um diretório específico; por outro lado este mesmo arquivo deve ser incluído no programa de setup destes projetos que por sua vez, normalmente, tem seus arquivos armazenados em um diretório chamado setup e, por motivos de organização, este arquivo fica neste diretório, assim acabo com a seguinte configuração:

c:\meus projetos\nome projeto\src\arquivo.txt
c:\meus projetos\nome projeto\src\setup\arquivo.txt

Agora eu tenho que decidir como gerenciar esta questão:

Mantenho o arquivo nos dois diretórios e corro o risco de ter duas versões diferentes do mesmo (e o que é pior, testar o projeto usando um arquivo e liberar um setup que usa o outro - não testado)
Manter apenas uma cópia do arquivo e ficar movendo a mesma de um diretório para o outro na medida do nescessário.

Usando hard links é possível manter uma única cópia do arquivo (provavelmente no diretório setup) e criar um hard link para este arquivo no direrório src resolvendo o problema (evitando trabalho desnecessário e/ou problemas por utilizar uma versáo incorreta do arquivo).

O melhor de tudo é que é possível mover qualquer uma das referências e tudo continuará a funcionar!

A questão que surge então é "como fazer para criar um hardlink?". A resposta rápida é: nas versões atuais o Windows não disponibiliza uma forma simples para se fazer isto. Mas como quase tudo no windows pode ser extendido (e o Shell não é diferente) já desenvolveram (pelo menos) uma Shell Extension.

Adriano

Vista Beta2

2006-06-01T20:56:00.000-03:00

Em um post sobre streams fiz alguns comentários sobre o Windows Vista Build 5365.

Neste post pretendo falar um pouco sobre minhas primeiras impressões sobre o Build 5384, ou seja, o Windows Vista Beta 2, que instalei ontem a noite.

Minha primeira frustração foi que o Windows (desde que foi lançado) não respeita dual boot com outros sistemas operacionais que não sejam da própria MS; resutado: bye bye Ubuntu. Na realidade o SO propriamente dito (Ubuntu) não foi apagado (seria um absurdo); o que ocorreu foi que o boot mananger do Vista não reconhece outros SOs, então ele não me da a opção de carregar os mesmos, ou seja, terei que reinstalar um boot manager (no caso o grub).
Meu segundo passo foi tentar instalar o AVG (antivirus); para minha surpresa o Vista reclamou e disse que o AVG tem problemas de compatibilidade com esta versão do SO (acredito firmemente que estes problemas serão sanados até o lançamento do Vista); solução? Instalei o Avast.
No post anterior comentei que notei alguns comportamentos estranhos; bem, posso dizer que estou muito satisfeito com esta versão. Os problemas citados não se manifestaram mais (pelo menos até agora) :).
O Windows Media Player funcionou muito bem
O sistema de controle de volume por aplicativos é bastante interessante. É possível controlar o volume indivialmente, ou seja, é possível ouvir som no "talo" sem correr o risco de ter que ouvir aqueles avisos sonoros do Windows (e/ou outros aplicativos) em um volume que incomode.

A performance em geral melhou bem
O IE não subiu no telhado nenhuma vez :)
De qualqer forma ainda observo alguns comportamentos estranhos:

Não houve como fazer com que o Vista ocupasse toda a área do meu monitor (mesmo configurando o monitor para ocupar 100% da área nota-se que temos duas margens não utilizadas pelo Vista.
Os "commom dialogs" continuam não reconhecendo a sintaxe de streams.

Bom, por enquanto é isso. Se encontrar algo acrescento depois.

Adriano

Mouse Whell no IDE do VB6

2006-06-01T09:17:00.000-03:00

Antes que reclamem, sim, eu entendo que VB6 é uma ótima ferramenta para desenvolvimento de aplicativos GUI (e quando o VB6 apresentar alguma limitação crie um componente COM em C++). A pelo menos 8 anos venho adotando esta linha: GUI => VB, código que necessite de mais recursos/performance/etc, componente COM em C++ e tem funcionado bem (incluse o Joel tem um post bem interessante sobre o assunto).

De qualquer forma, o objetivo deste post é outro.

Sempre senti falta do recurso do mouse whell no IDE do VB6 mas nunca me dei ao trabalho de procurar uma solução; hoje de manhã eu "trombei" com uma solução que pode ser conferida no site da Microsoft.

Streams alternativas de dados

2006-05-10T00:21:00.000-03:00

Poucas pessoas sabem que (pelo menos a partir do Windows 2000) o NTFS suporta o conceito de "Stream alternativa de dados". Uma stream de dados nada mais é que uma sequência de bytes gravadas no arquivo. O interessante é que, por default, o Windows sempre utiliza a stream principal, mas nada nos impede de criarmos outras streams:

No console acima observamos que não temos nenhum arquivo no dirertório c:\test (observe o 0 Files).

Logo a seguir criamos uma segunda stream no arquivo teste.txt chamada segunda_stream (ok, estou sem criatividade agora). Como o exemplo demonstra, a sintaxe para nomes de streams alternativas é:

nome_arquivo.ext:nome-stream

Mas como podemos verificar se um arquivo possui ou não streams alternativa? Simples; se você possui uma versão do Windows anterior ao Vista baixe o programa streams.exe do site Sysinternals.com.

Como podemos observar o programa detectou a stream segunda_stream.

Por outro lado, se você esta utilizando o Windows Vista basta acrescentar o parâmetro /r ao comando dir.

Algumas considerações importantes:

Apesar de muitos programas não trabalharem corretamente com stream a Win32 API não apresenta problemas para lidar com as mesmas (por exemplo a função CreateFile() trata nomes de arquivos com streams corretamente).
Você pode utilizar streams alternativas para armazenar dados extras de um programa sem dar muito na cara :).
O Windows Vista (build 5365) apresentou várias anomalias enquanto eu estava escrevendo este post (entre elas, o Explorer foi pro cacau várias vezes, o IE deu PT pelo menos uma vez, a performance para navegar no sistema de arquivos esta uma *$&*&@*, etc.); de qualquer forma não poss me esquecer que estou usando um produto beta.
Falem o que quiser... o visual do Vista esta cada vez melhor! Aero, Side bar, Miniaturas na task bar, etc.

Bem, espero que tenham achado este post útil :)

[]'s

Adriano

Evolução....

2006-05-03T13:54:00.000-03:00

Bom, este post é um pouco nostáugico :)

Ontem a noite estava pensando nas configurações de meus computadores e como elas evoluiram. Apenas como curiosidade aqui estão elas:

Ano	Processador	Frequência	Cooler	Memória	Disco Rígido	Placa Vídeo	Internet
1989	6502	0,75 MHz	O que é serve isto mesmo?	256 Kb	NA	OnBoard	NA
1992	Ciryx 486 DLC	40 MHz	Pra que?	4 Mb	100 Mb	Trident	NA
1996	Intel Pentium 100	100 MHz	Ainda não era necessário	16 Mb	1.0 Gb	?	28 Kbps
1999	AMD Athlon 400	400 MHz	Pequeno e silencioso.	128 Mb	30.0 Gb	OnBoard 4 Mb	56 Kbps
2002	AMD Athlon XP 2.1	1.8 GHz	Um monstro. Parece uma turbina de avião.	512 Mb	60.0 Gb	AGP 64 Mb	ADSL 350 Kbps
2006	AMD Athlon 64 3.8 X2	2.0 GHz	Mais silencioso que o anterior	2.0 Gb	370.0 Gb	PCI-X 256 Mb	2.0 Mbps

Algumas observações interessantes sobre as mudanças nestes 17 anos....:

Apesar da frequência dos processadores aumentar consistentemente notamos que nos últimos anos este aumento foi mais lento e atualmente observamos até uma redução; por exemplo
o processador Athlon 64 3.8 single core da AMD roda a 2.1 Ghz enquanto o 3.8 X2 (dual core) roda a 2.0 Ghz. Ok eu sei que isto é decorrência dos limites do processo atual (aumento
na frequência de operação implica basicamente em aumento da dissipassão térmica)

As empresas passaram a utilizar outros indicadores para comparação de performance (em detrimento à frequência).

Ao mesmo tempo eficiência térmica se tornou um item importante (também, ninguém merece um mini-aquecedor!)

Em 1992 as configurações mais comuns possuiam entre 2 e 4 Mb. Atualmente as configurações mais comuns estão na faixa dos 1.0 ~ 2.0 Gb (algo entre 250 e 500 vezes)

Neste mesmo período (1992 ~ 2006) o aumento da capacidade de armazenamento do disco rígido foi substancialmente maior (no mínimo 1000 vezes considerando-se discos atuais de 100 Gb)

O acesso a internet... aqueles que utilizaram modens de 14.400 Kbps sabem a tortura que era. Atualmente? Bom estou feliz com meu acesso de 2.0 Gbps (ok, confesso que já andei dando uma olhado no
plano de 8.0 Gbps :) mas ainda é muito caro)

Observe que a nomenclatura da AMD não especifica a frequencia do processador, mas sim um valor comparativo. Por exemplo, a frequência do Athlon 64 3.8 X2 é 2.0 GHz (ao invés de 3.8 GHz como o nome sugere).

Tags:teste

hardware

Brinquedo novo II

2006-03-29T17:23:00.000-03:00

Neste post comentei que estava comprando um computador novo e listei os componentes da minha máquina dos sonhos; pois bem, depois de quase um mês (de férias, graças a Deus) finalmente
montei meu novo computador com a seguinte configuração:

Processador: AMD X2 3800

Placa mãe: ASUS A8N SLI

Memória: Coirsar 2GB (2 x 1GB) DDR 400

Placa Vídeo: GeForce 6800 GS 256Mb

HD1: Seagate 120GB ATA (já possuia)

HD2: Maxtor 250GB SATA

Monitor: Samsung 17" CRT (já possuia)

Cooler: BOX

DVD: LG

Fonte: Thermaltake 430 W

Teclado: ABNT 2 Wireless Logitech

Mouse: Wireless Logitech

PS: Se você comprou um HD Sata II que não é reconhecido e/ou não funciona corretamente configure o mesmo para SATA I (normalmente através de um jumper no próprio HD);
isto deve resolver o problema. Outra possibilidade é tentar atualizar o firmware do seu HD (por sua conta e risco :).

No meu caso a Maxtor possui este artigo que trata sobre o assunto.

Bom, acho que é isto :) Agora vou aproveitar um pouco da minha nova máquina para jogar CS Source!

Abraços.

Tags:teste

hardware

Novo brinquedo :)

2006-02-14T11:26:00.000-02:00

Como todo bom apaixonado por informática estou sempre atualizando meu computador. Atualmente estou pesquisando uma configuração para minha nova máquina.

Abaixo segue a configuração dos sonhos :)

Processador: AMD X2 4600

Placa mãe: DFI LANPARTY nF4 SLI-DR

Memória: GeIL 2GB (2 x 1GB) DDR 400

Placa Vídeo: 2 x GeForce 7800GTX 256Mb (SLI é claro)

HD1: Western Digital Raptor 150GB

HD2: Seagate 7200.9 300GB SATA

Monitor: ViewSonic VX922 LCD

Cooler: COOLER MASTER AQUAGATE Mini R120

DVD: Qualquer gravador da LG esta bom

Fonte: OCZ OCZ520ADJ - 520W

Será que esqueci de alguma coisa? Com uma máquina destas acho que da para jogar CS, DOOM3, etc.

Bom, como esta é uma configuração que não tenho como pagar por ela ( +- R$ 11.000,00 em uma loja oficial aqui no Brasil) no próximo post colocarei a configuração que pretendo comprar :).

Abraços.

Tags:teste

hardware

O que esta errado com este programa (parte iv) : Resposta

2006-02-09T08:37:00.000-02:00

O problema com o programa do post anterior se encontra na linha 8 da função fatorial (isto não é muito difícil de se perceber).
Esta linha deveria se parecer com:

 0: return n * fatorial(n - 1);

ou seja, o desenvolvedor se esqueceu de incluir o return. É claro que o compilador gerou uma warning (aviso) mas eu a ignorei conscientemente.

Atenção

Ignorar avisos (warnings) do compilador não é uma prática saudável e eu não recomendo a ninguém fazê-lo! Pelo contrário; analise todas
as warnings geradas em seu código e entenda o porque o compilador esta reclamando. Não assuma que "o compilador possui bugs" muito menos
tome a postura arrogante de achar que sabe mais que o compilador. Se depois de estudar o motivo da warning você concluir que o código que causou
a warning é legítimo, desabilite a warning específica (via #pragma warning) no trecho de código em questão.

Agora vem a segunda pergunta: Porque, mesmo faltando o return (ou seja, o retorno da função não foi especificado nesta condição) o programa gera o resultado
correto (pelo menos compilando com o BC++ 3.0 e o VC7.1)?

Para responder esta pergunta teremos que recorrer à linguagem assembly do programa (não se preocupe, não é tão complicado assim).

Created with colorer-take5 library. Type 'asm'

 0: fatorial:
 1:     push    ebp
 2:     mov     ebp,esp
 3:     cmp dword ptr [ebp+0x8],0x1
 4:     jnz     proximo_valor
 5:     mov     eax,0x1
 6:     jmp     fim
 7: 
 8: proximo_valor:
 9:     mov     eax,[ebp+0x8]
10:     sub     eax,0x1
11:     push    eax
12:     call    fatorial
13:     add     esp,0x4
14:     imul    eax,[ebp+0x8]
15:     mov     [ebp+0x8],eax
16: 
17: fim:
18:     pop     ebp
19:     ret
20: 
21: ; Programa principal (apenas a parte da chamada da função
22: ; fatorial e do retorno da mesma.)
23: 
24: main:
25:     ;  [ebp  - 0x4] ==> Variável I
26:     ;  [ebp  - 0x8] ==> Variável N
27:     call    fatorial
28:     add     esp,0x4
29:     mov     [ebp-0x4],eax ; Aqui esta o motivo!
30:     mov     ecx,[ebp-0x4]
31:     push    ecx ; Efetivamente colocou o valor de EAX na pilha para a função printf!
32:     mov     edx,[ebp-0x8]
33:     push    edx
34:     push    0x40cb40
35:     call    printf
36:     add     esp,0xc
37:     mov     esp,ebp
38:     pop     ebp
39:     ret

O código da função fatorial começa na linha 0 (zero) e vai até a linha 19 (instrução ret). O código do programa principal começa na linha 24
e se extende até a linha 39.

Na linha 25 temos a chamada à função fatorial a partir do programa principal (observe que não inclui todo o código assembly do programa principal
por motivos de simplicidade).

Vamos analisar o código da função fatorial e, quando pertinente, entrar no código do programa principal.

Nas linhas 1 e 2 temos o código de prologo padrão de uma chamada de função em c; na linha 3 temos a comparação
da variável n com 1; se forem iguais, a instrução jnz na linha 4 não irá desviar o programa para o ponto proximo_valor, ou seja,
a execução do programa irá para a linha 5 que atribui 1 ao registrador eax e retorna para o programa principal.

Caso n seja maior que 1 a instrução jnz na linha 4 desviará a execução do programa para o label proximo_valor na linha 8; na linha 9
o valor valor de n é atribuido a eax, subtraido de 1 na linha 10, colocado na pilha novamente na linha 11 e, finalmente, na linha 12 a função
fatorial é executada recursivamente.

O ponto importante aqui é observarmos que o valor do registrador eax é utilizado como retorno da função fatorial. Podemos observar isto tanto na linha 5
da função, quanto na linhas 29, 30 e 31 do programa principal (visto que ele passa o valor de eax para a posição de memória [ebp-0x4], ou seja, a variável i, o que deixa claro que eax contém
o valor de retorno da função).

Assim, compreendemos que o programa funciona apenas quando o compilador mantém o resultado da expressão:

Created with colorer-take5 library. Type 'c'

0: n * fatorial(n - 1);

no registrador eax como é o caso quando compilamos com o BC++ 3.0 ou VC 7.1 (observe as linhas 15 e 16 do programa assembly):

Created with colorer-take5 library. Type 'asm'

0: imul    eax,[ebp+0x8]
1: mov     [ebp+0x8], eax

que armazena o resultado da referida expressão no registrador eax.

Por outro lado observe o código assembly gerado pelo VC 6.0 (usando a linha cl fatorial.c /Fafatorial.vc6.asm e editado para simplificar o código):

Created with colorer-take5 library. Type 'asm'

 0: fatorial:
 1:     push ebp
 2:     mov     ebp, esp
 3:     cmp     DWORD PTR _n$[ebp], 1
 4:     jne     proximo_valor
 5:     
 6:     mov     eax, 1
 7:     jmp     fim
 8:     
 9: proximo_valor:
10:     mov     eax, DWORD PTR _n$[ebp]
11:     sub     eax, 1
12:     push eax
13:     call _fatorial
14:     add     esp, 4
15:     mov     ecx, DWORD PTR _n$[ebp]
16:     imul ecx, eax
17:     mov     DWORD PTR _n$[ebp], ecx
18: 
19: fim:
20:     pop     ebp
21:     ret     0
22: 
23: main:
24:     mov  eax, DWORD PTR _n$[ebp]
25:     push eax
26:     call _fatorial
27:     add  esp, 4
28:     mov  DWORD PTR _i$[ebp], eax
29:     mov     ecx, DWORD PTR _i$[ebp]
30:     push ecx
31:     mov     edx, DWORD PTR _n$[ebp]
32:     push edx
33:     push OFFSET FLAT:$SG480
34:     call _printf
35:     add     esp, 12
36:     mov     esp, ebp
37:     pop     ebp
38:     ret     0

Observe que nas linhas 16 e 17 o resultado da expressão

Created with colorer-take5 library. Type 'c'

0: n * fatorial(n - 1);

é armazenado no registrador ecx ao invés do eax. Por isso quando compilado no vc6 este programa não funciona!

Observe que mesmo com os compiladores onde observei que o programa funcionava, qualquer mudança de opção (por exemplo otimização do código gerado) pode fazer com que o programa resultante não funcione.

O que esta errado com este programa (parte iv)?

2006-02-02T09:09:00.000-02:00

Antes de mais nada gostaria de explicar: encontrar o problema não é difícil (mesmo assim não vou dizer agora); o mais interessante
é entender porque o mesmo funciona (ou pelo menos, funciona em alguns compiladores).

Vi este programa ao corrigir o trabalho de um dos meus alunos (agora sou um ex-professor :) ). Na época compilei
usando o Borlando C++ 3.0 e funcionou! No VC98 o comportamento muda, mas no Visual Studio 2003 o comportamento foi o mesmo do
Borland C++ 3.0; é claro que o compilador emitiu um aviso (warning) o qual foi ignorado prontamente!

Atenção

O programa recebe um número pela linha de comando e, a seguir, chama uma função para calcular o fatorial deste número.

Bom, vamos ao programa:

0: int fatorial(int n)
1: {
2:     if (n == 1)
3:         return 1;
4:     else
5:         n = n * fatorial(n - 1);
6: }
7:
8: int main(int argc, char *argv[])
9: {
10:     int n = argc > 1 ? atoi(argv[1]) : 5;
11:     int i = fatorial(n);
12:   
13:     return printf("Farotial(%d): %d", n, i);
14: }

Depois de algum tempo estudando o mesmo entendi porque ele funcionou (mas só vou contar em um post futuro :)).

Abraços.

Oque esta errado com este código (Parte III) : Resposta

2006-01-31T13:57:00.000-02:00

Este programa apresenta dois erros comuns relacionados ao desenvolvimento de clientes de componentes COM (é isso ai Daniel, você encontrou os dois!):

Utilizar smart pointers no mesmo escopo em que se chama CoInitialize() e CoUninitialize().

Tratamento incorreto quando os métodos selectNodes() / selectSingleNode() não retorna nenhum item.

O primeiro problema esta relacionado com o fato de que a chamada a CoUninitialize() será realizada antes do destrutor da classe CComPtr (devido ao
escopo da variável).

Quando o destrutor da classe for executado o método Release() da interface será executado resultando provavelmente em uma exceção (Access Violation).

Como solucionar este problema? Simples, basta declarar a variável em um bloco interno de forma que o mesmo tenha um escopo que termine antes do
escopo da função main().

O segundo problema é que os métodos selectSingleNode() e selectNodes() retornam S_FALSE caso o XPath passado não selecione nenhum nó, ou seja, a expressão da linha 15 será availada como true mas o smart pointer item estará igual a NULL.

Adriano

Oque esta errado com este código (Parte III)

2006-01-23T23:06:00.000-02:00

Dando continuidade a série "Oque esta errado com este código?" apresento o terceito artigo.

Neste post o problema esta relacionado com COM (Component Object Model) e com o MSXML. Na realidade neste exemplo temos dois problemas.

Prepare suas ferramentas e boa sorte!

 0: #define _WIN32_WINNT 0x500
 1: 
 2: #include <windows.h>
 3: #include <atlbase.h>
 4: #include <atlcom.h>
 5: 
 6: #import "msxml3.dll" raw_interfaces_only
 7: 
 8: void main()
 9: {
10:     CoInitializeEx(NULL, COINIT_MULTITHREADED);
11:     CComPtr<MSXML2::IXMLDOMDocument> doc;
12:     
13:     HRESULT hr;
14:     hr = doc.CoCreateInstance(__uuidof(MSXML2::DOMDocument30));
15:     if (SUCCEEDED(hr))
16:     {
17:         VARIANT_BOOL sucesso;
18:         hr=doc->load(CComVariant(L"c:\\Teste.xml"), &sucesso);
19:         if (SUCCEEDED(hr) && sucesso != VARIANT_FALSE)
20:         {
21:             CComPtr<MSXML2::IXMLDOMNode> item;
22:             hr = doc->selectSingleNode(CComBSTR(L"//a/b/c"), &item);
23:             if (SUCCEEDED(hr))
24:             {
25:                 // Faz alguma coisa com o nó apontado por 'item'.
26:             }
27:         }
28:     }
29:     
30:     CoUninitialize();
31: }

O que esta errado com este código (parte II) : Resposta

2006-01-20T14:20:00.000-02:00

Se você executar o programa em questão verá que o resultado impresso sera:

N: 1 J: 7
N: 2 J: 6
N: 3 J: 5
N: 4 J: 4

Certamente esse não era o resultado esperado!

Olhando mais a fundo você observará que foram impressos itens consecutivos do vetor, no entanto a linha 38 (função printIt()) avança o índice de dois em dois (ou seja, os itens deveriam ser impressos intercalados)!

Para entender melhor o problema vamos analiasar a função "printIt()" (muito simples por sinal).

Na linha 38 temos um loop de 0 até o n. A cada passo o índice (i) utilizado para acessar o array é incrementado de dois, ou seja, o primeiro elemento acessado é o de índice 0 (zero), seguido pelos elementos de índice 2, 4 e assim sucessivamente.

Este acesso se dá através da chamada do método print() do objeto que se encontra no índice corrente (0, 2, 4, etc) na linha 40:

a[i].print();

O problema esta na forma como o compilador gera código para resolver a expressão a[i]. Esta expressão é equivalente a *(a + i) que nada mais é que aritmética de ponteiros. Bom, a especificação da linguagem determina que esta aritmética deve ser realizada baseada no tamanho do tipo em questão (neste caso o tipo da variável a), ou seja, sendo p um ponteiro igual a 1000, o endereço (p+2) é calculado como 1000 + 2 * sizeof(*p).

Se p for um ponteiro para char então p+2 será efetivamente:

1000 + 2 * sizeof(char) => 1000 + 2 * 1 == 1002

Contudo se p for um ponteiro para int então p+2 sera:

1000 + 2 * sizeof(int) => 1000 + 2 * 4 => 1008 (isto em 32 bits).

Veja o exemplo abaixo:

int v[4];
int *p = v;      // p == &v[0];
int *p1 = p + 1; // p1 == &v[1];

char *pc = (char*) p;
char *p1c = (char*) p1;

printf("Diferença: %d", p1 - p);

Agora que você já relembrou como é realizada aritimética de ponteiros, voltemos à nossa expressão:

a[i].print();

Como dissemos esta expressão é equivalente à:

base *p = &a[i];
p->print();

que é equivalente à:

base *p = (a + i);
p->print();

Já percebeu? Não?

Imagine que o vetor a[] possua a seguinte configuração na memória:

a[0] (1000)
a[1] (1016)
a[2] (1032)
... ...
a[n]

No diagrama acima observamos que o primeiro elemento de a[], ou seja, a[0] se encontra no endereço 1000. E a[1]? qual seu endereço?

Baseado no diagrama acima responderíamos: 1016 é claro!

O problema é que o compildor não viu este diagrama; então para calcular este endereço o mesmo irá empregar aritmética de ponteiros com as informações que possui em mãos, ou seja, o endereço inicial de a e seu tipo um vetor
de objetos do tipo base:

&a[i] == (a + i * sizeof(base))

Observe bem a expressão acima!

O compilador esta considerando o tamanho de "base" para calcular o deslocamento do elemento de indice "i" a partir do início do vetor, quando na realidade temos um vetor de objetos "derived", ou seja, para funcionar deveríamos tomar sizeof(derived) e não sizeof(base).

Assim, &a[1] será (assumindo que o primeiro elemento do vetor "a" se encontra no endereço 1000):

&a[1] => (1000 + 1 * sizeof(base)) => (1000 + 1 * 8) => 1008

Opss!! Não deveria ser 1016?

Então para a função "printIt()" o vetor 'a' tem a seguinte configuração:

Visão printIt()
---------------
a[0] (1000)
a[1] (1008)
a[2] (1016)
a[3] (1024)
a[4] (1032)
a[5] (1040)
a[6] (1048)
... ...
a[n]

Observe que isto ocorre porque sizeof(base) * 2 == sizeof(derived). Isto não é uma coicidência! Eu escrevi as classes para obter este resultado.

Na vida real, um erro como este (utilizar um vetor de objetos de forma polimorfica) normalmente causaria exceções de acesso a memória (access violations).

Quer fazer um teste? É bem simples, basta modificar o código de forma que o índice 'i' seja incrementado de 1 (um) ao invés de 2 (dois). Isto fará com que o programa tente acessar &a[1] que na realidade não é o endereço do segundo elemento do vetor mas sim um endereço no meio do primeiro objeto do vetor.

Como resolver isto? Simples! Nunca utilize vetores de objetos de forma polimorfica! Utilize um vetor de ponteiros para objetos!

Espero ter contribuido!

Adriano

Executando métodos de um objeto JScript a partir de um componente COM

2006-01-19T23:07:00.000-02:00

Outro dia recebi um email de um amigo perguntando como ele poderia chamar um método de um objeto JScript a partir de um componente COM, ou seja, ele queria fazer um call back para o script que havia executado o método em questão.

No primeiro momento não entendi direito.. achei que não pudesse ser feito; em casa, tomando banho (como sempre ocorre) me veio a solução (ou melhor, eu entendi o problema :). Vamos ao que interessa, o exemplo.

A primeira coisa que temos que entender é que o JScript (da Microsoft) é implementado utilizando-se a Script Engine que nada mais é que um punhado de componentes COM (ok estou simplificando um pouco as coisas). Assim sendo é natural que objetos em JScript suportem o modelo do COM.
Ótimo, o próximo ponto que devemos ter em mente é que sendo uma linguagem de script também é natural que estes objetos suportem a interface IDispatch.
Com isto em mente podemos escrever nosso código JScript que deve

Implementar uma classe
Instanciar um componente COM
Passar, de alguma forma, uma referância do objeto JScript para o componente COM

Primeiro vamos apresentar o código JScript.

0: function MinhaClasse_Teste1(i)
1: {
2:     this.Valor = i * 2;
3: }
4:
5: function MinhaClasse_Teste2()
6: {
7:     return this.Valor;
8: }
9:
10: function MinhaClasse()
11: {
12:     this.Teste1 = MinhaClasse_Teste1;
13:     this.Teste2 = MinhaClasse_Teste2;
14:     this.Valor = 1;
15: }
16:
17: var obj;
18: obj = new MinhaClasse();
19:
20: obj.Teste1(10);
21: WScript.Echo("Valor: " +
22:                  obj.Teste2() +
23:                  " [Antes de ter o callback executado]");
24:
25: var t = new ActiveXObject("TestScript.ScriptCallBack");
26: t.Callback = obj;
27: t.DoSomeAction(40);
28:
29: WScript.Echo("Valor: " +
30:                   obj.Teste2() +
31:                   " [Depois de executar o objeto COM]");

Nas linhas 10-15 declaramos uma classe (a função MinhaClasse() é tratada como o construtor da classe); dentro do construtor adicionamos os métodos/propriedades à classe (através de atribuição).

Pronto! Nossa classe já esta definida! A mesma possui dois métodos (Teste1() e Teste2()) e uma propriedade (Valor).

Nas linhas 17-23 executamos alguns métodos da classe apenas a título de teste.

Na linha 25 instanciamos o objeto COM que iremos utilizar.

Na linha 26 informamos a este objeto qual o objeto deve ser utilizado para realizar o callback (note que o mesmo deve possuir conhecimento prévio da estrutura da classe, ou seja, o objeto COM deve saber o nome do método e número de parâmetros do método a ser executado como callback).

Finalmente na linha 27 executamos o método do objeto COM que irá (em algum momento) executar o método do objeto JScript. O método DoSomeAction() irá chamar a função Teste1() da classe MinhaClasse() (JScript).

Neste ponto finalizamos a parte do script. Agora vamos abordar o componente COM:

0: #include "stdafx.h"
1: #include "TestScript.h"
2: #include "TestScriptImpl.h"
3:
4: STDMETHODIMP CScriptCallBack::put_Callback(IDispatch* rhs)
5: {
6:     if (obj)
7:     {
8:         obj.Release();
9:     }
10:
11:     if (rhs)
12:     {
13:         obj = rhs;
14:     }
15:
16:     return S_OK;
17: }
18:
19: STDMETHODIMP CScriptCallBack::DoSomeAction(INT i)
20: {
21:     HRESULT hr = E_UNEXPECTED;
22:     if (obj)
23:     {
24:         CComVariant param(i);
25:         hr = obj.Invoke1(OLESTR("Teste1"), &param);
26:     }
27:
28:     return hr;
29: }

Este é um componente típico, sem maiores complicadores. O ponto importante no mesmo é a propriedade Callback; a mesma espera um ponteiro para uma interface do tipo IDispatch que implemente um método com a seguinte assinatura:

Teste1(int n)

Quando o método DoSomeAction() é executado o mesmo chama o método Teste1() do objeto passado para a propriedade Callback.

Observe que para o componente COM não importa se o objeto apontado pela interface IDispatch em questão é ou não um objeto JScript; tudo que é necessário é que este objeto implemente a interface IDispatch e possua o método Teste1() com uma assinatura compatível.

Aproveitando a oportunidade, você consegue ver um problema em potencial neste código? Então fique atento... este será o assunto de um post futuro na série: "Oque esta errado com este código - parte N" :)

Have fun!

O que esta errado com este código (parte II)

2006-01-17T08:31:00.000-02:00

Este é um pouco mais difícil de entender apenas olhando o código. Para facilitar adianto que o programa deveria imprimir o seguinte:
- N: 1 J: 7
- N: 3 J: 5
- N: 5 J: 3
- N: 7 J: 1

Compile o programa e teste :) (tanto o VC6 quanto o VC7 geram o mesmo resultado)


0: #include <iostream>
1:
2: class base
3: {
4: public:
5:     base(int i) : n(i)
6:     {
7:     }
8:    
9:     virtual void print()
10:     {
11:         std::cout << "N: " << n << " ";
12:     }
13:    
14: private:
15:     int n;
16: };
17:
18: class derived : public base
19: {
20: public:
21:     derived(int x, int y) : base(x), j(y), t(0)
22:     {
23:     }
24:    
25:     virtual void print()
26:     {
27:         base::print();
28:         std::cout << "J: " << j << std::endl; 
29:     }
30:    
31: private:
32:     int j;
33:     int t;
34: };
35:
36: void printIt(base a[], int n)
37: {
38:     for (int i=0; i < n; i += 2)
39:     {
40:         a[i].print();
41:     }
42: }
43:
44: void main()
45: {
46:     derived d[] =   {
47:                     derived(1,7),
48:                     derived(2,6),
49:                     derived(3,5),
50:                     derived(4,4),
51:                     derived(5,3),
52:                     derived(6,2),
53:                     derived(7,1)
54:                     };
55:                        
56:    
57:     printIt(d, sizeof(d) / sizeof(d[0]));
58: }

O que esta errado com este código (Parte I) : Resposta

2006-01-12T08:24:00.000-02:00

Não fique frustrado se você não conseguiu identificar o problema (muitos desenvolvedores C++ ainda discutem se realmente o que vou expor representa ou não um problema).

A questão aqui é que o objeto X sofre de crise de identidade.

Para entender o problema pense em qual o resultado esperado quando executado o programa. Se você me fizesse esta pergunta a algum tempo atraz eu responderia de pronto:

"Eu espero que seja impresso a string '[C++] In base constructor I'm derived'".

Para minha surpresa (e de muitos, pode estar certo), quando executado o programa imprime:

"'[C++] In base constructor I'm base'.

Entendeu? Não? Eu explico melhor.

Uma vez que o método WhoAmI() foi definido como virtual os desenvolvedores esperam que a chamada a este método no construtor da classe base resolva para o método adequado, ou seja, se estivermos instanciando um objeto da classe base o método WhoAmI() desta classe deveria ser chamado; se estivermos instanciando um objeto da classe derived o método desta classe deveria ser executado. Contudo este não é o comportamento observado ao executar o programa. Na realidade observamos que o método da classe base será executado, não importa se estamos instanciando um objeto desta classe ou de uma subclasse (por exemplo a classe derived). Faça o teste.

Neste momento tenho certeza que já tem alguém dizendo:

"Mas que estúpido! Porque não implementam isto de forma correta?"

Vamos tentar analisar: O padrão C++ dita que um objeto deve ter os construtores de suas classes executados da classe mais base para a classe mais derivada; neste exemplo, quando o objeto x for instanciado os construtores serão executados na ordem:

base --> derived

ou seja, o construtor da classe base será executado primeiro, depois o construtor da classe derived será executado. Neste ponto surge o problema de "crise de identidade" do objeto x. A maioria dos compiladores implementa métodos virtuais através do conceito de vtables (para ser sincero não conheço nenhum que não utilize esta técnica).

[você não sabe o que é uma vtable? Vou emprestar uma frase feminina milenar:

"se você não sabe o que é uma vtable não sou eu quem vou lhe dizer";

brincadeira a parte, este é um assunto para outro post].

O problema é que neste ponto o (construtor da classe base) o construtor da classe derived ainda não foi executado e, assim sendo, a entrada do método WhoAmI() na vtable do objeto x ainda aponta para o método da classe base.

Somente após a execução do construtor da classe derived é que a vtable será corrida, ou seja, chamadas ao método WhoAmI() serão direcionados ao método desta classe ao invés da classe base. Faça um teste; simplesmente adicione a linha abaixo à função main() do programa de exemplo:


x.WhoAmI();

Observe que será impresso "derived", ou seja, neste ponto a vtable do objeto x já esta correta.

Isto occorre porque objetos nascem como objetos da classe mais base e vão amadurecendo, tomando a identidade de cada uma das classes base deste objeto, a medida que seus respectivos construtores vão sendo executados.

Observe que este comportamento não é decorrente de limitações tecnologicas mas sim de uma descisão consciente para previnir problemas; imagine qual seria o resultado de executar um método virtual de uma classe cujo construtor ainda não tenha sido executado (sim, a ordem de execução dos construtores não pode ser modificada). Neste exemplo não teriamos problema algum, contudo, em qualquer classe útil, possivelmente teríamos variáveis não inicializadas sendo utilizadas (isto realmente não é o comportamento que você deseja pode ter certeza).

Inclusive em algumas linguagens (por exemplo C#) objetos não sofrem desta crise de identidade mas por outro lado podem acessar variáveis não inicializadas se não forem corretamente implementados.

Espero ter sido claro.

O que esta errado com este código (Parte I) ?

2005-12-22T10:45:00.000-02:00

Antes de mais nada, eu sei, esta não é uma idéia muito original, mas eu acredito que seja uma forma bastante eficiente de apresentar tópicos de interesse e de chamar a atenção; então vamos lá, esta é relativamente simples.

 0: #include "iostream"
1:
2: class base
3: {
4: public:
5:     base()
6:     {
7:         std::cout << "[C++] In 'base' constructor I'm: ";
8:         WhoAmI();
9:     }
10:   
11:     virtual ~base()
12:     {
13:         std::cout << "[C++] In 'base' destructor I'm: ";
14:         WhoAmI();
15:     }
16:   
17:     virtual void WhoAmI() const
18:     {
19:         std::cout << "base" << std::endl;
20:     }
21: };
22:
23: class derived : public base
24: {
25: public:
26:     virtual void WhoAmI() const
27:     {
28:         std::cout << "derived" << std::endl;
29:     }
30: };
31:
32: void main()
33: {
34:     derived x;
35: }

No próximo post dou a resposta.

[Editado dia 12/01/2006: Incluí "Parte I" no título]

Livros

2005-11-22T16:58:00.000-02:00

Hoje vou postar apenas este link para uma lista de livros de programação/informática que acho bem interessante.

Antes que alguém pergunte, sim, eu já li a maioria dos livros que estão na lista (para falar a verdade tem 3 que ainda não li; dois eu pretendo comprar e 1 ainda não foi publicado).

Diferenças entre Generics X Templates C++

2005-11-10T14:40:00.000-02:00

Neste post vou abordar as principais diferenças entre generics e templates (gostaria de reafirmar que o assunto é muito extenso e que não tenho a pretenção de abordá-lo em profundidade. Assim se você deseja aprender mais visite o site da Microsoft e/ou outros sites).

Assim, se você não conhece C++ pode ignorar este post. Também gostaria de lembrar que além dos pontos aqui abordados temos a questão da integração Generics X Templates quando desenvolvemos em Managed C++, mas isto é um outro assunto.

Bom, vamos começar pelas diferenças que vem melhorar a utilização de Generics em relação à templates: code bloating. Code Bloating é o efeito resultante da instanciação de um mesmo template para vários tipos de dados. Por exemplo, imagine o seguinte template em C++:

0: #include <stdio.h>
1:
2: template <typename T>
3: class MyTestTemplate
4: {
5: public:
6:     MyTestTemplate(T t)
7:     {
8:         data_ = t;
9:     }
10:
11:     T GetIt()
12:     {
13:         return data_;
14:     }
15:
16: private:
17:     T data_;
18: };
19:
20: struct TestStruct
21: {
22:     int n1;
23:     char *str;
24: };
25:
26: void main()
27: {
28:     MyTestTemplate<int> a(10);          printf("int   : %d\r\n", a.GetIt());
29:     MyTestTemplate<char> b('A');        printf("char  : %c\r\n", b.GetIt());
30:     MyTestTemplate<double> c(1.2);      printf("double: %f\r\n", c.GetIt());
31:                                  
32:     TestStruct t = {10, "Adriano"};
33:     MyTestTemplate<TestStruct> d(t);    printf("struct: %d %s\r\n", d.GetIt().n1, d.GetIt().str);
34: }

Uau! Isto não é nenhuma obra prima mas serve para nosso propósito! :).

No exemplo acima estamos instanciando o template MyTestTemplate 4 vezes (um para o tipo de dado int, um para char, um para double e um para TestStruct).

Neste exemplo o compilador irá gerar quatro cópias do código fonte, uma para cada tipo instanciado. De uma forma bastante simplista podemos dizer que o código fonte resultante é equivalente ao gerado se escrevessemos algo como:

0: #include <stdio.h>
1:
2: #define DEFINE_TEST_CLASS(TYPE)               \
3: class MyTestTemplate_##TYPE                   \
4: {                                             \
5: public:                                       \
6:     MyTestTemplate_##TYPE(TYPE t)             \
7:     {                                         \
8:         data_ = t;                            \
9:     }                                         \
10:                                              \
11:     TYPE GetIt()                             \
12:     {                                        \
13:         return data_;                        \
14:     }                                        \
15:                                              \
16: private:                                     \
17:     TYPE data_;                              \
18: }
19:
20: struct TestStruct
21: {
22:     int n1;
23:     char *str;
24: };
25:
26: DEFINE_TEST_CLASS(int);
27: DEFINE_TEST_CLASS(char);
28: DEFINE_TEST_CLASS(double);
29: DEFINE_TEST_CLASS(TestStruct);
30:
31: void main()
32: {
33:     MyTestTemplate_int a(10);       printf("int   : %d\r\n", a.GetIt());
34:     MyTestTemplate_char b('A');     printf("char  : %c\r\n", b.GetIt());
35:     MyTestTemplate_double c(1.2);   printf("double: %f\r\n", c.GetIt());
36:
37:     TestStruct t = {10, "Adriano"};
38:     MyTestTemplate_TestStruct d(t); printf("struct: %d %s\r\n", d.GetIt().n1, d.GetIt().str);
39: }

Note que o processo de instanciação de templates não é simples assim (ou seja, não é apenas substituição de texto) mas para fins de análise de tamanho do código gerado podemos entender desta forma.

Agora ficou claro! Estamos criando 4 cópias do mesmo trecho de código.

Já com Generics este problema não existe quando utilizado com tipos referência (reference types) e é minimizado em muito quando uitilzados com tipos valores (value types). Para ser mais preciso, o compilador gera uma versão especializada do tipo generic para cada value type com o qual seja instanciado e apenas uma versão comum a todos os tipos referência utilizados. Assim, no exemplo abaixo (C#):

0: class MyTestTemplate<T>
1: {
2:     public MyTestTemplate(T t)
3:     {
4:         data_ = t;
5:     }
6:
7:     public T GetIt()
8:     {
9:         return data_;
10:     }
11:
12:     private T data_;
13: }
14:
15: class Test {}
16: class Test_1 {}
17:
18: public class MyTestTemplateDriver
19: {
20:     static void Main()
21:     {
22:         MyTestTemplate<int> a = new MyTestTemplate<int>(10);
23:         MyTestTemplate<double> b = new MyTestTemplate<double>(20.0);
24:         MyTestTemplate<Test> c = new MyTestTemplate<Test>(new Test()) ;
25:         MyTestTemplate<Test_1> d = new MyTestTemplate<Test_1>(new Test_1()) ;
26:     }
27: }

o compilador irá gerar três versões da classe MyTestTemplate() (uma para int, uma para double e uma para tipos referência) ao invés de quatro. Quando aplicado a código de programas de verdade isto pode representar uma diminuição significativa no tamanho do mesmo.

As demais diferenças entre os dois conceitos podem ser resumidas como:

- Generics, proprositadamente, não apresentam o mesmo grau de flexibilidade/complexidade que templates em C++.

Por exemplo, não é possível utilizar um type parameter como uma classe base do tipo genérico, ou seja, o exemplo abaixo não é válido:

0: class TypeParameterAsBaseClass<T> : T
1: {
2: }

- Generics não suporta type parameters que não sejam tipos

Por exemplo a classe abaixo não é válida em C#:

0: class NonType_TypeParameter<int i>
1: {
2:     public static void Main()
3:     {
4:         NonType_TypeParameter<100> t = new NonType_TypeParameter<100>();
5:         t.PrintIt();
6:     }
7:
8:     public void PrintIt()
9:     {
10:         System.Console.WriteLine("{0}", i);
11:     }
12: }

Além destas diferenças, podemos citar também a falta de suporte a especialização (total/parcial) do tipos genéricos. Basicamente estas são as principais diferenças entre templates em C++ e generics no .Net.

Este post encerra nossa discussão sobre generics!

Até a próxima :)

Generics III - Constrains

2005-10-31T13:32:00.000-02:00

Como prometi hoje vou falar um pouco sobre como utilizar o esquema de generics de uma forma mais eficaz.

Um dos problemas de templates em C++ é que, apesar do esforço do compilador, existem situações que o mesmo não detecta determinado tipo de erros, os quais, serão detectados apenas em tempo de execução.

Bom, para não ficar muito abstrato vamos apresentar um exemplo em C# mesmo (assim deixamos claro que podemos escrever código "não ideal" em qualquer linguagem):

0: using System;
1:
2: class TestConstrains<T>
3: {
4:     public TestConstrains(T data)
5:     {
6:         this.data = data;
7:     }
8:
9:     public void TakeSomeBadAction(T other)
10:    {
11:         Test(data, other);
12:    }
13:
14:     private void Test(T o, T other)
15:     {
16:         IComparable comp = (IComparable) o;
17:         Console.WriteLine(comp.CompareTo(other));
18:     }
19:
20:     private T data;
21: }
22:
23: class B
24: {
25:     public B(int data)
26:     {
27:         this.data = data;
28:     }
29:
30:     private int data;
31: }
32:
33: public class TestConstrainsDriver
34: {
35:     private static void Main()
36:     {
37:         TestConstrains<int> tc = new TestConstrains<int>(10);
38:         tc.TakeSomeBadAction(10);
39:
40:         TestConstrains<B> tcb = new TestConstrains<B>(new B(10));
41:         tcb.TakeSomeBadAction(new B(10));
42:     }
43: }

Neste exemplo a classe TestConstrains recebe em seu construtor um objeto do tipo T. Depois, no método TakeSomeBadAction() o mesmo executa o método Test().

Da forma como esta, o compilador ficará feliz em compilar este código, contudo em tempo de execução este programa gerará uma exceção do tipo InvalidCastException (você é capaz de dizer quais os pontos envolvidos neste problema sem compilar/executar o programa?).

O problema todo ocorre porque os compiladores não realizam análide de fluxo de código tão extensivamente para determinar o tipo de uma variável em todos os pontos de um programa (isto envolveria muito overhead).

Explico melhor: Neste programa ridiculamente pequeno o compilador poderia manter informações a respeito do tipo da variável utilizada para chamar o método TakeSomeBadAction() e assim verificar se este tipo suporta ou não a interface IComparable e emitir um erro em caso negativo.

Simples assim, correto? Talvez em um programa como este sim, mas não para a maioria dos programas "sérios"; confie em mim, você não iria querer esperar 3 horas para seu código (não tão extenso assim) compilar (talvez com a melhoria na performance dos computadores e a evolução da tecnologia, um dia teremos compiladores que analisam o fluxo do código mais agressivamente).

Para aliviar este problema, o framework permite que restrinjamos os possíveis tipos para um type argument. Para tanto utilizamos a sintaxe:

class C where (restrição aqui)

Basicamente o framework suporta 5 tipo de restrições (constrains): i) o tipo dever ser uma classe, ii) o tipo deve ser uma estrutura, iii) o tipo deve implementar (direta ou indiretamente) uma interface, iv) o tipo deve derivar (direta ou indiretamente) de uma classe, v) o tipo deve possuir um construtor (público) sem parâmetros. Não vou repetir aqui a explicação de como cada restrição funciona (vou usar o princípio DRY; para maiores informações consulte a documentação da Microsoft).

Para exemplificar melhor vamos utilizar o item iii (tipo deve implementar uma interface) para restringir T a tipos que implementem a interface IComparable:

 0: using System;
1:
2: class TestConstrains<T> where T : IComparable
3: {
4:     public TestConstrains(T data)
5:     {
6:         this.data = data;
7:     }
8:
9:     public void TakeSomeBadAction(T other)
10:    {
11:         Test(data, other);
12:    }
13:
14:     private void Test(object o, object other)
15:     {
16:         IComparable comp = (IComparable) o;
17:         Console.WriteLine(comp.CompareTo(other));
18:     }
19:
20:     private T data;
21: }
22:
23: class B
24: {
25:     public B(int data)
26:     {
27:         this.data = data;
28:     }
29:
30:     private int data;
31: }
32:
33: class C : IComparable
34: {
35:     public C(int data)
36:     {
37:         this.data = data;
38:     }
39:
40:     public int CompareTo(object o)
41:     {
42:         C other = o as C;
43:         if (other != null)
44:         {
45:             return data - other.data;
46:         }
47:    
48:         return -1;
49:     }
50:
51:     private int data;
52: }
53:
54: public class TestConstrainsDriver
55: {
56:     private static void Main()
57:     {
58:         TestConstrains<int> tc = new TestConstrains<int>(10);
59:         tc.TakeSomeBadAction(10); // Ok, Funciona corretamente...
60:    
61:         //TestConstrains<B> tcb = new TestConstrains<B>(new B(10));
62:         //tcb.TakeSomeBadAction(new B(10));  //oopsss Classe 'B' não suporta a interface IComparable
63:    
64:         TestConstrains<C> tcc = new TestConstrains<C>(new C(10));
65:         tcc.TakeSomeBadAction(new C(10));
66:     }
67: }

Agora tente remover os comentários das linhas 61 e 62 e compilar! Perfeito, agora o compilador emite um erro nos avisando que o tipo B não implementa a interface IComparable!

Além de tornar nosso código mais seguro a utilização de restrições também ajudam a documentar o código.

Bom, espero ter acrescentado informações úteis a seu conhecimento :)

Adriano

Versão final do .Net Framework II liberada

2005-10-28T09:14:00.000-02:00

A microsoft acabou de liberar a versão 2.0 do .Net Framework (e o sdk)

Mas esteja preparado para baixar aproximadamente 400 Mb entre o Framework e o SDK.

Adriano

Formatando código fonte no Blogger!

2005-10-26T21:07:00.000-02:00

Boa noite.

Este post será bastante resumido (e esta relacionado indiretamente com os anteriores sobre C#/.Net Framework).

Desde meus primeiros posts com código fonte eu me senti frustrado por não conseguir formatar o código de uma forma que me agradasse (bast olhar alguns dos referidos posts).

Contudo eu estava decidido a encontrar alguma solução; já havia tentado utilizar algum formatador do tipo c#2html mas o resultado não era satisfatório; depois de procurar bastante encontrei em um blog uma referência a este assunto.

O mesmo sugiria a utilização de um formatador chamado colorer; após alguns testes consegui o resultado esperado.

Para postar código formatado:

baixe o colorer
Execute o mesmo informando o programa fonte desejado
adicione em seu post (editando em html) as seguintes linhas:

<pre>
seu código formatado aqui
</pre>

Pronto! Nem parece que é tão simples assim. Na realidade a única coisa que temos que fazer é acrescentar a tag pre ao resultado do colorer.

Adriano

Generics II

2005-10-25T09:34:00.000-02:00

No post anterior discuti um pouco sobre Generics; apresentei alguns problemas e como os mesmos são resolvidos/atenuados com a utilização deste conceito.

De uma forma mais ampla, podemos usar o conceito de generics quando uma classe/algoritmo pode ser aplicado a mais de um tipo de dados, ou seja, esta classe/algoritmo é independente do tipo de dado em questão; ao invés de criar várias versões da mesma classe (uma para cada tipo de dado desejado), criamos uma classe genérica e deixamos o compilador (no caso do .Net o compilador/Framework) trabalhar por nós.

O exemplo apresentado no post anterior é um caso clássico: em um programa podemos ter a necessidade de armazenar coleções de diversos tipos de dados diferentes; uma solução é implementar classes que armazenam tipos de dados específicos, contudo esta, geralmente, não é uma boa solução, visto que teremos duplicação de código, trabalho, etc. Uma segunda alternativa é a solução adotada até a versão 1.1 do .Net Framework, ou seja, escrever coleções de dados que manipulam o tipo de dado base (no .Net Object); pelas razões discutidas no post anterior (entre outras) esta também não é uma solução muito atraente; uma terceita alternativa seria mesclar as duas primeiras, ou seja, ter uma implementação da coleção que aceita a classe Object e escrever versões mais especializadas que utilizam esta implementação (melhorou bastante mas ainda temos que escrever e dar manutenção nas versões específicas). Generics nos permite escrever classes/algorítmos sem nos preocuparmos com o tipo de dado manipulado; para ser mais preciso manipulamos um tipo de dado que sera especificado pelo usuário do nosso código.

Assim, um tipo genérico (por exemplo a classe List<T> do namespace System.Collections.Generic) representa apenas um modelo, ou seja, não podemos criar instâncias deste tipo. Por exemplo o seguinte código não compila:

IList list = new System.Collections.Generic.List(); 

Se você tentar compilar este trecho de código em um programa C# o compilador emitirá um erro semelhante a:

TestGenericCollections.cs(9,3): error CS0305: Using the generic type 'System.Collections.Generic.List<T>' requires '1' type arguments

Este erro nos informa que o tipo List requer um type parameter, que nada mais é que um tipo de dados que será aplicado ao tipo genérico. Em outras palavras o compilador não tem como decidir se desejamos uma lista de bananas, nomes, idades, etc. Este dado (o tipo de lista que desejamos) deve ser informado ao compilador utilizando o type parameter T. Assim, para que o exemplo compile temos que dizer ao compilador qual é este tipo:

IList<string> list = new System.Collections.Generic.List<string>();

Neste exemplo dizemos que o tipo String é um type parameter, ou seja, especifica o tipo que o compilador deve utilizar toda vez que T aparecer como um tipo na classe List).

Um tipo generic deve possuir um ou mais type parameters que devem ser substuídos por tipos específicos no momento do uso do mesmo. Acho que aqui vale um exemplo:

0: using System;
1:
2: class TestGeneric<T>
3: {
4:     public TestGeneric(T i)
5:     {
6:         data = i;
7:     }
8:
9:     public T Data
10:     {
11:         get
12:         {
13:             return data;
14:         }
15:
16:         set
17:         {
18:             data = value;
19:         }
20:     }
21:
22:     public string Name
23:     {
24:         get
25:         {
26:             return name;
27:         }
28:     }
29:
30:     private String name;
31:     private T data;
32: }
33:
34: public class TestGenericDriver
35: {
36:     private static void Main()
37:     {
38:         TestGeneric<string> t = new TestGeneric<string>("Adriano");
39:         Type tt = t.GetType();
40:
41:         Type[] defparams = tt.GetGenericArguments();
42:         foreach (Type tp in defparams)
43:         {
44:             Console.WriteLine("\r\nType parameter: {0}", tp.Name);
45:         }
46:     }
47: }

Neste exemplo definimos um tipo genérico (TestGeneric) que espera um Type Parameter (T) (Linha 2). Este tipo declara uma variável de instância data (Linha 31) do tipo T e também uma propriedade Data (Linha 9). Na linha 38 criamos uma instância da classe TestGeneric usando string como tipo para T, ou seja, tanto a variável de instância data quanto a propriedade Data assumem o tipo string para a variável t (linha 38).

Quando associamos um tipo a um type parameter dizemos que estamos criando uma instância do tipo genérico. Assim na linha 38 o trecho de código:

TestGeneric<string> t = new TestGeneric<string>("Adriano");

instancia o tipo TestGeneric (não confundir a instância de uma classe, ou seja, um objeto, com a instância de um tipo genérico) com o type parameter como string.

Da mesma forma ao escrevermos o seguinte código:

TestGeneric<int> ti;

estamos instanciando o tipo TestGeneric com T como int.

Apesar de neste exemplo em particular o tipo genérico possuir apenas um type parameter nada impede de definirmos tipos com dois ou mais type parameters.

Nos próximos posts pretendo discutir um pouco mais sobre:

constrains.
diferenças entre generics e templates C++.
Palavra reservada default.
Representação em runtime.

Adriano.

2005-10-07T13:51:00.000-03:00

Como comentei neste post, pretendo falar um pouco mais sobre as melhorias introduzidas na versão 2.0 do C#.

Na realidade, muitas destas melhorias só são suportadas pois foram introduzidas também no .Net Framework.
Vou começar pelo assunto Generics, uma vez que venho do "mundo C++" e gosto muito do conceito de templates (que é semelhante)

Em primeiro lugar, Generics é uma tecnologia que nos permite tratar um tipo de forma genérica (ok, sem gozação). Um caso clássico é a implementação de coleções (por exemplo listas encadeadas, filas, pilhas, etc). Até a versão 2.0 do .Net Framework coleções eram implementadas de forma a tratar os dados como Object. Funciona, mas esta abordagem traz vários problemas:

Uma vez armazenado na coleção, o objeto perde sua identidade, ou seja, tudo é tratado como object.

Isto obriga o desenvolvedor a fazer casts

Não é possível ao compilador verificar o correto uso da coleção quanto ao tipo de dado incluído na mesma.

Performance (basicamente boxing/unboxing)

Vamos apresentar um exemplo:

   1:  using System.Collections;

   2:  using System;

3:

   4:  class TestCollection

   5:  {

   6:     public static void Main()

   7:     {

   8:          IList col = new ArrayList();

9:

  10:          col.Add("Adriano");

  11:          col.Add("Verona");

12:

  13:          String s = (String) col[0];

  14:          foreach (string str in col)

  15:          {

  16:              System.Console.WriteLine(str);

  17:          }

18:

  19:          col.Add(10);

  20:          foreach (string str in col)

  21:          {

  22:              System.Console.WriteLine(str);

  23:          }

  24:     }

  25:  }

Os problemas começam na linha 13 (que ilustra o ponto 2). Porque o compilador não permite que eu atribua col[0] para a variável s sem um cast explícito? Bom, porque o indexador [] da interface IList foi declarado como retornando um object e não poderia ser diferente! O único tipo de dados genérico disponível era o object!

Outro problema pode ser observado na linha 19. Como o método Add() espera um object o compilador não tem como verificar que esta operação não é válida. Provavelmente o desenvolvedor que escreveu este código ficará surpreso ao ser gerada uma exceção na linha 20.

Agora observer o próximo exemplo:

   1:  using System.Collections.Generic;

   2:  using System;

3:

   4:  class TestGenericCollection

   5:  {

   6:     public static void Main()

   7:     {

   8:          IList<String> strCol = new List<String>();

9:

  10:          strCol.Add("Str1");

  11:          strCol.Add("Str1");

12:

  13:          String s = strCol[0]; // Agora sim!!

  14:          Console.WriteLine(s);

15:

  16:          // Tentar compilar com o código abaixo descomentado gera um erro de compilação

  17:          // strCol.Add(42);

  18:     }

  19:  }

A primeira diferença que observamos é quanto ao namespace utilizado. Neste exemplo passamos a utilizar o namespace System.Collections.Generic ao invés do tradicional System.Collections.

Na linha 8 declaramos uma lista para armazenar strings (denotado pela sintaxe <String> que segue a interface IList e a classe List).

Na linha 13 observamos que podemos recuperar elementos da lista sem necessidade de casts. Você pode estar pensando: "ummm, o compilador deu uma de esperto e fez o cast implicito!! ou seja, sintaxe suggar"; você esta enganado... observe o código IL gerado no primeiro exemplo:

   1:  .method public hidebysig static void  Main() cil managed

   2:  {

   3:    .entrypoint

   4:    // Code size       175 (0xaf)

   5:    .maxstack  2

   6:    .locals init (class [mscorlib]System.Collections.IList V_0,

   7:             string V_1,

   8:             string V_2,

   9:             class [mscorlib]System.Collections.Generic.IList`1<string> V_3,

  10:             class [mscorlib]System.Collections.IEnumerator V_4,

  11:             bool V_5,

  12:             class [mscorlib]System.IDisposable V_6)

  13:    IL_0000:  nop

  14:    IL_0001:  newobj     instance void [mscorlib]System.Collections.ArrayList::.ctor()

  15:    IL_0006:  stloc.0

  16:    IL_0007:  ldloc.0

  17:    IL_0008:  ldstr      "Adriano"

  18:    IL_000d:  callvirt   instance int32 [mscorlib]System.Collections.IList::Add(object)

  19:    IL_0012:  pop

  20:    IL_0013:  ldloc.0

  21:    IL_0014:  ldstr      "Verona"

  22:    IL_0019:  callvirt   instance int32 [mscorlib]System.Collections.IList::Add(object)

  23:    IL_001e:  pop

  24:    IL_001f:  ldloc.0

  25:    IL_0020:  ldc.i4.0

  26:    IL_0021:  callvirt   instance object [mscorlib]System.Collections.IList::get_Item(int32)

  27:    IL_0026:  castclass  [mscorlib]System.String

  28:    IL_002b:  stloc.1

  29:    IL_002c:  nop

  30:    IL_002d:  ldloc.0

Observe que na linha 27 existe uma instrunção castclass (que realiza o cast)

Agora veja o IL gerado no segundo exemplo (usando generics) :

   1:  .method public hidebysig static void  Main() cil managed

   2:  {

   3:    .entrypoint

   4:    // Code size       47 (0x2f)

   5:    .maxstack  2

   6:    .locals init (class [mscorlib]System.Collections.Generic.IList`1<string> V_0,

   7:             string V_1)

   8:    IL_0000:  nop

   9:    IL_0001:  newobj     instance void class [mscorlib]System.Collections.Generic.List`1<string>::.ctor()

  10:    IL_0006:  stloc.0

  11:    IL_0007:  ldloc.0

  12:    IL_0008:  ldstr      "Str1"

  13:    IL_000d:  callvirt   instance void class [mscorlib]System.Collections.Generic.ICollection`1<string>::Add(!0)

  14:    IL_0012:  nop

  15:    IL_0013:  ldloc.0

  16:    IL_0014:  ldstr      "Str1"

  17:    IL_0019:  callvirt   instance void class [mscorlib]System.Collections.Generic.ICollection`1<string>::Add(!0)

  18:    IL_001e:  nop

  19:    IL_001f:  ldloc.0

  20:    IL_0020:  ldc.i4.0

  21:    IL_0021:  callvirt   instance !0 class [mscorlib]System.Collections.Generic.IList`1<string>::get_Item(int32)

  22:    IL_0026:  stloc.1

  23:    IL_0027:  ldloc.1

  24:    IL_0028:  call       void [mscorlib]System.Console::WriteLine(string)

  25:    IL_002d:  nop

  26:    IL_002e:  ret

  27:  } // end of method TestGenericCollection::Main

Note (linhas 21, 22) que o compilador não usou a instrução castclass, ou seja, nenhum cast foi realizado!

No próximo post pretendo falar um pouco mais sobre generics e apresentar um exemplo.

Até mais.

Pinguins...

2005-09-26T23:53:00.000-03:00

Independentemente da disputa sem sentido entre alguns defensores do Linux contra o Windows (e vice-versa) tenho certeza que estes dois S.Os possuem suas qualidades e defeitos... Quanto a minha opnião... sou um pouco suspeito :). Trabalho a quase 10 anos com Windows; já com o Linux tive pouco contato.

Dentre as distribuições que já tive oportunidade de instalar (RH, Slack, Mandrake, Suse, Ubuntu, Mandriva), me identifiquei mais com a Mandrake e Mandriva; aliás, em meu computador tenho instalado atualmente o Mandriva 2005 LE. Particularmente uma das dificuldades que encontrei foi o processo de instalação de novos softwares; na boa, é um parto. Problemas de dependências entre bibliotecas são um pesadelo para se resolver! Sem contar as inúmeras vezes que tento iniciar um programa (clicando duas vezes sobre o mesmo) e nada acontece; meu, é frustante (e olha que não sou um usuário sem conhecimento)

De qualquer forma acredito que a facilidade de uso do Linux vem melhorando (mas pelo que pude perceber os requisitos de hardware também :).

Fica registrado aqui que estou gostando do Mandriva :). Quem sabe eu instalo o Mono qualquer dia destes e passo a desenvolver mais neste ambiente? Talvez Java; C++? Nem pensar... tenho coisa melhor para fazer em minha vida :)

C# 2.0 ? C# 3.0? Meu que loucura.

2005-09-26T10:30:00.000-03:00

Estou ficando louco ou a MS nem lançou a versão 2.0 do C# (e as respectivas mudanças na CLR) e já esta apresentando o que será a versão 3.0!!!

Não deixe de ver o documento de especificação.

Um ótimo blog que costumo ler todos os dias é o Cyru's Blather.

Para aqueles que ainda não tiveram a oportunidade de conheçer as novas funcionalidades da versão 2.0 do C# aqui vai uma lista:

Generics: Semelhanta a templates em C++ porém com uma série de melhorias, inclusive (segundo a MS), sem os problemas de "code bloat" inerentes aos templates em C++.
Anonymous Methods: Uma forma para simplificar o uso de delegates
Iterators: Melhoria no mecanismos de iterators já existentes.
Partial Types: Possibilidade de se implementar classes/estruturas/interfaces em dois ou mais arquivos separados
Nullable Types: Suporte a "value type" com valor nulo (veja este post)

Bom, espero poder discutir cada um dos tópicos com mais detalhes nos próximos posts.

That's all for now!

2005-03-07T08:59:00.000-03:00

Como podem ver faz algum tempo que não posto nada.... o velho problema da falta de tempo...

Enquanto não tenho tempo para continuar o assunto "metadados" vou incluir dois links para o site do Joel falando sobre Entrevistas de trabalho e Práticas de Programação.

Metadados II

2005-01-20T22:40:00.000-02:00

No último post apresentei brevemente o conceito de "metadados" que, quando aplicados à programas, acrescentam informações, que normalmente não são incluídas, ao binário gerado pelo compilador, tais como lista de tipos contidos no módulo, métodos, eventos, etc.

Este post contém um exemplo de como podemos explorar estes metadados em um programa em java.


1    import java.lang.reflect.*;

2    

3    public class TestReflection

4    {

5       public static void main(String []args)

6       {

7        if (args.length == 1)

8        {

9            TestReflection tr = new TestReflection();

10           tr.DumpMethods(args[0]);

11       }

12       else

13       {

14           System.out.println("Numero invalido de parametros");

15           System.out.println("Uso: java TestReflection 'classe'\r\n");

16           System.out.println("Ex: java TestReflection java.lang.String");

17       }

18      }

19   

20      private void DumpMethods(String className)

21      {

22       try

23       {

24           Class cls = Class.forName(className);

25           Method m[] = cls.getDeclaredMethods();

26   

27           for (int i=0; i < m.length; i++)

28           {

29               DumpMethod(m[i]);

30           }

31       }

32       catch(ClassNotFoundException cnfe)

33       {

34           System.out.println("Classe '" + className + "' nao foi encontrada!");

35       }

36      }

37   

38      private void DumpMethod(Method m)

39      {

40       System.out.print(Modifier.toString(m.getModifiers()) + " " + m.getReturnType().getName() + " " + m.getName() + "(");

41   

42       Class paramTypes[] = m.getParameterTypes();

43       for (int i=0; i < paramTypes.length - 1; i++)

44       {

45           System.out.print(paramTypes[i].getName() + ", ");

46       }

47   

48       if (paramTypes.length > 0)

49       {

50           System.out.print(paramTypes[paramTypes.length - 1].getName());

51       }

52   

53       System.out.println(")");

54      }

55   }

56

Toda a mágica é ocorre nos métodos DumpMethods() (linhas 20 - 36) e DumpMethod() (linhas 38 - 54).

Na linha 24, o método estático forName() da classe Class é utilizado para recuperar uma referência para o objeto Class que representa a classe passada como parâmetro. A seguir (linha 25) o método getDeclaredMethods() deste objeto é utilizado para recuperar a lista de métodos implementados pela classe. O próximo passo é chamar o método DumpMethod() (linhas 27 - 29) para cara objeto da lista obtida no passo anterior. Este método por sua vez utiliza os métodos da classe Method (que modela um método de um objeto) para obter informações sobre o nome do método, lista de parâmetros, modificadores, etc.

Nos próximos posts apresentarei um exemplo em .Net e também como "estender" o mecanismo de metadados adicionando seus próprios "atributos" mas isto é assunto para os próximos posts.

Metadados

2005-01-11T22:28:00.000-02:00

O que é?

Do ingles,

metadata
n. data about data, information known that makes it easy to access and use the data (e.g.: library catalog card, which includes information about the nature and location of a book); (Computers) descriptive information about data and documents (such as origin, size, formatting or different characteristics of a data)

Até pouco tempo, ao compilar um programa fonte obtínhamos como resultado o programa final (binário), pronto para ser executado, a partir do qual, pouco podia-se inferir a respeito do programa fonte original (por exemplo, não havia como descobrir os tipos definidos, informações sobre segurança, documentação, etc).

Apesar destas ?limitações? acredito que este modelo seja satisfatório para programas monolíticos, contudo, com a evolução do processo de desenvolvimento e conseqüente componentização do software, estas deficiências ficaram evidentes e as novas tecnologias passaram a incorporar mais informações (metadados) a respeito do programa fonte.

Utilidade

Até recentemente, a utilização de metadados podia ser observada principalmente na área de Gerenciadores de Banco de Dados; por exemplo, os servidores SQL disponibilizam informações a respeito do banco de dados através da própria linguagem SQL (por exemplo no SQL Server pode-se obter informações a respeito de uma tabela tais como lista de campos, índices, etc. utilizando o comando SQL: sp_help nome_tabela).

Contudo os desenvolvedores notaram que esta técnica poderia simplificar o desenvolvimento e/ou permitir a criação de programas mais flexíveis, assim passaram a adotá-la. Por exemplo, C++ possui o conceito de RTTI (ou run time type information) que podemos entender como uma forma primária de metadados. A tecnologia COM (Component Object Model) da Microsoft utiliza typelibraries, ou bibliotecas de tipos, para descrever as classes (ou melhor, CoClasses), interfaces, etc. implementadas em um determinado componente.

Um dos exemplos mais utilizados sobre a utilização de metadados é a criação de Object Browsers; implementar tal tipo de programa para linguagens que não suportam metadados representa um processo intrinsecamente complexo, exigindo, na maior parte dos casos parses para a linguagem em questão. Por outro lado, a implementação para linguagens que suportam este conceito, como Java, C#, VB.Net, etc. é bastante simplificada.

Outro tipo de ferramenta que se beneficia da existência de metadados para um programa são os geradores automáticos de documentação, testes unitários, etc.

Também, ao incluir um componente em uma aplicação COM+ este procura na typelib do componente por uma propriedade específica que defina o comportamento transacional do componente; se esta propriedade existir o administrador do sistema não terá que configurar o componente manualmente, diminuindo a chance de erros.

Todas estas aplicações se tornaram viáveis e/ou de implementação mais simples através da utilização de metadados, contudo as possibilidades de utilização são inúmeras. No próximo post descreverei a o processo, conhecido como reflection, de navegação pelos metadados, gerados pelo compilador da linguagem Java.

2005-01-06T01:55:00.000-02:00

eu...

apresentação ....

2005-01-06T01:18:00.000-02:00

Bom

Meu nome é Adriano, trabalho com desenvolvimento de programas a mais ou menos 10 anos, basicamente software para Windows em C/C++. Na medida do possível (tempo disponível) pretendo enviar dicas, compartilhar experiências, links, etc. relacionados ao assunto de programação em geral (Estruturas de dados, Componentes COM+, Win DNA, Win32, C++, .Net, Unit Test, Documentação, etc.); contudo devo incluir posts de assuntos variados (principalmente sobre minha filha, Carolina :-).

Sou apaixonado por computação, e meus amigos sabem que não gosto de ver código mal escrito (mesmo que seja meu mesmo :-(.

Além deste blog participo dos foruns da Microsoft (principalmente os de C++ e COM+).

Então, vamos parar de enrolação e vamos lá; neste primeiro post compartilho alguns blogs que leio diariamente (ou quase)...

http://blogs.msdn.com
http://blogs.msdn.com/ericgu (C#)
http://weblogs.asp.net/oldnewthing/ (você já se perguntou porque algo no Windows foi implementado - funciona - da forma como foi?)
http://thedailywtf.com/ (coooooxaaa... :-)
http://blogs.msdn.com/EricLippert
http://blogs.msdn.com/larryosterman/

Certamente existem outros (bons) blogs sobre o assunto. Você conhece algum? Compartilhe conosco.

Um abraço,

Adriano