1) O documento descreve um curso de programação C++ Builder, abordando conceitos de programação orientada a objetos, programação visual e componentes da linguagem. 2) São apresentados os principais componentes do ambiente C++ Builder e suas funcionalidades, como o Object Inspector e a criação de projetos e formulários. 3) São explicadas as classes TEdit, TButton e TLabel, com suas propriedades, métodos e eventos, ilustrando a construção de um projeto simples para soma de dois números.

1. Linguagem Avançada C++ Builder Prof. Wdson de Oliveira Local: Fatec Jahu Fevereiro-2011

2. Objetivo do curso Fornecer o conhecimento básico do ambiente de programação visual C++ Builder e de seus principais componentes para o desenvolvimento de aplicações.

3. Sobre o curso Serão abordados os conceitos básicos de: programação OO programação orientada a eventos; programação visual. Serão utilizados os principais componentes (objetos) da linguagem.

4. Programação Orientada a Objetos

5. Programação Orientada a Objetos Uma classe é uma abstração para agrupar determinados dados e manipulá-los de forma coerente. Em geral uma classe possui os seguintes elementos: Propriedades /Atributos Métodos Eventos

6. Programação Orientada a Objetos Propriedade de uma classe é um valor. Seja ele numérico, data, caracter ou qualquer outro tipo Método é uma operação que é realizada sobre as propriedades de uma classe. Uma classe pode possuir vários estados. Quando um destes estados muda, é acionado um evento associado a esta mudança.

7. O Ambiente C++ Builder

8. Tela Principal do Builder

9. Tela Principal do Builder SpeedBar é uma barra de ferramenta que contém botões para a execução das atividades mais utilizadas para estas opções estão contidas no Menu do Builder. Menu do Builder

10. Tela Principal do Builder Os componentes da página selecionada Guia ou Páginas

11. Tela Principal do Builder Guia de propriedades do Inspetor de Objetos (Object Inspector). Esta Guia especifica as propriedades do objeto selecionado. Guia de eventos do Inspetor de Objetos (Object Inspector) Neste ComboBox(Caixa de Combinação) temos relacionados todos os objetos do formulário, o nome do objeto que aparece selecionado é o objeto no qual o object Inspector esta exibindo suas propriedades.

12. Criando um projeto O Builder trabalha com projeto e com os formulários vinculados ao projeto. “ O projeto é o programa; os formulários vinculados ao projeto são as janelas ou seções“. Ao salvar um projeto, supondo-se que este projeto seja salvo com o nome de “Projeto” , o Builder salvará o projeto na pasta especificada e irá gerar os seguintes arquivos : Projeto . bpr Projeto . res Projeto . cpp

13. Criando um projeto Projeto . bpr  neste arquivo tem informações da versão do builder, formulários que estão ligados ao projeto, etc... Projeto . res  este é um arquivo de recurso do Builder Projeto . cpp  neste arquivo está a função principal(WinMain) do projeto, que por sua vez inicializa a execução do projeto e a criação de todos os formulários em tempo de execução.

14. Criando um projeto Depois de salvar o projeto iremos salvar o formulário com o nome de “Form” como “frm” , gerando os seguintes arquivos : frm . cpp  possui o código que foi inserido pelo usuário nos evento dos objetos. frm . h  neste arquivo está definido a classe do formulário e a declaração de todos os objetos colocados no formulário. frm . dfm  possui a imagem do formulário.

15. O projeto: Backup O Builder cria cópia dos arquivos do formulário que neste caso são : frm . ~cpp, frm . ~h e frm . ~dfm. Ao salvar um projeto o Builder cria mais três arquivos que são : Projeto . ~bpr, Projeto . ~res e Projeto . ~cpp.

16. Menus do Builder

17. Menu File: New Exibe a caixa de dialogo “New ”, que provê acesso para um novo formulários, nova aplicação para ser desenvolvida pelo usuário a partir do zero, etc.

