FMX - criando um novo cadastro num arquivo

No último post, nos responsabilizamos de fazer

um programa para criar cadastros num arquivo,

mas o programa tinha que ser capaz de saber

se existem cadastros vazios,

se existem, o programa deverá preencher

estes cadastros, se não houver cadastros vazios,

ou se todos já foram preenchidos o programa

deveria acrescentar um novo cadastro abaixo

do último registrado.

Na verdade tudo o que iriámos

precisar já foram feitos nos programas anteriores,

mas por falta de tempo passamos alguns

dias sem programar.

Para fazer este programa, criamos algumas

funções com retorno para string e inteiro,

e com alocação dinâmica, visto que os cadastros

tende à aumentar de acordo com uso.

O programa está apto à calcular o total

de cadastros, o total de linhas, e o tamanho em bytes

do arquivo e isto tudo em tempo de execução.

O funcionamento básico se resume na remoção

de um cadastro, ou na criação de um novo.

Quando um cadastro é removido,

o programa escreve no cadastro a palavra "Vazio",

e quando o usuário escolhe no menu a opção

criar cadastro, o programa pesquisa automaticamente,

por cadastros vazios utilizando a palavra

que ele mesmo escreveu (Vazio), se for encontrado,

é nesta posição que o novo cadastro será criado.

Na verdade até um ponto já seria suficiente

para isto, ou alguns caracteres em branco.

Para testar o funcionamento, vamos começar

com um arquivo totalmente vazio,

depois daremos uma pausa no vídeo,

e acrescentaremos manualmente vários outros cadastros,

para que o vídeo não fique tão extenso.

Depois iremos apagar e criar alguns.

Assistam o vídeo por favor.

//------------------------------------------------------------------------------

void T_Memo ( int X, int Y, int W, int H ) {

   Form5 -> Memo1 -> Position -> X = X;

   Form5 -> Memo1 -> Position -> Y = Y;

   Form5 -> Memo1 -> Width = W;

   Form5 -> Memo1 -> Height = H;

   Form5 -> Memo1 -> ShowScrollBars = True;

   Form5 -> Memo1 -> Size -> PlatformDefault = False;

   Form5 -> Memo1 -> TextSettings -> Font -> Family = "Consolas";

   Form5 -> Memo1 -> TextSettings -> Font -> Size = 14;

   Form5 -> Memo1 -> TextSettings -> Font -> Style = TFontStyles ( ) << fsBold << fsItalic;

   Form5 -> Memo1 -> TextSettings -> FontColor = claBlack;

}

//------------------------------------------------------------------------------

void T_Memo_1 ( int X, int Y, int W, int H ) {

   Form1 -> Memo1 -> Position -> X = X;

   Form1 -> Memo1 -> Position -> Y = Y;

   Form1 -> Memo1 -> Width = W;

   Form1 -> Memo1 -> Height = H;

   Form1 -> Memo1 -> ShowScrollBars = True;

   Form1 -> Memo1 -> Size -> PlatformDefault = False;

   Form1 -> Memo1 -> TextSettings -> Font -> Family = "Consolas";

   Form1 -> Memo1 -> TextSettings -> Font -> Size = 14;

   Form1 -> Memo1 -> TextSettings -> Font -> Style = TFontStyles ( ) << fsBold << fsItalic;

   Form1 -> Memo1 -> TextSettings -> FontColor = claBlue;

}

//------------------------------------------------------------------------------

void func ( bool val ) {

if ( val == false ) {

T_Text2 ( 150, 253, 170, 18, 1 );

Form5 -> Text2 -> Text = "Remover cadastro de Nº";

}

if ( val == true ) {

T_Text2 ( 150, 250, 270, 18, 3 );

Form5 -> Text2 -> Text = "O Cadastro foi removido com sucesso";

}

}

//------------------------------------------------------------------------------

