Objectivos q Componentes principais do Developer Studio q

Objectivos q Componentes principais do Developer Studio q Projectos e como criá-los q Desenvolver programas q Compilar, linkar, depurar e executar programas

Developer Studio - é um ambiente de desenvolvimento integrado para criar, compilar, linkar, depurar e testar programas q Editor – ambiente interactivo para criar e editar o código fonte (*. cpp, *. h) q Compilador – converte o código fonte na linguagem de máquina (*. obj) q Linker – combina os módulos gerados pelo compilador com os módulos das bibliotecas de programas q Bibliotecas – extendem a linguagem C++ com as rotinas que não fazem parte da C++.

Janela do editor Janela de projecto Janela de saída

Uma barra de ferramentas ancorável pode ser arrastada com o rato de forma a reposicioná-la na janela, por exemplo:

Quando está posicionada numa das quatro extremidades da janela, diz-se que está ancorada, tal como as barras de ferramentas que se vêm no topo das janelas de aplicações Se arrastarem uma barra de ferramentas ancorável da sua posição (ancorada), parecerá uma pequena janela. Neste estado é chamada barra de ferramentas flutuante Pressionar com o botão direito do rato sobre a barra de ferramentas fará aparecer uma lista de barras disponíveis

Por exemplo, podemos mover a barra de ferramentas da posição ancorada para uma posição normal e vice-versa Todas estas barras de ferramentas são ancoráveis

Existe outra maneira. Podem pressionar com o botão direiro do rato aqui e podem seleccionar uma opção do menu pop-up respectivo Uma barra de ferramentas é completa quando possui tooltips. Se o ponteiro do rato permanecer sobre um botão durante um ou dois segundos, aparecerá uma etiqueta amarela contendo informação acerca da funcionalidade desse botão assim como uma combinação de teclas de atalho

Usaremos um novo projecto para cada programa que desenvolvermos Um ambiente de trabalho pode conter vários projectos. Um projecto define todas as partes que irão constituir o programa. Está contido num único directório que contém todos os ficheiros de definição do projecto e o vosso código fonte Este directório de projecto contém também outros directórios que guardam, por exemplo, os resultados da compilação e de linking do vosso projecto

A definição de um projecto inclui: – O nome do projecto; – Uma lista com todos os ficheiros com código fonte; – A definição do tipo de programa que será construído a partir dos ficheiros com código fonte, como por exemplo, um programa executável (. exe) para Windows ou uma aplicação de consola; – Um conjunto de opções do editor, compilador, linker e outros componentes do Visual C++; – As janelas que são visualizadas quando o projecto é aberto.

Quando criam um novo projecto o ambiente gera automaticamente configurações para produzir duas versões da vossa aplicação. Uma inclui informação que vos irá ajudar a depurar o programa, chamada Debug Version. A outra, chamada Release Version, não inclui informação de depuração mas tem opções activas relativas ao compilador para optimização do código, de forma a obtermos um módulo executável, o mais eficiente possível. Podem escolher a versão do programa que pretendem seleccionando a configuração respectiva

Primeiro seleccionam New… a partir do menu File Como resultado poderão ver o seguinte menu Esta caixa de diálogo permite introduzir o tipo, nome e localização do vosso projecto Se simplesmente introduzirem nome do projecto, será criado automaticamente um directório com esse nome, a não ser que este já exista Quando carregarem no botão Ok o novo projecto será criado

Vocês podem criar um dos quatro tipos possíveis de aplicações que estão representadas na figura Podem comutar entre estas janelas seleccionando o separador da janela que pretendem. Podem ver que foram adicionados dois separadores à janela de projecto que mostram a Class. View e a File. View Iremos escolher a opção “A simple aplication” Carreguem no botão “Finish” para completar a criação do projecto

A Class. View mostra as classes definidas no vosso projecto e o conteúdo de cada classe Não temos nenhuma classe nesta aplicação e por isso a janela está vazia A File. View mostra os ficheiros que constituem o projecto Podem visualizar o conteúdo de qualquer ficheiro do projecto pressionando duas vezes com o botão esquerdo do rato sobre o nome do ficheiro na File. View Isto abrirá uma janela para o ficheiro e invocará automaticamente um editor que vos permitirá modificar o conteúdo do ficheiro

