|
Existe muitas teorias de
programação, Gambas implementa alguns de seus conceitos,
vamos conhecer um pouco a respeito das técnicas nas quais nos
apoiaremos para programar.
Programação estruturada
A
verdade é que este título é muito pretensioso,
há livros completos sobre o assunto, mas o que interessa
explicar é o conceito de "variável",
"funções" e "âmbito"
Variáveis
Os programas armazenam a
informação de uso imediato na memória RAM.
Trabalhando em baixo nível, colocando a informação
indicando o endereço na memória RAM diretamente.
é muito problemático, especialmente quando o
número de dados a armazenar é muito grande.
Para resolver o problema, as
linguagens de programação possuem um conceito de
"variável": é o nome a qual nos referimos para armazenar
informações ou obtê-la, de
endereços que administra sem que nos afete diretamente.
Nós daremos um nome, por exemplo, "MeuValor", designaremos valores com o operador " = " (MeuValor = 3"), e fazendo referência a esse nome poderemos ler seu conteúdo (IPRINT MeuValor, mostraria na janela "3" neste exemplo).
Segundo
a linguagem de programação fala-se que não
está "declarada", ou está "declarada", em
função do modo que se usa as variáveis. Em
linguagem "não declarada", cada variável pode armazenar
qualquer tipo de dados, (um número, uma cadeia de texto, etc.).
isto pode ser bom para programar muito rápido, porém
dá lugar a graves erros em grandes e médias
aplicações. Gambas pelo contrário, é uma
linguagem "declarada", isto significa temos que declarar as
variáveis antes de usa-la, especificando o tipo de dados que vai
conter. Estes são alguns exemplos de declaração
com o Gambas:
DIM MinhaVar As Integer
PRIVATE Resposta As String
PUBLIC Soma As Float
Nestes exemplos, o que nos interessa
agora é a primeira parte desta declaração
(DIM, PRIVATE, PUBLIC), estamos indicando que desejamos uma
variável chamada "MinhaVar" que armazena números
inteiros, outra chamada "Resposta" que armazena cadeia de texto e outra
chamada "Soma" que armazena número com ponto flutuante (quer
dizer, é capaz de armazenar número com parte decimal)
Funções
No
primórdio da
informática, na realidade, na atualidade os microprocessadores
trabalham assim, os programas eram uma quantidade enorme de ordens, uma
após a outra, sem nenhuma possibilidade de
"estruturação" como, dar saltos adiante ou atrás
no código.
Depois impos-se um modelo
mais "estruturado": dividir o código em blocos separados,
chamados "funções" ou "Métodos". Um programa
completo é formado por funções, pequenos blocos de
código o qual enviamos uma série de valores para que se
processe e nos devolva o valor pretendido.
Cada programa em Gambas começa
com uma função "Main", ou principal, e ao longo de
seu código, esta função envia dados a outras
funções, e se necessário, recebe seus resultados.
Este processo denomina-se "chamada", uma função chama a
outra função, esta pode chamar outras, etc. Os valores
que são enviados para serem processados, denominam-se
"parâmetros".
Para indicar ao Gambas o inicio de uma função, empregaremos basicamente esta nomenclatura:
PUBLIC FUNCTION nome_de_funcao (p1 As TipoDados, p2 As TipoDados... ) As TipoDados
ou assim
PUBLIC SUB nome_de_funcao (p1 As TipoDados, p2 As TipoDados...)
A respeito da palavra
"PUBLIC", não nos preocuparemos no momento, mas observe que
podemos indicar "FUNCTION" ou "SUB". a primeira palavra significa
que o código da função vai retornar algum valor,
enquanto que "SUB" significa que trata-se de uma função
que retorna algum valor, como foi o exemplo do nosso segundo tutorial,
onde emitíamos uma mensagem, mas não retornavam nenhum
valor.
nome_da_função: É o
nome com o qual chamaremos a função a partir de outras
parte do código, e será um identificador único
para esse fragmento de código em todo o programa.
(P1 AS TipoDados, P2 AS TipoDados....): A
seguir, indicamos as variáveis que serão passadas como
parâmetros, separados por vírgulas e indicando o tipo de
variável, do mesmo modo que nas declarações antes
explicadas. Segundo o que vai fazer a função empregaremos
mais ou menos parâmetros.
As TipoDados :Se
indicamos a palavra chave "FUNCTION", indicaremos ao final o tipo de
dados que vamos devolver. Dependendo do tipo de parâmetro que
utilizemos estes também podem utilizar-se em ocasiões
para devolver o resultado desejado, a margem deste valor retornado.
Alguns exemplos:
Uma função que não devolve nenhum valor não necessita parâmetros:
PUBLIC SUB MinhaFuncao()
Uma função que não devolve nenhum valor e necessita um valor inteiro como parâmetro:
PUBLIC SUB OutraFuncao(MeuValor As Integer)
U ma função que devolve uma cadeia de texto e necessita de um valor inteiro e um valor de cadeia:
PUBLIC FUNCTION OutrasMais(MeuDado As Integer, MinhaCadeia As String) As String
Âmbito
Nem
todas as funções e variáveis utilizam-se em todo o
código, há várias razões para limitarmos as
zonas de onde podemos acessar uma variável ou
função: desde razões de rendimento, por exemplo,
é melhor ter variáveis que crie-se e destrua-se
após ser usada, que ter um "monstro" na memória com todas
as variáveis permanentemente armazenadas,
até razões de comodidade para o programador, já
que é melhor definir o mesmo nome para certas variáveis,
em zonas "isoladas" do código, que ter que inventar mil
nomes ao longo de um grande programa.
Gambas
permite várias técnicas para separar ou isolar o
"âmbito" das variáveis e funções. Os
programas escrito em Gambas, constam de módulos",
"formulários" e "classes". O código de cada módulo
está parcialmente isolado do código dos demais, e de
igual modo sucede com os formulários e classes. É
possível ter dois módulos que contenham uma
função com o mesmo nome:
Módulo 1:
Public SUB MinhaFuncao(Dados As Integer)
Módulo 2:
Public SUB MinhaFuncao(Dados As Integer)
Si
nos encontramos dentro de
outra função do módulo 1, e quisermos chamar a
função "MinhaFuncao", diretamente faremos assim no
código:
...
MinhaFuncao(34)
...
Ao
chamar "MinhaFuncao", o interpretador sabe que nos referimos a
função que encontra-se dentro do mesmo módulo.
Agora, se nos encontrarmos dentro do módulo 2, ou de qualquer
outro módulo, classe ou formulário, temos de especificar
o módulo em que encontra-se a função. Assim
estando no módulo 2 faremos:
...
MinhaFuncao(9654)
...
Realmente
estaríamos chamando a função com esse nome que
encontra-se dentro do módulo 2. Temos de especificar que
desejamos utilizar a função do módulo 1 indicando
o nome do módulo, um ponto e o nome da função:
Modulo1.MinhaFuncao(9654)
A
segunda técnica para delimitar o âmbito da
função, é especificar ao interpretador se
desejamos que essa função seja acessível a partir
de outro módulo, formulário ou classe. Se indicarmos a
palavra "PUBLIC", antes da declaração da
função, esta poderá ser chamada de outros
módulos, formulários ou classes. porém se
indicarmos "PRIVATE", só poderemos acessar no próprio
módulo (diz-se também que "não é
visível" de outros módulos).
Quanto as variáveis, temos os mesmos casos que com as funções, e outras mais:
As
variáveis podem ser declaradas no inicio dos módulos,
formulários ou classes, antes de qualquer função,
neste caso empregaremos as palavras "PRIVATE" e "PUBLIC" como no caso
das funções, e estas variáveis existirá
enquanto existir o módulo, classe ou formulário. Mas
também podemos declarar uma variável dentro de uma
função, usando agora a palavra chave "DIM", e neste caso
a variável só existe quando entramos na
função até que saia, e não é
acessível em absoluto de nenhum outro local do código
fora da função.
PRIVATE Var1 As Integer
PUBLIC Var2 As String
PUBLIC FUNCTION SomaEspecial (V1 As Integer, V2 As Integer) As Integer
DIM Media As Integer
Media=(V1+V2)/2
RETURN Media+V1+V2
END
|
