Re: Редактор реестра. Страница 1. Раздел «Общение». Форум программистов «Весельчак У»

Алексей1153++, у меня нет времени на базар... Что я буду обсуждать? Удачна или не удачна моя реализация красно-черных деревьев и есть ли смысл в использовании динамического полиморфизма? Почему я организовал организацию выделения памяти так а не иначе? Почему использую свой класс строк? Код моих библиотек оттачивался мной почти 10 лет...

Ну допустим... Вот моя реализация кода поиска подстрок алгоритмом Кнута-Морриса-Пратта

Код:

int StrFindA( const char* T, const char* P) throw ( ELowResources*,  EComError*, ESystemError*)
{
  size_t n = StrLengthA( T);
  size_t m = StrLengthA( P);
  size_t k = 0;
  size_t q;

  char*  f = StrAllocA( m);
  f[0] = 0;
  for ( q = 1; q < m; q++)
  {
    while( k > 0 && P[k] != P[q])
    {
      k = f[k];
    }
    if ( P[k] == P[q]) k++;
    f[q] = k;
  }
  q = 0;
  for ( size_t i = 0; i < n; i++)
  {
    while( q > 0 && P[q] != T[i])
    {
      q = f[q];
    }
    if ( P[q] == T[i]) q++;
    if ( q == m)
    {
      StrFreeA( f);
      return (i - m + 1);
    }
  }
  StrFreeA( f);
  return -1;
}

Если бы я не упомянул Кнута-Морриса-Пратта стали бы вы спорить об его эффективности?
Даже что бы описать эту мизерную процедуру, необходимо показать реализацию StrFreeA,
StrLengthA, ELowResources*, ESystemError*, EComError*. Смотрим!

Код:

#define StrFreeA        __GlobalMM().__StrFreeA


size_t StrLengthA( const char* src) throw ( EComError*)
{
  size_t   stRes = 0;
  HRESULT  hr;
  if ( src && FAILED( hr = ::StringCchLengthA( src, STRDEF_MAX_CCH, &stRes)))
    throw new __EComError( hr);
  return stRes;
}

#ifdef DEBUG
#define __ELowResources()        ELowResources(__FILE__, __LINE__)
#else
#define __ELowResources()        ELowResources()
#endif

class ELowResources : public EExcept
{
public:
  ELowResources();
  ELowResources( const char* _module, int _line);

  virtual ExceptionReport& GetReport( ExceptionReport& Report) const throw();
  virtual const TCHAR* getClassName() const;
  virtual u_long getErrorCode() const;  
};
//******************************************************************************
//*ESystemError
//******************************************************************************
#ifdef DEBUG
#define __ESystemError(x)             ESystemError((x), __FILE__, __LINE__)
#else
#define __ESystemError(x)             ESystemError((x))
#endif
#define SYS_ERROR_MSG                 TEXT("%s (%u)")
             
class ESystemError : public EExcept
{
protected:
  DWORD                       m_dwError;
public:
  ESystemError( DWORD dwError);
  ESystemError( DWORD dwError, const char* _module, int _line);

  DWORD getError(void) const;
  __declspec( property( get = getError))
  DWORD                       Error;
  virtual ExceptionReport& GetReport( ExceptionReport& Report) const throw();
  virtual const TCHAR* getClassName() const;
  virtual u_long getErrorCode() const;
};
//******************************************************************************
//*EComError
//******************************************************************************
#ifdef DEBUG
#define __EComError(x)             EComError((x), __FILE__, __LINE__)
#else
#define __EComError(x)             EComError((x))
#endif
#define COM_ERROR_MSG              TEXT("%s (0x%.8X)")

class EComError : public ESystemError
{
public:
  EComError( HRESULT hResult);
  EComError( HRESULT hResult, const char* _module, int _line);

  HRESULT getResult(void) const;
  __declspec( property( get = getResult))
  HRESULT                     Result;

  ExceptionReport& GetReport( ExceptionReport& Report) const throw();
  virtual const TCHAR* getClassName() const;
};

Или может быть посмотрим реализацию дескриптора безопасности?

Код:


