Ich muss in einem Programm einige Registry Werte auslesen und ausgeben.
Alle Werte sind unter demselben Schlüssel, alle Werte sind REG_SZ.
Wenn ich nur einen Wert auslese und ausgebe, funktioniert alles ohne Probleme.
Wenn ich aber mehrere Werte auslese, stimmt die ausgabe nicht mit den werten überein.

Als kleines Beispielprogramm habe ich mal die Werte für das automatische Anmelden versucht zu lesen und auszugeben.
Wert: Daten (überprüft per Registry-Editor)
--------------
DefaultUserName: julian
DefaultDomain: JULIAN-DESKTOP1
DefaultPassword: *leer*

Die Ausgabe meines Programms:

DefaultUserName:	ju
DefaultDomain:	u
DefaultPassword:

Der Programmcode:

#include  <iostream>
#include  <Windows.h.>
using namespace std;

typedef unsigned char uchar;
typedef unsigned long ulong;

//  Variablen
HKEY hklm;
uchar name[1], domain[1], password[1];
ulong len = 256;

//  Funktionen
void GetValue( char value[256], uchar & ptr )
{
  RegQueryValueEx( hklm,
       value,
       NULL,
       NULL,
       ( unsigned char * ) & ptr,
       & len
       );
}

int main()
{

  //  Schlüssel öffnen
  RegOpenKeyEx( HKEY_LOCAL_MACHINE,
       "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon",
       0,
       KEY_READ,
       & hklm
       );

  //  DefaultUserName lesen
  GetValue( "DefaultUserName", * name );

  //  DefaultDomain lesen
  GetValue( "DefaultDomain", * domain );

  //  DefaultPassword lesen
  GetValue( "DefaultPassword", * password );

  //  Schlüssel schließen
  RegCloseKey( hklm );

  //  Test-Ausgabe
  cout << "DefaultUserName:\t" << name << endl
       << "DefaultDomain:\t" << domain << endl
       << "DefaultPassword:\t" << password << endl;

  system( "pause>nul" );

  return 0;
}

Dazu sei gesagt, dass ich erst seit ca. 1/2 Jahr C++ lerne und daher noch bei Konsolenprogrammen bin, nur falls sich jemand fragt, weshalb der typ hier nur alles in der konsole ausgibt.

Schonmal DANKE an alle, die mir helfen und helfen werden.

Julian__ schrieb:

uchar name[1], domain[1], password[1];

Du reservierst hier jeweils Speicherplatz für 1 (in Worten: einen) Character. Das wird wohl zu wenig sein. BTW: Wieso global!?

Julian__ schrieb:

void GetValue( char value[256], uchar & ptr )
//
//...
//
//Aufruf:
//
GetValue( "DefaultUserName", * name );

Wieso nimmst du als ersten Parameter für GetValue ein Array? uchar &ptr ist eine Referenz und kein Zeiger - wie deir Name ptr vermuten lassen könnte. Beim Aufruf dereferenzierst du name (*name) und übergibst dadurch den Wert in name[0]. GetValue nimmt davon eine Referenz ptr.

Julian__ schrieb:

void GetValue( char value[256], uchar & ptr )
{
  RegQueryValueEx( hklm,
       value,
       NULL,
       NULL,
       ( unsigned char * ) & ptr,  // <- 1)
       & len                       // <- 2)
       );
}

ad 1)
Hier nimmst du die Adresse von ptr was bedeutet die adresse von name[0] und RegQueryValueEx überschreibt es mitsamt des darauffolgenden Speichers -> Speicherverletzung!

ad 2)
RegQueryValueEx gibt dir in len (Anfangs 256) die Länge des in ptr zurückgegeben Strings zurück wodurch len für die weiteren Aufrufe verändert wird.

Weiters könnte es natürlich auch sein, das RegQueryValueEx fehlschlägt.

Ließ die Kapitel über Pointer und Speicherverwaltung in einem C/C++ Buch deines vertrauens nocheinmal gründlich durch!

So gehts:

#include <iostream>
#include <string>

#include <windows.h>

using namespace std;

