• Revista PROGRAMAR: Já está disponível a edição #53 da revista programar. Faz já o download aqui!

Marfig

[C++] Usar o Visual Studio para Desenvolvimento em C++

4 mensagens neste tópico

Vamos lá então.

Nota: O tutorial será desenvolvido em 6 partes. 4 já estão desenvolvidas.

...

Criar e Configurar um projecto C++ em Visual Studio

A primeira coisa a fazer é lançar o Visual Studio. A sério.

Se não alteraste nada nas configurações estarás a olhar para uma tab com o nome Start Page. Por norma eu altero as configurações para remover esta tab. Mas é uma questão de preferência. No canto superior esquerdo dessa tab notas uma caixa com o titulo "Recente Projects". Aqui poderás criar um novo projecto, abrir um projecto em que tenhas trabalhado recentemente ou abrir um projecto navegando para a sua localização. Prefiro no entanto fazer-te habituar aos menus do Visual Studio.

1. Ciar o Projecto

No Menu "File" do Visual Studio selecciona "New" e depois "Project...". A Caixa de Diálogo para a criação de um novo projecto aparece. No lado esquerdo desta caixa de diálogo sob o título "Project Types" tens os tipos de projectos que poderás criar. A lista será maior ou menor consoante a versão do Visual Studio que estás a usar e quais os componentes que instalaste. Interessa-te aqui os projectos inseridos dentro de "Visual C++". Clica nesse item se ainda não o fizeste para expor os seus sub-itens. Selecciona o item "Win32".

Este é o item que te interessa para desenvolveres um projecto em ISO C++. Irás portanto criar um projecto puro C++ que poderás usar para desenvolver uma aplicação que corra na consola do Windows ou mesmo uma aplicação que use janelas tal como as aplicações típicas para o Windows. Neste último caso terás que usar as bibliotecas do Windows como a Win32 API que é disponibilizada pelo Visual Studio ou bibliotecas externas como o WxWidgets que te permitem criar código mais fácil de transportar para outros sistemas operativos como o Linux e MacOS.

É importante deixar aqui uma referência aos termos "programar para windows" e "programar para o GUI". Programar para Windows é muitas vezes usado para significar as duas coisas. Terás que estar atento quando estás a ler o texto de alguém e tentar perceber qual o contexto em que se insere o termo. Programar para o GUI (Graphical User Interface) é usado quando se quer deixar claro que se está a falar de programar para janelas em windows ou noutro sistema operativo. "Programar para Windows" poderá querer dizer muitas coisas incluindo a anterior. Mas para todos os efeitos significa programar para o sistema operativo Windows o que inclui aplicações que vão correr unicamente na consola do windows ou aplicações que vão correr usar as tais janelas.

No nosso caso vamos criar uma aplicação que vai correr na consola. O Desenvolvimento para o GUI é complexo e aconselha-se os iniciantes à linguagem de programação para primeiro a estudarem a fundo antes de se iniciarem nesse tipo de desenvolvimento. O C++ obriga a um longo processo de aprendizagem, mas os benefícios são imensos. Uma linguagem de programação muito perto da máquina que me permite desenvolver programas para praticamente qualquer sistema operativo, uma linguagem de programação que me oferece as ferramentas necessárias para desenvolvimento de projectos de qualquer natureza desde jogos 3D até sistemas de controle de barragens e uma linguagem robusta que me permite aplicar complexos algoritmos.

Adiante... com o Win32 seleccionado, no lado esquerdo da Caixa de Diálogo "New Project" garante que tens seleccionado o item "Win32 Console Application". O nome é errado porque com este tipo de projecto poderás desenvolver qualquer tipo de aplicação: Consola ou GUI. Mas provavelmente é assim que se chama porque com este tipo de projecto, sem a utilização de bibliotecas adicionais a aplicação realmente correrá na consola do Windows. E é isso que queremos.

Em baixo, ainda na caixa de Diálogo dás um nome ao teu projecto no campo "Name". Vamos lhe chamar "FirstApp".

No campo abaixo com o nome "Location" irás definir onde o teu projecto ficará localizado. Pessoalmente tenho todos os meus projectos dentro de um directório chamados "projects" em C:\. É assim que eu gosto porque prefiro ter tudo dentro da mesma árvore. Digita a localização em que queres guardar o projecto ou clica na botão browse e navega até lá. Não precisas de acrescentar o nome do projecto ao campo Localização. O Visual Studio irá criar esse directório por ti.

Finalmente o último campo é chamado de "Solution Name" e contém também uma checkbox com o titulo "create directory for solution". O Visual Studio integra a noção de Solution no topo da de projecto. Eu não quero entrar em grandes pormenores aqui porque só te vai fazer confusão. Mas de uma forma simples, uma Solution permite-te gerir vários projectos ao mesmo tempo e é normalmente só usada para o desenvolvimento de projectos complexos com muitos outros projectos a dependerem dele ou ele a depender desses projectos. Não existe necessidade desta funcionalidade aqui. Portanto vais garantir que retiras a checkmark de "create directory for solution". O campo "Solution Name" passará a cinzento e estará tudo bem. Podes clicar em Ok.

2. O Project Wizard