//******************************************************************************
//* CRegkeySecurity
//******************************************************************************
class CRegkeySecurity : public CSecurityInfo
{
protected:
  static SI_ACCESS        m_RegkeyRightsBitmask[13];
  static SI_INHERIT_TYPE  m_RegkeyInheritTypes[];
public:
  CRegkeySecurity( const TCHAR* KeyName);
  CRegkeySecurity( HKEY hKeyHandle);
  virtual const PSI_ACCESS getAccessRights(void);
  virtual const PSI_INHERIT_TYPE getAceInheritTypes(void);
};

//******************************************************************************
//*CRegkeySecurity
//******************************************************************************
CRegkeySecurity::CRegkeySecurity( const TCHAR* KeyName)
                :CSecurityInfo( KeyName, SE_REGISTRY_KEY)
{
  m_bChild     = true;
  m_bContainer = true;
}
//------------------------------------------------------------------------------
CRegkeySecurity::CRegkeySecurity( HKEY hKeyHandle)
               :CSecurityInfo( hKeyHandle, SE_REGISTRY_KEY)
{
  m_bChild     = true;
  m_bContainer = true;
}
//------------------------------------------------------------------------------
const PSI_ACCESS CRegkeySecurity::getAccessRights(void)
{
  return m_RegkeyRightsBitmask;
}
//------------------------------------------------------------------------------
const PSI_INHERIT_TYPE CRegkeySecurity::getAceInheritTypes(void)
{
  return m_RegkeyInheritTypes;
}

Надо показать реализацию CSecurityInfo. Вот заголовок

Код:

//******************************************************************************
//*CSecurityInfo
//******************************************************************************
class CSecurityInfo : public CLifeControlObject, public ISecurityInformation
{
private:
  friend CPrivateSecurity;
  CSecurityInfo();
protected:
  static SI_ACCESS            m_AccessRightsBitmask[33];

  bool                        m_bContainer;               // Объект контейнер
  bool                        m_bChild;                   // Объект потомок
  wchar_t*                    m_ObjectName;               // Имя объекта
  HANDLE                      m_ObjectHandle;             // Хэндл объекта
  SE_OBJECT_TYPE              m_ObjectType;               // Тип объекта


  virtual HRESULT PrivateSetSecurity( SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor);
  virtual HRESULT PrivateGetSecurity( SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR* ppSecurityDescriptor, BOOL fDefault);

  //Возвращает массив возможных флагов доступа. У последнего в массиве
  //mask = 0!
  virtual const PSI_ACCESS getAccessRights(void);
  __declspec( property( get = getAccessRights))
  const PSI_ACCESS            AccessRights;

  //Возвращает массив возможных флагов наследования ACE.
  virtual const PSI_INHERIT_TYPE getAceInheritTypes(void);
  __declspec( property( get = getAceInheritTypes))
  const PSI_INHERIT_TYPE      AceInheritTypes;


//////////////////////////////////
//IUnknown
  HRESULT WINAPI QueryInterface( REFIID riid, PVOID* ppvObj);
public:
  u_long WINAPI  AddRef()  { return CLifeControlObject::AddRef();};
  u_long WINAPI  Release() { return CLifeControlObject::Release();};
protected:
//////////////////////////////////
//ISecurityDescriptor
  HRESULT WINAPI GetObjectInformation( PSI_OBJECT_INFO pObjectInfo);
  HRESULT WINAPI GetSecurity( SECURITY_INFORMATION  RequestedInformation,
                              PSECURITY_DESCRIPTOR* ppSecurityDescriptor, BOOL fDefault);
  HRESULT WINAPI SetSecurity(SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor);
  HRESULT WINAPI GetAccessRights( const GUID* pguidObjectType, DWORD dwFlags,
                                  PSI_ACCESS* ppAccess, ULONG* pcAccesses, ULONG* piDefaultAccess);
  HRESULT WINAPI MapGeneric( const GUID* pguidObjectType, UCHAR* pAceFlags, ACCESS_MASK* pMask);
  HRESULT WINAPI GetInheritTypes( PSI_INHERIT_TYPE* ppInheritTypes, ULONG* pcInheritTypes);
  HRESULT WINAPI PropertySheetPageCallback( HWND hwnd, UINT uMsg, SI_PAGE_TYPE uPage);
//////////////////////////////////
public:

  CSecurityInfo( const TCHAR* name, SE_OBJECT_TYPE type) throw ( ELowResources*);

  CSecurityInfo( HANDLE hObj, SE_OBJECT_TYPE type) throw ( ELowResources*);

