bpcreg.h

希望我上传的这些东西可以对搞编程的程序员有点小小的帮助！谢谢！

inline long GetUserRegValue(LPCTSTR szSubKey, LPCTSTR szValueName, DWORD &dw)
{
    DWORD cb = sizeof(DWORD);

    return GetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey, NULL,
            szValueName, REG_DWORD, (BYTE *) &dw, &cb);
}

inline long GetUserRegValue(LPCTSTR szValueName, DWORD &dw)
{
    DWORD cb = sizeof(DWORD);

    return GetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, NULL, NULL,
            szValueName, REG_DWORD, (BYTE *) &dw, &cb);
}

//-----------------------------------------------------------------------------
// SetRegValue
//
// Sets data into the registry.  There are numerous overloads of this function
// that basically just provide defaults for the arguments to this function.
//
// Please use the overload that defaults as much as possible.
//
// The registry key/value is a combination of the following five parts.
// The first four are the same as in OpenRegKey().
//
//   HKEY hkeyRoot
//   LPCTSTR szKey
//   LPCTSTR szSubKey1
//   LPCTSTR szSubKey2
//
//   LPCTSTR szValueName = The name of the value to be set.
//                         If it is NULL then the default value for the key
//                         will be set.
//
//                         Default: none
//
// There are four ways to specify the data to be set into the registry
// depending on the type of data being stored.
//
// REG_BINARY
//
//   BYTE *pb      = Pointer to the data.
//   DWORD cb      = Actual size of the data (in bytes).
//
// REG_SZ
//
//   TCHAR *psz    = The data is written as type REG_SZ.
//                   The length is calculated as _tcsclen(psz) + sizeof(TCHAR).
//
// REG_DWORD
//
//   DWORD dw      = The data is written as type DWORD.
//                   The length is calculated as sizeof(DWORD).
//
// All other types
//
//   DWORD dwType  = The data type.
//   BYTE *pb      = Pointer to the data.
//   DWORD cb      = Actual size of the data in bytes.
//
// Returns:
//     ERROR_SUCCESS or an error code.
//-----------------------------------------------------------------------------
long SetRegValue(HKEY hkeyRoot, LPCTSTR szKey, LPCTSTR szSubKey1,
        LPCTSTR szSubKey2, LPCTSTR szValueName,
        DWORD dwType, const BYTE *pb, DWORD cb);

//-----------------------------------------------------------------------------
// REG_BINARY variants
//-----------------------------------------------------------------------------
inline long SetRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
        LPCTSTR szValueName, const BYTE *pb, DWORD cb)
{
    return SetRegValue(HKEY_LOCAL_MACHINE, szKey, szSubKey1, szSubKey2,
            szValueName, REG_BINARY, pb, cb);
}

inline long SetRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
        LPCTSTR szValueName, const BYTE *pb, DWORD cb)
{
    return SetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, szSubKey1,
            szSubKey2, szValueName, REG_BINARY, pb, cb);
}

inline long SetRegValue(LPCTSTR szSubKey, LPCTSTR szValueName,
        const BYTE *pb, DWORD cb)
{
    return SetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, szSubKey, NULL,
            szValueName, REG_BINARY, pb, cb);
}

inline long SetRegValue(LPCTSTR szValueName, const BYTE *pb, DWORD cb)
{
    return SetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey, NULL, NULL,
            szValueName, REG_BINARY, pb, cb);
}

//-----------------------------------------------------------------------------
// REG_SZ variants
//-----------------------------------------------------------------------------
inline long SetRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
        LPCTSTR szValueName, const TCHAR *psz)
{
    return SetRegValue(HKEY_LOCAL_MACHINE,
            szKey, szSubKey1, szSubKey2, szValueName,
            REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
}
inline long SetRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
        LPCTSTR szValueName, const TCHAR *psz)
{
    return SetRegValue(HKEY_LOCAL_MACHINE, g_strBaseRegKey,
            szSubKey1, szSubKey2, szValueName,
            REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
}

inline long SetRegValue(LPCTSTR szSubKey, LPCTSTR szValueName, const TCHAR *psz)
{
    return SetRegValue(HKEY_LOCAL_MACHINE,
            g_strBaseRegKey, szSubKey, NULL, szValueName,
            REG_SZ, (const BYTE *)psz, _tcsclen(psz) + sizeof(TCHAR));
}

inline long SetRegValue(LPCTSTR szValueName, const TCHAR *psz)
{
    return SetRegValue(HKEY_LOCAL_MACHINE,
            g_strBaseRegKey, NULL, NULL, szValueName,
            REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
}

//-----------------------------------------------------------------------------
// REG_DWORD variants
//-----------------------------------------------------------------------------
inline long SetRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
        LPCTSTR szValueName, DWORD dw)
{
    return SetRegValue(HKEY_LOCAL_MACHINE,
            szKey, szSubKey1, szSubKey2, szValueName,
            REG_DWORD, (BYTE *) &dw, sizeof(DWORD));
}

inline long SetRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
        LPCTSTR szValueName, DWORD dw)
{
    return SetRegValue(HKEY_LOCAL_MACHINE,
            g_strBaseRegKey, szSubKey1, szSubKey2, szValueName,
            REG_DWORD, (BYTE *) &dw, sizeof(DWORD));
}

