C++ Este topico foi deletado

[xited]

_____________

[arfneto]

2 horas atrás, xited disse:

Queria fazer com que o arquivo "Xited.reg" fosse executado.
Procurei como poderia alterar chaves e valores do registro em c++, a unica maneira que achei foi usandoo system("diretorio_da_regedit"), mas queria executar o arquivo dentro da source e não puxa-lo de outro local no computador

 

Olá!

 

"Executar o arquivo dentro da source" e "puxá-lo de outro local do computador" são expressões que não entendi de fato.

 

Como não postou o conteúdo de Xited.reg não dá pra ter certeza do que quer fazer, mas imagino que seja como de costume um arquivo texto com algo a ser gravado ou lido no registro do sistema. Usar system() para executar o arquivo vai invocar o editor de registro se o editor de registro do windows estiver de fato configurado para abrir arquivos com extensão reg e é isso que você não quer fazer, já que disse que quer alterar chaves e valores de registro em seu programa

 

Entenda que uma coisa é alterar chaves e valores do registro em C++ e outra é processar arquivos reg em seu programa C++

 

alterar valores e chaves de registro em C++

 

Isso está bem documentado na fonte suprema dessas informações, a documentação do windows em http://docs.microsoft.com

Lá você pode ver um programa de exemplo, que funciona direitinho, para listar chaves de registro, nesta página

 

Eis o programa, só pra você poder dar uma olhada sem ter que ir até outro site:

// QueryKey - Enumerates the subkeys of key and its associated values.
//     hKey - Key whose subkeys and values are to be enumerated.

#include <windows.h>
#include <stdio.h>
#include <tchar.h>

#define MAX_KEY_LENGTH 255
#define MAX_VALUE_NAME 16383
 
void QueryKey(HKEY hKey) 
{ 
    TCHAR    achKey[MAX_KEY_LENGTH];   // buffer for subkey name
    DWORD    cbName;                   // size of name string 
    TCHAR    achClass[MAX_PATH] = TEXT("");  // buffer for class name 
    DWORD    cchClassName = MAX_PATH;  // size of class string 
    DWORD    cSubKeys=0;               // number of subkeys 
    DWORD    cbMaxSubKey;              // longest subkey size 
    DWORD    cchMaxClass;              // longest class string 
    DWORD    cValues;              // number of values for key 
    DWORD    cchMaxValue;          // longest value name 
    DWORD    cbMaxValueData;       // longest value data 
    DWORD    cbSecurityDescriptor; // size of security descriptor 
    FILETIME ftLastWriteTime;      // last write time 
 
    DWORD i, retCode; 
 
    TCHAR  achValue[MAX_VALUE_NAME]; 
    DWORD cchValue = MAX_VALUE_NAME; 
 
    // Get the class name and the value count. 
    retCode = RegQueryInfoKey(
        hKey,                    // key handle 
        achClass,                // buffer for class name 
        &cchClassName,           // size of class string 
        NULL,                    // reserved 
        &cSubKeys,               // number of subkeys 
        &cbMaxSubKey,            // longest subkey size 
        &cchMaxClass,            // longest class string 
        &cValues,                // number of values for this key 
        &cchMaxValue,            // longest value name 
        &cbMaxValueData,         // longest value data 
        &cbSecurityDescriptor,   // security descriptor 
        &ftLastWriteTime);       // last write time 
 
    // Enumerate the subkeys, until RegEnumKeyEx fails.
    
    if (cSubKeys)
    {
        printf( "\nNumber of subkeys: %d\n", cSubKeys);

        for (i=0; i<cSubKeys; i++) 
        { 
            cbName = MAX_KEY_LENGTH;
            retCode = RegEnumKeyEx(hKey, i,
                     achKey, 
                     &cbName, 
                     NULL, 
                     NULL, 
                     NULL, 
                     &ftLastWriteTime); 
            if (retCode == ERROR_SUCCESS) 
            {
                _tprintf(TEXT("(%d) %s\n"), i+1, achKey);
            }
        }
    } 
 
    // Enumerate the key values. 

    if (cValues) 
    {
        printf( "\nNumber of values: %d\n", cValues);

        for (i=0, retCode=ERROR_SUCCESS; i<cValues; i++) 
        { 
            cchValue = MAX_VALUE_NAME; 
            achValue[0] = '\0'; 
            retCode = RegEnumValue(hKey, i, 
                achValue, 
                &cchValue, 
                NULL, 
                NULL,
                NULL,
                NULL);
 
            if (retCode == ERROR_SUCCESS ) 
            { 
                _tprintf(TEXT("(%d) %s\n"), i+1, achValue); 
            } 
        }
    }
}

void __cdecl _tmain(void)
{
   HKEY hTestKey;

   if( RegOpenKeyEx( HKEY_CURRENT_USER,
        TEXT("SOFTWARE\\Microsoft"),
        0,
        KEY_READ,
        &hTestKey) == ERROR_SUCCESS
      )
   {
      QueryKey(hTestKey);
   }
   
   RegCloseKey(hTestKey);
}

Lá no site tem um botão marcado Copy que copia o código para a área de transferência e você pode colar de lá para seu compilador. Todos os exemplos de código lá tem isso e é mais seguro que tentar copiar daqui, o que geralmente insere caracteres estranhos em seu programa.

 

Toda a lista de funções para manipular o registro em seu programa está lá, em https://docs.microsoft.com/en-us/windows/win32/sysinfo/registry-functions

 

Processar arquivos reg em um programa C++

 

Isso é uma outra história: claro que no fundo vai acabar usando as mesmas funções, mas terá que abrir o arquivo reg e interpretar o texto lá, testar até onde possível a coerência do que está lá, comando a comando, e identificar a função certa pra executar, chamar a função e seguir para a próxima até o final do arquivo.