  ~CSecurityInfo();

  void ShowDialog( HWND hwndOwner) throw ( ESystemError*);

  virtual void QueryDacl( CAcl& dacl) throw ( ELowResources*, ESystemError*);
  virtual void SetDacl( const CAcl& dacl) throw ( ESystemError*);

  void QuerySacl( CAcl& sacl) throw ( ELowResources*, ESystemError*);
  void SetSacl( const CAcl& sacl) throw ( ESystemError*);

  virtual void QueryOwner( CSid& sid) throw ( ELowResources*, ESystemError*);
  virtual void SetOwner( const CSid& sid, bool bDefaulted) throw ( ELowResources*, ESystemError*);

  void QueryPrimaryGroup( CSid& sid) throw ( ELowResources*, ESystemError*);
  void SetPrimaryGroup( const CSid& sid) throw ( ESystemError*);

};

О чём вообще речь? А вот заголовок реализации красно-черных деревьев

Код:

//******************************************************************************
//*Двоичные деревья
//******************************************************************************
//FORWARDS
template <class _KeyT> class CBinaryTree;
template <class _KeyT> class CRbBinaryTree;


typedef int (CALLBACK *LPFNCompareKey)( const void* pKey1, const void* pKey2);

typedef int  (CALLBACK* MPNOTIFY) ( void* pContext, const void* data1ptr, const void* data2ptr);

//******************************************************************************
//*CTreeItem - Базовый класс для узлов двоичных деревьев.
//*            Нет доступа к значению ключа! Доступ могут получить
//*            только потомки этого класса.
//******************************************************************************