O caixa de diálogo anterior fechou e estás agora a olhar para outra com o nome "Project Wizard". Pessoalmente penso que esta caixa foi mal desenhada. É fácil para um utilizador inexperiente clicar em "Finish" e assim não poder fazer as configurações iniciais do projecto. Deveria tornar ser mais óbvio que esta caixa de diálogo contém configurações importantes. Mas enfim... não é para criticar o Visual Studio que estamos aqui.

Tu vais querer clicar em "Next" onde verás então as configurações iniciais do teu projecto. A opção "Console Poject" já está seleccionada por ti. É para manteres. Mas vais alterar outras coisas.

A primeira coisa a fazer é retirares a checkmark de "Precompiled Header". Pessoalmente nunca uso isto. Prefiro ter as minhas próprias headers pre-compiladas da forma que eu quero e o Visual Studio deixa-me fazer isso mais tarde já dentro do projecto. Mas para todos os efeitos não vou discutir o que são precompiled headers. Apenas garante que tens esta opção retirada.

De seguida vais querer seleccionar a opção "Empty Project". Isto vai criar o teu projecto sem qualquer ficheiro de código. É o que queremos para simplificar as coisas e criares um projecto "limpo" que possas usar à tua maneira sem ficheiros desnecessários. Nota que quando seleccionas esta opção o campo "Precompiled Headers" fica a cinzento. Portanto não precisavas realmente de seguir o parágrafo anterior. Mas quis deixar claro que não queres precompiled headers.

Clica em "Finished" e o teu projecto é criado. Finalmente!

3. Uma visita guiada ao teu projecto.

E pronto. Estamos já dento do teu projecto. Antes de avançar para o próximo post onde vamos criar um pequeno programa em C++, quero deixar algumas notas que considero mais importantes sobre o que estás a ver neste momento.

No lado esquerdo do ecrã, ocupando toda a extensão vertical deste, encontras o "Solution Explorer" que conterá todos os ficheiros pertencentes a este projecto. Os directórios que vez ali são apenas conceptuais. Não existem no teu disco. Ajudam-te a organizar os teus ficheiros. Pessoalmente costumo apagá-los e criar os meus próprios uma vez que prefiro organizar os meus projectos de forma completamente diferente. Mas vamos deixar as coisas como estão. De reter no entanto é a informação que é aqui que vais ver todos os teus ficheiros de código.

No topo do ecrã, logo abaixo do menu tens a barra de ferramentas. Mais tarde ou mais cedo, quando já estiveres minimamente habituado ao Visual Studio irás querer configurá-la a teu gosto, retirando alguns itens e acrescentando outros (e mesmo criar outras barras). Mas quero chamar a tua atenção para um dos itens aqui onde lês a palavra "Debug". Se clicares aí, verás que aparece um pequeno menu para escolheres entre "Debug", "Release" e "Configuration Manager". Vamos lá então a uma explicação rápida.

A programação em C++ contém o conceitos de "Build", "Compile" e "Link". Fazer um build é compilar e lincar o teu projecto, resultando então no ficheiro executável. Compilar um projecto é um passo que irá pegar no teu código, verificar quaisquer erros e criar os chamados ficheiros "obj" ou "object files". Este ficheiros contêm o teu código traduzido para algo que se chama em termos gerais object code. Sem entrar em pormenores, apenas te indico que o teu projecto não é ainda um executável mas este passo é fundamental. O passo seguinte é o de lincar (link) o teu projecto. Aqui os object files criados no passo anterior são novamente interpretados, desta feita para código máquina e para a criação de um ficheiro executável. Este sim, que agora poderás correr normalmente.

Ora, o Build portanto faz estes passos em sequência sem precisares de os fazer um a um. Dizer que se fez um build de um projecto é dizer que se gerou um executável do projecto a partir dos ficheiros de código (conhecidos também como source files). Em C++ usam-se normalmente dois tipos de build. Debug e Release. Durante o desenvolvimento do projecto procuramos estar em modo Debug a maior parte do tempo. Este tipo especial de build irá criar object files e o executável com instruções especiais que nos permitem, caso hajam erros, fazer o debug do programa. Fazer o debug do programa (depurar um programa, em Português) é usar um debugger (depurador) que é uma aplicação incluída no Visual Studio que nos permite executar o programa enquanto estamos a observar em que linha do nosso código o programa está actualmente. Somos capazes de perceber assim onde é que está o erro e com a ajuda das várias ferramentas do debugger perceber mesmo qual é o erro exactamente (eu vou-te dar um exemplo muito simples do uso do debugger quando criarmos o tal projecto no próximo post).

O modo Release irá criar então um executável sem essas instruções especiais - e portanto muito mais pequeno - que é então o executável que quererás distribuir pelos teus amigos ou convidar as pessoas a usar. Entretanto, os object files e o executável gerado em modo release não podem ser usados pelo Debugger. Para alterares o modo em que estás basta somente ires a este item na barra de ferramentas e seleccionares entre Debug e Release.

4. A continuar...

E pronto. Este já está. Agora dá-me só algum tempo para comer, descansar, organizar ideias e escrever os próximos posts. Aí iremos criar um pequeno programa, explicar um pouco da sintaxe do C++ e saber como efectuar algumas configurações no teu projecto. Aprenderás ainda o básico do Debugger. Depois disso... é a bibliografia e um desejo de boa sorte e que te divirtas.

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Vamos então criar o nosso pequeno programa.