18. Menu File: New - Application Esta opção está disponível na caixa de diálogo da opção New do Menu File, a finalidade desta opção é gerar uma nova aplicação sem nada nela desenvolvida para que usuário possa desenvolver o seu sistema da maneira como quiser.

19. Menu File: New Form Através desta opção pode-se adicionar um novo formulário em um projeto.

20. Menu Project

21. Menu Project: Add to Project Esta opção abre a caixa de diálogo a seguir :

22. Menu Project: Add to Project Use esta caixa de diálogo para adicionar uma unit existente e seu formulário ao projeto atualmente aberto no C++ Builder. Quando você adiciona uma unit no projeto, o C++ Builder automaticamente faz referências da unit adicionando uma declaração de #include para o projeto no arquivo de extensão .BPR.

23. Menu Project: Remove from Project Use esta caixa de diálogo para selecionar um ou mais unit que deseja remover do projeto atual. Quando você seleciona uma unit e clica em OK, C++ Builder remove a unit selecionada (os arquivos .CPP, .H e .DFM) do projeto atual mas não apaga nenhum arquivo de seu disco.

24. Menu Project: Add to Repository Use este comando para somar projetos, códigos, e formulários para o Repository de Object . É útil em situações onde você usa muito um formulário. Adicionando este formulário no Repository Object, depois através da opção New do Menu File você poderá incluir o seu formulário sem ter que fazê-lo de novo.

25. Menu Project: Options

26. Menu Project: Options Use as páginas(guias) desta janela de diálogo para especificar Forms, Application, Compile, Linker, C++, etc Forms Controlam os formulário criados. Através da opção Main Form podemos especificar qual formulário será executado primeiro em um projeto com mais de um formulário. Application Especifica o título(Title), nome de arquivo de ajuda(Help File), e nome de ícone associados com a aplicação(Load Icon).

27. Menu Project: Options Compile especifica as opções gerais para os C++ compilador interruptores que detemina como código deve ser compilado. Advance Compile Especifica opções adicionais para o compilador de C++. C++ Especifica opções do compilador C++.

28. Menu Project: Options Pascal Especifica opções do compilador de Objeto Pascal Linker Gerencia como seus arquivos de programa são Linkados Directories/Conditionals Especifica a localização de arquivos necessários para compilar e Linkar seu programa

29. Menu Project: Options VersionInfo Especifica as informação de identificação do produto Packages Especificam os pacotes com os objetos estão instalados Tasm Configura os parâmetros e âmbito para o montador de turbo Assembly

30. Menu Run

31. Menu Run Run : utilizada para compilar e linkar a sua aplicação e logo após executa o programa. Se o compilador encontra um erro, exibe uma caixa de diálogo de Erro; Não encontrando nenhum erro de sintaxe no código do programa o compilador constrói um arquivo executável Program Reset : É utilizado para terminar a execução do programa atual e retira da memória um programa na qual ocorreu um erro em tempo de execução.

32. Menu Database Explore : Executa o Explore(Explorador de Banco de dados ou Explorador de SQL). Ambas as ferramentas lhe deixarão : criar, visualizar, e editar dados e pseudônimos de BDE. Explorador de SQL permite examinar bancos de dados locais e distantes. Form Wizard : Esta opção permite criar um formulário que exibe dados de um banco de dados sem muito trabalho.

33. Menu tools Database Desktop : Executa o Database Desktop que é uma ferramenta utilizada para criar e reestruturar tabelas de um banco de dados. Você pode trabalhar com elas em Paradox, dBASE, e formatos de SQL. Image Editor : aplicativo utilizado para criar imagem para objetos que você criou, para criar ícones, arquivos bitmap, etc... Configure Tools : Nos permite configurar as opções do Menu Tools.

34. Object Inspector

35. Object Inspector (OI) Permite visualizar rapidamente as propriedades e eventos de um determinado objeto, mostrando ainda de qual classe ele pertence. Para verificar as propriedades de um determinado objeto, basta clicar no objeto em que se esta trabalhando, e o OI alternará para as propriedades e eventos deste objeto.

