Nós já desenvolvemos muitos aplicativos C++ Standard com saída para o console e no post anterior desenvolvemos um aplicativo C++ Visual usando diretamente a API do Windows para criar a GUI, agora vamos utilizar o método predefinido pela Microsoft para programação C++ em Windows, visto que também é possível utilizar o Framework e desenvolver aplicativos C++ usando o CLR. A seguir vamos saber mais sobre estes assuntos e sobre programação C++ para Windows.
.NET Framework
Microsoft .NET é uma iniciativa da empresa Microsoft, que visa uma plataforma única para desenvolvimento e execução de sistemas e aplicações. Todo e qualquer código gerado para .NET pode ser executado em qualquer dispositivo que possua um framework de tal plataforma. Com ideia semelhante à plataforma Java, o programador deixa de escrever código para um sistema ou dispositivo específico, e passa a escrever para a plataforma .NET.
O .NET Framework é um conceito central no Visual Studio, bem como em todos os outros produtos de desenvolvimento da Microsoft .NET. O .NET Framework é composto de dois elementos: o Common Language Runtime (CLR ), em que o aplicativo é executado em um conjunto de bibliotecas chamado bibliotecas de classes do .NET Framework . As bibliotecas de classe Framework .NET fornecem o apoio funcional para o seu código e será necessário durante a execução do CLR , independente da linguagem de programação assim utilizada nos programas escritos em C++ , C#, ou qualquer das outras línguas que suportam o . NET Framework todos usam a mesma biblioteca .NET.
Existem dois tipos fundamentalmente diferentes de aplicativos C ++ que você pode desenvolver com o Microsoft Visual C++. Você pode escrever aplicações que executam nativamente em seu computador. Estas aplicações serão referidas a programas como C++ nativo , você escrever programas C++ nativo na versão do C++ definida pela ISO/IEC (International Standards Organization e International Electrotechnical Commision ), este é o padrão da linguagem.
Você também pode escrever aplicativos para serem executados sob o controle do CLR em um versão estendida do C++ chamado C++/CLI. Estes programas irão ser encaminhados para programas como CLR , ou programas C++/CLI.
O NET Framework não é estritamente parte do Visual C++, mas sim um componente do Sistema operacional Windows que torna mais fácil construir aplicações de software e serviços web.
O .NET Framework oferece vantagens substanciais em termos de viabilidade e segurança do código , bem como a capacidade de integrar o seu código C++ com código escrito em mais de 20 outras linguagens de programação que são alvo do .NET Framework. Uma ligeira desvantagem de segmentação do .NET Framework . É que não há uma penalidade de desempenho pequeno em comparação com código nativo, mas você não consegue perceber isso na maioria das circunstâncias ou seja quando você precisa de um desempenho maior é preciso usar código C++ nativo.
CLR
O Common Language Runtime (CLR) é um ambiente padronizado para a execução de programas escritos em uma ampla gama de linguagens de alto nível.
Em C++ o caderno de especificações da CLR está agora incorporada nos Fabricantes European Computer Manufacturers (ECMA) para o Common Language Infrastructure (CLI), o ECMA – 335, e também na norma ISO equivalente, ISO/IEC 23271, de modo que o CLR é uma aplicação do presente padrão.
O CLI é, essencialmente, um caderno de especificações para um ambiente de uma máquina virtual que permite que os aplicativos escrito em diversas linguagens de programação de alto nível sejam executados em sistema de diferente ambientes sem que o código fonte original seja alterado ou replicado. As especificações CLI referem se a uma linguagem intermediária padrão para a máquina virtual com uma linguagem de alto nível onde o código-fonte é compilado. Com o .NET Framework, esta linguagem intermediária é conhecida como Microsoft Intermediate Language (MSIL). Código na linguagem intermediária é finalmente mapeado para código de máquina pelo Just-in-time (JIT) quando você executa um programa. Claro que, o código na linguagem intermediária CLI pode ser executado em qualquer outro ambiente que tenha uma implementação CLI.
C++ no Windows
Você tem duas opções básicas para aplicações do Windows: Você pode escrever código que executa com o CLR, e você também pode escrever código que compila diretamente para código de máquina e, portanto, executa nativamente. Para as janelas com base aplicações que visam a CLR, você usa o Windows Forms como a base para a interface gráfica fornecida pelas bibliotecas do .NET Framework. Usando o Windows Forms permite o desenvolvimento GUI rápido, porque você monta a GUI graficamente a partir de componentes padronizados e têm o código gerado automaticamente.
Para executar nativamente o código, você tem várias maneiras de fazer este trabalho. Uma possibilidade é usar o Microsoft Fundation Classes (MFC) para a programação da interface gráfica de usuário para a sua aplicação Windows. O MFC encapsula o Application Programming Interface (API) do sistema operacional Windows para a criação e controle da GUI e facilita muito o processo de desenvolvimento do programa.
A API do Windows se originou muito antes da linguagem C++ chegar ao sistema, por isso não tem nenhuma das características orientada a objetos que seria de esperar se fosse escrito hoje, no entanto, você está não é obrigado a usar o MFC. Se você quer um melhor em desempenho, você pode escrever seu código C++ para acessar a API do Windows diretamente.
Conceitos Windows
Um programa do Windows, se é um programa nativo C++ ou um programa escrito para o CLR, tem uma estrutura diferente daquela do programa típico de console que executa a partir da linha de comando, e é mais complicado. Em um programa de console você pode obter a entrada do teclado e escrever saída de volta para a linha de comando diretamente, ao passo que um programa do Windows pode acessar a entrada e instalações de saída do computador, apenas a título de funções fornecidas pelo ambiente do hospedeiro, não é permitido ter acesso direto aos recursos de hardware. Porque vários programas podem estar ativos de uma só vez no Windows, o Windows determina a aplicação de uma determinada entrada cru, como um clique do mouse ou o acionamento de uma tecla no teclado, é destinado a, e sinalizar o programa em causa. Assim, o sistema operacional Windows tem controle primário de toda comunicação com o usuário.
Windows Messages
Eventos em um aplicativo do Windows são ocorrências como ao usuário clicar com o mouse ou pressionando uma tecla ou se um temporizador atingir zero. O sistema operacional Windows registra cada evento em uma mensagem e coloca a mensagem em uma fila de mensagens para o programa para o qual a mensagem se destina. Assim uma mensagem do Windows é simplesmente um registro dos dados relativos a um evento, e a fila de mensagens para uma aplicação é apenas uma sequência de tais mensagens aguardando para serem processados pela aplicação, por envio de uma mensagem, o Windows pode dizer ao seu programa de que algo precisa ser feito, ou que algum informação tornou-se disponível, ou que um evento como um clique do mouse ocorreu. Se o seu programa está devidamente organizado, ele vai responder de forma adequada à mensagem. Tem muitos tipos diferentes de mensagens e eles podem ocorrer com muita frequência, muitas vezes até por segundo quando o mouse está sendo arrastado, por exemplo.
Um programa do Windows deve conter uma função especificamente para lidar com essas mensagens. a função é muitas vezes chamada WndProc () ou WindowProc (), embora ele não tenha um nome específico porque o Windows acessa a função através de um ponteiro para uma função que você forneceu.
Você passa uma mensagem de volta para o Windows chamando uma função padrão fornecido pelo Windows chamada DefWindowProc (), o que proporciona o processamento de mensagem padrão.
Windows API
Todas as comunicações entre qualquer aplicativo do Windows e o próprio Windows usam o Windows Application Programming Interface, também conhecido como a API do Windows. Isto consiste em, literalmente, centenas de funções que são fornecidos como padrão com o sistema operacional Windows que fornece os meios pelos quais um aplicativo se comunica com o Windows, e vice-versa. A API do Windows foi desenvolvida nos dias em que C foi a principal língua em uso, muito antes do advento do C++, e, por esta razão, as estruturas, em vez de classes são frequentemente utilizadas para a passagem de alguns tipos de dados entre o Windows e o seu programa aplicativo.
A API do Windows abrange todos os aspectos das comunicações entre o Windows e a sua aplicação. Porque há um número tão grande de funções na API, utilizando-as na mão pode ser uma tarefa muito difícil.
Tipos de Dados Windows
O Windows define um número significativo de tipos de dados que são usados para especificar parâmetro de função, tipos e tipos de retorno na API do Windows. Estes tipos específicos do Windows também se propagam através de funções que são definida em MFC.
MICROSOFT FOUNDATION CLASSES
O Microsoft Foundation Classes (MFC) é um conjunto de classes predefinidas sobre a qual a programação Windows com Visual C++ é construída. Estas classes representam uma abordagem orientada a objeto para programação Windows que encapsula a API do Windows. O MFC não cumpri rigorosamente os princípios de orientação a objeto e de encapsulamento e ocultamento de dados, principalmente porque grande parte do código MFC foi escrito antes de tais princípios serem bem estabelecidos.
O processo de escrever um programa do Windows envolve a criação e uso de objetos MFC ou objetos de classes derivadas do MFC. No principal, você vai derivar suas próprias classes de MFC, com assistência considerável a partir das ferramentas especializadas em Visual C++ que tornam este trabalho muito mais fácil.
Como Criar uma Aplicação MFC
O MFC Application utiliza o método da Microsoft de Design Time, o “Design First, Code Later”, o que significa que você desenvolve o design da tela usando a IDE do Visual Studio, colocando os componentes diretamente da ToolBox no Form e pode manipular as propriedades e eventos dos componentes utilizando a janela Properties. Para nossa aplicação MFC utilize a imagem abaixo como referencia de design.
Visual Studio
- No menu Files escolha New Project.
- Na Lista de projetos C++ escolha MFC Application.
- Nomeie o projeto para: Concatenador e clique em OK.
- No Wizard clique em Next.
- Na pagina Application Type escolha: Dialog Based e clique em Finish.
- A IDE abre no modo Design Time, que possibilita você arrastar componentes da ToolBox para o Form aberto.
- Apague os componentes default do form, que são um Static Text e dois Buttons.
- Selecione na ToolBox e coloque no Form os seguintes componentes:
- Um componente Static Text.
- Três componentes Edit Control.
- Um componente Button e mude o seu texto para: Somar.
- Monte a disposição na tela de acordo com a figura acima.
- Clique com o botao direito do mouse em cima do primeiro componente Edit Control e escolha ADD Variable, no Wizard em variable name coloque o nome: texto1 e clique em Finish.
- Clique com o botao direito do mouse em cima do segundo componente Edit Control e escolha ADD Variable, no Wizard em variable name coloque o nome: texto2 e clique em Finish.
- Clique com o botao direito do mouse em cima do componente Button e escolha ADD Variable, no Wizard em variable name coloque o nome: botao e clique em Finish.
- Clique com o botao direito do mouse em cima do terceiro componente Edit Control e escolha ADD Variable, no Wizard em variable name coloque o nome: resultado e clique em Finish.
- Ainda no terceito Edit Control na janela de propriedades, mude Read Only para True.
- Clique com o botão direito em cima do componente Button e escolha: Add Event Handler, no Wizard em Message Type selecione BN_CLICKED clique em Add and EDIT.
- Neste momento uma nova unidade de codigo fonte é aberta com o evento escolhido, preencha a void do evento igual ao codigo abaixo.
Exemplo:
Neste exemplo criamos um programa visual em C++ utilizando MFC que concatena duas String, como usamos o conceito de “Design First e Code Later” da Microsoft você precisa apenas copiar o conteúdo da ultima void do código, todo o resto é gerado automaticamente.
C++
// Código Gerado automaticamente - MFC - Visual Studio 2013 - Ultimate
// Vá para o final do código
// Nossa implementação se trata apenas da ultima void
// ConcatenadorDlg.cpp : implementation file
//
#include "stdafx.h"
#include "Concatenador.h"
#include "ConcatenadorDlg.h"
#include "afxdialogex.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
// CAboutDlg dialog used for App About
class CAboutDlg : public CDialogEx
{
public:
CAboutDlg();
// Dialog Data
enum { IDD = IDD_ABOUTBOX };
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
// Implementation
protected:
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialogEx(CAboutDlg::IDD)
{
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()
// CConcatenadorDlg dialog
CConcatenadorDlg::CConcatenadorDlg(CWnd* pParent /*=NULL*/)
: CDialogEx(CConcatenadorDlg::IDD, pParent)
{
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
void CConcatenadorDlg::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
DDX_Control(pDX, IDC_EDIT1, texto1);
DDX_Control(pDX, IDC_EDIT2, texto2);
DDX_Control(pDX, IDC_BUTTON1, botao);
DDX_Control(pDX, IDC_EDIT3, resultado);
}
BEGIN_MESSAGE_MAP(CConcatenadorDlg, CDialogEx)
ON_WM_SYSCOMMAND()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_BN_CLICKED(IDC_BUTTON1, &CConcatenadorDlg::OnBnClickedButton1)
END_MESSAGE_MAP()
// CConcatenadorDlg message handlers
BOOL CConcatenadorDlg::OnInitDialog()
{
CDialogEx::OnInitDialog();
// Add "About..." menu item to system menu.
// IDM_ABOUTBOX must be in the system command range.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
BOOL bNameValid;
CString strAboutMenu;
bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
ASSERT(bNameValid);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
}
}
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
// TODO: Add extra initialization here
return TRUE; // return TRUE unless you set the focus to a control
}
void CConcatenadorDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
{
CAboutDlg dlgAbout;
dlgAbout.DoModal();
}
else
{
CDialogEx::OnSysCommand(nID, lParam);
}
}
// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.
void CConcatenadorDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialogEx::OnPaint();
}
}
// The system calls this function to obtain the cursor to display while the user drags
// the minimized window.
HCURSOR CConcatenadorDlg::OnQueryDragIcon()
{
return static_cast<HCURSOR>(m_hIcon);
}
/*
*********************
** Evento do Botão **
*********************
*/
// Evento do Botão
void CConcatenadorDlg::OnBnClickedButton1()
{
// TODO: Add your control notification handler code here
// Copie este codigo
CString _texto1;
CString _texto2;
CString concatena;
texto1.GetWindowTextW(_texto1);
texto2.GetWindowTextW(_texto2);
concatena = _texto1 + _texto2;
resultado.SetWindowText(concatena);
}
Ricardo Mantovani
Desenvolvimento Código Aberto 