cyer

Uma das possível implementações para isso seria verificar se o endereço da variável está em algum modulo do processo ou dentro do próprio executável, para fazer isso basta usar a winapi VirtualQuery para pegar o endereço da pagina e verificar se essa pagina está com algum modulo registrado no processo(para isso vou usar a winapi GetModuleFileNameA), um pequeno exemplo: bool dinamicamente_alocada( void* endereco ) { MEMORY_BASIC_INFORMATION mbi = { 0 }; // VirtualQuery para pegar o endereço de pagina onde essa memória foi alocada if ( VirtualQuery( endereco, &mbi, sizeof( mbi ) ) ) { char nome_modulo[ 256 ] = { 0 }; // Tenta pegar o nome do modulo, se o retorno da GetModuleFileNameA for 0, é porque o modulo não está registrado, então essa memória não está no stack e sim no heap return ( GetModuleFileNameA( static_cast< HMODULE >( mbi.AllocationBase ), nome_modulo, sizeof( nome_modulo ) ) == 0 ); } return false; } int main() { char pilha[ 0x1000000 ]; // Memória alocada no stack char* dinamicamente = new char[ 0x1000000 ]; // Memória alocada no heap std::cout << dinamicamente_alocada( pilha ) << std::endl; std::cout << dinamicamente_alocada( dinamicamente ) << std::endl; // Como não vamos mais precisar dessa memória liberamos ela delete[] dinamicamente; return 0; } Saída: 0 1 Não esqueça de incluir a biblioteca da VirtualQuery e GetModuleFileNameA(#include <Windows.h>)

Não entendi sua dúvida, você precisa converter um char* para wchar_t*? Se for, essa é a forma mais fácil: std::wstring string_to_wstring( const std::string &str ) { std::wstring w( str.begin( ), str.end( ) ); return w; } const wchar_t* char_str_to_wchar_str( const char* str ) { return string_to_wstring( str ).c_str( ); } LPCSTR = const char* LPWSTR = const wchar_t* Tente assim: MessageBox(hwnd, psFilename, "Missing Shader File", MB_OK); Se mesmo assim não funcionar, troque o MessageBox para MessageBoxA

@AnsiC Obrigado, consegui resolver, eu estava fazendo errado, tinha que executar o teste por pelo menos 10000 vezes depois armazenar o tempo de cada teste em uma variável e depois dividir esse tempo pelo número de testes(10000) #include <iostream> #include <math.h> #include <intrin.h> #include <chrono> #include <functional> using namespace std; #define MAX_LOOP 10000u auto sse_sqrt( float n ) { __m128 reg = _mm_load_ss( &n ); return _mm_mul_ss( reg, _mm_rsqrt_ss( reg ) ).m128_f32[ 0 ]; } auto executar_teste( std::function< void() > t ) { auto timer = 0ull; for ( auto i = 0u; i < MAX_LOOP; ++i ) { auto start = std::chrono::high_resolution_clock::now(); t(); timer += ( std::chrono::high_resolution_clock::now() - start ).count(); } return timer / static_cast< unsigned long long >( MAX_LOOP ); } auto stl_sqrt_t() { return std::sqrt( 1000 ); } auto sse_sqrt_t() { return sse_sqrt( 1000 ); } int main() { cout << "stl_sqrt: " << executar_teste( stl_sqrt_t ) << "\n"; cout << "sse_sqrt: " << executar_teste( sse_sqrt_t ) << "\n"; cin.ignore(); return 0; } Primeira execução: stl_sqrt: 69 sse_sqrt: 80 Segunda execução: stl_sqrt: 72 sse_sqrt: 78 Terceira execução: stl_sqrt: 71 sse_sqrt: 73

Acredito que não, porque se fosse realmente isso iria acontecer sempre pois é passado o mesmo valor para ambas as funções, isso acontece apenas em 30 ~ 50% dos testes

Estou tentando testar o tempo de execução de um código, porém estou sempre obtendo valores incorretos, o primeiro teste vai ser sempre o que tem o pior tempo. E na maioria das vezes o segundo teste é sempre 0. #include <iostream> #include <math.h> #include <intrin.h> #include <chrono> using namespace std; #define MAX_LOOP 100000 #define NUM 10000.f auto sse_sqrt( float n ) { __m128 reg = _mm_load_ss( &n ); return _mm_mul_ss( reg, _mm_rsqrt_ss( reg ) ).m128_f32[ 0 ]; } auto stl_sqrt_timer() { auto start = std::chrono::high_resolution_clock::now(); for ( auto i = 0; i < MAX_LOOP; i++ ) { auto v = std::sqrt( NUM ); } auto end = std::chrono::high_resolution_clock::now(); return ( end - start ).count(); } auto sse_sqrt_timer() { auto start = std::chrono::high_resolution_clock::now(); for ( auto i = 0; i < MAX_LOOP; i++ ) { auto v = sse_sqrt( NUM ); } auto end = std::chrono::high_resolution_clock::now(); return ( end - start ).count(); } int main() { cout << "stl_sqrt: " << stl_sqrt_timer() << "\n"; cout << "sse_sqrt: " << sse_sqrt_timer() << "\n"; cin.ignore(); return 0; } Primeira execução: sse_sqrt: 12461 stl_sqrt: 0 Segunda execução: sse_sqrt: 2643 stl_sqrt: 378 Invertendo a ordem de testes: Primeira execução: stl_sqrt: 23032 sse_sqrt: 378 Segunda execução: stl_sqrt: 2265 sse_sqrt: 0 Estou compilando em Release x86, com otimização /Ox

@isrnick usando a api WinVerifyTrust funcionou perfeitamente, obrigado.

Isso não está relacionado ao meu problema, eu preciso pegar uma informação(assinatura digital) de uma dll que foi carregada em um executável

Estou desenvolvendo um projeto de um anticheat em C++, estou detectando as dlls injetadas no jogo, mas estou tendo problemas em identificar se a dll injetada é uma dll legitima(Dll do Windows ou de aplicativos legitimos como: Fraps, Steam Overlay, OBS, Discord) ou uma dll de trapaça A solução que eu tenho em mente é verificar se a dll que foi injetada no jogo possui uma assinatura digital valida(como a da imagem abaixo): Qual função do Windows em C/C++ é possível usar para pegar a assinatura digital de um modulo?

Esse código não compila em alguns compiladores pelo fato da variável Xvalor não ser uma constante, um exemplo disso é no Visual Studio 2017: O ideal é usar alocação dinâmica para evitar esses problemas.

Você teria que definir o tamanho do vetor(se quiser definir o tamanho do vetor com entrada de valores teria que fazer uma alocação dinâmica) E você poderia fazer tudo isso em apenas um for. int main() { int i, Xvalor; printf( "Quantos indices desejas nos vetores?\n" ); scanf( "%d", &Xvalor ); int* VetA = ( int* )malloc( Xvalor * sizeof( int ) ); int* VetB = ( int* )malloc( Xvalor * sizeof( int ) ); int* VetC = ( int* )malloc( Xvalor * sizeof( int ) ); for ( i = 0; i < Xvalor; i++ ) { printf( "Digite um numero para o indice:%d do VetorA. \n", i ); scanf( "%d", &VetA[ i ] ); } for ( i = 0; i < Xvalor; i++ ) { printf( "Digite um numero para o indice:%d do VetorB. \n", i ); scanf( "%d", &VetB[ i ] ); } for ( i = 0; i < Xvalor; i++ ) { VetC[ i ] = VetA[ i ] * VetB[ i ]; } for ( i = 0; i < Xvalor; i++ ) { printf( "VetC[%d]=%d\n", i, VetC[ i ] ); } free( VetA ); free( VetB ); free( VetC ); }

Poderia simplificar o código usando uma lambda: string str_toupper(string s) { transform(s.begin(), s.end(), s.begin(), [](char c) { return c - 32; }); return s; }

@LuisOPsum Isso não é C++, isso é C, o autor quer em C++

A forma mais simples e menos trabalhosa é do @AnsiC, porém se você estiver afim de se divertir(quebrar a cabeça), você pode criar sua própria função de scanf. #include <stdio.h> #include <stdlib.h> #include <Windows.h> int my_scanf() { int tam = sizeof(char) + 1; // Tamanho inicial, + 1 por conta do caractere nulo que indica o final de uma string('\0') int qntNumDigitados = 0; char* numeros_digitados = (char*)malloc(tam); // vetor onde vai salvar os números digitados pelo usuário while (true) { char currentResult = getchar(); // Se o usuario apertar enter termina o loop if (currentResult == '\n') { numeros_digitados[qntNumDigitados] = '\0'; // Termina a string break; } // Verifica se é um número que foi digitado atraves do valor retornado pela getchar // Segundo a tabela ASCII(http://www.ricardoarrigoni.com.br/tabela-ascii-completa/): // 48 = número 0 // 49 = número 1 // ... // ... // 57 = número 9 if (currentResult < 48 || currentResult > 57) // Valor digitado pelo usuario não é um número continue; // Salva o caractere digitado no vetor numeros_digitados[qntNumDigitados] = currentResult; tam += sizeof(char); // Realoca um novo vetor com mais memória para o proximo número digitado numeros_digitados = (char*)realloc(numeros_digitados, tam); qntNumDigitados++; } // Transforma a string para um inteiro int numero_digitado = atoi(numeros_digitados); // Libera a memória que foi alocada para o vetor onde está armazenado os números free(numeros_digitados); return numero_digitado; } int conversor_hrs(int hrs, int minutos, int segundos) { int total_segundos = 0; total_segundos = (hrs * 60 * 60) + (minutos * 60) + segundos; return(total_segundos); } int main() { conversor_hrs(my_scanf(), my_scanf(), my_scanf()); system("pause"); return 0; }

Como limitar um valor que foi inserido/alterado pelo endereço de memória? PS: Eu não posso limitar pela função, essa função é apenas uma função de exemplo mostrando o problema, vou precisar passar esse objeto para funções de outras bibliotecas na qual eu não posso alterar. #include <iostream> template <typename type> class Var { private: type Value = (type)0; type ClampMin = (type)0; type ClampMax = (type)0; bool NeedClamp = false; public: Var() { } Var(type initialVal) : Value(initialVal) { } Var(type initialVal, type Min, type Max) { this->NeedClamp = true; this->ClampMin = Min; this->ClampMax = Max; this->operator=(initialVal); } constexpr bool IsClampActive() const { return this->NeedClamp; } constexpr type Min() const { return this->ClampMin; } constexpr type Max() const { return this->ClampMax; } // Operador seguro pois consegue limitar os valores inseridos type& operator=(type val) noexcept { if (this->NeedClamp) { if (val > this->ClampMax) this->Value = this->ClampMax; else if (val < this->ClampMin) this->Value = this->ClampMin; else this->Value = val; } else { this->Value = val; } return this->Value; } // Para converter automaticamente o tipo // Não seguro // Como limitar o valor inserido nesse operador? operator type*() { return &this->Value; } // Para converter automaticamente o tipo // Não seguro // Como limitar o valor inserido nesse operador? operator type&() { return this->Value; } template <typename typeVal> constexpr bool operator==(typeVal val) const { return (this->Value == (type)val); } template <typename typeVal> constexpr bool operator!=(typeVal val) const { return (this->Value != (type)val); } }; #define MIN_VALORTESTE 1.f #define MAX_VALORTESTE 100.f float problema(float& valor) { valor = 200.f; // Vai alterar o valor para um valor maior que o limite definido(100.f), como limitar o valor inserido nesse caso? return valor; } int main() { //Var<float> Valor_Teste = 50.f; Var<float> Valor_Teste = { /* Valor inicial da variável */ 50.f, /* Valor minimo permitido para a variável*/ MIN_VALORTESTE, /* Valor maximo permitido para a variável */ MAX_VALORTESTE }; std::cout << problema(Valor_Teste) << std::endl; // Mostrando o novo valor da variável(vai mostrar um valor inválido, pois está maior que o limite definido(MAX_VALORTESTE)) std::cout << Valor_Teste << std::endl; std::cin.get(); return 0; }

Você pode converter esse número para string: #include <stdio.h> #include <iostream> #include <string> #include <math.h> #include <locale.h> #include <iomanip> using namespace std; int main() { int funcionarios, horas; double valorhora, soma; cout << "informe o numero de funcionarios: "; cin >> funcionarios; cout << "Informe a quantida de de horas trabalhadas: "; cin >> horas; cout << "Informe o valor por hora : "; cin >> valorhora; cout << "Numero do funcionario = "<<funcionarios << endl; soma = horas*valorhora; string salario = "U$ " + to_string(soma); cout << "Seu salario final é = " << salario << soma; return 0; }

Toda função da linguagem C é possível usar na linguagem C++, porém se existir uma alternativa pra essa função na linguagem C++ prefira a função da linguagem C++, não se esqueça que você está programando em C++ e não em C. Alguns motivos para usar sempre funções da linguagem C++ em vez da linguagem C: 1 - Melhor otimização do código: Como é um compilador da linguagem C++ vai utilizar de uma forma melhor os recursos e otimização do compilador se o código for em C++ em vez de C, resultando uma melhor velocidade do código e da aplicação. 2 - Maior segurança: Algumas funções da linguagem C não são seguras, por exemplo, no caso da strcpy: char nome[10]; strcpy(nome, "Joao Ferreira"); // Está copiando um nome maior que o tamanho que foi reservado para o nome. Se fosse em C++ o problema acima não iria acontecer porque a classe string possui alocação dinâmica, problemas como estouro de memória por exemplo, você não tem que se preocupar, deixa que a classe cuida da alocação de memória para você. Em C++ ficaria bem seguro e até mais fácil de usar: std::string nome; // Podemos colocar o nome que for e com quantos caracteres sem se preocupar com problemas diferentemente da strcpy nome = "Joao Ferreira"; nome = "Maria Ferreira Souza do Nascimento"; Outros exemplos de função que não é segura que foram até citadas por você é: printf e scanf scanf por exemplo, é muito comum ter estouros de buffers em strings(char*, char[]) 3 - Facilidade maior e melhor legibilidade do código: A linguagem C++ existe varias classes e funções que não existe na linguagem C, você pode usar um índice de como string ou qualquer outro tipo, graças a classe map, exemplo: std::map<std::string, int> idades; idades["Joao"] = 20; idades["Maria"] = 21; idades["Larissa"] = 30; Na linguagem C você sempre usa indices como inteiro ficando de uma forma bem limitada. ------ Como eu disse acima, a função printf não é segura, então por isso prefira sempre usar a cout em vez da printf e cin em vez de scanf. Mas se você quiser usar o printf/scan de uma forma segura, existe varias bibliotecas postadas na internet contendo uma uma função de print/scanf muito mais segura que a do C. Uma deles é a tiny format: https://github.com/c42f/tinyformat

@isrnick realmente esse algoritmo é muito melhor que o que eu tinha feito.

Com esse algoritmo vai acabar passando da faixa limitada(com muitos números gerados), tentei rodar com o Visual Studio, gerava exceção para números grandes.

Um pequeno exemplo(basta implementar no seu código): #include <iostream> #include <Windows.h> // Se quiser algo mais preciso que o GetTickCount, pode usar timeGetTime ou QueryPerformanceCounter ou a classe chrono #define TempoAtual GetTickCount class Contador { private: DWORD tempoAtual = 0; public: Contador(bool Iniciar = false) { if (Iniciar) this->Iniciar(); } void Iniciar() { tempoAtual = TempoAtual(); } void Zerar() { tempoAtual = 0; } void Resetar() { this->Zerar(); this->Iniciar(); } const double Millisegundos() const { return (TempoAtual() - this->tempoAtual); } const double Segundos() const { return (TempoAtual() - this->tempoAtual) / 1000.0; } }; int main() { while (true) { static Contador contador(true); if (contador.Segundos() > 10) { contador.Resetar(); std::cout << "10 segundos passados, pressionando dois enter.\n\n"; } } system("pause"); return 0; }

Se fosse em C++ ficaria mais fácil fazer isso, mas até que não ficou tão ruim: #include <stdio.h> #include <Windows.h> #include <time.h> bool numJaFoiGerado(int* vet, int size, int num) { for (int i = 0; i < size; i++) if (vet[i] == num) return true; return false; } int gerarNum(int min, int max) { return rand() % (max - min + 1) + min; } int main() { srand((unsigned int)GetTickCount()); int tam = sizeof(int) * 2; // * 2 para ficar uma posição livre no vetor, ficando equivalente a int vet[1] em vez de int vet[0] int* vet = (int*)malloc(tam); int qntNum = 0; while (qntNum < 30) // Gera 30 números { int num = gerarNum(1, 50); // Gera números entre 1 e 50 while (numJaFoiGerado(vet, qntNum, num)) // Verifica se o número gerado já existe no vetor, se existir gera novamente um número num = gerarNum(1, 50); // Gera novamente números entre 1 e 50 // Número gerado não existe ainda no vetor, então adiciona no vetor e aloca mais memória para o vetor vet[qntNum++] = num; tam += sizeof(int); // Realoca uma nova posição para o vetor vet = (int*)realloc(vet, tam); // Mostra o número printf("%i\n", num); Sleep(200); } // Libera memória que foi alocada para o vetor free(vet); system("pause"); return 0; } Saída: 1 44 20 48 37 50 4 24 7 28 16 40 32 38 30 36 39 5 6 15 23 11 9 27 29 13 49 10 41 14 Pressione qualquer tecla para continuar. . .

@kadafimatatu por favor poderia postar a pergunta da questão?

@giu_d realmente o código ficou bem mais limpo, não tinha pensado em usar a função substr para limitar, muito boa sua ideia.

Como foi dito pelo AnsiC, seu código passa longe de ser C++, isso é C, você quer em qual linguagem C ou C++? E não entendi bem o que você quer fazer(você esqueceu de postar a pergunta da questão e embora seja simples meu Portugol/VisualAlg é péssimo), parece que você quer apenas multiplicar uma matriz até uma coluna tal, é isso? Por favor poste a questão

Eu não falei que ia abandonar ou trocar, só perguntei porque na minha região você dificilmente vai encontrar trabalhos para programadores em C, a maioria prefere o C++(embora ainda prefiro a linguagem C), apenas para você ter uma ideia de como o C++ está ficando cada vez mais forte no mercado

@AnsiC onde você mora encontra muito mercado para linguagem C? Pois onde eu moro não. Não, podemos programar em algo muito mais baixo, como por exemplo em Assembly, utilizando até IDEs para C/C++, como por exemplo o Visual Studio ou CodeBlocks, ambos possuem suporte para inline assembly. Tudo que se pode fazer em C pode fazer em C++ e em 99% dos casos de uma forma até melhor.