Você está aqui: C++ ::: Win32 API (Windows API) ::: Formulários e Janelas

Usando a função EnumWindows() da API do Windows para retornar uma lista das janelas visíveis

Quantidade de visualizações: 7965 vezes
A função EnumWindows() é usada quando precisamos obter uma lista de todas as janelas de nível alto (top-level) visíveis na tela (ainda que minimizadas ou sobrepostas pelas janelas de outros programas).

Esta função opera juntamente com uma função de CALLBACK EnumWindowsProc() que deve ser fornecida por nossos programas C++. Veja o protótipo da função EnumWindows():

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

BOOL EnumWindows(
   WNDENUMPROC lpEnumFunc,
   LPARAM lParam
);

Veja que o primeiro parâmetro da função é um ponteiro para a função de callback definida em nossa própria aplicação. Esta função de callback é chamada uma vez para cada janela encontrada. O segundo parâmetro é um valor a ser fornecido também por nossa aplicação. Geralmente fornecemos o valor 0 para este parâmetro.

Veja agora o protótipo da função de callback EnumWindowsProc():

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

BOOL CALLBACK EnumWindowsProc(
  HWND hwnd,
  LPARAM lParam
);

Esta função de callback possui dois parâmetros. O primeiro (hwnd) guarda o handle para a janela encontrada na iteração atual. O segundo parâmetro (lParam) é o valor fornecido à função EnumWindows() no momento de sua chamada. Para continuar e exibir os dados da próxima janela, a função de callback deve retornar TRUE. Para interromper a listagem, basta retornar o valor FALSE.

Veja um programa no qual listamos todas as janelas visíveis na tela, incluindo seu handle, id do processo, título e caminho e nome do executável:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <cstdlib>
#include <iostream>
#include <windows.h>
#include <psapi.h>

/*
  Este exemplo usa o header <psapi.h>
  É necessário fazer uma referência à psapi.lib 
*/

using namespace std;

// função de CALLBACK usada para listar todas as janelas
BOOL CALLBACK EnumWindowsProc(HWND hWnd, LPARAM lParam){
  CHAR temp[255];
  DWORD dwThreadId, dwProcessId;
  HINSTANCE hInstance;
  HANDLE hProcess;

  if(!hWnd)
    return TRUE; // não é uma janela
  if(!IsWindowVisible(hWnd))
    return TRUE; // é janela, mas não está visível
  if(!SendMessage(hWnd, WM_GETTEXT, sizeof(temp), (LPARAM)temp))
    return TRUE; // é janela, está visível, mas não possui título

  // obtém o handle da instância da janela
  hInstance = (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE);
  // obtém o id da thread que criou este processo
  dwThreadId = GetWindowThreadProcessId(hWnd, &dwProcessId);
  // abre o processo
  hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);

  // exibe o handle da janela
  cout << "Handle: " << hWnd << endl;
  
  // exibe o ID do processo
  cout << "Id do processo: " << dwProcessId << endl;
  
  // exibe o título da janela
  cout << "Titulo da janela: " << temp << endl;
  
  // obtém o nome do executável ou DLL
  if(GetModuleFileNameEx(hProcess, hInstance, temp, sizeof(temp)))
    cout << "Executavel: " << temp << endl;
  else
    cout << "Nao foi possivel obter a informacao\n";

  cout << "\n" << endl;

  CloseHandle(hProcess);
  return TRUE;
}

int main(int argc, char *argv[]){
  // vamos listar todas as janelas visíveis
  EnumWindows(EnumWindowsProc, 0);
  
  system("PAUSE");
  return EXIT_SUCCESS;
}

Note que alguns programadores C/C++ fornecem o valor NULL como segundo argumento para uma chamada à EnumWindows(). No Dev-C++ 4.9, teremos uma mensagem de advertência se fizermos isso. Veja:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

[Warning] passing NULL used for non-pointer converting 2 of 
'BOOL EnumWindows(BOOL (*)(HWND__*, LPARAM), LPARAM)' 


Link para compartilhar na Internet ou com seus amigos:

C++ ::: Dicas & Truques ::: Ponteiros, Referências e Memória

Como usar ponteiros em C++ - Apostila de C++ para iniciantes

Quantidade de visualizações: 7973 vezes
Antes de pensarmos em ponteiros, é importante nos lembrarmos de alguns aspectos referentes à variáveis. Dependendo do seu conhecimento de programação, você deve saber que variáveis possuem nomes que as identificam durante a execução do programa. Você deve saber também que uma variável armazena um valor (que pode ser fixo, no caso de uma constante, ou pode mudar durante a execução de seus códigos).