Programar em C++

1. Um pequeno programa em C++

Vamos criar um pequeno programa que recebe do utilizador um número e multiplica-o por 2. Se o utilizador digitar 0, o programa sai. Caso contrário pedirá por um novo número. Este é um exemplo muito básico de programação em C++. A ideia é apenas falar um pouco sobre alguns conceitos iniciais só para te ajudar a melhor perceberes como incorporar código de outros sítios e a usares o Visual Studio. Gostaria no entanto de deixar claro aqui que o objectivo deste tutorial não é ensinar-te a programar em C++. O objectivo é ajudar a preparar-te para estudares e aprenderes a programar em C++.

2. Criar o ficheiro de código e Configurar o Projecto

Vamos então criar o ficheiro de código que irá conter as instruções C++ para o compilador interpretar.

No lado esquerdo do teu ecrã, clica com o botão direito do rato no directório "Source Files". Do menu que aparecem escolhe "Add -> New Item". Uma caixa de diálogo chamada "Add new Item - FirstApp" aparece. No lado esquerdo tens os tipos de ficheiros que podes criar. Para todos os efeitos irás sempre querer criar ou um "C++ File (.cpp)" ou um "C++ Header (.h)".

Um ficheiro .cpp é um source file (ou ficheiro-fonte) e contém o teu código. Um ficheiro .h, ou .hpp  é um header file que também contém código mas que tem uma função diferente. Não vou entrar em uitos pormenores sobre o que distingue header files de source files aqui. Poderá ficar para discussão sobre este tutorial ou para mais tarde.

Assegura-te portanto que seleccionas "C++ File (.cpp)". A seguir vais dar um nome a este ficheiro no campo denominado "Name". Este vai ser o teu ficheiro que conterá a função "main" (já lá iremos). Ou seja o ficheiro de código que conterá a função que serve como ponto de entrada ara o teu programa. Por norma eu chamo sempre este ficheiro de "main". Outros nomes possíveis são "entry" e o nome do projecto que se está a desenvolver; neste caso FirstApp. Para todos os efeitos o nome é irrelevante. Garante no entanto que não contém espaços ou caracteres especiais. De preferência nem sequer uses caracteres com acentos. Eu vou chamar-lhe de "main".

O campo "Location" indica que o ficheiro será gravado no directório do projecto. Poderias gravá-lo em qualquer sitio. Mas este será talvez o melhor. Fica tudo arrumado no mesmo directório. Pessoalmente também não gosto da forma como o Visual Studio arruma os ficheiros de código misturados com outros ficheiros e costumo alterar tudo isto. Mas para os nossos efeitos não é isso que vamos fazer. Deixa ficar como está, garante apenas que fizeste as selecções acima e deste o nome ao ficheiro e clica em "Add".

Boom! Aí tens o teu ficheiro-fonte prontinho a adicionar código. O ficheiro é um ficheiro .cpp como podes ver. Por norma os ficheiros-fonte C++ têm esta extensão e os header files C++ têm a extensão .hpp. Isto para os distinguir mais facilmente da linguagem de programação C que usa ".c" e ".h", respectivamente.

O Visual Studio selecciona-o na lista da esquerda, abre-o e coloca o cursor na primeira linha. Chegando aqui começo a pensar melhor se devo continuar. Ainda me arrisco a que me venhas a tirar o emprego :D

3. Configurar o Projecto

Uma vez criado o primeiro ficheiro-fonte é possível configurar a compilação do projecto. Iremos realmente fazer aqui duas alterações simples. Tudo o resto não vai ser discutido aqui. Muitas das opções existentes só farão sentido mais tarde quando fores mais conhecedor da linguagem de programação. Vamos também fazer uma pequena alteração ao editor.

Para configurar o Projecto é necessário ir ao menu "Project" e clicar no item "FirstApp Properties...". A caixa de diálogo "FirstApp Property Pages" abre-se. Do lado esquerdo, se o item "Configuration Porperties" não estiver aberto clica no simbolo "+" ao lado.

Irás notar que no topo da caixa de diálogo estás sob a configuração "(Active) Debug". Isto significa que quaisquer alterações aqui só irão afectar o build "Debug". Poderás clicar nessa caixa para ver as outras opções. São "Debug", "Release" e "All Configurations". Para todos os efeitos "(Active) Debug" e "Debug" são exactamente a mesma coisa. Só está a mostrar o texto "Active" entre parêntesis para te lembrar que essa é a configuração em que estás actualmente no editor.

Vamos fazer uma alteração ao compilador. Clica no símbolo "+" do item "C/C++". As configurações aqui presentes irão afectar a compilação do teu projecto. Selecciona o item "General". Aqui tens as configurações genéricas do compilador C/C++. O que nos interessa aqui é alterar a opção "Warning Level" de 3 para 4. Força, altera e depois clica no botão "Apply". De seguida, no lado esquerdo da caixa de diálogo clica em "Language" e altera a opção "Disable Language Extensions" para "yes". Clica depois em "Ok".

