Ir ao conteúdo
  • Cadastre-se
Regras do Clube do Hardware

C++ name lokupk change foriso for scope-permissive

Mayrinck Bernardo

Por Mayrinck Bernardo
em C/C#/C++

 Compartilhar

Posts recomendados

Mayrinck Bernardo
 

Mayrinck Bernardo

Postado
Postado 
		
		string coisa;  int repete = 0,p,q,n;
		for(int k=0;k<=(name_unico.size());k++){
			if(k==0){
				coisa = name_unico[k];
				p++;
			}else{
				repete = 0;
      //percorre o vetor distinto verificando se o valor existe no mesmo
      for(q=0;q<=(name_unico.size());q++){
        if(name_unico[k]== coisa) {
          repete++;
        }
      }
      //se o valor  não foi encontrado no vetor distinto, então adiciona
      if (repete < 1) {
       coisa = name_unico[k];
        n++;// aumenta o tamanho do vetor distinto
      }
    }
  }
  for (k = 0; k < n; k++){
 
  cout<<coisa<<endl;
   }
}

IAE GALERA ESTOU COM UM PROBLEMA NESTE TRECHO DE UMA FUNÇÃO ESTOU TENTANDO FAZERNÃO REPETIR OS NOMES ENTÃO USEI UM MÉTODO QUE VI EM C MAS ESTÁ DANDO ESSES ERROSQUE VOU DEIXAR NO PRINT ALGUEM ME AJUDA PF NÃO SEI O QUE ESTÁ ERRADO

thrth.png

  • Curtir 1
Link para o comentário
Compartilhar em outros sites
Mayrinck Bernardo
 

Mayrinck Bernardo

Postado
  • Autor
Postado

@AdrianoSiqueira 

#include<windows.h> 
#include<tlhelp32.h> 
#include<iostream> 
#include<bits/stdc++.h> 
using namespace std;
bool compareFunction (std::string a, std::string b);
	bool compareFunction (std::string a, std::string b){
	for(int k=0;k<=a.size()-1;k++){ 
		a[k]=tolower(a[k]); 
	};
	for(int k=0;k<=b.size()-1;k++){ 
		b[k]=tolower(b[k]);
	};
	return a<b; 
};
int main(){
	
		HANDLE hProcessSnap;
	 	PROCESSENTRY32 pe32;
	 	DWORD dwPriorityClass;
	 	hProcessSnap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 ); 
	 	pe32.dwSize = sizeof( PROCESSENTRY32 ); 
	 	vector <string> process_name;
		while( Process32Next( hProcessSnap, &pe32 ) ){
			process_name.push_back(pe32.szExeFile); 		
		};
		vector <string> process_name_unique;
		process_name_unique.push_back(process_name[3]);
		for(int k=3;k<=process_name.size()-1;k++){ 
			int add_unique=1; 
			for(int j=0;j<=process_name_unique.size()-1;j++){ 
				string st1=process_name[k]; 
				string st2=process_name_unique[j];
				if(strcmp(st1.c_str(),st2.c_str())==0 && add_unique==1 ){
					add_unique=0;
				}; 
			}; 
			if(add_unique==1){ 
				process_name_unique.push_back(process_name[k]);
			};
		};
		vector <string> process_name_unique_unsorted;
		for(int k=0;k!=process_name_unique.size();k++) process_name_unique_unsorted.push_back(process_name_unique[k]);
		std::sort(process_name_unique.begin(),process_name_unique.end(),compareFunction);
		for(int k=0;k!=process_name_unique.size();k++) for(int j=0;j!=process_name_unique.size();j++){ 
		}; 
		for(int k=0;k<=(process_name_unique.size()-1);k++){
			
			cout<<process_name_unique[k]<<"\n";//ARMAZENE ESSE VETOR
			//REINICIAR E COMPARAR COM A NOVA
			//  ALGUM DIFERENTE? PRINTF DIFERENTE
		}
}

 

  • Curtir 1