template <class _KeyT> class CTreeItem : virtual public CLifeControlObject
{
friend CBinaryTree<_KeyT>;
friend CRbBinaryTree<_KeyT>;
private:
  CTreeItem<_KeyT>*           m_pParent;
  CTreeItem<_KeyT>*           m_pLeft;
  CTreeItem<_KeyT>*           m_pRight;
  char                        m_Color;
  u_long                      m_ulSize; // Количество вершин, включая эту.
                                        // Дополнительно - признак NULL узла!
protected:
  _KeyT                       m_Key;

public:
  CTreeItem(void);

  const CTreeItem<_KeyT>* getParent(void) const;
  __declspec( property( get = getParent))
  const CTreeItem<_KeyT>*     Parent;

  const CTreeItem<_KeyT>* getLeft(void) const;
  __declspec( property( get = getLeft))
  const CTreeItem<_KeyT>*     Left;

  const CTreeItem<_KeyT>* getRight(void) const;
  __declspec( property( get = getRight))
  const CTreeItem<_KeyT>*     Right;

  char getColor(void) const;
  __declspec( property( get = getColor))
  char                        Color;

  _KeyT getKey(void) const;
  __declspec( property( get = getKey))
  _KeyT                       Key;

};
//******************************************************************************
//*CBinaryTree  Нимдасис
//******************************************************************************
template < class _KeyT> class CBinaryTree : virtual public CLifeControlObject
{
protected:
  mutable CRITICAL_SECTION    m_csTreeGuard;
  CTreeItem<_KeyT>*           m_pRoot;
  u_long                      m_ulBalanceFactor;
  CTreeItem<_KeyT>            m_NULL;
  LPFNCompareKey              m_pCmpFunc;
  
public:
  CBinaryTree(void);
  ~CBinaryTree(void);

  //Поиск.
  CTreeItem<_KeyT>* Search( const _KeyT& key, bool bAddRef) const throw ( ESystemError*, EComError*);

  //Минимум. Если дерево пустое возвращает NULL.
  CTreeItem<_KeyT>* Minimum(void) throw ();

  //Максимум. Если дерево пустое возвращает NULL.
  CTreeItem<_KeyT>* Maximum(void) throw ();

  //Следующий по росту. NULL - нет следующего
  CTreeItem<_KeyT>* Succ( CTreeItem<_KeyT>* pItem) throw ( ESystemError*);

  //Предыдущий по росту. NULL - нет предыдущего.
  CTreeItem<_KeyT>* Pred( CTreeItem<_KeyT>* pItem) throw ( ESystemError*);

  //Добавить новый элемент. Если ключ присутствует, генерирует
  //исключение. Память под элемент выделяет вызывающая сторона.
  //В случае успешной вставки, для узла вызывается AddRef.
  void Insert( CTreeItem<_KeyT>* pNewItem) throw ( ELowResources*, ESystemError*, EComError*);

  //Удаление. Для изъятого узла вызывается Release
  void Delete( CTreeItem<_KeyT>* pItem) throw ( ESystemError*);

  //Очистка. Для очищаемых узлов вызывается Release.
  void Clear(void) throw ();

  //Блокировать дерево вызывающим потоком. Опасно!
  void Lock(void) const throw ();

  //Разблокировать дерево
  void Unlock(void) const throw ();

  //Корень.
  const CTreeItem<_KeyT>* getRoot(void) const;
  __declspec( property( get = getRoot))
  const CTreeItem<_KeyT>*     Root;

  u_long getCount(void) const;
  __declspec( property( get = getCount))
  u_long                      Count;

  LPFNCompareKey getOnCompare(void) const;
  void setOnCompare( LPFNCompareKey cmpfunc);
    __declspec( property( get = getOnCompare, put = setOnCompare))
  LPFNCompareKey              OnCompare;

  //Выбор элемента по индексу.
  CTreeItem<_KeyT>* Select( u_long ulIdx, bool bAddRef) const throw ( ESystemError*);

  //Порядковый номер - количество элементов меньших pItem->m_Key.
  //Если дерево содержит только уникальные ключи - это индекс в массиве.
  u_long Rank( CTreeItem<_KeyT>* pItem) const throw ( ESystemError*);

};
//******************************************************************************
//*CRbBinaryTree
//******************************************************************************
template <class _KeyT> class CRbBinaryTree : public CBinaryTree<_KeyT>
{
protected:


  //Левое вращение. Правый ребенок не должен быть NULL.
  void LeftRotate( CTreeItem<_KeyT>* pItem) throw ( ESystemError*);

  //Правое вращение. Левый ребенок не должен быть NULL.
  void RightRotate( CTreeItem<_KeyT>* pItem) throw ( ESystemError*);

  //Восстановление RB свойств после удаления.
  void RBDeleteFixup( CTreeItem<_KeyT>* pItem) throw ( ESystemError*);

public:
  CRbBinaryTree(void);

  //Добавить новый элемент. Если ключ присутствует, генерирует
  //исключение. Память под элемент выделяет вызывающая сторона.
  //В случае успешной вставки, для узла вызывается AddRef.
  //RBInsert
  void Insert( CTreeItem<_KeyT>* pNewItem) throw ( ELowResources*, ESystemError*, EComError*);

  //Удаление. Для изъятого узла вызывается Release
  //RBDelete
  void Delete( CTreeItem<_KeyT>* pItem) throw ( ESystemError*);

  //Черная высота узла
  u_long BHeight( CTreeItem<_KeyT>* pItem) throw ( ESystemError*);

};
//******************************************************************************
//*Принудительное инстанцирование
//******************************************************************************

template class CTreeItem<long>;
template class CTreeItem<u_long>;
template class CTreeItem<char*>;

template class CBinaryTree<long>;
template class CBinaryTree<u_long>;
template class CBinaryTree<char*>;

template class CRbBinaryTree<long>;
template class CRbBinaryTree<u_long>;
template class CRbBinaryTree<char*>;

typedef CTreeItem<long>       CLongTreeItem, *PLongTreeItem;
typedef CBinaryTree<long>     CLongBinaryTree, *PLongBinaryTree;
typedef CRbBinaryTree<long>   CLongRbTree, *PLongRbTree;

typedef CTreeItem<u_long>     CUlongTreeItem,  *PUlongTreeItem;
typedef CBinaryTree<u_long>   CUlongBinaryTree, *PUlongBinaryTree;
typedef CRbBinaryTree<u_long> CUlongRbTree, *PUlongRbTree;

typedef CTreeItem<char*>      CTextTreeItemA,   *PTextTreeItemA;
typedef CBinaryTree<char*>    CTextBinaryTreeA, *PTextBinaryTreeA;
typedef CRbBinaryTree<char*>  CTextRbTreeA, *PTextRbTreeA;

	Автор	Тема: Re: Редактор реестра (Прочитано 8145 раз)
0 Пользователей и 1 Гость смотрят эту тему.