void func_2 ( bool val ) {

  if ( val == false ) {

T_Rect ( 150, 60, 260, 18, 1, 2 );

T_Text ( 150, 60, 260, 18, 16, false, 1, 0, "Leitura de todos os cadastros" );

  }

  if ( val == true ) {

T_Rect ( 150, 60, 260, 18, 5, 4 );

T_Text ( 150, 60, 260, 18, 16, false, 5, 0, "Leitura de todos os cadastros" );

  }

}

//------------------------------------------------------------------------------

FMX - Abrindo imprimindo e alterando um arquivo

No último post, há alguns dias atrás,

criamos um programa no C++ builder,

que fazia leitura, pesquisa individual,

e remoção de um cadastro criado manualmente

num arquivo.

E como ficou determinado que no post seguinte,

nós faríamos alterações num cadastro dentro

de um arquivo de texto, aqui está cumprido.

Pena que por falta de tempo suficiente

não fizemos isto antes, mas conseguimos

reservar algumas horas para programar.

Sempre que temos que fazer alterações num

arquivo, optamos por trabalhar com a abertura

de dois e de nomes diferentes, isto é óbvio,

sendo um como leitura e outro como escrita.

No arquivo que abrimos como escrita,

fizemos as alterações, mas ele precisa

assumir o nome do arquivo que foi aberto 

como leitura, sendo que o arquivo,

que foi aberto como leitura precisa

ser destruído, e o arquivo que foi aberto

como escrita e que recebeu as alterações,

agora é o arquivo principal.

Para fazer este processo conheço

duas maneiras, uma é a clássica, usando,

as funções da biblioteca padrão do C,

à saber, as funções rename ( ..., ... );

e remove ( ... ); e a outra maneira,

pouco usada, acredito assim, mas que estamos

usando neste programa e no programa do post

anterior, que é na força bruta, com comandos

do dos, e que funciona perfeitamente ainda hoje.

Na opção de alterar cadastro, preferi manter,

o que foi configurado no programa anterior,

isto é, apagar um cadastro deixando o espaço

em branco, para isto basta clicar no botão

"Editar", sem que nada tenha sido escrito,

nos campos do componente de edição.

Mesmo nós tendo criado manualmente 29 cadastros,

O programa está pronto para selecionar um cadastro,

entre centenas ou milhares, porque a pesquisa

é eficiente e não falha, e sabemos muito bem

do que estamos falando.

Então, nos posts anteriores, fizemos leitura,

fizemos precisa pesquisa, fizemos remoção,

e agora alteração de cadastros em arquivo.

Pergunta:

Podemos fazer um programa para criar cadastros,

onde um foi removido com sucesso,

ou se não houver cadastros vazios, inserir

com precisão abaixo do último cadastro?

ora, o programa terá de ser inteligente

o suficiente para detectar cadastros vazios,

e inserir o novo cadastro no primeiro vago

que encontrar, e se não houver cadastros vazios,

ele automaticamente irá inserir depois do último.

Vamos queimar nossos miolos?

Até breve, se Deus quiser. 

Assistam o vídeo por favor.

Se precisarem de ajuda com o C++ builder,

entre em contato comigo.

//-----------------------------------------------------------------------

//FormCreate está funcionando com um evento OnClick do Button1

void __fastcall TForm2::FormCreate ( TObject *Sender ) {

   Label_Manual ( Sender );

   ScrollBox1 -> Visible = false;

   Button1 -> Visible = false;

   //pos X, pos Y, Width, Height, Size, Bool, Color,String

   T_Text ( 50, 35, 500, 20, 17, true, 2, 3, "ARQUIVO - ABRINDO IMPRIMINDO E ALTERANDO" );

   Imprime_Arquivo ( Sender );

   Button1 -> Visible = true;

   x++;

   if (  x == 2 && Form2 -> Edit1 -> Text == "" ) {

Beep ( 500, 500 );

Form2 -> Show ( );

Form3 -> Hide ( );

Form1 -> Hide ( );

                        x = 1;

   }

   if ( x == 2 ) {

   int c = 0;

   c = Contador ( );

   T_Text ( 100, 60, 270, 17, 14, true, 3, 1, "Alterando o cadastro de Nº: " );

   T_Rect ( 340, 60, 20, 17, 3, 4 );

   T_Text ( 340, 60, 20, 17, 14, true, 3, 0, c );

   Form2 -> Terceira_janela ( Sender );

   x = 1;

   }

}