*. cpp *. h Código fonte *. dsp Definição do projecto (nome, lista de ficheiros, opções do compilador, etc. ) *. opt Opções do espaço de trabalho (janelas abertas, etc. ) *. dsw Indica os projectos incluidos no espaço de trabalho *. ncb Informação de pesquisa (browse) para Developer Studio *. html Log file (informação visualizada na janela de saída) Nunca deve editar estes ficheiros à mão

/Debug *. obj Ficheiros produzidos pelo compilador *. exe Ficheiro executável produzido pelo linker *. ilk Incremental linking (usa-se quando os ficheiros fonte sofreram alterações não significativas) *. pch Pre-compiled header *. pdb Informação de depuração *. idb Informação de depuração adicional *. bsc Informação de pesquisa (browse) para o utilizador Nunca deve editar estes ficheiros à mão

Stdafx. h Stdafx. cpp Estes ficheiros são utilizados para construir o pre-compiled header No ficheiro Stdafx. h deve incluir ficheiros de cabeçalho que são utilizados frequentemente mas que são modificados com pouca frequência

#include "stdafx. h" int main(int argc, char* argv[]) { Este é o esqueleto do 0; principal nossoreturn programa } #include "stdafx. h" Existem aqui três grupos de ficheiros: Source (código fonte), Este ficheiro inclui apenas alguns dados standard. Header (definição dos interfaces dasminúsculas classes) e Resource Prestem atenção às e maiúsculas (recursos – menus, barras de ferramentas, ícones, etc. ) nos ficheiros header // ………………. // TODO: reference additional headers your program requires here #include <iostream. h> Por exemplo: // ……………. . . Neste ficheiro encontrarão a seguinte linha. Deve adicionar aqui os headers que o vosso programa requer

int main(int argc, char* argv[]) { Aqui cout é o nome de um objecto que é usado quando queremos cout << "nosso primeiro programa" << endl; mostrar dados no ecrã. Para utilizar este objecto devemos incluir o return 0; respectivo comqualquer o nome iostream. h. Isto pode ser feito num Como não header possuímos classe, o separador } específico do ficheiro Std. Afx. h File. View tem osítio seguinte aspecto #include <iostream. h> Escrevam o seguinte programa. Adicionem esta linha ao programa. Ctrl-F 5 Para compilar, efectuar o linking e executar o vosso programa pressionem Ctrl-F 5

Vamos incluir um ficheiro novo ao nosso projecto. Para este fim precisamos executar os seguintes passos:

Não se esqueçam de inserir esta linha. Se acrescentam qualquer ficheiro CPP novo, devem inserir esta linha #include "stdafx. h" void multiply_display (int a, int b) { cout << “Vamos multiplicar dois inteirosn”; int c; c = a * b; cout << "a * b = " << c << endl; }

Por favor escrevam e corram este programa simples. Devem repetir os passos que vos foram mostrados Vamos ver agora como podem depurar o vosso programa

Pressionem de novo a mesma tecla F 10 Se pressionarem a tecla F 10 o depurador passará para a próxima linha do programa F 11 Por favor façam isso para que compreendam a diferença entre o F 10 e o F 11 Se pressionarem periodicamente a tecla F 10 o controlo não será passado para as funções, tal como multiply_display(); . Se pretendem entrar no corpo da função devem pressionar F 11 quando estiver activa a linha com a invocação da função

Comecem a depuração. Para isso pressionem F 10 e depois seleccionem as seguintes opções F 10…F 10 e depois F 11 para entrar à função multiply_display()

Se quiserem terminar a depuração seleccionem esta opção Usem esta opção para correr o vosso programa até ao cursor Podem ver também os resultados intermédios do vosso programa numa janela de contexto na parte inferior do ecrã Se colocarem o cursor sobre qualquer variável poderão ver o seu valor actual, como por exemplo, b=7

Pressionem F 9 se quiserem inserir um ponto de paragem (breakpoint). Para executar o programa até ao ponto de paragem pressionem F 5. Para remover o ponto de paragem coloquem o cursor na linha respectiva e pressionem de novo F 9 Por favor executem todas estas operações

Agora vamos criar uma classe isto significa right mouse click constructor destructor

Este código vai ser criado automaticamente class livro { public: livro(); virtual ~livro(); }; Se quiseremos introduzir uma variável, podemos fazer o seguinte: O destructor é uma função virtual. Ela não é significativa neste contexto e por isso vai ser considerada posteriormente