O que fizemos em primeiro lugar foi aumentar o nível de mensagens de Warning para o nível máximo (nível 4). Ao fazer isto garantimos que o compilador vai informar sempre que o nosso código contiver instruções que possam não ser as mais correctas de acordo com as regras da linguagem. Avisa-nos também sobre potenciais problemas como o código. Por norma, um programador C++ deve sempre compilar os seus projectos no maior nível de mensagens possível de forma a mais facilmente detectar quaisquer problemas. O Compilador poderá gerar mensagens de Warning, mas não interromperá o processo. Só as mensagens de Erro o fazem. Mas muitas vezes as mensagens de Warning são indicadores de problemas graves que podem vir a surgir durante a execução do programa e portanto ajudam-nos a melhor desenvolver os nossos programas.

A segunda alteração foi retirar do compilador a possibilidade de usar Extensões C++. A Linguagem C++ é descrita num documento ISO que define o Standard a respeitar por todos os compiladores. No entanto os compiladores são livres de adicionar novos elementos na forma de extensões à linguagem. Todos (que eu saiba) o fazem; O VC++ que é o que estás a usar, o gcc, o MinGW que é um port do gcc para Windows, o BC++ da Borland, DigitalMars, DJGPP, Watcom,... Enfim a lista é grande como vês. Mas ao usares as  extensões que estes compiladores possam oferecer estás a criar um problema: o teu código deixa de ser possível - na esmagadora maioria dos casos - de compilar noutro compilador. O C++ é uma linguagem que foi pensada de raiz para ser portátil. Portanto muitos programadores não vêem com bons olhos o uso de extensões. Para efeitos de aprendizagem também não é aconselhável aprender sobre estas extensões por enquanto porque poderão induzir-te em erro e pensares que fazem pare da linguagem C++, quando não o fazem.

Portanto retirámos ao compilador a capacidade de usar estas extensões e sempre que ele detectar uma no teu código reportará um erro e não prosseguirá com a compilação.

Vamos só fazer mais uma alteração rápida. Agora que estás de volta ao editor, no menu "Tools" escolhe a última opção "Options...". Uma caixa de diálogo "Options" aparece. No lado esquerdo localiza o item "Text Editor". Abre-o e localiza o item C/C++. Selecciona esse item e coloca uma checkmark na opção "Line Numbers". Depois clica em "Ok." O teu editor de texto passa a mostrar a numeração das linha de código. Tanto o compilador como o linker e o debugger (e muitas outras ferramentas associadas ao C++) indicam as linhas de código em que estão a operar através do seu número. Faz portanto todo o sentido veres esta numeração.

E pronto. Estamos tu e eu fartos de configurações. Vamos lá programar.

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

4. Programar em C++. Finalmente!

Como disse antes vamos desenvolver um programa que multiplica por 2 os valores introduzidos pelo utilizador. A forma como vamos construir este programa é de baixo para cima. Ou seja, vou começar com pouco código, explico o código e depois vou adicionando mais código explicando-o à medida que prosseguimos.

Em ISO C++ todo o programa terá que ter um entry point (ponto de entrada). Esse entry point é a função main(). Todo o programa C++ tem que ter este função e é aqui que o programa começa a executar. Só pode existir uma função main() em todo o programa. Mais do que uma e o compilador recusa-se a prosseguir. Durante a tua aprendizagem verás programas que parecem não conter esta função. Por exemplo, quando se programa para a Windows API a função de entrada é WinMain(). Criar uma função main() neste tipo de programas irá gerar um erro. Outras funções de entrada existem e algumas bibliotecas externas obrigam à utilização das suas próprias funções de entrada. O que acontece-se em muitos casos é que a função main() é definida dentro da biblioteca ou API e ao utilizarmos a função de entrada sugerida iremos realmente estar a chamar essa função main().

Portanto o primeiro código que vamos escrever é:


int main() {

}

O que é que tens aqui?

Antes de tudo o mais, em C++ o código é sensível a capitalização. "main" não é o mesmo que "Main" e "SUCCESS" não é o mesmo que "SUCcESS". Tem sempre em conta isto durante a fase inicial da tua aprendizagem. Por vezes podes estar a usar o nome de uma função, objecto ou variável correctamente e não perceberes porque é que o compilador te diz que o objecto ou função não existem.

O código acima é o código mínimo que podes escrever em ISO C++. É uma programa que não faz nada. É executado e termina logo de seguida.

A função main() ali descrita é uma função que devolve um int e não tem nenhum argumento (os parênteses não contêm nada). Existem alguns tipos de funções main() que podem ser usados. Não os vou discutir aqui. No entanto uma função main() sempre, mas sempre, devolve int. Poderás ver código aqui e ali que descreve main() como devolvendo um tipo especial de "void". Mas isto é um erro. É mau código e deve ser evitado.

Em C++ uma função que devolva algo precisa de uma instrução "return". Não colocar esta instrução algures na função de forma a que seja sempre executada é um erro e o compilador não prossegue. No entanto a função main() é uma função especial e permite realmente este comportamento bizarro de não incluir um "return". É no entanto considerado de mau gosto e portanto vamos colocar o return.


#include <cstdlib>

int main() {

    return EXIT_SUCCESS;
}

Na realidade este código vai ser alterado de seguida para uma forma mais simples. Mas quis colocá-lo assim para introduzir já alguns conceitos importantes antes de avançarmos.

4a. O Pré-processador

