class MyDriverClass
{
    PDRIVER_OBJECT m_DriverObject;
public:

    DRIVER_INITIALIZE mf_DriverEntry;
    MyDriverClass();
};

MyDriverClass *g_DriverObject;

// The C linkage wrapper function
extern "C" DRIVER_INITIALIZE DriverEntry;

extern "C" NTSTATUS DriverEntry(__in PDRIVER_OBJECT DriverObject, __in PUNICODE_STRING RegistryPath)
{
   // Create/Initialize class MyDriverClass with a pointer
   // to it in g_DriverObject.
   g_DriverObject = new MyDriverClass();
   if (g_DriverObject == NULL)
   {
       //...
   }

   NTSTATUS st = g_DriverObject->mf_DriverEntry(DriverObject,RegistryPath);
   //...
}

// Implement the DriverEntry member function
NTSTATUS MyDriverClass::mf_DriverEntry(__in PDRIVER_OBJECT DriverObject, __in PUNICODE_STRING RegistryPath)
{
   m_DriverObject = DriverObject;
   //...
}

    char * a = new char();

error LNK2019: unresolved external symbol "void * __cdecl operator new(unsigned int)" (??2@YAPAXI@Z) referenced in function _DriverEntry@8

vector<int> v;

vector<int> v;

pool_allocator alloc(....);

std::vector<int, pool_allocator> v(alloc);

vector<int> v;

pool_allocator alloc(....);

std::vector<int, pool_allocator> v(alloc);

GN>>В каком из случаев можно ответить на вопрос: "в каком пуле аллоцируется память?"

pool_allocator nppa(non_paged_pool);
pool_allocator ppa(paged_pool);
assert( ppa == nppa );

20.4.1.2 allocator globals

template <class T1, class T2>
bool operator==(const allocator<T1>&, const allocator<T2>&) throw();

1 Returns: true.

pool_allocator nppa(non_paged_pool);
pool_allocator ppa(paged_pool);
assert( ppa == nppa );

std::vector<int, pool_allocator> vnpp(nppa);
std::vector<int, pool_allocator> vpp(ppa);
vnpp.swap(vpp); // прекрасно?

GN>pool_allocator nppa(non_paged_pool);
GN>pool_allocator ppa(paged_pool);
GN>assert( ppa == nppa );

GN>std::vector<int, pool_allocator> vnpp(nppa);
GN>std::vector<int, pool_allocator> vpp(ppa);
GN>vnpp.swap(vpp); // прекрасно?
GN>

- Доктор, у меня болит когда я делаю вот так!
- Ну так не делайте вот так.

делать их в мемберах аллокатора (это наверное и идеологически правильней — при доступе к памяти)

GN>А еще баят, что Стандарт врёт и состояние в аллокаторе хранить — можно.

void *malloc(size_t sz) {return ExAllocatePool( PagedPool, sz); }

O>И чем это проверки в мемберах аллокатора помогут при доступе к уже выделенной памяти, когда никакие мемберы аллокатора ваще никаким боком не используюся ?

pointer address(reference x) const;

O>То есть, таки нужны "другие" аллокаторы

GN>>А еще баят, что Стандарт врёт и состояние в аллокаторе хранить — можно.

O>void *malloc(size_t sz) {return ExAllocatePool( PagedPool, sz); } 
O>

O>то получит по рукам. Ибо нефиг. Но таких кернелдевелоперов у нас слава Богу нету

O>Ну то есть уже пришли к тому что имеющиеся STL тоже не подходят

template <class T, class Allocator = allocator<T> > class vector;

void* operator new(std::size_t) throw(std::bad_alloc);// ууу как же никто не вспомнил среди проблем такую жирную

.text:00000164 ; int __stdcall HandleCppException(int, int, int, int, struct _s_FuncInfo *, __int32, int)