void wait( )
{
    cout << endl << "Press return to continue..." << endl;
    cin.clear();
    cin.ignore(std::cin.rdbuf()->in_avail());
    cin.get();
}

string get_errmsg( unsigned long error )
{
    void *buffer;
    FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                   0,
                   error,
                   MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
                   reinterpret_cast< char* >( &buffer ),
                   0,
                   0
    );

    string errmsg = string( reinterpret_cast< char* >( buffer ) );
    LocalFree( buffer );
    return errmsg;
}

bool reg_read_value_string( string &value, const HKEY &hkey, const char *value_name )
{
    unsigned long value_type;

    // test for data type:
    RegQueryValueEx( hkey, value_name, 0, &value_type, 0, 0 );

    if( value_type != REG_SZ )

        return false;

    // read the data:

    unsigned long result;
    unsigned long size = 1;
    unsigned char *data = new unsigned char[ 1 ];

    if( ( result = RegQueryValueEx( hkey, value_name, 0, 0, data, &size ) ) ) {

        delete [ ] data;

        if( result != ERROR_MORE_DATA )

            return false;

        try {

            data = new unsigned char[ size ];

        } catch( bad_alloc ) {

            return false;
        }

        if( RegQueryValueEx( hkey, value_name, 0, 0, data, &size ) )

            return false;
    }

    value = reinterpret_cast< char* >( data );
    delete [ ] data;
    return true;
}

int main()
{
    HKEY reg_key;
    unsigned long result;

    if( ( result = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
                                 "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon",
                                 0,
                                 KEY_READ,
                                 &reg_key
                               )
        ) ) {

        cout << "RegOpenKeyEx() failed:" << endl;
        cout << get_errmsg( result ) << endl;
        wait( );
        return EXIT_FAILURE;
    }

    string name, domain, password;

    if( !reg_read_value_string( name, reg_key, "DefaultUserName" ) ) {

        RegCloseKey( reg_key );
        cout << "Failed to read DefaultUserName!" << endl;
        wait( );
        return EXIT_FAILURE;

    } else {

        cout << "DefaultUserName: " << name << endl;
    }

    if( !reg_read_value_string( domain, reg_key, "DefaultDomainName" ) ) {

        RegCloseKey( reg_key );
        cout << "Failed to read DefaultUserName!" << endl;
        wait( );
        return EXIT_FAILURE;

    } else {

        cout << "DefaultDomain:   " << domain << endl;
    }

    if( !reg_read_value_string( password, reg_key, "DefaultPassword" ) ) {

        RegCloseKey( reg_key );
        cout << "Failed to read DefaultUserName!" << endl;
        wait( );
        return EXIT_FAILURE;

    } else {

        cout << "DefaultPassword: " << password << endl;
    }

    RegCloseKey( reg_key );

    wait( );
    return EXIT_SUCCESS;
}

Greetz, Swordfish

ja, das kommt davon, wenn man spät abends noch mit sowas (für mich recht anspruchsvollem) anfängt. heute morgen hab ich erst ma selbst über den code gelacht.
ich hatte keine lust mehr auf die ganzen fehlermeldungen und habe so lange (recht kurz) mit * und & ausprobiert, bis keine mehr kamen.

naja, ich finds toll, dass du mir hier eine fertige lösung vorgibst, aber ich mach das ja grad, um nicht auf copy&paste zurückgreifen zu müssen, ich würd den code auch gern verstehen.
beim größten teil komm ich auch mit, aber könntest du mir vielleicht nochmal
get_errmsg() und reinterpret_cast<>() erklären?
ich habe schon danach gegoogelt, aber nichts wirklich gut verständliches gefunden.
wär echt nett von dir.
außerdemverstehe ich das hier

if( ( result = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
                                 "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon",
                                 0,
                                 KEY_READ,
                                 &reg_key
                               )
        ) ) {

        cout << "RegOpenKeyEx() failed:" << endl;
        cout << get_errmsg( result ) << endl;
        wait( );
        return EXIT_FAILURE;
    }

nicht ganz (wann ist if(true), wann if(false)?), wäre nett, auch das nochmal zu erläutern. danke.

mfg, julian