A nossa função continua a não fazer nada. Mas agora fomos explícitos em colocar a instrução "return". Aqui EXIT_SUCCESS é igual ao valor 0. Podes ver isso se passares o mouse por cima de EXIT_SUCCESS. Vais ver uma instrução "#define EXIT_SUCCESS 0" aparecer numa tooltip amarela que basicamente define EXIT_SUCCESS como sendo a mesma coisa que 0. Em C++ o processo de compilação é na realidade separado em duas fases distintas. O pré-processamento e a compilação propriamente dita. Ou talvez seja mais correcto dizer que pré-processamento é uma fase, compilação outra e link a terceira. A fase de pré-processamento é uma fase especial que vai alterar o teu código em certas partes para o preparar para compilação. Sempre que queremos dar instruções à fase de pré-processamento fazemos com recurso a uns comandos especiais chamados de Preprocessing Directives" (Directivas de Pre-processamento) ou apenas Directives.

Todas as directivas começam com o símbolo # de forma a se distinguirem de outras instruções. No caso da directiva #define que tu vês quando passas o mouse por cima de "EXIT_SUCCESS", está a ser dada uma instrução ao pré-processador para alterar o teu código de forma a substituir EXIT_SUCCESS por 0 antes de compilar. Ou seja, o que o compilador vai realmente ver é "return 0;" em vez de "return EXIT_SUCCESS;".

Naquele código estás a ver outro tipo de directiva. O "#include". Esta directiva irá pegar num ficheiro e introduzir todo o seu código naquela localização. Ora, aquele #define que viste para EXIT_SUCCESS tem que existir em algum lado para puder ser reconhecido. De outra forma EXIT_SUCCESS daria erro porque nem o pre-processador nem o compilador o conheceriam. EXIT_SUCCESS está definido dentro de um header file chamado stdlib.h. Para veres que está faz o seguinte:

Clica com o botão direito do rato algures no texto EXIT_SUCCESS. No menu que aparece, clica na opção "Go to Definition". Esta opção permite-te abrir o ficheiro onde este EXIT_SUCCESS está definido e posiciona-te no local exacto onde essa definição acontece. Portanto o editor abriu o ficheiro stdlib.h e estás neste momento a ver a tal instrução "#define EXIT_SUCCESS 0". Não alteres este ficheiro! Faz parte da Standard Library (já lá iremos) e portanto alterar este ficheiro podes ter consequências graves para todos os teus projectos. Podes fechar este ficheiro indo ao menu "File" e seleccionar "Close" ou clicando no "X" que se encontra no extremo direito das tabs que contêm os nomes dos ficheiros abertos.

Portanto, vimos que EXIT_SUCCESS está definido em stdlib.h. Mas o que é que isso tem a ver com o texto "cstdlib" que vemos no #include e o que significam aqueles "<" e ">"?

4b. A Standard Library

Eu não queira falar disto. Tentei, tentei mas não consegui evitar. Porque realmente é difícil de explicar e vai levar algum tempo (levou comigo) até te habituares à noção de Standard Library no contexto do C++. Portanto vamos lá ver se consigo explicar isto de uma forma sucinta mas que pelo menos te dê as bases para perceberes a importância da Standard Library (Biblioteca Standard) e como a deves utilizar.

O C++ propriamento dito - a linguagem de programação C++ - é na realidade relativamente pequena. O número de palavras reservadas reconhecidas pela linguagem é relativamente reduzido. 73 palavras(www) que compõem o universo da linguagem C++. Isto coloca o C++ com a mesma capacidade linguística de uma criança de 2 anos. No entanto mesmo assim este número é considerado excessivo por alguns críticos e linguagens de programação há que contêm menos de metade deste número.

Só que desenvolver um programa com base em apenas 73 palavras reservadas seria um pesadelo. Felizmente o C++ inclui uma biblioteca de funções e objectos que facilitam a programação. Por exemplo, em vez de teres que desenvolver código para ordenar uma lista de nomes, a Standard Library do C++ oferece-te várias funções para o fazeres mais rapidamente.

A Standard Library é composta por 3 partes essencialmente: A C Standard Library que contém os elementos da linguagem C, a C++ Standard Library que adiciona novos elementos à biblioteca do C e a Standard Template Library. Não vamos falar desta última aqui.

Portanto com este conhecimento à mão, vamos lá perceber aqueles "stdlib.h" e "cstdlib". Em C++, para se usar uma função, classe, constante ou objecto da Standard Library é preciso incluir o header file onde esse elemento é declarado. Isto faz-se como viste acima com a directiva #include. Para todos os efeitos todo e qualquer header da standard library deve ser incluído entre os delimitadores "<" e ">". Assim poderás ver coisas como #include <cassert> ou #include <vector>.

Em segundo lugar, no C++ os headers files da Standard Library não têm extensão. Ou seja o nome dos ficheiros não têm a extensão .h ou .hpp. Portanto a directiva #include também não colocará a extensão.

Resumindo nunca deverás escrever #include <cstdlib.h> ou #include "cstdlib.h" ou #include "cstdlib" quando estás a incluir ficheiros da Standard Library. Deverás sempre escrever #include <cstdlib>. Sem extensão e com os delimitadores "<" e ">". Ora, porque é que isto é importante?