Link para o comentário
Compartilhar em outros sites
AdrianoSiqueira
 

AdrianoSiqueira

Postado
Postado

Não tenho como testar esse código no Linux. Tente seguir os comentário que eu coloquei no código: 

#include<windows.h>
#include<tlhelp32.h>
#include<iostream>
#include<bits/stdc++.h>

using namespace std;

bool compareFunction(string a, string b);

int main() {
    HANDLE hProcessSnap;
    PROCESSENTRY32 pe32;
    DWORD dwPriorityClass;
    hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    pe32.dwSize = sizeof(PROCESSENTRY32);

    vector<string> process_name;

    while (Process32Next(hProcessSnap, &pe32)) {
        process_name.push_back(pe32.szExeFile);
    };

    vector<string> process_name_unique;
    process_name_unique.push_back(process_name[3]);

    // Deixe essa linha assim:
    // for (int k = 3; k < process_name.size() - 1; k++) {
    for (int k = 3; k <= process_name.size() - 1; k++) {
        int add_unique = 1;

        // Deixe essa linha assim:
        // for (int j = 0; j < process_name_unique.size() - 1; j++) {
        for (int j = 0; j <= process_name_unique.size() - 1; j++) {
            string st1 = process_name[k];
            string st2 = process_name_unique[j];

            if (strcmp(st1.c_str(), st2.c_str()) == 0 && add_unique == 1) {
                add_unique = 0;
            };
        };

        if (add_unique == 1) {
            process_name_unique.push_back(process_name[k]);
        };
    };

    vector<string> process_name_unique_unsorted;

    for (int k = 0; k != process_name_unique.size(); k++) {
        process_name_unique_unsorted.push_back(process_name_unique[k]);
    }

    sort(process_name_unique.begin(), process_name_unique.end(), compareFunction);

    for (int k = 0; k != process_name_unique.size(); k++) {
        for (int j = 0; j != process_name_unique.size(); j++) {
        }
    }

    // Deixe essa linha assim:
    // for (int k = 0; k < (process_name_unique.size() - 1); k++) {
    for (int k = 0; k <= (process_name_unique.size() - 1); k++) {
        cout << process_name_unique[k] << "\n";
        // ARMAZENE ESSE VETOR
        // REINICIAR E COMPARAR COM A NOVA
        // ALGUM DIFERENTE? PRINTF DIFERENTE
    }
}

bool compareFunction(string a, string b) {
    for (int k = 0; k <= a.size() - 1; k++) {
        a[k] = tolower(a[k]);
    }
    
    for (int k = 0; k <= b.size() - 1; k++) {
        b[k] = tolower(b[k]);
    }

    return a < b;
}

 

  • Curtir 1
  • Amei 1
Link para o comentário
Compartilhar em outros sites
arfneto
 

arfneto

Postado
Postado
9 horas atrás, Mayrinck Bernardo disse:

o objetivo é toda vez que abrir um programa dá um printf voce abrir x programa

 

Não sei se entendi. Você quer que mostre ao iniciar o nome do programa que foi aberto? Ou identificar os dados do processo, do seu processo, no windows?

 

Se quer o nome do programa, pode usar argv[0] que é exatamente isso.

  • Curtir 1
Link para o comentário
Compartilhar em outros sites
arfneto
 

arfneto

Postado
Postado

 

Acho que eu postei algo sobre isso aqui esses dias, inclusive o link para a documentação e um programa exemplo da Microsoft

 

https://docs.microsoft.com/pt-br/windows/win32/toolhelp/taking-a-snapshot-and-viewing-processes

 

Acho que você está indo no caminho certo, mas achei um pouco complicado.

 

O que esse programa originalmente fazia era usar essas chamadas a Process32First() e depois ir chamando Process32Next() enquanto ela retornar algo, e montar um retrato --- snapshot -- de momento dos processos rodando no sistema, tudo em torno dessa estrutura aí abaixo 