//---------------------------------------------------------------------------

FMX - Pesquisando e removendo cadastros em arquivo

Com este programa criado no C++ builder,

utilizando alguns recursos lógicos do C,

podemos fazer leitura, pesquisa individual,

e remoção de um cadastro criado manualmente

num arquivo. No post anterior nós listamos

e pesquisamos dentro de um arquivo, já neste,

podemos listar, fazer pesquisa individual

e remover cadastro dentro de um arquivo.

Será que podemos no próximo post fazer

alterações num cadastro dentro de um arquivo?

Eu acredito que sim, fomos capacitados para isto.

//---------------------------------------------------------------------------

void __fastcall TForm4::Button2Click ( TObject *Sender ) {

T_Rect ( 90, 112, 150, 80, 4, 1 );

T_Rect ( 60, 260, 460, 20, 4, 1 );

Button1 -> Visible = true;

str_5 = "";

Edit1 -> Text = "";

Label1 -> Text = "";

                                        y = true;

nl = 0;

                                        b1 = 0;

Button2 -> Visible = false;

Memo1 -> Visible = false;

Primeira_janela ( Sender );

}

//---------------------------------------------------------------------------

FMX - abrindo - lendo e pesquisando em arquivo

No post anterior, criamos um programa

para criar, listar, remover e apagar

cadastros, e tudo funcionou perfeitamente,

mas aquele programa não salvava os cadastros

num arquivo, tudo se perde quando o programa

é fechado, pensando em criar uma nova versão

daquele programa, com recursos para salvar,

ler, remover e alterar os cadastros em um

arquivo, comecei fazendo a parte de leitura

e pesquisa mas num arquivo previamente criado.

O programa apresentado aqui, faz uma precisa

pesquisa em um arquivo, em chamadas totalmente

aleatória, e nem foi preciso usar a função

fseek do C, mas o raciocínio lógico foi 

indispensável.

O programa oferece quatro opções num menu

clássico e funciona tudo corretamente.

Assista no vídeo o programa funcionando:

//---------------------------------------------------------------------------

void __fastcall TForm1::Pesquisando_Cadastros ( TObject *Sender ) {

   //Limpa -> "Todos os cadastros"

   T_Rect_1 ( 240, 70, 160, 18 );

   //Limpa Nome

   T_Rect_1 ( 120, 112, 60, 20 );

   //Limpa Altura

   T_Rect_1 ( 120, 128, 88, 20 );

   //Limpa peso

   T_Rect_1 ( 120, 143, 78, 20 );

   //Limpa Idade

   T_Rect_1 ( 120, 160, 95, 20 );

   T_Rect_1 ( 107, 290, 390, 20 );

   //Limpa da tela o Informe

   T_Rect_1 ( 100, 250, 180, 35 );

ScrollBox1 -> Visible = false;

const int TAM = 60;

char **buffer;

buffer = ( char** ) malloc ( 2000 * sizeof ( char* ) );

char *pt;

pt = ( char * )  malloc ( 100 );

T_Rect_4 ( 120, 80, 250, 20 );

T_Text_3 ( 120, 78, 250, 20, 16, false, true, 0, "Digite o número do cadastro" );

T_Rect_1 ( 107, 290, 390, 20 );

Edit1 -> Visible = true;

Edit1 -> SetFocus ( );

Edit1 -> Text = "";

Button1 -> Visible = true;

Button2 -> Visible = false;

String st = "0";

st += Edit1 -> Text;

wcstombs (  pt, st.c_str ( ), 100 );

free ( pt );

free ( buffer );

}

//---------------------------------------------------------------------------

Fmx - programa cadastros de amigos

Sempre que ficamos muitos dias sem programar,

Quando voltamos, fica aquele embaraço e perguntas:

Por onde começar? O que fazer? tentar corrigir alguns bugs

