primeiro programa

Diversos programas-exemplo serão apresentados durante este curso, sendo que os mesmos foram processados no C++Builder 5.02, C++Builder 3, C++Builder 4 e no C++Builder 6, todos da Borland. Alguns desses programas foram escritos com o intuito de ilustrar os tópicos apresentados; outros, para deixar o curso mais interessante. Sendo assim, procuraremos apresentar tutoriais sobre a confecção de programas, que irão se completando aos poucos, à medida que avançamos no curso. No final, tudo deverá fazer sentido.

O código-fonte de um programa C++ pode ser escrito em qualquer editor de texto simples que possa salvar seu conteúdo em formato de texto puro. Podemos, inclusive, usar o Bloco de Notas do Windows. Porém, no lugar da extensão .txt, devemos salvar os códigos do programa com extensão .cpp. Contudo, a forma mais rápida e sensata de se escrever um programa C++ é usando o próprio editor de códigos que acompanha o ambiente de desenvolvimento C++. Esclarecemos aqui que muitos exemplos deste livro estão redigidos com fonte formatada (itálica, negrito, colorida etc) apenas para fins didáticos e para facilitar uma eventual localização no mesmo. Um código-fonte C++ não deverá ser escrito com este formato e sim, conforme já exposto, em formato de texto puro, não formatado. Se você está procurando um bom editor de códigos para seus programas, nos atrevemos a indicar o ConTEXT. Usamos esse editor grandemente na elaboração destas páginas. Com ele ficou muito fácil padronizar a visualização dos códigos fontes, bem como exportar os mesmos, já formatados, para o padrão .html ou .rtf. Para maiores informações, consulte http://www.fixedsys.com/context

Inicialmente, para compreendermos melhor o conceito dos comandos e das instruções em C++, trabalharemos um programa definido como aplicação Console Win32, que gera programas parecidos com o DOS quando estão rodando, mas, na realidade, trata-se de programas de 32 bits executados no ambiente Windows.

Bem, chega de conversa e vamos por as mãos na obra:

1. inicialize o C++Buider;

2. dê um clique no menu File;

3. dê um clique em New...

4. Na janela que se abrir, selecione a opção Console Wizard e clique em OK;

5. selecione Console em Window Type e clique em finish.

O Builder C++, abrirá o editor de textos para você. É nesta janela que digitaremos o código-fonte de nosso programa.

Observe o próprio BuiderC++, por default (padrão), já digita parte do código que usaremos. Porém essa sugestão da Borland, neste tipo de aplicação Console Wizard, em princípio, pode ser ignorada, conforme demonstramos abaixo. Você pode optar por qualquer uma das duas formas para desenvolver seus programas:

Na sugestão da Borland:

#pragma hdrstop
#include <condefs.h>


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

#pragma argsused
int main(int argc, char* argv[])
{
return 0;
}

devemos digitar o código-fonte de nosso programa imbricando-o no código pré-estabelecido acima.

Outra opção que temos é deletar todo esse código e simplesmente iniciar nosso programa a partir do código já visto do menor programa possível em C++:

main() 
{ 
}

Esse modelo é aconselhável, se você estiver usando outro tipo de compilador. Caso haja algum conflito entre o exemplo apresentado e o seu compilador, procure ajuda no manual do mesmo.

Nosso primeiro programa, ao ser compilado, escreverá na saída de vídeo uma string (cadeia de caracteres) com um espaço de tabulação na segunda linha da tela, levará o cursor para a terceira linha da tela, emitirá um beep e, por fim, aguardará que uma tecla qualquer seja pressionada para encerrar a aplicação.

Delete toda a sugestão da Borland e, no editor de textos, digite:

#include <iostream>
#include <conio>

main()
{
std::cout << "\n\tEstou fazendo o meu primeiro programa\n\a";
getch();
}

Se preferir manter a sugestão da Borland, o código deverá ficar assim:

#pragma hdrstop
#include <condefs.h>
#include <iostream>
#include <conio>


//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
std::cout << "\n\tEstou fazendo o meu primeiro programa\n\a";
getch();
return 0;
}

Para Salvar, clique o menu File, escolha a opção Save e, na pasta de sua preferência, salve o programa com o nome PrimProgram.bpr.

Agora vamos rodar o programa para ver o resultado.

Compilar significa converter o código-fonte em linguagem que o processador (CPU) entenda, ou seja, em código de máquina, reunindo todos os comandos em um só arquivo. Linkeditar é transformar esse código fonte em um executável - um .exe (programa pronto).

Para executar o programa, nós podemos pressionar a tecla F9, ou podemos dar um clique em Run no menu Run, ou podemos clicar a seta verde (Run F9) sob o botão Open Project.

