Odczytywanie wartości zapisanej w rejestrze

[PeTeKa]

Witam, chciałbym, aby program który stworzyłem, uruchamiał się tylko raz na danym PC. W tym celu na starcie aplikacji tworzę wpis w rejestrze:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

void __fastcall TForm1::Button1Click(TObject *Sender)
{
HKEY hKey;
                if(RegCreateKeyEx(HKEY_CURRENT_USER,
                                 L"SOFTWARE\\Test",
                                0, NULL, 0, KEY_ALL_ACCESS, NULL,
                                 &hKey, NULL) == ERROR_SUCCESS)
                {
                String nazwa = "Uruchomione";
                String wartosc = "1";
                RegSetValueEx(hKey, nazwa.t_str(), 0, REG_SZ, (PBYTE)(wartosc.c_str()), (wartosc.Length() * 2));
                RegCloseKey(hKey);
                }
}

Mam problem teraz żeby testowo odczytać sobie ową wartość 1. Próbowałem w ten sposób:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

HKEY hKey;
 String name = "Uruchamione";
 TCHAR date[255];
 DWORD length = 255 * sizeof(TCHAR);

 if(RegOpenKeyEx( HKEY_LOCAL_MACHINE,
                 L"SOFTWARE\\Test",
                0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS)
 {
  RegQueryValueEx( hKey, name.t_str(), NULL, NULL, (LPBYTE)date, &length);

  RegCloseKey(hKey);
 }
 Edit1->Text = (String)date;

Czy ktoś mógłby podpowiedzieć jak wyłuskać wartość 1? np. do Jakiegoś edita, lub labela.

[Android]

Wklejam kod źródłowy funkcji, do obsługi rejestru, z których korzystam - może coś z tego Ci się przyda.
Funkcje odczytujące wartość przyjmują jako parametr zmienna do której zapisywana jest wartość.

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

typedef UnicodeString US;
//---------------------------------------------------------------------------
 bool Autostart(UnicodeString NazwaProgramu, bool uruchom)
 {
         bool Wynik=false;
         UnicodeString adres_programu =  ExpandFileName(Application->ExeName);
         TRegistry* Rejestr = new TRegistry();
         Rejestr->Access=KEY_SET_VALUE;
         Rejestr->RootKey=HKEY_CURRENT_USER;

         if(Rejestr->OpenKey("Software\\Microsoft\\Windows\\CurrentVersion\\Run", false))
         {
                 if(uruchom)
                 {
                         Rejestr->WriteString(NazwaProgramu, adres_programu);
                 }
                 else
                 {
                         Rejestr->DeleteValue(NazwaProgramu);
         }
         }
   Rejestr->CloseKey();
   delete Rejestr;

 }
 //--------------------------------------------------------------------------
 bool SprawdzAutostart(UnicodeString NazwaProgramu)
 {
        bool Autostart = false;
        TRegistry* Rejestr = new TRegistry();
        Rejestr->Access=KEY_READ;
        Rejestr->RootKey=HKEY_CURRENT_USER;
        if(Rejestr->OpenKey("Software\\Microsoft\\Windows\\CurrentVersion\\Run", false))
        {
                if(Rejestr->ValueExists(NazwaProgramu))
                {
                        Autostart=true;
                }
                else
                {
                        Autostart=false;
        }
    }
        Rejestr->CloseKey();
        delete Rejestr;
         return Autostart;
 }
 //--------------------------------------------------------------------------
 bool DodajWartoscDoRejestru(HKEY Root, US Klucz, US Nazwa, US Wartosc, int typ, bool Stworz )
 { //typ 0 = string, typ 1 = int
        bool wynik=false;
        TRegistry * Rejestr = new TRegistry();
        Rejestr->RootKey=Root;
        Rejestr->Access=KEY_SET_VALUE;

        if(Rejestr->OpenKey(Klucz, Stworz))
        {
                switch(typ)
                {
                        case 0:
                        {
                                Rejestr->WriteString(Nazwa, Wartosc);
                                break;
                        }
                        case 1:
                        {
                                int wart = StrToInt(Wartosc);
                                Rejestr->WriteInteger(Nazwa, wart);
                                break;
                        }
                        default:
                        {
                                wynik=false;
            }
                }

                if(Rejestr->ValueExists(Nazwa))
                {
                        wynik=true;
                }
                else
                {
                        wynik=false;
                }

        }
        else
        {
                wynik=false;
    }


        Rejestr->CloseKey();
        delete Rejestr;
        return wynik;
 }
 //--------------------------------------------------------------------------
 bool UsunWartoscZRejestru(HKEY Root, US Klucz, US Nazwa)
 {
         bool wynik=false;
         TRegistry * Rejestr = new TRegistry();
         Rejestr->RootKey=Root;
         Rejestr->Access=KEY_ALL_ACCESS;

         if(Rejestr->KeyExists(Klucz))
         {
                 if(Rejestr->OpenKey(Klucz, false))
                 {
                         if(Rejestr->ValueExists(Nazwa))
                         {
                                 Rejestr->DeleteValue(Nazwa);
                         }

                         Rejestr->CloseKey();
                         wynik=true;
                 }
                 else
                 {
                         wynik=false;
                 }
         }
         else
         {
                 wynik=true;
         }

         delete Rejestr;
         return wynik;
 }
 //--------------------------------------------------------------------------
 //funkcja OdczytajWartoscZRejestru zwraca true gdy odczyt sie udal lub false w przeciwnym
 //wypadku, wlasciwa wartosc zapisywana jest w zmiennej UnicodeString do, ktorej adres
 //nalezy podac jako parametr Wartosc, kody typow zdefiniowane we wnetrzu funkcji
 bool OdczytajWartoscZRejestru(HKEY Root, US Klucz, US Nazwa, US* Wartosc, int typ)
 { //typ 0 = string, typ 1 = int
         bool wynik=false;
         TRegistry * Rejestr = new TRegistry();
         Rejestr->RootKey=Root;
         Rejestr->Access=KEY_ALL_ACCESS;

      if(Rejestr->KeyExists(Klucz))
         {
                 if(Rejestr->OpenKey(Klucz, false))
                 {
                         if(Rejestr->ValueExists(Nazwa))  //jesli istnieje wartos to odczytaj
                         {
                                  switch(typ)
                                  {
                                          case 0:
                                          {
                                                 *Wartosc=Rejestr->ReadString(Nazwa);
                                                 break;
                                          }
                                          case 1:
                                          {
                                               *Wartosc=IntToStr(Rejestr->ReadInteger(Nazwa));
                                                 break;
                                          }
                                  }

                                  wynik=true;
                         }
                         else //jesli wartosc nie istnieje
                         {
                                 wynik=false;
                         }

                         Rejestr->CloseKey();

                 }
                 else   //jesli nie mozna otworzyc klucza
                 {
                         wynik=false;
                 }
         }
         else     // jesli klucz nie istnieje
         {
                 wynik=false;
         }

         delete Rejestr;
         return wynik;
 }
 //--------------------------------------------------------------------------
 bool PobierzListeWartosci(HKEY Root, US Klucz, TStringList * Lista)
 {
        bool wynik=false;
        TRegistry * Rejestr = new TRegistry();
        Rejestr->RootKey=Root;
        Rejestr->Access=KEY_ALL_ACCESS;

        TStringList * Listatemp = new TStringList();

        std::auto_ptr<TStrings> vList(Listatemp);

        if(Rejestr->KeyExists(Klucz))
        {
                if(Rejestr->OpenKey(Klucz,false))
                {
                   Rejestr->GetValueNames(vList.get());
                   //kopiowanie z temp do wlasciwiej
                   for(int i=0; i<Listatemp->Count; i++)
                   {
                           Lista->Add(Listatemp->Strings[i]);
                   }
                   wynik=true;
                }
                else
                {   //nie udalo sie otworzyc
                        wynik=false;
        }
        }
        else
        {   //nie ma klucza wiec pobranie spisu jest nie mozliwe
                wynik=false;
    }

        delete Rejestr;
        return wynik;
 }
 //--------------------------------------------------------------------------
 US PobierzNazweCurrentUser()
 {
        US nazwa_uzytkownika ="";
        TRegistry * Rejestr = new TRegistry();
        Rejestr->RootKey=HKEY_CURRENT_USER;
        Rejestr->Access=KEY_ALL_ACCESS;
        US Klucz = "\\Volatile Environment\\";
        if(Rejestr->KeyExists(Klucz))
        {
                if(Rejestr->OpenKey(Klucz,false))
                {
                        //ShowMessage("Jest");
                        //dla Visty i Win 7
                        if(Rejestr->ValueExists("USERNAME"))
                        {
                                //ShowMessage("Jest USERNAME");
                                nazwa_uzytkownika=Rejestr->ReadString("USERNAME");
                        }
                        else if (Rejestr->ValueExists("HOMEPATH")) //dla starszych systemow odczytaj z HOMEPATH
                        {
                                //ShowMessage("Jest HOMEPATH");
                                US temp=Rejestr->ReadString("HOMEPATH");
                                US znak ="\\";
                                int dlugosc = temp.Length();
                                int poz_uk =0;
                                for(int i=dlugosc; i>0; i--)
                                {
                                        //ShowMessage(znak[1]);
                                        if(temp[i]==znak[1])
                                        {
                                                 poz_uk = i;
                                                 break;
                                        }
                                }
                                ShowMessage(IntToStr(poz_uk)+"    "+IntToStr(dlugosc));
                                for(int i=poz_uk+1; i<=dlugosc; i++)
                                {
                                        nazwa_uzytkownika+=temp[i];
                }
                        }
                }
        }


        delete Rejestr;
        return nazwa_uzytkownika;
 }
 

[Cyfrowy Baron]

► patrz serwis: Cyfrowy Baron dział: teoria obsługa rejestru.

Do odczytywania wartości typu Integer służy funkcja ReadInteger:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

 #include <Registry.hpp>

 String name = "Uruchamione";
 
 TRegistry *Rejestr = new TRegistry();
 Rejestr->RootKey = HKEY_LOCAL_MACHINE;
 Rejestr->OpenKey("Software\\Test", false);

 Edit1->Text = IntToStr( Rejestr->ReadInteger(name) );

 delete Rejestr;

Z twojego kodu wynika jednak że do klucza uruchomione zapisujesz co prawda liczbę, ale jako tekst, czyli wartość typu String. Trochę to niezrozumiałe, ale może być. W takim przypadku powinieneś posłużyć się funkcją ReadString:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

 Edit1->Text = Rejestr->ReadString(name);