Objectivos
 Componentes principais do Developer Studio
 Projectos e como criá-los
 Desenvolver programas
 Compilar, linkar, depurar e executar programas
Developer Studio
- é um ambiente de desenvolvimento integrado para criar, compilar, linkar,
depurar e testar programas
 Editor – ambiente interactivo para criar e editar o código
fonte (*.cpp, *.h)
 Compilador – converte o código fonte na linguagem de
máquina (*.obj)
 Linker – combina os módulos gerados pelo compilador com
os módulos das bibliotecas de programas
 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
ClassView e a FileView
Iremos escolher a opção
“A simple aplication”
Carreguem no botão “Finish” para completar a criação do projecto
A ClassView 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 FileView 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 FileView
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 StdAfx.h
FileView tem osítio
seguinte
aspecto
#include <iostream.h>
Escrevam o seguinte programa. Adicionem esta linha ao programa.
Ctrl-F5
Para compilar, efectuar o linking e
executar o vosso programa
pressionem Ctrl-F5
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 inteiros\n”;
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
F10
Se pressionarem a tecla F10
o depurador passará para a
próxima linha do programa
F11
Por favor façam isso para que compreendam
a diferença entre o F10 e o F11
Se pressionarem periodicamente a tecla F10 o controlo não será
passado para as funções, tal como multiply_display();. Se pretendem
entrar no corpo da função devem pressionar F11 quando estiver
activa a linha com a invocação da função
Comecem a depuração. Para isso pressionem F10 e
depois seleccionem as seguintes opções
F10…F10 e depois
F11 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 F9 se quiserem inserir um ponto de paragem
(breakpoint). Para executar o programa até ao ponto de paragem
pressionem F5. Para remover o ponto de paragem coloquem
o cursor na linha respectiva e pressionem de novo F9
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:
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 inteiros\n";
int c;
c = a * b;
cout << "a * b = " << c << endl;
}
void multiply_display (int a, int b);
multiply_display.h