Como tu viste mais acima, parece que eu estou a entrar em contradição. Afinal disse-te que a Standard Library do C++ não tem headers com a extensão .h, mas ainda à pouco abriste o ficheiro stdlib.h que pertence à Standard Library. Bom, lembras-te de certo que ainda agora te disse que um dos componentes da Standard Library é a C Standard Library. Esse ficheiro com extensão .h é um ficheiro da C Standard Library. E a biblioteca do C é integrada na Standard Library do C++ através da criação de um header file com o mesmo nome do ficheiro C mas sem extensão e com a letra "c" adicionada ao início do ficheiro. É dentro desse header file que está então uma directiva "#include <stdlib.h>" (aí sim, estará a incluir um ficheiro que existe com extensão .h).

Como é que podes ver isto com o Visual Studio? É fácil...

No código que temos estado a escrever, na linha da directiva #include clica com o botão direito do rato no texto "cstdlib". Do menu que aparece clica no item "Open Documento <cstdlib>". Não alteres este ficheiro!

Repara no nome do ficheiro que foi aberto. É apenas cstdlib. Não é cstdlib.h ou cstdlib.hpp. Esta é a header C++. Agora olha para o código. Na linha 13 ou perto dela verás "#include <stdlib.h>". É aqui que o header C++ está a incluir o header C. Pode fechar este ficheiro.

Portanto tu incluis sempre a versão C++ da Standard Library. Não incluis o ficheiro stdlib.h, mas sim o ficheiro cstdlib (o ficheiro C sem extensão e com a letra "c" adicionada ao início). Poderás ver na internet todo o tipo de código: Programas C++ que incluem "stdlib.h" ou <stdlib.h>. Mas agora sabes melhor. E sabes que quem fez isso está a fazê-lo mal.

E pronto. Já sabes mais ou menos como a standard library deve ser usada em termos da directiva #include. Espero que tenha sido claro. Existe uma razão para toda esta complicação que vamos discutir em breve quando te falar de uma coisa chamada namespace. Mas o pior já passou e a partir de agora será mais código e menos conversa.

Com o tempo vais te habituar à Standard Library e serás mesmo capaz de dizer todos os headers files que a compõem de trás para a frente. Leva o seu tempo. Mas a bibliografia no fim deste tutorial vai dar-te algumas dicas também...

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

4.c Sair da aplicação

Ora, como disse mais acima, vamos então simplificar o código anterior. Afinal se EXIT_SUCCESS vai ser substituído por 0 ainda antes da compilação, então o que vem a seguir faz todo o sentido, certo? E assim nem precisamos do #include.


int main() {

    return 0;
}

Como foi referido anteriormente EXIT_SUCCESS é definido como sendo 0. Agora imaginemos, que em vez do Visual Studio, estamos a utilizar outro compilador, por exemplo em um outro sistema operativo, onde o valor para indicar que a aplicação terminou normalmente não é 0, mas 1.

Para respeitar o comportamento desse sistema operativo, o header <stdlib> onde EXIT_SUCCESS está definido teria uma linha com #define EXIT_SUCCESS 1 em vez de #define EXIT_SUCCESS 0. O que aconteceria ao nosso código que acabámos de alterar? Como deve ser fácil de perceber nunca devolveria ao sistema operativo a indicação de que terminou normalmente. Portanto o nosso programa comportava-se de forma diferente ou daria mesmo erro durante a compilação ou durante a execução neste sistema operativo. Por outras palavras não era portável para esse sistema operativo.

Ou seja, de repente EXIT_SUCCESS começa a fazer sentido, não começa? Ou seja, escreve-se mais e tem que que se incluir um header da Standard Library mas começas a perceber a razão de porquê este trabalho. É que assim garantimos que o nosso código seja portável para qualquer outro compilador ou sistema operativo que respeite o Standard C++ e portanto inclua <stdlib> e defina EXIT_SUCCESS.

É assim com EXIT_SUCCESS e muitos outras constantes e restantes identificadores na Standard Library do C++. Existem para garantir que o código compile se este for escrito para o Standard C++. Cabe aos fabricantes do compilador implementar estes headers de acordo com o Standard.

No entanto, mesmo assim vamos manter o código como está agora. Porquê?

Acontece que o Standard C++ também define que quando a função main() devolve 0 o compilador deve alterar este valor para o que quer que seja que o sistema operativo entende como a aplicação ter terminado normalmente. Portanto, para o caso acima, o tal compilador fictício iria alterar 0 para 1. O Standard C++ (faz parte da bibliografia no fim deste tutorial) é um documento longo e complexo que só será possível entender em pleno quando já tiveres alguma experiência com a linguagem. Nem sempre de leitura fácil, é no entanto o documento que serve de base para a construção de um compilador C++.

Este documento define toda a linguagem de programação e as suas regras. É também de importante leitura por parte de um programador a partir de certa fase de aprendizagem porque possibilita ao programador saber se o seu código respeita os standards ou não e se portanto é código que pode ser reaproveitado por outros compiladores e até mesmo diferentes sistemas operativos. No nosso caso, à partida retirar EXIT_SUCCESS parecia significar que estávamos a limitar o alcance do nosso código. Mas acontece que o Standard tem uma disposição que nos permite fazer esta alteração.