Agora temos: Podemos usar os class livro mesmos passos para { introduzir uma nova public: variável, por exemplo livro(); virtual ~livro(); o ano quando o livro foi publicado private: char* titulo; De notar, que }; os valores dos campos class livro ano e título não { Por outras palavras, estão definidos public: os campos livro(); devem, em geral, virtual ~livro(); ser inicializados private: unsigned ano; char* titulo; };

Este trabalho é efectuado por uma função especial que é chamada construtor da classe O construtor da classe possui o mesmo nome que a classe e não devolve nenhum valor, nem do tipo void. Todas as outras características de um construtor de uma classe são semelhantes às de um método normal Vamos acrescentar o seguinte código ao constructor: class livro { public: livro(char*, unsigned); virtual ~livro(); private: unsigned ano; char* titulo; }; livro: : livro(char* T, unsigned A) { titulo = T; ano = A; }

Agora vamos incluir algumas funções na classe livro (ao tipo novo livro), por exemplo: Para incluir as 1. char* Qual_é_o_titulo(void); funções podemos usar 2. unsigned Quando_foi_publicado(void); os mesmos passos, 3. void Imprimir_os_dados(void); por exemplo

Finalmente a nossa classe vai ser apresentada da seguinte forma: char* livro: : Qual_e_o_titulo() { return titulo; } unsigned livro: : Quando_foi_publicado() { return ano; } void livro: : Imprimir_os_dados() { cout << "Titulo: " << titulo << "; Ano: " << ano << endl; }

Consideremos a seguinte função main: int main(int argc, char* argv[]) { livro PPO("C++", 2000); PPO. Imprimir_os_dados(); cout << "livro: " << PPO. Qual_e_o_titulo() << 't' << PPO. Quando_foi_publicado() << endl; cout << "nosso primeiro programa" << endl; return 0; } Neste caso os resultados do nosso programa vão ser os seguintes:

class livro { public: Vamos supor que void Imprimir_os_dados(void); nós gostaríamos unsigned Quando_foi_publicada(void); de definir algum char* Qual_e_o_titulo(); ponteiro para o livro(char*, unsigned); objecto do tipo virtual ~livro(); livro. Neste caso private: precisamos de usar unsigned ano; a seguinte notação: char* titulo; }; Os resultados são os seguintes: int main(int argc, char* argv[]) { livro *meu_livro; livro PPO("C++", 2000); meu_livro = &PPO; meu_livro->Imprimir_os_dados();

Existem algumas opções que são muito úteis para desenvolver o vosso programa. Vamos abordar algumas delas. Esta opção permite ver e seleccionar as classes do programa e os membros delas, por exemplo

Temos muitas outras opções importantes Podemos ver onde esta função foi definida

Como o vosso programa pode ser organizado: 1. Headers (por exemplo livro. h) têm as respectivas declarações, por exemplo: class livro { public: void Imprimir_os_dados(void); unsigned Quando_foi_publicado(void); char* Qual_e_o_titulo(); livro(char*, unsigned); virtual ~livro(); private: unsigned ano; char* titulo; };

2. Ficheiros. cpp (por exemplo livro. cpp) têm as respectivas definições (implementações), por exemplo: livro: : livro(char* T, unsigned A) { titulo = T; ano = A; } char* livro: : Qual_e_o_titulo() { return titulo; } unsigned livro: : Quando_foi_publicado() { return ano; } // etc.

3. O ficheiro principal tem a seguinte forma: #include "stdafx. h" Todos os headers que #include "multiply_display. h" nós precisamos de usar #include "livro. h" para o nosso programa int main(int argc, char* argv[]) principal { livro *meu_livro; livro PPO("C++", 2000); meu_livro = &PPO; meu_livro->Imprimir_os_dados(); PPO. Imprimir_os_dados(); cout << "livro: " << PPO. Qual_e_o_titulo() << 't' << PPO. Quando_foi_publicada() << endl; cout << "nosso primeiro programa" << endl; multiply_display (49, 11); return 0; }

4. Os diferentes ficheiros podem ser organizados da seguinte forma: #include "stdafx. h" multiply_display. cpp void multiply_display (int a, int b) { cout << "Vamos multiplicar dois inteirosn"; int c; c = a * b; cout << "a * b = " << c << endl; } void multiply_display (int a, int b); multiply_display. h