.text:0000017D                 mov     eax, dword ptr ds:_EHExceptionRecord * g_CurrentException
.text:00000182                 test    eax, eax
.text:00000184                 jz      loc_266
.text:0000018A                 mov     [ebp+arg_0], eax
.text:0000018D                 mov     eax, dword ptr ds:_CONTEXT * g_CurrentContext

20.9.5.2 allocator globals

template <class T1, class T2>
bool operator==(const allocator<T1>&, const allocator<T2>&) throw();

1 Returns: true.

20.1.5/4 Implementations of containers described in this International Standard are permitted to assume that their
Allocator template parameter meets the following two additional requirements beyond those in Table 32.
— All instances of a given allocator type are required to be interchangeable and always compare equal to
each other.
— The typedef members pointer, const_pointer, size_type, and difference_type are
required to be T*,T const*, size_t, and ptrdiff_t, respectively.

У меня не совсем отлажено. В целом работает, но могут быть косяки. Если что я предупреждал ща поищу

Про дерефенренс — какие преимущества имеет С по сравнению с С++ и RAII где ресурсы освобождаются автоматически?

не сподвигнувшиеся выучить ООП (а некоторые из них про него и не слышали, искренне считая все технологии после 1981 г. унылым говном), разжигают холивар, который, как правило, сводится к необходимости описывать каждый чих в ООП с одной стороны и необходимость изобретать уйму велосипедов для хоть какой-нибудь объектности с другой.

We have tested our unpacking algorithm against the following, widely used, packers:

* acprotect
* andpakk2
* armadilo
* aspack
* asprotect
* execrypter
* expressor
* fsg
* morphine
* npack
* nspack
* packman
* pecompack
* pelock
* pespin
* rlpack
* svk protector
* telock
* themdia
* upx
* winunpack
* yoda protector

For all these packers Lugh has successfully identified and extracted the self modifying code nearly in real-time.

GN>Не пойму, троллишь, или С++ не знаешь?

GN>Еще раз: basic_string может содержать '\0'. "что тоже очень плохо накладывается на c_str". Поэтому c_str нужно пользоваться с учётом этого, то есть не нужно С чего ты взял что для этого обязательно менять интерфейс? Для эжтого достаточно почитать описание basic_string.

UNICODE_STRING us;
//
std::wstring s;
s.append(us.Buffer, us.Length/sizeof(WCHAR));

UNICODE_STRING us;
//
std::wstring s;
s+= us.Buffer;

O>UNICODE_STRING us;
O>//
O>std::wstring s;
O>s.append(us.Buffer, us.Length/sizeof(WCHAR));
O>

append(s, us);

s += "\0 ";

const_unicode_string cus(L"format c:");

// а вот так можно сконструировать basic_string без strlen, привет Стандарту ;)
std::wstring ws(cus.get_string());

O>UNICODE_STRING us;
O>//
O>std::wstring s;
O>s+= us.Buffer;
O>

s + us;

UNICODE_STRING us;
//
std::wstring s;
s+= us.Buffer;

const_unicode_string cus;//(L"format c:");
// ... берём откудато UNICODE_STRING

// если со строкой из внешнего мира надо как следует поработать, делаем копию. Иначе - <algorithm> не имеет проблем с 0м.
std::wstring ws(cus.get_string());

s += "\0 ";

    template<typename CT>
    basic_string& operator+=(const CT* const& s)
    {
      static_assert((is_same<CT, value_type>::value), "charT must to be value_type");
      return append(s, traits_type::length(s));
    }

    template<size_t Size>
    basic_string& operator+=(const charT(&s)[Size])   { return append(s, Size-1); }

O> А написать специательные хелперы — это конечно дело хорошее и благородное, его многие пытались сделать, мир праху их

GN>>Заметно сильное влияниев С, а в С++ Buffer будет приватным членом

GN>>К тому же, ты продемонстировал advanced-технику, неокрепший ум скорее будет использовать

s + us;

а свободный operator+() можно реализовать без проблем.