EXIT_SUCCESS não é no entanto uma redundância. Pelo contrário, continua ainda a ser possivelmente a melhor solução. Um compilador que não implemente a regra da função main() agora descrita, de certo implementará EXIT_SUCCESS. No entanto tal compilador não respeita o Standard, pelo que não será um compilador a ter como referência.

4.d Ouput para o ecrã e o namespace std

Está na altura de começarmos a escrever código a sério. Vamos começar o nosso programa. Para relembrar o que queremos é uma aplicação que recebe do utilizador um número e o multiplique por 2. Se o utilizador digitar 0, a aplicação termina e sai. Caso contrário pedirá por um novo número.

Vamos começar por informar o utilizador que estamos a pedir que introduza um número e que zero tem um valor especial.


#include <iostream>

int main() {

    std::cout << "\nIntroduza um numero (0 para sair):";

    return 0;

}

cout é um objecto da Standard Library definido em <iostream>. É portanto necessário fazer um include deste header para que o nome seja reconhecido pelo compilador. cout representa o standard output, que no nosso caso é o ecrã.

O que o código acima está a fazer é emitir para o ecrã uma linha em branco seguida pela string "Introduza um numero (0 para sair):". A string começa com "\n". Estes dois caracteres definem uma escape sequence. Uma escape sequence permite-nos introduzir caracteres numa string que não são possíveis de representar no ecrã. "\n" é portanto a escape sequence para uma nova linha. Outras escape sequences existem, como "\t" para um tab. Uma vez que todas as escape sequences começam pelo caracter "\", se existir a necessidade de introduzir este caracter nas nossas strings, devemos escrever "\\".

"<<" é o operador usado por cout para fazer o output (não confundir com o símbolo "«". << escreve-se digitando duas vezes o símbolo "menor-que" no teu teclado). O que estiver à direita deste operador é enviado para cout, processado e eventualmente enviado para o ecrã.

No código acima o nome cout está a ser utilizado como "std::cout". O operador "::" é conhecido como scope operator e neste caso está a dizer que cout pertence ao namespace std.

Em C++ um namespace é essencialmente um mecanismo para expressar associações lógicas (ou unidades lógicas). Se um nome está associado a outro, poderá ser desejável incluir ambos dentro de um namespace. A Standard Library coloca a maioria dos seus nome no namespace std. Para usar o cout precisamos de algum modo referir que queremos usar aquele que está definido dentro desse namespace. Temos três formas de o fazer. A primeira já vimos. As outras duas são usando uma using directive ou uma using declaration.


#include <iostream>

using namespace std; // using directive

int main() {

    cout << "\nIntroduza um numero (0 para sair):";

    return 0;

}


#include <iostream>

int main() {

    using std::cout; // using declaration

    cout << "\nIntroduza um numero (0 para sair):";

    return 0;

}

A using directive nunca deve ser usada quando está a servir para introduzir nomes declarados do namespace std. É frequente ler código com "using namespace std;". Serve, segundo os seus autores para simplificar o seu código e não terem que estar constantemente a digitar "std::" atrás de cada nome da standard library. O C++ não é uma linguagem de programação para preguiçosos; terão que procurar noutro lugar. O namespace é, apesar da sua aparente simplicidade, uma ferramenta muito poderosa de code composition que para projectos de médias e grandes dimensões proporcionará ao programador uma forma de melhor organizarem os seus nomes e expressarem o seu código. Nesse contexto, poderá ser desejável usar uma using directive. Mas para o namespace std, nunca. A using directive introduz todos os nomes declarados no namespace no scope em que é usado. Portanto no caso acima, o que se está efectivamente a fazer é derrotar todo o namespace std introduzindo os seus nomes no global scope do programa.

Eu compreendo que poderás não estar a entender tudo o que estou para aqui a dizer. Por exemplo nem sequer expliquei o que é um scope. Mas a ideia de todo este tutorial é de servir como referência para certos aspectos da programação menos discutidos em livros e outros tutoriais e não ensinar a programar em C++. Poderás usar esta informação como suporte ao que estiveres a aprender por um livro ou tutorial na internet.

A using declaration é outra forma, mais benigna no contexto do namespace std, de introduzir nomes no scope. O segundo exemplo mostra uma using declaration que introduz apenas o nome cout. Reparas também que a coloquei dentro da função main() e não do lado de fora como no caso da using directive. Assim a using declaration só será reconhecida dentro da função main(), qualquer outra função não terá acesso a esta declaração e terá que ou criar a sua, ou usar std::cout. A using declaration introduz um sinónimo no scope em que é usada, permitindo usar cout sem nos referirmos explicitamente ao namespace std.

Por fim existe a terceira forma que é a que vimos no princípio; explicit qualification. Usar std::cout. Esta é a forma mais desejável para lidarmos com nomes declarados no namespace std que são os que compõem a Standard Library. Tanto as using directives como as declarations podem ser usadas dentro do corpo de um função em vez de no global scope (fora de qualquer função). No que diz respeito ao namespace std, o conselho é sempre usar dentro de uma função e nunca no global scope. Mas o ideal mesmo, é habituares-te em muitos casos a escrever "std::". Não custa nada.

