Jump to content
Luigi

DllStructCreate, uma nova forma de trabalhar com variáveis

Recommended Posts

Primeiramente sugiro que leia a seguinte página: DllStructCreate

 

Leu?

 

Entendeu alguma coisa?

 

Não?

 

Ahaahhahah não se preocupe, eu sempre li essa página algumas dezenas de vezes e não entendia nada!

 

Mas vamos com calma...

 

Você que está lendo esse texto agora, há duas possibilidades para você:

  • você nunca viu uma linguagem de programação na vida, e está tendo dificuldades para entender a diferença entre Local, Global e Dim.
  • você já tem um certo conhecimento de alguma linguagem de programação, e sabe trabalhar e definir muito bem o seu conjunto de variáveis.

 

Mas vou lhe contar um segredo, as vezes eu tenho dificuldade para entender o meu conjunto de variáveis.

Como assim, as vezes são muitas, e eu não fico contente com o nome e tento mudar para algo que faça mais sentido.

No dia seguinte, não contente, mudo de novo, na intenção de tentar escrever algo, como o mínimo de letras possíveis, mas que faça algum sentido.

 

Vamos pegar um exemplo clássico, vamos falar de pessoa (apenas algumas características básicas):

 

Uma pessoa tem:

  • nome
  • sobrenome
  • idade
  • altura
  • peso
  • sexo

Como eu representaria isso no AutoIt?

 

Forma 1

Global $sNome = "Luigi"
Global $sSobreNome = "da Silva"
Global $iIdade = 40
Global $fAltura = 1,69
Global $fPeso = 70,2
Global $sSexo = "h"

Tá... E se fosse mais do que uma pessoa? Tipo umas duzentas?

Xi...

Vamos ter que apelar para um array(alguns chamam de vetor)... Ficando assim:

Forma 2

Global Enum $eNome = 1000, $eSobreNome, $eIdade, $eAltura, $ePeso, $eSexo
Global $aPessoa[200][6]

$aPessoa[0][$eNome] = "Luigi"
$aPessoa[0][$eSobreNome] = "da Silva"
$aPessoa[0][$eIdade] = 40
$aPessoa[0][$eAltura] = 1,69
$aPessoa[0][$ePeso] = 70,2
$aPessoa[0][$eSexo] = "h"

$aPessoa[1][$eNome] = "Pato"
$aPessoa[1][$eSobreNome] = "Donald"
$aPessoa[1][$eIdade] = 60
$aPessoa[1][$eAltura] = 0,90
$aPessoa[1][$ePeso] = 20,5
$aPessoa[1][$eSexo] = "h"

$aPessoa[2][$eNome] = "Wolfgang"
$aPessoa[2][$eSobreNome] = "Amadeus Mozart"
$aPessoa[2][$eIdade] = 50
$aPessoa[2][$eAltura] = 1,62
$aPessoa[2][$ePeso] = 65,3
$aPessoa[2][$eSexo] = "h"

; E assim por diante...

Talvez alguns aqui do fórum, já tenha percebido a dificuldade que é trabalhar com mais do que 10 variáveis...

Cada botão é uma variável, um input, as variáveis internas, vixi!

 

Não me recordo de alguém usando DllStructCreate aqui no fórum, me perdoe pela gafe se alguém já usou e eu estou falando besteira.

 

Uma Struct é uma forma de guardar dados.

Mas no C#, é elegante, chega até ser bonito (tá loco?).

 

Antes de começar, precisamos entender que o AutoIt não é uma linguagem tipada, isto é, quando você cria uma variável com Local, Global, Dim ou Assign, tanto faz o que você colocar lá...

Pode ser número, texto, decimal, não importa, o AutoIt armazena qualquer coisa.

 

Agora, outras linguagens como C, C++, C#, Java, o negócio é diferente.

Por exemplo, em Java se você define:

int numero;

e tenta executar a seguinte operação

numero = "felicidade";

Vai dar erro, pois número foi definido como int, e espera receber um número inteiro, não é texto, não é decimal, é um número inteiro.

 

Para trabalhar com Struct, é a mesma coisa, você precisa saber o tipo do dado que está trabalhando, então vamos lá.

 

 

Para começar, temos que construir a TAG da struct, dessa forma:

 Global Const $tagPessoa = "struct;char nome[30];char sobrenome[60];int idade;float altura;float peso;char sexo[1];endstruct"

A boa prática orienta que:

  • o nome da struct comece com 'tag' depois algum nome que faça sentido
  • deve possuir o atributo 'Const', quer dizer, ela será uma constante, não será possível modificar a string da struct
  • todos os campos devem ser separados por ponto e vírgula
  • a string deve começar com a palavra 'struct'
  • a string deve terminar com a palavra 'endstruct'
  • entre o início e o fim, você adiciona os dados que você achar necessário

Definimos que:

nome, como um char array (array de characteres) de 30 caracteres

sobrenome, como um char array (array de characteres) de 60 caracteres

idade, como um campo 'int', que só recebe inteiros

float altura, que armazena números com valores decimais

float peso, que armazena números com valores decimais

sexo, como um char array de 1 caractere

 

Até aqui foi definido a criação da struct, agora vamos construí-la:

Global $tPessoa = DllStructCreate($tagPessoa)

Não confunda:

$tagPessoa é a string de criação da struct

$tPessoa é a struct

Como atribuir um valor em uma struct?

É bem fácil, é assim ó:

Forma 3

