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

1 hora atrás, AnsiC disse:

Não seria porque da segundo vez a CPU detecta a rotina em cache e faz os cálculos lá mesmo!?

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.

19 horas atrás, LuisOPsum disse:

Olá..

Esse faz.:

#include <iostream>
#include "DLL_.h"
#define DLL_EXPORT extern "C" { DECLDIR int Add( int a, int b ) { return( a + b ); }
DECLDIR void Function( void ) { std::cout << "DLL Called!" << std::endl; }
}

Espero ter ajudado e até...

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?

2 horas atrás, isrnick disse:

@guilherme.cabrals O tamanho do vetor é fixado no momento em que ele é criado, um vetor com tamanho variável depende do valor da variável entre os colchetes no momento em que o vetor é declarado.

 

Você poderia definir os vetores após obter o valor da variável:

#include<stdio.h>

int main () {
    int Indice,i,Xvalor;
    
    printf("Quantos indices desejas nos vetores?\n");
    scanf("%d",&Xvalor);
    Indice = Xvalor - 1;
    
    int VetA[Xvalor];
    int VetB[Xvalor];
    int VetC[Xvalor];
    
    for (i=0;i<=Indice;i++){
        printf("Digite um numero para o indice:%d do VetorA. \n",i);
        scanf("%d", &VetA[i]);
    }
    
    for (i=0;i<=Indice;i++){
        printf("Digite um numero para o indice:%d do VetorB. \n",i);
        scanf("%d", &VetB[i]);
    }
    
    for(i=0;i<=Indice;i++){
        VetC[i]= VetA[i] * VetB[i];
    }
    
    for(i=0;i<=Indice;i++){
        printf("VetC[%d]=%d\n",i,VetC[i]);
    }
    
    return 0;
}

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:

Citação

1>c:\users\admin\source\repos\ch\ehhelper\main.cpp(460): error C2131: expression did not evaluate to a constant
1>c:\users\admin\source\repos\ch\ehhelper\main.cpp(460): note: failure was caused by a read of a variable outside its lifetime
1>c:\users\admin\source\repos\ch\ehhelper\main.cpp(460): note: see usage of 'Xvalor'

O ideal é usar alocação dinâmica para evitar esses problemas.

46 minutos atrás, guilherme.cabrals disse:

@isrnick mesmo eu declarando o valor de indice e so usando a variavel depois?

 

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 );
}

10 horas atrás, giu_d disse:

@Sh 1  Olá. Dá uma olhada no código para ver se é isso q você quer:

 

#include <iostream>
#include <algorithm>
#include <string>
using namespace std;

char my_toupper(char ch) {
    return toupper(static_cast<unsigned char>(ch));
    //return toupper(ch);
}

string str_toupper(string s) {
    transform(s.begin(), s.end(), s.begin(), ::toupper);
    return s;
}

int main() {

    string texto = "Exemplo de String";

    cout <<  str_toupper(texto) << endl;

    char letra = 'a';

    cout << my_toupper(letra) << endl;

    return 0;
}

 

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

Em 24/05/2018 às 14:10, LuisOPsum disse:

Olá...

Sua solução.:

#include <conio.h>
#include <stdio.h>
int main()
{
    int i,n,s=0;
    for(i=1; i<=2; i++){
    printf("Digite a U$ %d de 0 ate 99.: ",i);
    scanf("%d",&n);
    if((n >= 0) && (n <= 99))
     s = s + n;
     else
     {
         printf("apenas de U$: 0 ate 99\n");
         i--;
     }
    }
    printf("a soma de U$: %d Dolares.",s);
    getch();
}

Saida.:

Digite o U$ 1 de 0 ate 99.: 40

Digite o U$ 2 de 0 ate 99.: 50

O valor U$: 90 Dolares.

Obs.: valor acima ou abaixo ele retorna a digitar e obriga apenas de 0 ate 99.

 

Luís - espero ter ajudado e até...

 

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.

6 minutos atrás, isrnick disse:

@cyer Esse método é muito ineficiente, imagine por exemplo que o intervalo vai de 1 até 1000, e deseja-se escolher 980 números aleatórios sem repetição, nesse caso seu algoritmo vai ficar gerando um novo número novamente centenas até milhares de vezes pois já existe o número na lista. Além do algoritmo precisar checar o vetor inteiro de números já gerados toda vez que um novo número é gerado.

 

O método usando um vetor embaralhado definitivamente é uma opção melhor.

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

3 horas atrás, AnsiC disse:

Em nenhum momento estou pedindo para você abandonar uma coisa pela outra; Pelo contrario faça como quiser e siga a tendencia de sua regiã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.

Citação

C é o mais perto que podermos chegar da máquina

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.