Desenvolvendo Aplicativos Usando o C

Prévia do material em texto

Desenvolvendo Aplicativos Usando o C/C++ Development Toolkit do Eclipse
Criando um aplicativo C++ usando a Standard Template Library e o CDT
Quando a maioria das pessoas pensa em "Eclipse", elas pensam em "Java™ IDE". O Eclipse é muito mais. Com os plug-ins apropriados, pode-se usar o Eclipse para funcionar com PHP, Ruby e Groovy, C e C++. Neste artigo, o C/C++ Development Toolkit (CDT) do Eclipse é introduzido. Construímos um aplicativo simples em C++ usando o CDT e a Standard Template Library (STL) do C++ para simplificar o processo e tirar proveito de alguns dos potentes recursos de C++.
0 Comentários
Michael Galpin, Software architect, Ludi Labs
10/Jul/2007
Índice
Desenvolva e implemente seu próximo aplicativo na plataforma de cloud do IBM Bluemix.
Comece seu
trial gratuito
Este artigo, que é uma sequência de " Desenvolvimento de C/C++ com a Plataforma Eclipse", destina-se a desenvolvedores de C++ que desejam aprender o desenvolvimento de C++ usando o CDT do Eclipse. Um aplicativo C++ simples é desenvolvido no artigo. O aplicativo usa a STL do C++. Os leitores devem estar familiarizados com a STL, assim como com os princípios básicos de programação orientada a objetos, como herança e polimorfismo. Uma familiaridade com o Eclipse será útil, mas não é necessária.
Antes de Iniciar
É necessário instalar o seguinte:
Eclipse
Estamos usando o CDT, que é um plug-in do Eclipse, portanto, é lógico que você precisa do Eclipse. O artigo usa o Eclipse V3.2.
Java Runtime Environment
Estamos construindo um aplicativo C++, mas estamos usando o Eclipse. O Eclipse é um aplicativo Java em si, portanto, precisa de um Java Runtime Environment (JRE). O artigo usa o Eclipse V3.2, que requer um JRE da V1.4 ou superior. Se quiser usar o Eclipse também para desenvolvimento de Java, precisará de um Java Development Kit (JDK).
C/C++ Development Toolkit (CDT) do Eclipse
Este artigo é sobre o CDT, portando precisará dele, é claro. Leia um arquivo do developerWorks de 2003 intitulado " Desenvolvimento de C/C++ com a Plataforma Eclipse." para obter instruções sobre como instalar o CDT em versões anteriores do Eclipse.
Cygwin
Se você estiver usando o Microsoft Windows®, você achará o Cygwin — que fornece um ambiente semelhante ao Linux®no Windows — útil.
Ferramentas de Desenvolvimento GNU C/C++
O CDT usa as ferramentas GNU C/C++ padrão para compilar seu código, construindo seu projeto e depurando os aplicativos. Essas ferramentas são GNU Compiler Collection (GCC) para C++ (g++), make e GNU Project Debugger (GDB). Se você for um programador que está usando Linux ou Mac OS X, há uma boa chance de essas ferramentas estarem instaladas em sua máquina. O artigo contém instruções para configurar essas ferramentas para o Windows.
Voltar para parte superior
O CDT do Eclipse
O CDT do Eclipse é um plug-in do Eclipse que transforma o Eclipse em um potente C/C++ IDE. Foi projetado para trazer muitos dos ótimos recursos do Eclipse desfrutados pelos desenvolvedores de Java para desenvolvedores de C/C++, como gerenciamento de projeto, depuração integrada, assistentes de classe, construções automatizadas, coloração de sintaxe e conclusão de código. Quando o Eclipse é usado como Java IDE, ele usa e integra-se ao JDK. De forma semelhante, o CDT usa e integra-se a ferramentas C/C++ padrão, como g++, make e GDB. Isso levou à sua popularização no Linux, onde essas ferramentas estão prontamente disponíveis e são usadas para a maior parte do desenvolvimento de C++. O CDT pode ser configurado no Windows para usar as mesmas ferramentas. Há também um esforço contínuo para fazer com que o CDT funcione com as ferramentas C++ da Microsoft para torná-lo ainda mais atraente para desenvolvedores do C++ para o Windows.
Voltar para parte superior
Instalando o CDT
Começamos supondo que você tenha instalado o Eclipse e possa executá-lo. Caso contrário, consulte o Web site do Eclipse para ativá-lo e executá-lo. Vamos instalar o CDT. O CDT é um plug-in do Eclipse, portanto, usa o recurso Atualizações de Software do Eclipse. Selecione Ajuda > Atualizações de Software > Localizar e Instalar.
Figura 1. Atualizações de Software do Eclipse
Em seguida, você deve escolher Procurar para os novos recursos a instalar.
Figura 2. Procurar Novos Recursos
Se você estiver usando uma nova versão do Eclipse, os sites de descoberta Callisto ou Europa devem ser incluídos. (Nota do Editor: Como este documento foi escrito em abril de 2007, o release do Europa ainda estava nos estágios de planejamento. No entanto, espera-se que a instalação do Europa seja semelhante à do Callisto.) Simplesmente selecione-o e clique em Concluir.
Figura 3. Callisto Discovery Site
O Eclipse pode pedir que você escolha em uma lista de sites espelho para o Callisto Discovery Site. Escolha o que parecer mais próximo de você. Você deve ver uma lista de plug-ins do Callisto Discovery Site. Você deve selecionar Desenvolvimento de C e C++ e clicar em Avançar.
Figura 4. Plug-ins Disponíveis do Callisto
Será solicitado que você aceite a licença do CDT. Depois de fazer isso, você pode clicar em Avançar. Você verá um resumo do que irá ser transferido por download e instalado. Simplesmente clique em Concluir.
Figura 5. Download e Resumo da Instalação
O Gerenciador de Atualizações do Eclipse fará download, então, do plug-in do CDT do site espelho selecionado anteriormente. O CDT tem um total de aproximadamente 11 MB, portanto, isso pode levar alguns minutos, dependendo da velocidade de sua conexão da Internet. Depois de ter sido feito download de tudo, será solicitado que você confirme que deseja instalar os novos recursos. Clique em Instalar Tudo.
Figura 6. Confirmar Instalação
Após concluir a instalação do CDT, será solicitado que você reinicie o Eclipse. Faça isso. Assim que o Eclipse for reiniciado, o CDT estará pronto.
Voltar para parte superior
Configuração do Windows
Se você estiver executando o Eclipse no Linux ou Mac OS X, você estará pronto para usar o CDT para desenvolver um aplicativo C++. Se estiver no Windows, pode haver algumas etapas adicionais. Conforme mencionado, o CDT depende das ferramentas de desenvolvimento padrão GNU C++: g++, make e GDB. Elas geralmente estão incluídas no Linux ou Mac OS X. Geralmente não estão incluídas no Windows. Mas não se preocupe. Essas ferramentas podem ser facilmente instaladas no Windows. Provavelmente a maneira mais fácil seja instalando o Cygwin. O Cygwin fornece um ambiente semelhante ao Linux no Windows (consulte Recursos). Ao instalar o Cygwin, será solicitado que você escolha os pacotes que deseja instalar. Certifique-se de ir para a seção de desenvolvimento e selecione gcc: g++, make e GDB. Isso fará com que seus pré-requisitos sejam instalados também.
Quando tiver terminado de instalar o Cygwin, será necessário incluir g++, make e GDB em seu caminho. A maneira mais fácil de fazer isso é incluir o diretório bin do Cygwin em seu caminho, já que é onde g++, make e GDB podem ser localizados. Quando isso for feito, reinicie o Eclipse.
Voltar para parte superior
Jogando na Loteria
Neste ponto, deveríamos estar prontos para iniciar o desenvolvimento de nosso aplicativo com CDT. Vamos pausar para descobrir o que queremos desenvolver. O aplicativo de amostra é um programa simples da linha de comando para gerar números da loteria. Muitos estados têm loterias e as regras variam muito. Vamos permitir que o usuário selecione para qual loteria estadual ele deseja gerar números. Isso fornecerá uma boa maneira para usar suporte do C++ para comportamento polimórfico.
Voltar para parte superior
Criando o Projeto
O Eclipse usa os conceitos de perspectivas para permitir diversos plug-ins para customizar seus comandos e visualizações. O Eclipse começa, por padrão, na perspectiva Java. O CDT inclui sua própria perspectiva, portanto, vamos alternar para ela. Para fazer isso, selecione Janela > Abrir Perspectiva > Outro. Você deve ver uma lista de perspectivas disponível para você. Selecione a perspectiva C/C++ e cliqueem OK.
Figura 7. Selecionar a Perspectiva C/C++
O Eclipse agora deve ter aparência semelhante à Figura 8.
Figura 8. A Perspectiva C/C++
O Eclipse organiza seu código em projetos, portanto, você irá querer criar um novo projeto. Selecione Arquivo > Novo > Projeto Make C++ Gerenciado.
Figura 9. Novo Projeto C++
Você pode ter observado que havia diversas opções diferentes para o projeto. Queríamos um projeto C++. Selecionamos um "Make Gerenciado", já que isso permitirá que o Eclipse crie o arquivo make. Você pode selecionar uma opção "Make Padrão" e escrever seu próprio arquivo make. Agora, devemos estar no assistente Novo Projeto, onde denominaremos nosso projeto Lottery e clicaremos em Concluir.
Isso criará um projeto vazio, que você deve ver na janela Projetos C/C++. Clique com o botão direito do mouse no projeto e selecione Novo > Pasta de Origem . Isso ativará o assistente "Nova Pasta de Origem", onde denominaremos nossa pasta src e clicaremos em Concluir.
Voltar para parte superior
Loteria Básica
Estamos prontos para iniciar a criação de algum código. Vamos iniciar a criação do executável de nosso aplicativo. Clique com o botão direito do mouse na pasta de origem que acabamos de criar e selecione Novo > Arquivo de Origem, conforme mostrado na Figura 10.
Vamos criar um método main vazio por hora. Ele é apenas um marcador; vamos incluir mais nisso após termos criado o resto de nosso projeto.
int main() {
 return 0; }