inline long SetRegValue(LPCTSTR szSubKey, LPCTSTR szValueName, DWORD dw)
{
    return SetRegValue(HKEY_LOCAL_MACHINE,
            g_strBaseRegKey, szSubKey, NULL, szValueName,
            REG_DWORD, (const BYTE *) &dw, sizeof(DWORD));
}

inline long SetRegValue(LPCTSTR szValueName, DWORD dw)
{
    return SetRegValue(HKEY_LOCAL_MACHINE,
            g_strBaseRegKey, NULL, NULL, szValueName,
            REG_DWORD, (const BYTE *) &dw, sizeof(DWORD));
}

//-----------------------------------------------------------------------------
// The following variants are for setting values in an already open key.
//-----------------------------------------------------------------------------
inline long SetRegValue(HKEY hkey, LPCTSTR szValueName, const BYTE *pb, DWORD cb)
{
    return SetRegValue(hkey, NULL, NULL, NULL, szValueName,
            REG_BINARY, pb, cb);
}

inline long SetRegValue(HKEY hkey, LPCTSTR szValueName, const TCHAR *psz)
{
    return SetRegValue(hkey, NULL, NULL, NULL, szValueName,
            REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
}

inline long SetRegValue(HKEY hkey, LPCTSTR szValueName, DWORD dw)
{
    return SetRegValue(hkey, NULL, NULL, NULL, szValueName,
            REG_DWORD, (const BYTE *) &dw, sizeof(DWORD));
}

//-----------------------------------------------------------------------------
// SetUserRegValue
//
// Same as SetRegValue except hkeyRoot defaults to HKEY_CURRENT_USER.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// REG_BINARY variants
//-----------------------------------------------------------------------------
inline long SetUserRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
        LPCTSTR szValueName, const BYTE *pb, DWORD cb)
{
    return SetRegValue(HKEY_CURRENT_USER, szKey, szSubKey1, szSubKey2,
            szValueName, REG_BINARY, pb, cb);
}

inline long SetUserRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
        LPCTSTR szValueName, const BYTE *pb, DWORD cb)
{
    return SetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey1,
            szSubKey2, szValueName, REG_BINARY, pb, cb);
}

inline long SetUserRegValue(LPCTSTR szSubKey, LPCTSTR szValueName,
        const BYTE *pb, DWORD cb)
{
    return SetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, szSubKey, NULL,
            szValueName, REG_BINARY, pb, cb);
}

inline long SetUserRegValue(LPCTSTR szValueName, const BYTE *pb, DWORD cb)
{
    return SetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey, NULL, NULL,
            szValueName, REG_BINARY, pb, cb);
}

//-----------------------------------------------------------------------------
// REG_SZ variants
//-----------------------------------------------------------------------------
inline long SetUserRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
        LPCTSTR szValueName, const TCHAR *psz)
{
    return SetRegValue(HKEY_CURRENT_USER,
            szKey, szSubKey1, szSubKey2, szValueName,
            REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
}
inline long SetUserRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
        LPCTSTR szValueName, const TCHAR *psz)
{
    return SetRegValue(HKEY_CURRENT_USER, g_strBaseRegKey,
            szSubKey1, szSubKey2, szValueName,
            REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
}

inline long SetUserRegValue(LPCTSTR szSubKey, LPCTSTR szValueName, const TCHAR *psz)
{
    return SetRegValue(HKEY_CURRENT_USER,
            g_strBaseRegKey, szSubKey, NULL, szValueName,
            REG_SZ, (const BYTE *)psz, _tcsclen(psz) + sizeof(TCHAR));
}

inline long SetUserRegValue(LPCTSTR szValueName, const TCHAR *psz)
{
    return SetRegValue(HKEY_CURRENT_USER,
            g_strBaseRegKey, NULL, NULL, szValueName,
            REG_SZ, (const BYTE *) psz, _tcsclen(psz) + sizeof(TCHAR));
}

//-----------------------------------------------------------------------------
// REG_DWORD variants
//-----------------------------------------------------------------------------
inline long SetUserRegValue(LPCTSTR szKey, LPCTSTR szSubKey1, LPCTSTR szSubKey2,
        LPCTSTR szValueName, DWORD dw)
{
    return SetRegValue(HKEY_CURRENT_USER,
            szKey, szSubKey1, szSubKey2, szValueName,
            REG_DWORD, (BYTE *) &dw, sizeof(DWORD));
}

inline long SetUserRegValue(LPCTSTR szSubKey1, LPCTSTR szSubKey2,
        LPCTSTR szValueName, DWORD dw)
{
    return SetRegValue(HKEY_CURRENT_USER,
            g_strBaseRegKey, szSubKey1, szSubKey2, szValueName,
            REG_DWORD, (BYTE *) &dw, sizeof(DWORD));
}

inline long SetUserRegValue(LPCTSTR szSubKey, LPCTSTR szValueName, DWORD dw)
{
    return SetRegValue(HKEY_CURRENT_USER,
            g_strBaseRegKey, szSubKey, NULL, szValueName,
            REG_DWORD, (const BYTE *) &dw, sizeof(DWORD));
}

inline long SetUserRegValue(LPCTSTR szValueName, DWORD dw)
{
    return SetRegValue(HKEY_CURRENT_USER,
            g_strBaseRegKey, NULL, NULL, szValueName,
            REG_DWORD, (const BYTE *) &dw, sizeof(DWORD));
}

#endif // BPCREG_H
#pragma option pop /*P_O_Pop*/