De programas passados? nisto lá vai um bom tempo perdido...

Nesta procura, procurei inspiração nos blogs que temos,

E no canal do youtube, e foi lá vendo um vídeo de um programa,

Que criamos alguns anos atrás que tive a idéia de convertê-lo

Para uma janela gráfica do C++ builder.

Criando Projeto:

Quando criamos um projeto no C++ builder, ele gera automaticamente,

Estes quatros arquivos antes memo de salvar e compilar:

Project1.cpp

Este arquivo funciona como a função main() do C/C++,

Ele inicializa os Forms e o que for necessário para o início

através de um método interno.

(Não entendo quase nada disto, mas também não acho isto

importante, pelo menos por agora )

Unit1.CPP: Neste arquivo escrevemos nossas rotinas,

em geral, tudo o que sabemos da linguagem e precisamos aplicar 

para que nosso programa funcione corretamente.

Unit1.H: Neste arquivo escrevemos os protótipos

das funções, declarações de variáveis, de qualquer

tipo aceito pelo C ou C++.

Unit1.FMX:

Neste arquivo são escritos, todas as informações

dos componentes arrastados para o form,

e o interessante dele, é que ele escreve tudo

automaticamente, porém em Delph, mas não me importo.

O que mais me agrada no C++ builder é que podemos

programar sem a IDE (Precisa ter um bom conhecimento)

E possuir uma linha de comando bem configurada,

Apontando para os includes, libs, e ferramenta de builds.

qualquer dia vou tentar isto.

Poderia ter criado o programa num único Form,

Mas por questão de organização e de limpeza de 

Variáveis, limpeza de tela preferi, criar cada função

 em um form Independente, mas até este momento

eu não sabia que iria precisar de alguns valores de variáveis

em outros forms, aqui começaram os problemas.

Depois de muitas cabeçadas me lembrei do comando “extern”,

Que estudamos no começo de nossa formação, mas que na prática,

Nunca o tinha usado antes. Foi a nossa saída, e o programa começou a funcionar.

Quando comecei escrevendo logo declarei uma struct do C,

Esta mania de criar projetos em C++, e mesclar com códigos do C ,

É grave, “Acho que agente sai do C, mas o C nunca sai da gente”

Bom, isto não me incomoda muito, afinal, o C++ builder está preparado

Para aceitar qualquer função do C.

Mas fazendo meus testes declarei uma classe simples do C++,

E tudo funcionou normalmente, porque na verdade,

Uma struct do C e uma classe simples do C++, não possui

Grandes diferenças, eu penso sinceramente que só descobrimos

O poder das classes do C++ quando começamos entender

Método construtor

Método destrutor

Métodos e variáveis privados

Métodos e variáveis públicos

Métodos e variáveis protegidos

Poliformismo

Classes derivadas, etc...

Se um programa é simples e não precisa disto então,

Porque usar uma classe: (Opinião)

O programa terminou e ficou tudo funcionando perfeitamente,

Mas ainda tem uma questão, e se eu quisesse manter os cadastros

Criados para comparação quando saísse e retornasse para o programa?

Certamente precisaríamos salvar tudo em um arquivo,

Nisto o programa sofreria mudanças em todos os forms,

pensando bem isto ficará para uma próxima versão.

Se alguém tiver interesse no projeto, basta entrar em contato.

//---------------------------------------------------------------------------

void __fastcall TForm2::Button1Click ( TObject *Sender ) {

Button1 -> Visible = true;

Button2 -> Visible = true;

Edit1 -> Visible = true;

Edit2 -> Visible = true;

Edit2 -> SetFocus ( );

Edit3 -> Visible = true;

if ( Edit2 -> Text != "" && Edit3 -> Text != "" ) {

  a++;

          codigo = a;

          Edit1 -> Text = StrToInt ( a );

  amigo [ codigo ].cod = codigo;

char *pt;

pt = ( char * )  malloc ( 100 );

String st;

st += Edit2 -> Text;

wcstombs (  pt, st.c_str ( ), 100 );

*amigo [ codigo ].nome = pt;

char *pt_2;

pt_2 = ( char * )  malloc ( 100 );

String st_2;

st_2 += Edit3 -> Text;

wcstombs (  pt_2, st_2.c_str ( ), 100 );

*amigo [ codigo ].telefone = pt_2;

}

if ( Edit2 -> Text == "" || Edit3 -> Text == "" ) {

   T_Rect_3 ( 60, 260, 390, 20 );

   T_Text_2 ( 60, 260, 400, 20, 16, true, 0, "Um ou mais campo do cadastro está vazio" );

}

}