Feito isso, seu primeiro programa produzirá um executável semelhante à figura abaixo:

Muito bem, salvado o programa, encerre o aplicativo C++Builder. Abra a pasta onde você salvou o projeto PrimProgram.bpr e observe que o compilador colocou lá cinco arquivos:

PrimProgram.bpr

PrimProgram.cpp

PrimProgram.exe

PrimProgram.obj

PrimProgram.tds

Ora, mas vejam só, nós já temos um arquivo .exe (PrimProgram.exe) em nossa pasta! Inicialize-o e perceba que o nosso primeiro programa já roda sem auxílio do compilador. Pois bem, pressione uma tecla qualquer para encerrar o aplicativo e dê um (ou dois) clique(s) em PrimProgram.bpr para ver o que acontece: ... Estamos de volta no ambiente de desenvolvimento do primeiro programa.

A seguir, procuraremos entender como conseguimos criar esse programa. Na explanação, aparecerão nomes como Classes, objetos, macros, funções etc, que talvez lhe pareçam estranhos e incompreensíveis. Não se preocupe, pois, no momento certo, tudo ficará claro.

diretivas de pré-processador

O pré-processador C++ é um programa que fornece mecanismos para inclusão de arquivos-textos, cabeçalhos padrão e compilação condicional baseada em macros. Esse programa também pode ser usado para definir e usar macros.

Talvez você esteja se perguntando: afinal, o quê quer dizer esse monte de coisas?

Por enquanto, apenas para elucidar nosso primeiro programa sem tumultuar nosso entendimento, vamos nos contentar com uma explicação bem singela:

O pré-processador C++ é um programa que roda antes do compilador e, baseando-se em certas instruções denominadas diretivas de compilação, examina o programa fonte e implementa-lhe algumas modificações.

As diretivas de compilação mais comuns são:

#include

#define

#line

#ifdef

#ifndef

#if

#else

#elif

#endif

#undef

#error

#pragma

Algumas particularidades:

1ª. todas as diretivas iniciam com #;

2ª. devemos respeitar a regra de colocar somente uma diretiva em cada linha. Ou seja, não podemos colocar outro comando qualquer na linha em que há uma diretiva.

a diretiva #include

Imagine que muitos dos resultados que esperamos obter de nossos programas já estão, de certa forma, prontos, na biblioteca padrão, para ser inseridos em nosso código-fonte. Ou seja, não temos necessidade de desenvolver determinados arquivos (classes, funções ou gabaritos) porque eles já existem e podem ser usados em qualquer momento que precisemos deles.

Quando o pré-processador encontra a diretiva #include em nosso código fonte, substitui a mesma pelo conteúdo do arquivo indicado (no nosso exemplo, o conio e o iostream). O resultado é que o compilador encontrará e processará o arquivo implementado, e não a diretiva de compilação.

A diretiva #include é um mecanismo de tratamento do código-fonte que reúne, em um único arquivo de compilação, códigos (arquivos de cabeçalho ou hearder files, ou arquivos que contenham funções ou definições de dados) que se encontram dispersos em vários arquivos.

Para incluir os herder files em nosso código-fonte, devemos usar os símbolos < e > ou " e " para envolver o arquivo de cabeçalho:

#include <iostream>

ou

#include "iostream.h"

Se deixarmos espaço entre o caracter < e o nome do arquivo de cabeçalho, ou entre o caracter " e o nome do arquivo de cabeçalho, o compilador indicará erro:

< iostream.h> // [C++ Error] Project2.cpp(4): E2209 Unable to open include file ' iostream'.

Convencionou-se usar para os arquivos de cabeçalho o sufixo .h e para outros tipos de arquivos que contenham funções ou definições de dados, o sufixo .hpp, .c, ou .cc, .cpp, .cxx, .C, conforme o compilador. No caso do C++Builder, o arquivo que se encontra associado é o .hpp, responsável pela interface com a VCL, que foi escrita em Object Pascal.

Historicamente, o sufixo .h era padrão para todos os arquivos de cabeçalho. Entretanto, para evitar problemas de compatibilidade com cabeçalhos de versões redefinidas de biblioteca padrão, ou com novos recursos de biblioteca que foram surgindo, resolveu-se suprimir o sufixo .h dos nomes de cabeçalho padrão (podemos dizer que cabeçalho padrão é o arquivo de cabeçalho definido na biblioteca padrão). A partir de então, nenhum sufixo é necessário para cabeçalhos da biblioteca padrão: <iostream>, <conio>, <map> etc.