Já agora, lembras-te de falarmos de uma razão por detrás de toda aquela complicação com as directivas #include da Standard Library? Pois bem, uma das razões é a de o C++ colocar todos os nomes das C Library definidos em ficheiros com a extensão h, dentro do seu namespace std. Assim, para cada ficheiro header da C Library, existe um ficheiro com o mesmo nome, acrescido da letra "c" no início e sem extensão que em muitos casos a única coisa que faz é introduzir os nomes declarados nesse ficheiro da C Library no namespace std.

4.e Compilar e testar o código

Já sabes o que é um "build" e quais os passos para efectuar um; pré-processamento, compilação e linkagem. Vamos agora fazer um build da nossa aplicação.

No Menu do editor existe um item convenientemente chamado de "Build". Se clicares nesse item, o submenu mostrará várias opções de build. As três primeiras referem-se à Solução -- que é, se bem te lembras, um conjunto de projectos que podes ter abertos ao mesmo tempo e que de algum modo estão relacionados entre si. Uma vez que não vamos utilizar Soluções neste tutorial e para todos os efeitos estes items servem também para compilar uma Solução que só tem um projecto, é nestes três que nos vamos concentrar.

A primeira opção "Build Solution" faz o build completo do nosso projecto. Vamos clicar aí. Enquanto o build decorre verás no fundo do ecrã ou resultado do build. Se tudo correr bem, como deverá, a última linha irás ler qualquer coisa como "Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped". Na penúltima linha estará qualquer coisa como "FirstApp - 0 error(s), 0 warning(s)".

Esta penúltima linha do resultado do build informa-nos do número de erros e warnings gerados pelo build. Idealmente quererás ter 0 em ambos. Um ou mais erros interromperá sempre o build pelo que o ficheiro executável não será gerado. Mas o build prosseguirá sempre com 1 ou mais warnings.

Para testarmos o executável, existem duas coisas que poderemos fazer. A ideal, e porque isto é um executável que vai correr na consola do Windows, é ires ao teu menu Start do Windows (ou Iniciar se o Windows estiver em Português) e clicares no item "Run..." (não sei qual é o nome em Português. Provavelmente "Executar..." ou "Correr..."). Depois escrever "cmd" (sem as aspas) na caixa de diálogo que aparece e clicar em Ok.

Aparecerá uma janela da consola do windows. Deves então navegar para o directório onde tens o teu projecto e, uma vez aí dentro, deverás navegar para o directório "Debug" que foi criado quando fizeste o build pela primeira vez. Se o build tivesse sido efectuado em modo Release (o que iremos fazer quando terminarmos o nosso projecto), o executável encontra-se não no directório "Debug", mas sim no directório "Release". Este último não existe ainda porque não fizemos ainda nenhum build em modo Release. Ficará para mais adiante.

Uma vez dentro do directório Debug, basta só correr o executável FirstApp.exe que nós criámos ainda aora quando fizemos o build. Parabéns, tens o teu primeiro programa inteiramente desenvolvido em C++!

Outra forma de testar o código é clicar nos items "Start Debugging..." ou "Start Without Debugging..." do menu "Debug" (à direita do menu "Build"). Ou ainda clicares na seta verde na barra de ferramentas imediatamente à esquerda da listbox que lê "Debug".

Esta últimas serão as forma mais convenientes, mas irás reparar que verás a janela da consola aparecer por uns segundos e depois desaparecer sem teres tido tempo de ver o resultado do teu trabalho. Isto acontece porque no Windows, a consola termina imediatamente após o programa que a chamou tiver terminado. Para evitares que isso aconteça, terás que criar no código alguma forma de garantires que a janela se mantém activa. Por exemplo, o programa só termina quando o utilizador clicar nas tecla "enter" ou "return". Há medida que vamos avançando no nosso projecto verás outra forma, mas por enquanto vamos então alterar o nosso código para incluir esta funcionalidade.


#include <iostream>

int main() {

    std::cout << "\nIntroduza um numero (0 para sair):";

    std::cout << "\nPrima Enter ou Return para sair...";
    std::cin.get();

    return 0;

}

Se agora compilares e testares o código através do Visual Studio, verás que a janela não se fecha, mas antes fica à espera que primas uma das teclas "Enter" ou "Return". Verás também frequentemente system("pause") em vez de std::cin.get(). Não quero entrar em grande debate sobre isto. Escolhe a que gostares mais -- system("pause") tem a vantagem de não precisares de escrever o texto informativo que vês ali -- mas não te esqueças nunca que system("pause") só funciona em Windows e é perigoso porque alguém pode colocar por exemplo um ficheiro chamado pause.exe no directório onde a tua aplicação está a correr e será esse ficheiro que será chamado em vez do pause do sistema. Se esse ficheiro formatar todo o teu disco...

Com system() ficará assim:


#include <iostream>

int main() {

    std::cout << "\nIntroduza um numero (0 para sair):";

    std::cout << std::endl;
    system("pause");

    return 0;

}

Nota que coloquei uma linha antes de system("pause") porque o texto informativo é enviado para o ecrã sem uma linha no início. "std::endl" é um manipulador. Existem vários manipuladores, alguns bastante úteis até. Este apenas cria uma nova linha. Equivalente a escrever std::cout << "\n";

NOTA: Continua no próximo post

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!


Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.


Entrar Agora