O que poucos programadores se lembram é que uma variável possui um endereço, e que o nome da variável não é nada mais que um apelido para a localização deste endereço. Desta forma, um ponteiro não é nada mais que um tipo especial de variável que armazena o endereço de outra. Veja um exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <iostream>

using namespace std;

int main(int argc, char *argv[]){
  // variável do tipo int
  int valor = 10;

  // ponteiro para uma variável do tipo int
  int *p = &valor;

  // exibe o valor da variável "valor", apontada
  // pelo ponteiro p
  cout << *p << endl;

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

Neste código nós temos a declaração e definição de duas variáveis:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

int valor = 10;
int *p = &valor;

A primeira variável é uma variável do tipo int e a segunda é um ponteiro para uma variável do tipo int. Veja que devemos sempre usar "*" antes do nome de um ponteiro em sua declaração. O símbolo "&" serve para indicar que estamos acessando o endereço de uma variável e não o seu conteúdo. O resultado destas duas linhas é que agora temos um ponteiro que nos permite acessar e manipular a variável valor.

Observe a linha:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
 
cout << *p << endl;

Aqui nós estamos acessando o valor da variável apontada por p. Veja o uso do símbolo "*" para acessar o valor da variável. Isso é chamado de desreferenciamento de ponteiros. Pareceu complicado? Veja uma linha de código que altera indiretamente o valor da variável valor para 30:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
 
*p = 30;

Ponteiros são ferramentas muito importantes na programação em C++. No entanto, é preciso ter muito cuidado ao lidar com eles. A primeira coisa a ter em mente é que um ponteiro não está apontando para nenhum lugar até que atribuimos a ele o endereço de uma outra variável. E é aí que mora o perigo. Um programa entra em colapso absoluto se tentarmos acessar um ponteiro que aponta para um local de memória que já foi liberado novamente ao sistema. No caso menos grave, estaremos tentando acessar locais de memória inválidos ou reservados a outros programas ou tarefas do sistema operacional. Isso me lembra os velhos tempos da tela azul de morte.


C++ ::: Dicas & Truques ::: Strings e Caracteres

Como retornar o tamanho de uma string em C++ usando a função size()

Quantidade de visualizações: 7943 vezes
Nesta dica mostrarei como podemos obter a quantidade de caracteres de uma string em C++ usando a função size() da classe string. Esta função não exige nenhum argumento e retorna um número inteiro contendo a quantidade de caracteres na string.

Veja o código C++ completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <string>
#include <iostream>
 
using namespace std;
 
// função principal do programa C++ 
int main(int argc, char *argv[]){
  // vamos declarar um objeto string
  string frase = "Gosto de C++";
 
  // vamos obter o tamanho da string
  size_t tamanho = frase.size();
  
  // e mostramos o resultado
  cout << "A frase possui " << tamanho << " caracteres."; 
     
  cout << "\n" << endl;	    
  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

Ao executarmos este código C++ nós teremos o seguinte resultado:

A frase possui 12 caracteres.


C++ ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes)

Vetores e matrizes em C++ - Como passar vetores e matrizes para as suas funções C++

Quantidade de visualizações: 12016 vezes
Muitas vezes precisamos passar um vetor ou uma matriz C++ para nossas funções. O trecho de código abaixo mostra como isso é feito. Observe que a passagem de uma matriz para uma função é feita por referência, ou seja, qualquer alteração nos valores da matriz dentro do método será refletida na matriz original:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <iostream>
 
using namespace std;
 
// função usada para exibir os valores
// da matriz
void exibir_matriz(int matriz[], int quant)
{
  for(int i = 0; i < quant; i++){
    cout << matriz[i] << endl;
  }
}
 
int main(int argc, char *argv[])
{
  // cria uma matriz com 5 inteiros
  int valores[] = {54, 3, 89, 6, 1};
 
  // passa a matriz para a função exibir_matriz()
  // veja que temos que enviar também a quantidade
  // de elementos
  exibir_matriz(valores, 5);
 
  system("PAUSE"); // pausa o programa
  return 0;
}

Ao executar este código C++ nós teremos o seguinte resultado:

54
3
89
6
1


Vamos testar seus conhecimentos em Engenharia Civil - Instalações Hidráulicas Prediais

O projeto de instalação hidrossanitária

As fossas sépticas consistem em alternativas para o tratamento primário, em soluções individuais de esgotamento sanitário. A ABNT NBR 7229:1993 (Projeto, construção e operação de sistemas de tanques sépticos) define alguns cuidados necessários em relação ao tamanho e ao dimensionamento necessário.

Considere as seguintes sentenças:

I - O tanque séptico consiste em uma unidade cilíndrica ou prismática retangular de fluxo horizontal para tratamento de esgotos por processos de sedimentação, flotação e digestão, o qual deve respeitar uma distância mínima de 1,50m de construções.

II - O sumidouro é definido como um poço seco escavado no chão, sendo impermeabilizado.

III - O lodo e a escuma removidos dos tanques sépticos podem ser lançados em corpos de água ou galerias de águas pluviais, desde que atendam aos limites de lançamento definidos em lei.

Assinale a alternativa correta:

A) Apenas a sentença II está correta.