A principal diferença entre a biblioteca padrão e a não padrão é que, enquanto uma biblioteca não padrão tem de ser incorporada manualmente, a padrão é incorporada automaticamente pelo compilador. É importante saber, ainda, que os recursos da biblioteca padrão estão definidos num ambiente de nomes chamado std e apresentados como uma série de cabeçalhos.

o arquivo de cabeçalho iostream

Para o nosso programa imprimir a string Estou fazendo o meu primeiro programa no vídeo, nós providenciamos para que a Classe iostream fosse chamada à compilação através da diretiva #include. A biblioteca iostream contém as declarações necessárias ao uso de streams de entrada (teclado) e saída (vídeo), como, por exemplo, o objeto cout e o operador de inserção <<. Obtém-se o operador de inserção << digitando-se o caracter "menor que" duas vezes.

O objeto cout é o responsável pela saída, no console ou na tela, da string que digitamos: Estou fazendo o meu primeiro programa.

O operador de inserção << (envie para) escreve o argumento da direita (a string) no da esquerda (no cout).

Além do cout e do operador de inserção << a Classe iostream contém outras definições de impressão e leitura (I/O), que estudaremos mais adiante.

Você deve ter notado que demonstramos a inclusão dos arquivos de cabeçalho da Classe iostream de três modos diferentes:

#include <iostream> // Cabeçalho padrão sem sufixo .h

#include "iostream.h" // Cabeçalho de biblioteca não padrão

#include <iostream.h> // Cabeçalho padrão com sufixo .h

Não há necessidade de inserirmos nenhum sufixo para cabeçalhos da biblioteca padrão, porque os símbolos < > já denotam o chamamento de cabeçalhos padrão. Contudo, as declarações dos cabeçalhos mais antigos, são colocadas no ambiente de nomes global, carecendo do sufixo .h.

Os cabeçalhos colocados entre aspas " " determinam que o pré-processador procure o cabeçalho primeiro no diretório atual, e depois na biblioteca padrão (Include).

Em nosso programa: #include<iostream> instrui o pré-processador a incluir os recursos de entrada e saída de iostream padrão, e std::cout determina a inclusão do cout padrão.

Se quisermos, podemos tornar todos os nomes std globais, o que nos poupa da tarefa de ter que digitar constantemente o prefixo std:: antes de cout:

#include <iostream>

using namespace std;

Se algum dos nossos programas não rodar, podemos usar uma versão mais tradicional. Para isso colocamos o sufixo .h nos cabeçalhos e removemos o prefixo std::. Exemplo:

#include <iostream.h>
#include <conio.h>

main()
{
cout << "\n\tEstou fazendo o meu primeiro programa\n\a";
getch();
}

Boa parte dos programadores, talvez por praticidade, parece preferir essa segunda versão. Daqui para frente, escolha é sua!

o arquivo de cabeçalho conio

Nosso programa possui outro cabeçalho, o arquivo conio. Trata-se de um arquivo de inclusão necessário à utilização da função getch(). Quando descrevemos o que o nosso programa faria, afirmamos que, por fim, ele aguardaria que uma tecla qualquer fosse pressionada para encerrar a aplicação. Essa tarefa foi desempenhada pela função getch() que retorna o caracter lido no teclado, sem imprimi-lo no vídeo. Se quisermos que o caracter lido seja impresso no vídeo, podemos usar a função getche(), também integrante de a conio.

Lembra-se do menor programa possível em C++, quando afirmamos que tudo o que veríamos seria um breve piscar da janela na tela e o encerramento do programa? Pois bem, poderíamos usar getch() para segurar a janela na tela até que uma tecla fosse pressionada!

caracteres especiais

Antes que nossa string fosse imprimida no vídeo, o programa pulou uma linha (caracter de nova linha) e imprimiu uma caracter de tabulação horizontal. Depois da string, o programa colocou o cursor na linha de baixo (nova linha) e emitiu um beep (sinal sonoro).

Como fizemos isso?

Alguns caracteres não podem ser inseridos diretamente pelo teclado. Por exemplo, se, durante a elaboração do código-fonte, no meio da string, pressionarmos a tecla Enter pensando que estaremos inserindo uma nova linha, faremos com que o compilador apresente uma mensagem de erro.

A solução é usarmos algumas combinações de caracteres que realizam essas tarefas. Essas combinações, conhecidas como seqüência de escape, são representadas por uma barra invertida \ e um caracter. Por exemplo, a combinação \n representa nova linha (Enter), \t representa tabulação horizontal (Tab) e \a representa o beep. Essas seqüências de escape, nós já conhecemos. Vejamos outras:

string(s) de texto