//---------------------------------------------------------------------------

 

FMX - convertendo numeral em cardinal II

OBS: Esta versão veio para melhorar 

alguns detalhes na interface gráfica.

Para definir um valor a objetos ou seres de qualquer espécie,

ou ainda qualquer coisa física que se encontra em nosso contexto,

utilizamos a palavra Numeral.

Podemos dizer que os numerais são os mesmos cardinais

porém quando se escreve são escritos

através de algarismos arábicos ou o menos usados romanos.

Os números cardinais expressam quantidade ou contagem exatas

de objetos, seres de qualquer espécie ou coisas físicas

existente em nosso contexto diário,

mas quando precisamos escrevê-los,

são escritos pelo seu nome propriamente dito,

ou como muitos dizem por ( extenso ).

A primeira versão deste programa, foi criada 

por mim mesmo em linguagem C, com os resultados

imprimidos na tela do CMD do windows.

Depois criamos uma versão em Java (texto),

e outra em JavaFx.

Agora criamos uma versão para rodar numa interface

gráfica do C++ builder, e se manteve bem fiel

a primeira versão criada em C, as poucas alterações

foram aplicadas somente nos comandos utilizados

pelos componentes da janela gráfica.

O interessante deste programa é que ele não utiliza

nenhum recurso avançado nem do C e nem do C++,

mesmo assim, eu me lembro que na criação da primeira versão,

me deu bastante trabalho na organização dos códigos. 

Limitamos o programa a imprimir resultados de até,

9999 (Nove Mil Novecentos e Noventa e Nove),

mas nada impede isto ser expandido para valores

muito acima disto, sem nenhuma dificuldade.

Assista agora o programa funcionando no vídeo:

 //---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click ( TObject *Sender ) {;

   Close ( );

}

//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate ( TObject *Sender ) {

   Label_Manual ( Sender );

   Text2 -> Visible = false;

//pos X, pos Y, Width, Height, Size, Bool, Color,String

T_Text ( 50, 35, 500, 20, 17, true, 3, "FMX - CONVERTENDO NUMERAL EM CARDINAL II" );

T_Rect_2 ( 60, 280, 165, 20 );

T_Text ( 40, 280, 200, 20, 13, true, 0, "Número entre 0 e 10000" );

}

//---------------------------------------------------------------------------

FMX - convertendo numeral em cardinal

Para definir um valor a objetos ou seres de qualquer espécie,

ou ainda qualquer coisa física que se encontra em nosso contexto,

utilizamos a palavra Numeral.

Podemos dizer que os numerais são os mesmos cardinais

porém quando se escreve são escritos

através de algarismos arábicos ou o menos usados romanos.

Os números cardinais expressam quantidade ou contagem exatas

de objetos, seres de qualquer espécie ou coisas físicas

existente em nosso contexto diário,

mas quando precisamos escrevê-los,

são escritos pelo seu nome propriamente dito,

ou como muitos dizem por ( extenso ).

A primeira versão deste programa, foi criada 

por mim mesmo em linguagem C, com os resultados

imprimidos na tela do CMD do windows.

Depois criamos uma versão em Java (texto),

e outra em JavaFx.

Agora criamos uma versão para rodar numa interface

gráfica do C++ builder, e se manteve bem fiel

a primeira versão criada em C, as poucas alterações

foram aplicadas somente nos comandos utilizados

pelos componentes da janela gráfica.

O interessante deste programa é que ele não utiliza

nenhum recurso avançado nem do C e nem do C++,