DllStructSetData($tPessoa , "nome", "Luigi")
DllStructSetData($tPessoa , "sobrenome", "da Silva")
DllStructSetData($tPessoa , "idade", 40)
DllStructSetData($tPessoa , "altura", 1,69)
DllStructSetData($tPessoa , "peso", 70,2)
DllStructSetData($tPessoa , "sexo", "h")

Pronto, da forma acima você acabou de gravar na struct os dados de uma pessoa.

Mas e como faz para ler/recuperar a informação de uma struct?

Faz assim:

ConsoleWrite("nome[" & DllStructGetData($tPessoa , "nome") & "]" & @LF)
; ou
ConsoleWrite("nome[" & DllStructGetData($tPessoa , 1) & "]" & @LF)

Tanto faz você utilizar o nome do campo (nome, sobrenome, idade) ou o número referente à ele (1, 2, 3), é a mesma coisa.

 

E aí? O que achou de trabalhar com struct? Fácil né?

 

Não? Pois olha, vou te falar a verdade, eu concordo com o que você está pensando, é mais complicado do que a forma tradicional (Local,Globa,Dim,Assign).

 

Mas agora vem a parte legal, essa eu descobri sozinho hoje.

 

Então vamos construir a struct de novo:

Global Const $tagPessoa = "struct;char nome[30];char sobrenome[60];int idade;float altura;float peso;char sexo[1];endstruct"
Global $tPessoa = DllStructCreate($tagPessoa)

Essa parte não tem como facilitar, é isso mesmo e ponto final, mas a partir de agora para definir valores, você pode fazer assim:

$tPessoa.nome = "Luigi"
$tPessoa.sobrenome = "da Silva"
$tPessoa.idade = 40
$tPessoa.altura = 1,69
$tPessoa.peso = 70,2
$tPessoa.sexo = "h"

E para ler/recuperar as informações:

ConsoleWrite("nome.....[ " & $tPessoa.nome & " ]" & @LF)
ConsoleWrite("sobrenome[ " & $tPessoa.sobrenome & " ]" & @LF)
ConsoleWrite("idade....[ " & $tPessoa.idade & " ]" & @LF)
ConsoleWrite("altura...[ " & $tPessoa.altura & " ]" & @LF)
ConsoleWrite("peso.....[ " & $tPessoa.peso & " ]" & @LF)
ConsoleWrite("sexo.....[ " & $tPessoa.sexo & " ]" & @LF)

Essa forma de gravar/ler informações, é elegante.

E você sabe que $tPessoa contém todos os atributos, bastando colocar um ponto e o nome do atributo para acessá-lo.

 

Mas e se fosse o casso das duzentas pessoas?

 

Monta um array de struct, assim:

Global Const $tagPessoa = "struct;char nome[30];char sobrenome[60];int idade;float altura;float peso;char sexo[1];endstruct"
Global $tPessoa = DllStructCreate($tagPessoa)
Global $aPessoa[200]
; para atribuir valores às variáveis
$aPessoa[0] = DllStructCreate($tagPessoa)
$aPessoa[0].nome = "Luigi"
$aPessoa[0].sobrenome = "da Silva"
$aPessoa[0].idade = 40
$aPessoa[0].altura = 1,69
$aPessoa[0].peso = 70,2
$aPessoa[0].sexo = "h"

$aPessoa[1] = DllStructCreate($tagPessoa)
$aPessoa[1].nome = "Pato"
$aPessoa[1].sobrenome = "Donald"
$aPessoa[1].idade = 60
$aPessoa[1].altura = 0,90
$aPessoa[1].peso = 20,5
$aPessoa[1].sexo = "h"

; para ler o valor das variáveis
ConsoleWrite("nome........[ " & $aPessoa[1].nome & " ]" & @LF)
ConsoleWrite("sobrenome...[ " & $aPessoa[1].sobrenome & " ]" & @LF)
ConsoleWrite("idade.......[ " & $aPessoa[1].idade & " ]" & @LF)
ConsoleWrite("altura......[ " & $aPessoa[1].altura & " ]" & @LF)
ConsoleWrite("peso........[ " & $aPessoa[1].peso & " ]" & @LF)
ConsoleWrite("sexo........[ " & $aPessoa[1].sexo & " ]" & @LF)

; ou ainda

For $ii = 0 To UBound($aPessoas, 1) -1
    For $jj = 1 To 6
        ConsoleWrite( DllStructGetData($$aPessoa[$ii], $jj) & @LF)
    Next
    ConsoleWrite(@LF)
Next

; ou ainda

Global $aFields[6] = ["nome", "sobrenome", "idade", "altura", "peso", "sexo"]
For $ii = 0 To UBound($aPessoas, 1) -1
    For $jj = 1 To 6
        ConsoleWrite(aFields[$jj] & "=" & DllStructGetData($$aPessoa[$ii], $jj) & @LF)
    Next
    ConsoleWrite(@LF)
Next

Pelo menos pra mim, essa foi a novidade:

Poder atribuir assim:

$tPessoa.nome = "Pato"

 

E ler assim

ConsoleWrite("nome........[ " & $tPessoa.nome & " ]" & @LF)

Edited by Luigi
  • Like 4

Share this post


Link to post
Share on other sites

Ótimo tutorial, uma maneira confiável para armazenar os dados, evitando muitos erros, achei muito importante essa abordagem, continue nos mostrando esses métodos avançados do autoit.

Share this post


Link to post
Share on other sites

Parabéns @Luigi pelo excelente tutorial, quando eu tiver um tempo vou ver o que consigo fazer com as dicas que vc deu!

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now


×