37. Figura do Object Inspector à esquerda temos as propriedades do objeto Edit1 (classe TEdit), já no lado direito temos o Object Inspector mostrando os métodos deste mesmo objeto.

38. Primeiro Projeto

39. Soma dois números Para a construção deste programa iremos precisar de três componentes (ou classes): TEdit; TButton e; TLabel

40. Classe TEdit Propriedades : Name . é o nome do objeto. Todo objeto precisa ter um nome, para ser referenciado Text . guarda o conteúdo digitado, ou o conteúdo para ser mostrado na tela ReadOnly . aceita os valores true/false, caso o valor seja true, o usuário não poderá digitar nenhum valor neste objeto. Visible . pode receber os valores true/false, caso o valor seja true o objeto será mostrado na tela.

41. Classe TEdit Métodos : SelectAll . seleciona todo o conteúdo do objeto CopyToClipboard . copia o conteúdo selecionado do objeto para a área de Clipboard PasteFromClipboard . cola o conteúdo da área de Clipboard na propriedade Text do objeto Clear . limpa o conteúdo da propriedade Text. SetFocus . fará com que o cursor seja posicionado neste objeto.

42. Classe TEdit Eventos : OnChange . é acionado quando a uma mudança na propriedade Text ocorrer, ou seja, quando houver uma mudança nesta propriedade o evento OnChange é acionado. OnEnter . é acionado quando o Focus da aplicação é passado para esse objeto, ou seja, quando entra no objeto. OnExit . ao contrário do evento OnEnter é acionado na saída do objeto.

43. Exemplos Classe TEdit Edit1 e Edit2 são objetos da classe TEdit Exemplo 1: Igualar a propriedade Text de dois objetos Edit1->Text = Edit2->Text; Exemplo 2: Igualar a propriedade Text de dois objetos, só que utilizando métodos Edit2->SelectAll(); Edit2->CopyToClipboard(); Edit1->Clear(); Edit1->PasteFromClipboard(); Edit1->SetFocus();

44. Exemplos Classe TEdit Exemplo 3: Mostrar uma mensagem na tela se o conteúdo da propriedade Text do objeto Edit1 for alterado. clicar no objeto Edit1, ir no Object Inspector, selecionar Events (eventos), dar dois cliques no evento OnChange , que o C++ Builder criará uma procedure, que deverá ser chamada toda vez que ocorrer uma mudança na propriedade Text. Dentro desta procedure, nós podemos escrever qualquer comando, como por exemplo:

45. Exemplos Classe TEdit ShowMessage(“Houve uma alteração de valor”); /* A função ShowMessage mostra uma mensagem qualquer na tela */ A implementação completa ficaria assim: void __fastcall TForm1::Edit1Change(TObject *Sender) { ShowMessage("Houve uma alteração de valor"); }

46. Classe TButton Propriedades : Caption . A propriedade Caption fará com que seja mostrado o nome indicado no botão. Enabled . Esta propriedade pode receber os valores true/false. Caso o valor seja true, o objeto pode ser acionado normalmente com um click do mouse. Caso a propriedade seja false, o click do mouse não fará efeito algum. O objeto estará desabilitado até que a propriedade seja alterada.

47. Classe TButton Métodos : SetFocus . A funcionalidade é a mesma do método SetFocus de TEdit Eventos : OnClick . O evento OnClick será acionado quando o usuário clicar no botão.

48. Exemplos Classe TButton Exemplo 1: Colocar o texto “Calcular” no botão Button1. Button1->Caption = “Calcular”; Exemplo 2: Mostrar a mensagem “Você clicou no botão” quando Button1 for pressionado. O botão ser pressionado significa que aconteceu o evento OnClick dentro de Button1. Logo dentro deste evento basta colocarmos o comando ShowMessage(“Você clicou no botão”). O comando completo: void __fastcall TForm1::Button1Click(TObject *Sender) { ShowMessage("Você clicou no botão"); }

