3-Bim Manipulação de dados na memória.

Universidade do Vale do Paraíba
Colégio Técnico Antônio Teixeira Fernandes
Disciplina Programação Orientada a Objetos - II
Material III-Bimestre
Manipulação de Arrays, Funções e Procedimentos
Ponteiros, Barra de Progressão, Barra de rastro,
Timer , Gráficos e Imagens
site : http://www1.univap.br/~wagner
Prof. Responsáveis
Wagner Santos C. de Jesus
Array(Vetores)
Array vem a ser a forma de criar uma variável
que pode representar uma coleção de elementos.
Onde cada item de dado especifica um elemento
que deve ser associado a um índice.
Exemplo :
<tipo> <variável> [<indice>][...][...]... = <valor>;
Onde o índice representa o número de
elementos que o vetor irá possuir, Um vetor
poderá possuir mais de um índice.
Onde o índice representa o número de
elementos que o vetor irá possuir, Um vetor
poderá possuir mais de um índice.
Exemplo da utilização de um
Array com os elementos fixos.
int k[] = { 50, 22, 38 };
Um Array poderá ser criado da
seguintes Maneiras.
Exemplo :
int k[3];
k[0] = 50;
k[1] = 22;
k[2] = 38;
int m[3][4]; // Este exemplo cria um Array de três
linhas e quatro colunas.
Exemplo : Programa que preenche o vetor m com
elementos.
int v1[3][4];
int k = 30;
for(int i=0;i<=2;i++){
for(int j=0;j<=3;j++){
v1[i][j] = k;
k+=5;
}
}
O programa irá preencher na memória o vetor v1 da
seguinte forma.
Obs : Todo o vetor em C++ será iniciado na posição (0).
Portanto um vetor de três elementos irá ter o índices de
zero à dois.
Funções e Procedimentos
Uma função vem a ser uma rotina externa ao
programa principal que está sendo
executado, normalmente uma função
retorna um valor já um procedimento possui
o mesmo comportamento da função mas
não sendo possível retorna valor.
Declarando procedimentos e
funções em C++.
Para se declarar um procedimento deve-se usar a palavra void
em antes do nome do mesmo.
Sintaxe :
void <nome-procedimento>([<parâmetros>]) {
:
: <Instruções>
}
Exemplo declaração Procedimento
Exemplo
void teste(char letras[])
{
ShowMessage(letras);
}
:
:
teste("Teletubbies dizem Oi...");
Criando uma Função
Para declarar uma função usa-se a seguinte notação. O tipo
de dados que esta função irá retornar seguindo do nome da
função e logo após os parâmetros que serão passados.
Sintaxe :
<tipo> <nome-função>([<parâmetros>]) {
:
: <Instruções>
return <valor>
}
Importante : Toda função deverá possuir a instrução return
após Ter sido encerrado seu processamento.
Exemplo :
int soma(int a, int b){
int v = a + b;
return v;
}
:
:
int c = 45;
int d = 2;
int s = soma(c, d);
ShowMessage(s);
Atenção : O local onde devem ser
declaradas as funções e procedimentos é
análogo ao das variáveis globais ou seja
uma função ou procedimento será sempre
global ao formulário que estará sendo
executado.
#pragma hdrstop
#include "Unit1.h"
//--------------------------------------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
void teste( char letras[] )
{
ShowMessage(letras);
}
int soma( int a, int b ){
int v = a + b;
return v;
}
Unidade para funções
Para que uma função possa ser chamada em
qualquer formulário de um projeto devemos
criar uma unidade (Unit) de funções e
procedimentos.
Criando uma unidade (unit)
Basta selecionar File, New e
Unit.
Será mostrada a seguinte estrutura
//--------------------------------------------------------------------------#pragma hdrstop
#include "Unit2.h"
//--------------------------------------------------------------------------#pragma package(smart_init)
int soma(int a, int b){
int v = a + b;
return v;
}
Para vincular a unidade nova ao
formulário.
Selecione a opção File, Include Unit ou
pressione a tecla Alt+F11. Em seguida
a função deve ser declarada no
formulário a ser usado.
Exemplo da inclusão e definição de
uma função no formulário corrente.
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
//--------------------------------------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
int soma(int n,int y);
//--------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
Ponteiros
Um ponteiro é uma variável que representa
a localização de um item de dados na
memória ou seja ele aponta para um
endereço de memória na qual existe um
dado para ser processado.
Os ponteiros são usados para otimizar e
aumentar performance de memória em uma
aplicação.
A memória de um computador é dividida em
células adjacentes que são numeradas
consecutivamente, do inicio para o fim a
área de memória associada com seu número
e sua respectiva célula denominamos
endereço. Que em sua grande maioria os
computadores usam o sistema de numeração
hexadecimal.
Abaixo encontramos a ilustração de
endereço.
Armazenamento da informação na
memória RAM
Ponteiro
*p
0012F588
num =
80
0012F580
*j
x =
RAM
123.89
Variável
inteira
(int)
Variável
dupla
precisão
(double)
Ponteiro vem a ser a variável que aponta para um desses
endereços.
Usando um ponteiro.
Para declarar um ponteiro devemos usar o símbolo de
asterisco na frente da variável.
Exemplo:
int *j;
Obs: Neste caso a variável j será um ponteiro de inteiro.
Para que j aponte para um endereço devemos
indicar para que endereço de memória
desejamos que j aponte. Para fazer isso
usamos o símbolo de (e comercial) &.
Exemplo :
int *j;
int k = 3;
j = &k;
Veja a ilustração do que irá ocorrer na
memória.
Se o valor do ponteiro j
alterada o valor de k.
for alterado logo será
Ou seja :
int *j;
int k = 3;
j = &k;
*j = 6;
Obs : Logo o novo valor da variável k será 6 pelo simples
motivo de j estar apontando para o endereço da variável k.
Visualizando o endereço de
memória onde o ponteiro esta.
#include <stdio.h> // Deverá ser colocada
void __fastcall TForm1::Button1Click(TObject *Sender)
{
int *p;
char buffer[8];
int num = 123;
p = #
sprintf(buffer,"%p",p);
ShowMessage(buffer); // O resultado Será buffer=0063F2B8
}
Aplicações como ponteiros.
Um exemplo da aplicação com ponteiros é o caso do evento
OnKeyPress que pega o valor da tecla pressionada.
void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key)
{
char *j = &Key;
ShowMessage(*j);
}
Este exemplo captura o valor ASCII da tecla pressionada.
void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key)
{
char *j = &Key;
int k = *j;
ShowMessage(k);
}
Exemplo usando ponteiro para usar a caixa de
texto aceitando somente números.
void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char
&Key)
{
char *j = &Key;
if(*j < '0' || *j > '9') {
ShowMessage("Digito Não Permitido...");
Edit1->SetFocus();
Edit1->Clear();
}
}
Exemplo de Ponteiro na manipulação de caracteres.
void __fastcall TForm1::Button1Click(TObject *Sender)
{
char *a = "As Poderosa dizem oi para Teletubbies";
int x = strlen(a);
int i = 1;
while(i <= x ) {
char y = *a++;
if(y=='o')
ShowMessage(y);
i++;
}
}
Operadores de deslocamento de bits
Para realizarmos o deslocamento em
uma variável que contém 1 byte podemos
realizar operações matemática binária ou
utilizar recursos da linguagem para efetuar
as operações de maneira mais rápida e com
segurança.
Esses operadores sãos denominados
shift.
E são representados da seguinte forma >> <<
Onde :
>> - deslocamento para direita.
<< - deslocamento para esquerda.
Sintaxe :
Variável >> num-bits; // para direita
Variável << num-bits; // para esquerda
Observação
Os operadores de deslocamento de bits
devem ser usados para tipos de dados char,
int(correspondente) e byte; que é o mais
recomendado. São muito eficientes para
decodificar input de dispositivos internos,
como conversor A/D.
Exemplo de operação
128
1
0
0
0
64
0
1
0
0
32
0
0
0
0
16
0
0
1
0
8
0
0
0
1
4
0
0
0
0
byte nbit = 128;
nbit = nbit >> 1; // Desloca um bit para direita
nbit = nbit >> 2; // Desloca dois bit para direita
nbit = nbit >> 1; // Desloca dois bit para direita
2
0
0
0
0
1
0
0
0
0
Exemplo de deslocamento de bits à esquerda
bit a bit
128
0
0
0
0
0
0
0
1
64
0
0
0
0
0
0
1
0
32
0
0
0
0
0
1
0
0
16
0
0
0
0
1
0
0
0
8
0
0
0
1
0
0
0
0
4
0
0
1
0
0
0
0
0
2
0
1
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
Programa Exemplo
byte a = 1;
int x = 1;
while( x <= 8){
ShowMessage(a);
a = a << 1 ;
x++;
}
Passando Parâmetros por Valor
e por Referencia.
Para passarmos parâmetros para uma
função podemos usar duas formas muito
comuns uma é a passagem de parâmetros
por valor que já foi vista no inicio da
abordagem de funções e procedimentos, a
outra é a passagem por intermédio de
referencia no que é passado endereço e não
o valor de conteúdo da variável.
Exemplo de passagem por valor.
int soma( int a, int b ){
int v = a + b;
return v;
}
:
:
int c = 45;
int d = 2;
int s = soma(c, d);
ShowMessage(s);
Exemplo de passagem por referencia.
void soma(int &a, int &b){
int *pont = &b;
b = a + b;
}
:
int h = 3;
int y = 2;
soma(h,y);
ShowMessage(y);
Obs : Ao final da execução desse programa o valor da
variável y será igual a cinco que corresponde a soma
de h e y.b
Objetos Especiais.
Em Builder C++ temos a palheta win32 na
qual podemos observar alguns componentes
para fazermos representações estatísticas de
dados.
ProgressBar : Permite criar uma barra de
progressão onde o usuário da aplicação pode
verificar a porcentagem da operação que estará
sendo realizada. Palheta win32.
Propriedade importantes :
Position - que captura o ascendente onde a barra de
rolagem esta posicionada.
Max - permite atribuir o valor máximo onde a barra
deverá alcançar
Min - permite atribuir o valor mínimo onde será iniciada
a contagem.
Exemplo :
for(int i=0;i<=100;i++){
for(int j=0;j<=200000000;j++);
ProgressBar1->Position++;
}
O exemplo acima preenche a barra de rolagem em 100%
contando para cada valor Position aproximadamente 20
segundo. Onde Max = 100 e Min = 0.
TrackBar - Permite criar uma barra de rastro
Barra de Rastro possibilitando o usuário da
aplicação escolher a escala em que deseja
trabalhar. Palheta win32.
Propriedade importantes :
Position - que captura o ascendente onde a barra
de rolagem esta posicionada.
Max - permite atribuir o valor máximo onde a
barra deverá alcançar
Min - permite atribuir o valor mínimo onde será
iniciada a contagem.
Exemplo :
void __fastcall TForm1::TrackBar1Change(TObject
*Sender)
{
Label1->Font->Size = TrackBar1->Position;
}
Timer - Permite executar uma operação
recursivamente em um determinado intervalo
de tempo de 1000 milisegundo que equivale a
um segundo. Palheta system.
Propriedade importantes :
Enabled - Habilita ou desabilita o timer o
padrão é true habilitado.
Interval - Determina o intervalo de espera
para execução do evento.
Exemplo :
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
AnsiString linha[] = {"Abacaxi","Laranja","Banana"};
Label1->Caption = linha[i];
i++;
if(i= =3)
i = 0;
}
Exemplo : Para carregar uma figura na tela.
void __fastcall TForm1::Button6Click(TObject *Sender)
{
Image1->Picture->LoadFromFile("c:/windows/lixo.bmp");
}
VtChart - O objeto VtChart permite a criação de gráficos para realização de
estatística de valores e visualização de dados, esse objeto se encontra na palheta
ActiveX.
Sintaxe :
VtChart1.<propriedade>=valor | [<método>];
Propriedade Principais para a configuração
de
visualização do gráfico.
ChartType : determina qual o tipo de gráfico
será desenhado.
VtChart1->ChartType = <valor>;
O valor deverá ser instânciado de acordo
com a tabela abaixo:
Valor
0
1
2
3
4
5
10
11
13
14
21
22
Tipo
Barras em três dimensões
Barras em duas dimensões
Linhas em três dimensões
Linhas em duas dimensões
Área em três dimensões
Área em duas dimensões
Barras horizontais em três dimensões
Barras horizontais em duas dimensões
Tortas em três dimensões
Tortas em duas dimensões
Gráfico de Gantt em duas dimensões
Gráfico de Gantt em três dimensões
ShowLegend : Permite mostrar ou não a
legenda de um gráfico. Booleano (true/false)
Exemplo :
VtChart1->ShowLegend = true;
TitleText : Exibe um título para o gráfico.
Exemplo :
VtChart1->TitleText = "Rendimeto Bimestral
2 Anos de Informática";
TitleText
ColumnCount : Determina o número de
colunas ou setores que o gráfico terá.
Exemplo:
VtChart1->ColumnCount = 2;
ColumnCount
RowCount : Determina o número de linhas
de dados que o gráfico irá ter.(Número de
divisões do eixo x).
Exemplo :
VtChart1->RowCount = 3;
RowCount
Column : Seta em que coluna do gráfico será
alterado por uma informação ou dado.
VtChart1->Column = 1;
Column =1
Column =2
ColumnLabel : Determina um título para a
coluna setada por Column(Título da
Legenda).
Exemplo :
VtChart1->ColumnLabel = "1-Trim-2004";
ColumnLabel
Column =1
Column =2
FootnoteText : Coloca uma mensagem no
rodapé do gráfico.
VtChart1->FootnoteText = "Acompanhamento Trimestral de vedas";
FootnoteText
Row : Determina o número da linha que
receberá os dados .
VtChart1->Row = 1;
Row =1
Row =2
Row =3
RowLabel : Determina o título para o eixo x.
Exemplo :
VtChart1->RowLabel = "JAN";
RowLabel = “2J2D – 4.5/5.0”
Data : Propriedade mais importante do objeto gráfico, permite atribuição
do valor que irá desenhar o gráfico.
Atenção : Mesmo sendo um valor numérico para o desenho do gráfico
essa informação deverá ser sempre uma string, como o exemplo abaixo.
Exemplo :
VtChart1->Data = "5.5";
Data = “5.5”
DrawMode : Desenha o gráfico na tela por
intermédio dos valores (0 ou 1).
0 - Desenha o gráfico com a cor de fundo
padrão.
1 - Desenha o gráfico com cor de fundo
branca.
DrawMode : Desenha o gráfico na tela por intermédio dos valores
(0 ou 1).
0 - Desenha o gráfico com a cor de fundo padrão.
1 - Desenha o gráfico com cor de fundo branca.
Exemplo :
VtChart1->DrawMode = 0;