Salve seu projeto e o Eclipse fará isso para você automaticamente. Você deve ver alguma saída no console indicando que foi compilado com êxito.
Estamos prontos para criar nossa primeira classe. Clique com o botão direito do mouse na pasta de origem que acabamos de criar e selecione Novo > Classe.
Figura 10. Nova Classe
Isso deve ativar o assistente Nova Classe. Vamos dar à nossa classe um namespace lotto e vamos chamar nossa classe Lottery.
Figura 11. Classe Lottery
O Eclipse agora irá criar stubs para sua classe. O CDT faz muitas coisas boas para você. Gera as diretivas do compilador apropriado no arquivo de cabeçalho. Estimula boas práticas gerando arquivos de interface (Lottery.h) e implementação (Lottery.cpp) separados. Estimula uma outra boa prática tornando o destruidor de sua classe virtual. Você pode inserir o código de origem para essas classes conforme visto nas Listagens 1 e 2.
Lista 1. Lottery.h
#ifndef LOTTERY_H_
#define LOTTERY_H_
#include <string>
#include <sstream>
#include <cstdlib>
#include <time.h>
using namespace std;
namespace lotto
{
class Lottery
{
 protected:
 int ticketSize, maxNum;
 int* generateNumbers();
public:
 Lottery(int,int);
 virtual ~Lottery();
 virtual string printTicket();
};
}
#endif /*LOTTERY_H_*/
A Lista 2 mostra o arquivo de implementação para a classe Lottery .
Lista 2. Lottery.cpp
#include "Lottery.h"
namespace lotto
{
Lottery::Lottery(int size, int num)
{
 this->ticketSize = size;
 this->maxNum = num;
}
Lottery::~Lottery()
{
}
int* Lottery::generateNumbers()
{
 int* allNums = new int[this->maxNum +1];
 for (int i=0; i <= this->maxNum ; i++)
 {
 allNums[i] = 0;
 }
 int* nums = new int[this->ticketSize];
 for (int i=0; i < this->ticketSize; i++)
 {
 int val = 1 + rand() % (this->maxNum);
 if (allNums[val])
 {
 i--;
 }
 else
 {
 nums[i] = val;
 allNums[val] =1;
 }
 }
 return nums;
}
string Lottery::printTicket()
{
 ostringstream str;
 int* nums = this->generateNumbers();
 for (int i=0;i< this->ticketSize; i++)
 {
 str << *nums << ' ';
 nums++;
 }
 return str.str();
}
}
O que esse código está fazendo? Bem nossa classe Lottery possui dois atributos. O atributo ticketSize é o número de números do bilhete de loteria. O maxNum é o número máximo no bilhete. Posteriormente, vamos usar a loteria do estado da Flórida como exemplo. Lá, você escolhe seis números de 1 a 53, portanto, ticketSize seria 6 e maxNum seria 53.
O método generateNumbers gera uma array de números correspondente aos números de um bilhete de loteria. Usa a função rand() da STL para gerar números aleatoriamente. Uma array allNums é usada para acompanhar quais números foram gerados até o momento, de forma que possamos assegurar que um número duplicado não seja obtido em seu bilhete. Por fim, printTicket() cria uma representação de string de nosso bilhete.
Ao salvar os arquivos, o Eclipse constrói seu projeto automaticamente. Novamente, se você salvar o projeto, deve ser compilado e você deverá ver mensagens de compilação no console, conforme mostrado na Lista 3.
Lista 3. Saída do Compilador no Console
**** Construção da Depuração da configuração para o projeto Lottery ****
make -k all
Building file: ../src/Main.cpp
Invoking: GCC C++ Compiler
g++ -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"src/Main.d" -MT"src/Main.d"
-o"src/Main.o" "../src/Main.cpp"
Finished building: ../src/Main.cpp
Building target: Lottery
Invoking: MacOS X C++ Linker
g++ -o "Lottery" ./src/Lottery.o ./src/Main.o
Finished building target: Lottery
Build complete for project Lottery
Voltar para parte superior
Classe MegaLottery
Você pode ter percebido que tornamos o método printTicket() virtual quando foi declarado no arquivo de cabeçalho. Isso permitirá que determinemos a subclasse de Lottery e substituamos o método. Queríamos fazer isso porque alguns estados têm uma loteria com um número "mega". Esse é um número sorteado separadamente que qualquer bilhete deve corresponder além dos outros números sorteados. Vamos criar uma classe MegaLottery para esses estados que determinarão a subclasse de Lottery.
Mais uma vez, clique com o botão direito do mouse em sua pasta de origem e selecione Novo > Classe, como fizemos anteriormente. Desta vez, no assistente Nova Classe, vamos declarar nossa nova classe no mesmo namespace, mas chame-a de MegaLottery.
Figura 12. Classe MegaLottery
Para determinar a subclasse de Lottery, selecione o botão Incluir ao lado da seção Classes Base. Ativará o diálogo Escolher Classe Base. Você pode começar a digitar o nome da classe e o Eclipse limitará a lista de candidatas a classe base rapidamente. Você deve selecionar Lottery e clicar em OK.
Figura 13. Escolher Classes Base
Podemos inserir o código para MegaLottery, conforme mostrado nas Listagens 4 e 5.
Lista 4. MegaLottery.h
#ifndef MEGALOTTERY_H_
#define MEGALOTTERY_H_
#include "Lottery.h"
using std::string;
namespace lotto
{
class MegaLottery : public lotto::Lottery
{
 protected:
 int maxMegaNum;
public:
 MegaLottery(int,int,int);
 virtual ~MegaLottery();
 string printTicket();
};
}
#endif /*MEGALOTTERY_H_*/
A Lista 5 mostra o arquivo de implementação para a classe MegaLottery .
Lista 5. MegaLottery.cpp
#include "MegaLottery.h"
using namespace std;
namespace lotto
{
MegaLottery::MegaLottery(int ticketSize, int maxNum, int maxMegaNum) :
 Lottery(ticketSize,maxNum)
{
 this->maxMegaNum = maxMegaNum;
}
MegaLottery::~MegaLottery()
{
}
string MegaLottery::printTicket()
{
 ostringstream tick;
 tick << Lottery::printTicket() << " Mega: ";
 int mega = 1 + rand() % this->maxMegaNum;
 tick << mega;
 return tick.str();
}
}
A diferença principal entre Lottery e MegaLottery é que MegaLottery tem um atributo extra maxMegaNum. Esse é o valor máximo que o número mega pode aceitar. Substitui o método printTicket() . Usa a classe base para gerar a primeira parte do bilhete, em seguida, gere o número mega e anexe-o à representação da string do bilhete.
Só precisamos de uma maneira para criar as diversas loterias. Vamos usar uma classe Factory Pattern para fazer isso. Faremos isso incluindo uma classe LotteryFactory . Queremos que todas Lotteries venhamdo mesmo factory, portanto, tornaremos LotteryFactoryum singleton. O código para ele está nas Listagens 6 e 7.
Lista 6. #ifndef LOTTERYFACTORY_H_
#define LOTTERYFACTORY_H_
#include "Lottery.h"
namespace lotto
{
class LotteryFactory
{
public:
 enum State { California, Florida };
 static LotteryFactory* getInstance();
 Lottery* getLottery(State);
private:
 LotteryFactory();
};
}
#endif /*LOTTERYFACTORY_H_*/
A Lista 7 mostra o arquivo de implementação para a classe LotteryFactory .
Lista 7. LotteryFactory.cpp
#include "LotteryFactory.h"
#include "MegaLottery.h"
namespace lotto
{
LotteryFactory::LotteryFactory()
{
 srand(time(NULL));
}
Lottery* LotteryFactory::getLottery(State s)
{
 if (s == LotteryFactory::California)
 {
 Lottery* lotto = new MegaLottery(5,47,27);
 return lotto;
 }
 else
 {
 Lottery* lotto = new Lottery(6,53);
 return lotto;
 }
}
LotteryFactory* LotteryFactory::getInstance()
{
 static LotteryFactory instance;
 return &instance;
}
}
A LotteryFactory tem uma enumeração dos diferentes tipos de loterias. Colocamos somente Flórida e Califórnia no exemplo, mas não deveria ser difícil incluir quantas quiser. O construtor do LotteryFactory determina o valor inicial da função rand() usada por nossas classes de loteria. Precisamos apenas implementar o método main de nosso executável.
Lista 8. Main.cpp
#include <iostream>
#include "LotteryFactory.h"
using namespace lotto;
int main()
{
 LotteryFactory* factory = LotteryFactory::getInstance();
 cout << "What lottery do you want to play?" << endl;
 cout << "(1) California, (2) Florida" << endl;
 int cmd;
 scanf("%d", &cmd);
 Lottery* lotto = 0;
 switch (cmd)
 {
 case 1 :
 lotto = factory->getLottery(LotteryFactory::California);
 break;
 case 2 :
 lotto = factory->getLottery(LotteryFactory::Florida);
 break;
 default :
 cout << "Sorry didn't understand that" << endl;
 }
 cout << "Ticket: " << lotto->printTicket() << endl;
 delete lotto;
 return 0;
}
Voltar para parte superior
Executando o Programa
Estamos prontos para a execução de nosso programa. Selecione Executar > Executar.
Figura 14. Escolher Classes Base
Selecione Aplicativo Local C/C++ e clique no botão Novo .
Figura 15. Novo Perfil de Execução C/C++
Isso ativará a interface Criar Configuração de Execução para o projeto Lottery. Será necessário selecionar seu executável clicando no botãoProcurar Projeto .
Figura 16. Procurar Executável no Projeto
Você pode selecionar o binário que o Eclipse criou para você e clicar em OK.
Figura 17. Procurar Executável no Projeto
Simplesmente clique em Executar e o programa deve ser executado em seu console. O código abaixo mostra alguma saída de amostra.
What lottery do you want to play?
(1) California, (2) Florida
2
Ticket: 12 28 24 15 35 22
Voltar para parte superior
Depurando o Programa
Nosso programa deve ser bem executado, mas vamos dar uma olhada na depuração do aplicativo. Primeiro, crie um ponto de interrupção em nosso código. Escolha uma linha e clique com o botão direito do mouse ao lado dela e selecione Alternar Ponto de Interrupção.
Figura 18. Criar Ponto de Interrupção
Precisamos criar uma configuração de depuração, de forma bem semelhante à criação da configuração de execução. Selecione Executar > Depurar.
Figura 19. Criar Configuração de Depuração
Isso deve ativar a Configuração de Depuração. Isso é baseado na Configuração de Execução e não deve ser necessário alterar nada. Simplesmente clique em Depurar.
Figura 20. Configuração de Depuração
Assim que o depurador iniciar, solicitará que você alterne para a perspectiva Depurador. Faça isso. Observe que na configuração configuramos coisas para serem interrompidas automaticamente na inicialização de nosso método principal. Assim, o depurador deve ser interrompido imediatamente e você deve ver uma tela semelhante à Figura 21.
Figura 21. O Depurador
Voltar para parte superior
Resumo
Construímos e depuramos nosso aplicativo de loteria. É possível incluir facilmente mais esquemas de loteria no mesmo. Alguns desses poderiam envolver subclasses adicionais. CDT facilita mais do que nunca a criação dessas classes e as hierarquias de classes e a execução e depuração aplicativo para testá-lo.