typedef struct tagPROCESSENTRY32 {
  DWORD     dwSize;
  DWORD     cntUsage;
  DWORD     th32ProcessID;
  ULONG_PTR th32DefaultHeapID;
  DWORD     th32ModuleID;
  DWORD     cntThreads;
  DWORD     th32ParentProcessID;
  LONG      pcPriClassBase;
  DWORD     dwFlags;
  CHAR      szExeFile[MAX_PATH];
} PROCESSENTRY32;

Estamos usando C++. Então tudo sugere o simples, como o sistema faz: crie uma classe Snapshot com essa lista de processos, programe um alarme para daí a um certo intervalo. E aí cria outro snapshot. Cria uma função na classe SnapShot que compara duas variáveis desse tipo e retorna a diferença, elá deve estar a lista de programas que foram abertos entre um snapshot e o próximo.

  

BOOL QueryFullProcessImageNameA(
  HANDLE hProcess,
  DWORD  dwFlags,
  LPSTR  lpExeName,
  PDWORD lpdwSize
);

 

Essa função aí acima retorna o caminho para o executável, e você pode filtrar aí por exemplo, excluindo determinados programas porque a lista pode ter centenas deles.

 

Não precisa usar sort() e fornecer compare(). Basta usar uma classe que já ofereça ordem, tipo Map ou Set ou uma simples lista ou vetor em que você insere os caras já na ordem. Pense bem: você lê um por um e espera para chamar sort no fim? Porque já não insere na ordem ou usa uma estrutura que já faça isso?

 

E se tivesse esse tal SnapShot poderia declarar

  

SnapShot* A, B;
A = new SnapShot;
// programa um alarme para o intervalo que quer
B = new SnapShot;

 

e escrever uma função  

SnapShot dif(SnapShot* antes, SnapShot* agora);

por exemplo que faria a diferença entre os dois e retornaria um terceiro SnapShot só com a diferença.

 

Ou mesmo redefinir o operador ´-´ e poder escrever

  

SnapShot novos = B - A;

 

postei um código aqui que mostra como fazer isso, algo com ´sobrecarga de operadores´ no título.

 

E na criação de cada SnapShot você enfia essa lógica de montar uma lista dos processos que tem um nome de um executável no disco...

Na criação quer dizer o construtor da classe e não precisa de mais de um construtor porque o processo só tem um jeito mesmo.

 

  • Curtir 2
Link para o comentário
Compartilhar em outros sites
Mayrinck Bernardo
 

Mayrinck Bernardo

Postado
  • Autor
Postado
8 horas atrás, arfneto disse:

programe um alarme para daí a um certo intervalo. E aí cria outro snapshot

tipo um sleep e um go to?

adicionado 1 minuto depois

 

adicionado 7 minutos depois
8 horas atrás, arfneto disse:

crie uma classe Snapshot com essa lista de processos,

 

8 horas atrás, arfneto disse:

postei um código aqui que mostra como fazer isso, algo com ´sobrecarga de operadores´ no título.

ok vou procurar

Link para o comentário
Compartilhar em outros sites
arfneto
 

arfneto

Postado
Postado

Tipo um sleep até receber o alarme. Mas acho que no Windows isso é arriscado. Veja essa função

 

BOOL CreateTimerQueueTimer(
  PHANDLE             phNewTimer,
  HANDLE              TimerQueue,
  WAITORTIMERCALLBACK Callback,
  PVOID               DueTime,
  DWORD               Period,
  DWORD               Flags,
  ULONG               Parameter
);

Descrita Lá onde tem tudo sobre Windows

é uma que pode ajudar. No fundo você quer parar por um tempo e quando der a hora você executa uma função que pega um snapshot e compara com o anterior.

 

Um desenvolvedor excepcional chamado Mark Russinovich escreveu um desses programas anos atrás e você pode ver em https://docs.microsoft.com/pt-br/sysinternals/downloads/ e baixar uma cópia. Ele usou as mesmas estruturas que você vai usar. E é muito muito muito bom. Veja o Process Explorer e o Process Monitor. São dos anos 90 :)