B) As sentenças I e II estão corretas.

C) Apenas a sentença I está correta.

D) Apenas a sentença III está correta.

E) Apenas as sentenças II e III estão corretas.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Engenharia Civil - Instalações Hidráulicas Prediais

Materiais empregados para instalação de água fria e esgoto

Em terminais de pias e acessórios embutidos na parede, onde são rosqueadas mangueiras e conexões, é indicada a aplicação de joelhos reforçados, em que a rosca é metálica, embutida sob pressão no PVC. A identificação dessa conexão é por um anel azul em sua face. Em relação ao joelho convencional, que é todo em PVC, a vantagem é:

A) estética, uma vez que a face do joelho proporciona um acabamento rente ao azulejo superior à comum.

B) econômica pois elimina uma série de outros componentes e conexões.

C) o sistema de engate rapido por meio de utilização de anel de vedação junto à rosca.

D) o fato de que, com o joelho reforçado, o risco de acontecer trinca resultante de aperto é menor.

E) que fica exposta, eliminando o encaixe na alvenaria, diferentemente das comuns.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Hidrologia

(Enem 2016) A renaturalização de rios e córregos é, há muito tempo, uma realidade na Europa, no Japão, na Coreia do Sul, nos Estados Unidos e em outros países. No Brasil ainda são muito tímidas as iniciativas, mas algumas poucas cidades estão adotando essa importante prática.

Disponível em: http://sosriosdobrasil.blogspot.com.br. Acesso em: 10 dez. 2012 (adaptado).

A legislação brasileira avançou ao estabelecer como unidade territorial para a gestão desse recurso

A) os biomas.

B) as reservas ecológicas.

C) as unidades do relevo.

D) as bacias hidrográficas.

E) as áreas de preservação ambiental.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Ética e Legislação Profissional

O exercício do direito à propriedade

O direito de passagem é um direito de vizinhança reconhecido por lei no caso de terreno encravado e de passagem de cabos, tubulações e dutos na propriedade do vizinho. Assinale a alternativa correta sobre o direito de passagem enquanto direito de vizinhança e a ação de passagem forçada:

A) É possível condenar judicialmente o vizinho a conceder passagem forçada mesmo que haja acesso à via pública, mas que o acesso se dê de forma mais cômoda e facilitada se passar pela propriedade dele.

B) A ação de passagem forçada é possível no caso de terreno encravado sem acesso à via pública e para passagem de cabos, tubulações e dutos para serviços essenciais.

C) Se o proprietário vendeu parte do terreno que lhe pertencia, e ficou sem acesso à via pública, pode, depois, pleitear direito de passagem forçada pelo terreno do vizinho.

D) O vizinho que ganha do outro o direito à passagem forçada não será obrigado a indenizá-lo, pois esse direito decorre de lei.

E) Se ocorrer concessão de direito de passagem de cabos e tubulações na propriedade do vizinho e esses apresentarem risco, fica por conta dele as obras de segurança, pois ele é o proprietário e a quem foi atribuído o dever de passagem.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Ética e Legislação Profissional

Postura ética profissional

Os engenheiros são profissionais responsáveis por criar soluções para situações do dia a dia que, de certa forma, pareciam impossíveis. Eles otimizaram as formas de transporte, de construção e, principalmente, de produção das indústrias. Diante dessas inovações, é comum que esses profissionais enfrentem situações éticas em que precisem decidir se avançam ou não com tais projetos.

Quanto ao conceito de ética na engenharia, é correto afirmar que:

A) A ética na engenharia é um aspecto que deve ser considerado em segundo lugar ante os benefícios que pode trazer à humanidade.

B) A ética engloba a avaliação racional de ganhos e riscos, definindo as responsabilidades individuais durante a execução de um projeto.

C) A ética engloba a avaliação social dos riscos e das responsabilidades coletivas durante a execução de um projeto.

D) A ética é um conceito que não se aplica à engenharia, somente à medicina, por esta área tratar diretamente da vida de um indivíduo.

E) A ética somente diz respeito à engenharia, pois as descobertas realizadas por tal área englobam um grande número de pessoas.
Verificar Resposta Estudar Cards Todas as Questões

Desafios, Exercícios e Algoritmos Resolvidos de C++

Veja mais Dicas e truques de C++

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: Delphi
6º lugar: C
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2024 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 26 usuários muito felizes estudando em nosso site.