mesmo assim, eu me lembro que na criação da primeira versão,

me deu bastante trabalho na organização dos códigos. 

Limitamos o programa a imprimir resultados de até,

9999 (Nove Mil Novecentos e Noventa e Nove),

mas nada impede isto ser expandido para valores

muito acima disto, sem nenhuma dificuldade.

Assista agora o programa funcionando no vídeo:

//----------------------------------------------------------------------------

  if ( mi == 9000 ) {

   if ( de == 0 && un == 0 ) {

str_1 = "Nove Mil";

Button3 -> Text = Form1 -> Button3 -> Text + str_1;

   } else {

str_1 = "Nove Mil e ";

Button3 -> Text = Form1 -> Button3 -> Text + str_1;

   }

              }

  if ( mi == 8000 ) {

   if ( de == 0 && un == 0 ) {

str_1 = "Oito Mil";

Button3 -> Text = Form1 -> Button3 -> Text + str_1;

   } else {

str_1 = "Oito Mil e ";

Button3 -> Text = Form1 -> Button3 -> Text + str_1;

   }

              }

//---------------------------------------------------------------------------

FMX - conversor de unidades métricas

Quando declaramos uma classe em C++,

por definição ela é privada,

isto significa que não podemos acessar,

nem suas variáveis membros,

nem suas funções membros através de outras

funções que não seja também membro da classe.

Uma classe pode possuir tantos membros privados

como públicos, isto é um modo de conseguirmos

encapsular os seus membros e funções,

para que determinados itens não sejam acessados

por outras funções que não convém.

Para tornar partes de uma classe públicas,

isto é, acessíveis a outras partes do seu programa,

você deve declará-las após a palavra reservada public.

Todas as variáveis ou funções definidas depois de public

estão disponíveis a todas as outras funções no programa.

Para mostrar na prática o uso de classes em C++,

declarei uma classe e dei-lhe o nome de: Conversor_Metrico,

esta classe possui várias funções membros públicas

e com retorno para serem utilizados nas chamadas

dos eventos dos botões correspondente.

Nossos conhecimentos e habilidades em C++, 

e no C++ Builder, nos permite criar dezenas de conversões,

em variadas áreas, isto seria dividido em várias janelas

com menus bem organizados, dando um estilo bem profissional,

mas como isto aqui é didático, não precisamos perder

muito tempo com isto, porque o caminho à percorrer é longo,

e o tempo é muito curto, quase não temos tempo para programar.

Se alguém tiver interesse no projeto basta nos solicitar,

porque disponibilizamos apenas algumas partes dos códigos,

para poder obter algum feedback positivo de preferência,

mas críticas, quando feitas com sinceridade e conhecimento

também são aceitas.

//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click ( TObject *Sender ) {;

Conversor_Metrico conv;

//METRO

if ( a == 1 ) {

   T_Rect_2 ( 160, 220, 320, 20 );

   T_Rect ( 160, 220, 200, 20 );

   //pos X, pos Y, Width, Height, Size, Bool, Color,String

   T_Text ( 170, 220, 200, 20, 16, false, 0, "De metro para metro" );

double conversor = conv.converter_0 ( x, conv.CENTIMETRO );

Edit2 -> Text = FloatToStrF ( conversor, ffFixed, 8, 1 );

}

//CENTÍMETRO

if ( a == 2 ) {

   T_Rect_2 ( 160, 220, 320, 20 );

   T_Rect ( 160, 220, 250, 20 );

   //pos X, pos Y, Width, Height, Size, Bool, Color,String

   T_Text ( 170, 220, 250, 20, 16, false, 0, "De centímetro para metro" );

double conversor = conv.converter_3 ( x, conv.METRO );

Edit2 -> Text = FloatToStrF ( conversor, ffFixed, 8, 2 );

}

//POLEGADAS