Zu deiner anderen Frage: Schau doch mal hier http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/regopenkeyex.asp

Wenn alles klappt liefert RegOpenKeyEx ERROR_SUCCESS zurück. ERROR_SUCCESS ist als 0 definiert, deshalb klappt das. Ob ERROR_SUCCESS allerdings für immer garantiert ist 0 zurückzugeben, ist eine andere Frage. Wenn nicht, dann ist Swordfishs code auch in dieser Hinsicht grob fahrlässig.

MfG,
:schland: *Ranner* :schland:

Lass dich von diesem groben Unfug nicht verwirren.

Kannst du mir bitte mal erklären, was an meinem Code "grober Unfug" ist!?

{ Ranner | Ranner | Real_Ranner } schrieb:

reinterpret_cast< char* > ist im Prinzip das gleiche wie (char*) also ein reiner Cast.

Nein ist es nicht. Was soll ein "reiner Cast" sein!?

{ Ranner | Ranner | Real_Ranner } schrieb:

Ich verstehe auch nicht warum Swordfish seinen Code immer unnötig kompliziert machen muss, damit Neulinge wie du ihn dann eh nicht verstehen.

Ich schreibe meinen Code sicherlich nicht "unnötig kompiziert", sondern tu was notwendig ist.

{ Ranner | Ranner | Real_Ranner } schrieb:

Wenn nicht, dann ist Swordfishs code auch in dieser Hinsicht grob fahrlässig.

Ich trau' mich die Hand dafür in's Feuer legen, das ERROR_SUCCESS bis in alle Ewigkeit (oder, falls das früher eintritt: bis es diese Konstante nicht mehr gibt) 0 (in Worten: Null) sein und bleiben wird.

Greetz, Swordfish

anstatt reinterpret_cast<char>* kann ich auch die normale explizite typumwandlung (char)* benutzen, das hab ich ausprobiert.

wo der unterschied zu reinterpret_cast<char*> liegt, weiß ich allerdings immer noch nicht.

ein reinterpret_cast< type >( var ) sorgt dafür, das der Speicher, auf welchen var Zeigt wie type interpretiert wird. Hätte wir zum Beispiel

#include <iostream>
using namespace std;