49. Classe TLabel Propriedades : Caption . A propriedade Caption fará com que seja mostrado o nome indicado no label.

50. Agora já estamos prontos para fazermos a nossa primeira implementação.....

51. Código Fonte: arquivos gerados Project1.bpr  gerado automaticamente. Guarda os parâmetros de compilação para o programa, bem como os endereços de bibliotecas; Project1.cpp  gerado automaticamente e não precisa ser alterado. É a partir dele que as Unit´s serão chamadas Unit1.dfm  gerado a partir das definições de objeto que o usuário vai fazendo na tela, ou seja, basta o usuário ir posicionando os objetos na ordem que desejar, com suas respectivas propriedades e eventos, que o arquivo vai sendo gerado automaticamente; Unit1.cpp  conterá o programa propriamente dito que possibilitará a soma dos dois números. Unit1.h  Este arquivo também é gerado automaticamente , e constitui os cabeçalhos e funções, procedures e declaração de objetos. Para funções definidas pelo programador, ele precisará sofrer pequenas alterações. Não é o caso neste exemplo.

52. Arquivo Unit1.dfm As definições de tela são armazenadas no arquivo com a extensão dfm. O Objeto Form1 é da classe TForm, e é a tela onde serão colocados os outros objetos. Os objetos Label1, Label2 e Label3 são da classe TLabel, e foram utilizados para escrever um conteúdo na tela.

53. Arquivo Unit1.dfm Os objetos Edit1, Edit2 e Edit3 são da classe TEdit e foram utilizados para a entrada e a saída dos resultados. O objeto Button1 da classe TButton, que foi o objeto utilizado para realizar a operação de soma.

54. Nossa tela Label1 Label2 Button1 Label3 Edit1 Edit2 Edit3 Form1

55. Arquivo Unit1.cpp Neste arquivo, devemos incluir o que queremos que o nosso programa faça. Faremos isto no evento OnClick do objeto Button1 , ou seja, quando o usuário clicar no botão executaremos uma determinada ação. Para fazermos isso, basta o usuário dar dois cliques em Button1, que este criará a função Button1Click , associada ao evento OnClick deste botão. Agora basta escrevermos o que desejamos que a função faça:

56. Arquivo Unit1.cpp /* Cria uma variável R (maiúscula) que armazenará valores reais */ float R; /* A função StrToFloat converte uma String em um número real, como a propriedade Text do objeto Edit1 é do tipo String, esta conversão torna-se necessária. O mesmo ocorre com Edit2 */ R = StrToFloat(Edit1->Text) + StrToFloat(Edit2->Text); /* Já a função FloatToStr faz exatamente o contrário, ou seja, converte um número real em uma String, para poder ser exibida no objeto Edit3, na propriedade Text */ Edit3->Text = FloatToStr(R);

57. Listagem completa do programa //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop #include &quot;Unit1.h&quot; //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource &quot;*.dfm&quot; TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { float R; R = StrToFloat(Edit1->Text) + StrToFloat(Edit2->Text); Edit3->Text = FloatToStr(R); } //---------------------------------------------------------------------------

58. Arquivo Unit1.h //--------------------------------------------------------------------------- #ifndef Unit1H #define Unit1H //--------------------------------------------------------------------------- #include <Classes.hpp> #include <Controls.hpp> #include <StdCtrls.hpp> #include <Forms.hpp> //--------------------------------------------------------------------------- class TForm1 : public TForm { __published: // IDE-managed Components TLabel *Label1; TEdit *Edit1; TLabel *Label2; TEdit *Edit2; TButton *Button1; TLabel *Label3; TEdit *Edit3; void __fastcall Button1Click(TObject *Sender); private: // User declarations public: // User declarations __fastcall TForm1(TComponent* Owner); }; //--------------------------------------------------------------------------- extern PACKAGE TForm1 *Form1; //--------------------------------------------------------------------------- #endif