Outro programa para ver claro é o TaskMGR.exe que você pode rodar em sua máquina: Win+R TaskMgr.exe

 

Process Monitor

p-monitor.png.20710fc86fa7d873f00d144f4605ecf4.png

 

Process Explorer

 

p-explorer.thumb.png.c3582be5f92fb8bcfdc8171aa02f8b63.png

 

Task Manager

 

taskmgr.thumb.png.62ab48b7c6940ff96fe5ebe567cd50e2.png

 

Link para o comentário
Compartilhar em outros sites
Mayrinck Bernardo
 

Mayrinck Bernardo

Postado
  • Autor
Postado

@arfneto como to querendo algo simples desenvolvi isso em c mesmo mas to tendo problemas pois não está mostrando  e não sei como resolver poderia ajudar pf 

#include <windows.h>
#include <tlhelp32.h>
#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char oi[200];

int main( ){
  HANDLE hProcessSnap;
  HANDLE hProcess;
  PROCESSENTRY32 pe32;
  DWORD dwPriorityClass;
  hProcessSnap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
  pe32.dwSize = sizeof( PROCESSENTRY32 );
  
  do
  {
  	if(strcmp(pe32.szExeFile,oi)==0){
  	strcpy(oi,pe32.szExeFile);
  	return main();
  	 else{
  	printf("%s\n",pe32.szExeFile);
return main();
  } while( Process32Next( hProcessSnap, &pe32 ) );
  
}
}
}

 

Link para o comentário
Compartilhar em outros sites
arfneto
 

arfneto

Postado
Postado

Vi seu programa. Ainda não faz quase nada.

 

Note que essa é a definição da estrutura que descreve um processo no Windows 

/***** Process walking *************************************************/

typedef struct tagPROCESSENTRY32W
{
    DWORD   dwSize;
    DWORD   cntUsage;
    DWORD   th32ProcessID;          // this process
    ULONG_PTR th32DefaultHeapID;
    DWORD   th32ModuleID;           // associated exe
    DWORD   cntThreads;
    DWORD   th32ParentProcessID;    // this process's parent process
    LONG    pcPriClassBase;         // Base priority of process's threads
    DWORD   dwFlags;
    WCHAR   szExeFile[MAX_PATH];    // Path
} PROCESSENTRY32W;

então WCHAR é o tipo de szExeFile. Isso quer dizer que não pode usar strcpy() ou printf() ou strcmp() com esse vetor.

 

Postei uma solução possível para isso num outro tópico.

 

Como te disse, CreateToolhelp32Snapshot() devolve a lista de processos no momento da chamada. Mas aí você precisa chamar OpenProcess() para cada um e pegar as informações de que precisa sobre cada processo. Sem surpresa: elas virão numa estrutura dessas acima para cada processo. Então você precisa armazenar isso de algum modo.

E quando for o caso chama as mesmas rotinas e faz a mesma coisa: salva o tal snapshot novo.

 

Entre uma lista e outra você tem processos que se encerraram e processos novos, e precisa comparar as duas listas, que foi o que te mostrei no programa de exemplo. Se quer só os novos tanto faz: é trivial.

 

Um programa normal não tem acesso a muitos dos processos em execução no sistema, mas pelo que escreveu acho que seu interesse está em programas abertos por usuários então estará bem. Para acessar processos do sistema tem que configurar um Handle com as permissões adequadas. Veja na documentação sobre Access Rights na Microsoft começando por aqui: https://docs.microsoft.com/en-us/windows/win32/procthread/process-security-and-access-rights

 

Assim é. Recomendo rodar o programa que te mostrei no outro tópico e entender porque funciona

 

 

  • Curtir 1
Link para o comentário
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora
 Compartilhar
Ir à lista de tópicos

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

Mais

×
×
  • Criar novo...