int main( )
{
//  einen

    float f = 2.345f;

//  dann könnten wir mit einem

    unsigned char *p = reinterpret_cast< unsigned char* >( &f );

//  an das erste Byte von f kommen und so

    for( size_t i = 0; i < sizeof( float ); ++i ) {

        cout << "0x";
        cout.width( 2 );
        cout.fill( '0' );
        cout << hex << p[ i ] << " ";
    }

//  alle Bytes nacheinander ausgeben.

Der Unterschied zu einem C-Style Cast ist, daß man mit ihm keine consts "wegcasten" kann:

int main( )
{
    const char str[ ] = "Hello";
    char *p = reinterpret_cast< char* >( str ); // <- *)
}

wird zu einem Compilerfehler ähnlich dem Wortlaut "'reinterpret_cast' : 'const char [6]' kann nicht in 'char *' konvertiert werden" führen. Mit einem C-Style Cast ist dies möglich:

int main( )
{
    const char str[ ] = "Hello";
    char *p = ( char* ) str;

    cout << "Before: \"" << str << "\"" << endl;

    p[ 1 ] = 'a'; // wir schreiben munter in konstanten Speicher!

    cout << "After: \"" << str << "\"" << endl;
}

Ausgabe:

Before: "Hello"
After: "Hallo"

Mit C++ Casts wäre dazu explizit ein const_cast nötig:

#include <iostream>

using namespace std;

int main( )
{
    const char str[ ] = "Hello";
    char *p = const_cast< char* >( str );

    cout << "Before: \"" << str << "\"" << endl;

    p[ 1 ] = 'a';

    cout << "After: \"" << str << "\"" << endl;
}

Somit kann es mit C++ Casts nicht passieren, das man sich "aus versehen" in's Bein schießt.

Greetz, Swordfish

code:

#include  <iostream>
#include  <string>
#include  <windows.h>

using namespace std;

#define cls system("cls")
#define wait  system  ("pause>nul")
void  color(string  pColor)
{
  string  cmdstr  = "color "  + pColor;
  system(cmdstr.c_str());
}

typedef unsigned  long  ulong;
typedef unsigned  char  uchar;

bool  RegReadValueString(  string &value_data, const HKEY  &hkey,  const char* value)
{
  ulong val_type;

  //  Typ des Wertes prüfen
  RegQueryValueEx(  hkey, //  Schlüssel -ein
                    value,  //  Wert  -ein
                    0,  //  immer NULL  -ein
                    &val_type, //  Typ des Wertes -aus
                    0,  //  Puffer für Daten des Wertes -ein
                    0 //  Größe des Puffers -aus
                 );

  if( val_type  !=  REG_SZ  )
    return  false;  //  falls Werte-Typ !=  String

  //  Daten lesen
  ulong result;
  ulong size  = 1;  //  Größe des Daten-Puffers
  uchar *data = new uchar[1]; //  Daten-Puffer  ( Platz für 1 Zeichen => \0 )

  if( result  = RegQueryValueEx(  hkey, value,  0,  0,  data, &size  ) )
  {
    delete  []  data;

    if( result  !=  ERROR_MORE_DATA )
      return  false;  //  Falls Daten = "\0"

    try
    {
      data  = new uchar[size];  //  Puffer  auf die richtige Größe bringen
    }
    catch(  bad_alloc )
    {
      return  false;  //  falls Vergrößern des Puffers fehlschlägt
    }

    if( RegQueryValueEx(  hkey, value,  0,  0,  data, &size ) )
      return  false;  //  falls weitere Fehler auftreten
  }
  value_data  = (char*) data;  //  Daten in C-String-Parameter schreiben
  delete  []  data; //  Daten-Array leeren
  return  true; //  bei Erfolg

} //  RegDataToStr

int main()
{
  HKEY  hkey;
  string  status, name, domain, password;

  //  Schlüssel öffnen
  if( RegOpenKeyEx( HKEY_LOCAL_MACHINE, //  Host-Key
                    "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon",
                      //  Unerschlüssel
                    0,  //  immer NULL
                    KEY_READ, //  Zugriffsberechtigungen zum öffnen
                    &hkey //  HKEY-Handle
                  )
    )
  {
    cls;
    color("c");
    cout  <<  "Fehler: HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\"
          <<  "CurrentVersion\\Winlogon konnte nicht geoeffnet werden.\n"
          <<  "beliebige Taste zum Beenden ...\n";
    wait;
    exit(-1);
  }

  //  Daten lesen

  //  Status lesen
  if( !RegReadValueString(  status, hkey, "AutoAdminLogon" ) )
  {
    cls;
    color("c");
    cout  <<  "Fehler: AutoAdminLogon konnte nicht gelesen werden.\n";
    cout  <<  "name";
    wait;
    exit(-1);
  }
  else
  {
    if( status  ==  "1" )
      status  = "AKTIVIERT";
    else
      status  = "DEAKTIVIERT";
  }

  //  Namen lesen
  if( !RegReadValueString( name, hkey, "DefaultUserName" )  )
  {
    cls;
    color("c");
    cout  <<  "Fehler: DefaultUserName konnte nicht gelesen werden.\n";
    wait;
    exit(-1);
  }

  //  Domain lesen
  if( !RegReadValueString(  domain, hkey, "DefaultDomain" ) )
  {
    cls;
    color("c");
    cout  <<  "Fehler: DefaultDomain konnte nicht gelesen werden.\n";
    wait;
    exit(-1);
  }

  //  Passwort lesen
  if( !RegReadValueString(  password, hkey, "DefaultPassword" ) )
  {
    cls;
    color("c");
    cout  <<  "Fehler: DefaultPassword konnte nicht gelesen werden.\n";
    wait;
    exit(-1);
  }

  //  Hauptmenü ausgeben
  hm:

  int choice;

  cls;
  cout  <<  "\t\tautomatischer Login  ist "  <<  status  <<  endl
        <<  "\t\tBenutzername:            " <<  name  <<  endl
        <<  "\t\tDomain:                  " <<  domain  <<  endl
        <<  "\t\tPasswort:                " <<  password  <<  endl;
  return  0;
}

ausgabe:

Fehler: DefaultDomain konnte nicht gelesen werden.

Julian__ schrieb:

ausgabe:

Fehler: DefaultDomain konnte nicht gelesen werden.

Ich nehme mal an, das SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\AutoAdminLogon bei dir (wie auch bei mir) schlichtweg nicht existiert. Du könntest jeden Wert auf Existenz prüfen, bevor du versuchst ihn zu lesen und wenn ein Wert nicht existiert mit dem nächsten weitermachen. Testen kannst du das zB. mit:

bool reg_value_exists( HKEY reg_key, const string value )
{
    char value_name[ 256 ];
    unsigned long size = 256;

    long result = 0;

    if( ( result = RegEnumValue( reg_key, 0, value_name, &size, 0, 0, 0, 0 ) ) )
        return false;

    if( value.compare( value_name ) == 0 )
        return true;

    for( unsigned long i = 1; true; ++i ) {

        size = 256;

        if( ( result = RegEnumValue( reg_key, i, value_name, &size, 0, 0, 0, 0 ) ) )
            return false;

        if( value.compare( value_name ) == 0 )
            return true;

        ++i;

    } while( true );

    return false;
}

Achja, noch was zu deinem Code:

// ...

#define cls system("cls")             // 1)
#define wait  system  ("pause>nul")   // 2)

void color(string  pColor)            // 3)
{
  string  cmdstr  = "color "  + pColor;
  system(cmdstr.c_str());
}

// ...

exit(-1);                             // 4)

// ...

hm:                                   // nicht benutzt
int choice;                           // ebenfalls

1. wenn du einen Makro als einen Funktionsersatz verwendest, solltest du im á la

#define cls() system("cls")

// Aufruf:

cls();

Klammern verpassen, damit man nicht in Versuchung kommt, ihn für einen Variablenamen zu halten.

2. schau dir mal DOS und Win32-Konsole :: Automatisches Schließen verhindern an.

3. zum Löschen des Bildschirms und farbiger Ausgabe solltest du die Improved Console ansehen.

4. bei exit( int code ) verwendet man als Parameter üblicherweise EXIT_SUCCESS bzw. EXIT_FAILURE. Ein einfaches return( 0 ) tuts in den meisten fällen genauso gut.

Hoff' ich konnt' helfen.

Greetz, Swordfish

naja, mit deiner vermutung lagst du fast richtig.
ich überleg den ganzen verdammten tag, woran das liegen könnte und eben fällt mir auf, dass der key ja nicht "DefaultDomain", sondern "DefaultDomainName" heißt.
schön blöd...

ja, lacht ruhig, hab ich auch gemacht.

und danke für die links!

aber: ich habe den C++BuilderX (borland), der war bei einem anfängerbuch dabei und gefällt mir sehr gur, ist halt nur keine RAD, aber ich schreib ja (noch) nur konsolenprogramme. und der C++BuilderX ist nicht unter den unterstützten compilern bei Improved Console aufgeführt. sollte das trotzdem klappen?

[...] der C++BuilderX ist nicht unter den unterstützten compilern bei Improved Console aufgeführt. sollte das trotzdem klappen?

Entweder probierst du's einfach aus oder du fragst hier: Improved Console

Greetz, Swordfish

ok, nochmal danke swordfish für deine hilfe hier bei meinen (meist durch eigene dummheit entstandenen) problemen.

euer forum werd ich mir merken, ist, wirklich gut hier, hab schon viel schlechteres erlebt.

mfg, julian

yo hab ich schon gemacht. funktioniert auch alles, bis auf die dropdown-menüs mit den möglichen methoden, aber das liegt ja am compiler (an der IDE).

ok, nochmal danke swordfish für deine hilfe hier bei meinen (meist durch eigene dummheit entstandenen) problemen.

euer forum werd ich mir merken, ist, wirklich gut hier, hab schon viel schlechteres erlebt.

mfg, julian

Dieses Forum nicht nur merken, sonder Klicken

Greetz, Swordfish