if ( a == 3 ) {

T_Rect_2 ( 160, 220, 320, 20 );

T_Rect ( 160, 220, 250, 20 );

//pos X, pos Y, Width, Height, Size, Bool, Color,String

T_Text ( 170, 220, 250, 20, 16, false, 0, "De polegadas para metro" );

double conversor = conv.converter_6 ( x, conv.POLEGADAS_2 );

Edit2 -> Text = FloatToStrF ( conversor, ffFixed, 8, 4 );

}

}

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate ( TObject *Sender ) {

   Label_Manual ( Sender );

//pos X, pos Y, Width, Height, Size, Bool, Color,String

T_Text ( 60, 15, 500, 20, 17, true, 3, "FMX - CONVERSOR DE UNIDADES MÉTRICAS" );

T_Text ( 50, 240, 300, 40, 14, true, 3,  "Por: " );

T_Text ( 120, 240, 300, 40, 14, true, 2,  "Samuel Lima" );

T_Text ( 100, 255, 300, 40, 14, true, 0,  "sa_sp10@otmail.com" );

}

//---------------------------------------------------------------------------

FMX - gerando e comparando dois arrays de caracteres

Este programa utiliza três dos seis operadores

relacionais da linguagem C, e a finalidade,

é comparar dois vetores de caracteres do C.

Isto não traz nenhuma novidade para nós,

mas a forma estratégica na qual organizamos 

os códigos para fazer as comparações,

foi perfeita e pode ser utilizada até em outras

comparações, como por exemplo, saber se dois vetores

são iguais ou distinto ou se seus elementos são comuns.

Assista o vídeo e comprove o programa funcionando:

//---------------------------------------------------------------------------

void Cria_Array_Embaralhado ( char *A, char *B ) {

             TObject *Sender;

int i;

Mix_Int ( A );

Mix_Int ( B );

if ( a == 1 ) {

T_Rect ( 160, 75, 150, 20 );

Rectangle3 -> Fill -> Color = claYellow;

Rectangle3 -> Stroke -> Color = claYellow;

Rectangle3 -> XRadius = 10;

Rectangle3 -> YRadius = 10;

//pos X, pos Y, Width, Height, Size, Bool, Color,String

T_Text ( 55, 50, 400, 20, 16, false, 0, "Imprimindo abaixo o array A" );

for ( i = 0; i < 5; i++ ) {

T_Text ( 24 + i * 30, 75, 300, 20, 16, true, 0,  A [ i ] );

C [ i ] = A [ i ];

}

Button1 -> Text = "Gerar o array B";

}

if ( a == 2 ) {

T_Rect ( 160, 125, 150, 20 );

Rectangle3 -> Fill -> Color = claTurquoise;

Rectangle3 -> Stroke -> Color = claTurquoise;

Rectangle3 -> XRadius = 10;

Rectangle3 -> YRadius = 10;

//pos X, pos Y, Width, Height, Size, Bool, Color,String

T_Text ( 55, 100, 400, 20, 16, false, 0, "Imprimindo abaixo o array B" );

for ( i = 0; i < 5; i++ ) {

T_Text ( 24 + i * 30, 125, 300, 20, 16, true, 0, B [ i ] );

D [ i ] = B [ i ];

}

Button1 -> Width = 150;

Button1 -> Text = "Comparar os dois arrays";

}

if ( a == 3 ) {

Compara_Array ( );

Button1 -> Width = 100;

Button1 -> Text = " Sobre ";

}

if ( a == 4 ) {

  Informe ( );

  Button1 -> Width = 100;

  Button1 -> Text = "Nova operação";

  }

  if ( a == 5 ) {

Form1 -> FormCreate ( Sender );

T_Rect ( 30, 35, 550, 240 );

Rectangle3 -> Fill -> Color = claWhite;

Rectangle3 -> Stroke -> Color = claWhite;

a = 0;

for ( i = 0; i < 27; i++ ) {

A [ i ] = ' ';

B [ i ] = ' ';

C [ i ] = ' ';

D [ i ] = ' ';

}

T_Rect ( 320, 280, 260, 50 );

Rectangle3 -> Fill -> Color = claWhite;

Rectangle3 -> Stroke -> Color = claWhite;

  }

}

//------------------------------------------------------------------------