Constante caracter é uma letra ou símbolo colocado entre apóstrofes: 'a', 'b', '~', 'A', 'B', '\n, '\r', '\xa0', '\xa2', 'xa3' etc.

Uma importante atividade nos programas em geral é a manipulação de textos como palavras, frases, nomes etc. Na realidade, esses textos são constantes string(s), que se compõem de um conjunto de caracteres colocados entre aspas: "Estou fazendo o meu primeiro programa", "constante string", "\tOuviram do Ipiranga as margens pl\xa0" "cidas\n\tde um povo her\xa2ico o brado retumbante\n\te o sol da liberdade em raios f\xa3lgidos,\n\tbrilhou no c\x82u da P\xa0tria nesse instante.\n"

funções

Funções são a base de qualquer programa C++. Elas compõem, juntamente com as Classes, os blocos construtivos da linguagem. Dentro das funções, encontramos todos os comandos executáveis, sendo que as mesmas são a maneira típica de se obter alguma execução em C++.

Vamos reescrever o primeiro programa. Por enquanto, não queira compreender todos os detalhes da alteração, uma vez que, por ora, nossa preocupação é apenas esclarecer, sem pormenores, quais são os elementos básicos de uma função. Em outra seção deste curso, abordaremos as funções de uma forma mais abrangente e minuciosa.

Inicialize PrimProgram.bpr, caso não esteja com ele aberto. No compilador, clique em Edit e depois em Select All; Clique novamente em Edit e depois em Delete. Agora copie o código abaixo no editor de textos do compilador.

/*Dica: não use o recurso de copiar e colar códigos-fontes 
quando estiver estudando.

#include <iostream>
#include <conio>
using namespace std; // torna todos o nomes std globais
void ModifPrimProg(void); // declara a finção ModifPrimProg

int main() // estamos em main() 
{ 
ModifPrimProg(); // chama a função ModifPrimProg
return 0;
} // fim de main()

void ModifPrimProg(void) // cabeçalho da definição da função 
{

cout << "\n\t\tModificando o primeiro programa."
"\n\n\n\t\tDigite dois caracteres mas veja "
"s\xa2 o primeiro: ";
getche(); // retorna e imprime o caracter lido no vídeo
cout << '\a'; // beep - sinal sonoro
getch(); // retorna o caracter sem imprimi-lo no vídeo

} // fim de ModifPrimProg()

Execute o programa e volte aos estudos.

Com essa pequena alteração no código, podemos visualizar melhor alguns detalhes sobre as funções.

Uma função deve ter a seguinte forma geral:

tipo nome(declaração dos parâmetros)

{

Primeira_Instrução;

Segunada_Instrução;

Etc_instrução;

}

Nosso programa agora possui quatro funções: main(), ModifPrimProg(), getche() e getch(). O nome delas é: main, ModifPrimProg, getche e getch respectivamente. A função main(), como sabemos, é a principal, é aquela onde a execução do programa se inicia; ModifPrimProg() é uma função que não estava em biblioteca alguma, tendo sido criada por nós; getche() e getch() nós também já conhecemos do arquivo de cabeçalho conio.

Precedendo o nome da função main() temos o tipo int, que informa ao compilador que main() pode retornar um tipo int. Já a função ModifPrimProg() é do tipo void. O tipo void significa que a função não possui valor de retorno. Quando nenhum tipo de retorno for especificado, presume-se o valor de retorno int para a função. As funções retornam valores por meio do comando return.

Após o nome de qualquer função temos parênteses de abertura "(" e de fechamento ")". Nesses parênteses, informamos ao compilador a lista de parâmetros que a função pode receber. Logo, ModifPrimProg(void) não pode receber nenhum parâmetro por causa do tipo void.

Entende-se por cabeçalho da definição da função o conjunto tipo nome(declaração dos parâmetros) que antecede a chave "{" de abertura do corpo da função. Entre a chave de abertura "{" e a de fechamento "}" do corpo da função, encontramos as tarefas (instruções) que a mesma realiza.

Instruções são as tarefas que determinados comandos realizam. Toda instrução é encerrada com um ponto e vírgula ";":

cout << "uma instrução!";

getch();

return 0;

A falta do ponto e vírgula ensejará mensagem de erro pelo compilador. Porém, não se coloca ponto e vírgula após as chaves de abertura e fechamento das funções.

Não se preocupe em entender, por ora, todos os conceitos apresentados, posto que os abordaremos novamente no correr do curso. Até aqui, tivemos apenas a intenção de colocá-los em contado com o ambiente de programação C++Builder e com os fundamentos da linguagem C++.

últimas mensagens do Fórum