void create_and_mapping_file(const char*);
  bool check_PE_header();
  void make_some_shit_with_codesection();

HANDLE fhandle = CreateFile(Victim,GENERIC_READ+GENERIC_WRITE,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
if(fhandle==INVALID_HANDLE_VALUE) {
    MessageBox(NULL,mbFOpen,mbErrTitle,MB_ICONERROR);
    return 0;
};

DWORD fsize = GetFileSize(fhandle,NULL);
HANDLE maphandle = CreateFileMapping(fhandle,NULL,PAGE_READONLY,NULL,NULL,NULL);
DWORD mfile = (DWORD)MapViewOfFile(maphandle,FILE_MAP_READ,NULL,NULL,NULL);
DWORD vmem = (DWORD)VirtualAlloc(NULL,fsize+4096,MEM_COMMIT,PAGE_READWRITE);

    HANDLE file = CreateFile(file_name, 
                             GENERIC_READ | GENERIC_WRITE, 
                             FILE_SHARE_READ, 
                             NULL,
                             OPEN_EXISTING,
                             FILE_ATTRIBUTE_NORMAL,
                             NULL);

    if (file == INVALID_HANDLE_VALUE) 
    {
        MessageBox(NULL, mbFOpen, mb_title, MB_ICONERROR);
        return 0;
    }

    DWORD  file_size = GetFileSize(file, NULL);
    if (file_size == INVALID_FILE_SIZE)
    {
        return 0;
    }

    HANDLE file_mapping = CreateFileMapping(file, NULL, PAGE_READONLY, NULL, NULL, NULL);
    if (file_mapping == 0)
    {
        CloseHandle(file);
        return 0;
    }
    void*  file_base = MapViewOfFile(file_mapping, FILE_MAP_READ, NULL, NULL, NULL);

    if ( file_base == 0 )
    {
        CloseHandle(file_mapping);
        CloseHandle(file);
        return 0;
    }
    void* vmem = VirtualAlloc(NULL, file_size + 4096, MEM_COMMIT, PAGE_READWRITE);

    if (vmem == 0)
    {
        UnmapViewOfFile(file_base);
        CloseHandle(file_mapping);
        CloseHandle(file);
        return 0;
    }

while (d2!=0) {
    *(BYTE*)d0 = *(BYTE*)mfile;
    d0 = d0+1;
    mfile = mfile+1;
    d2 = d2-1;};

WORD w0 = *(WORD*)vmem;
if(*(WORD*)(vmem)==0x5A4D) {
    DWORD PEstart = *(DWORD*)(vmem+60);
    if(*(DWORD*)(vmem+PEstart)==0x4550) {
        PEstart += (DWORD)(vmem);
        DWORD EP = *(DWORD*)(PEstart+40);
        DWORD sVA = *(DWORD*)(PEstart+0x104);
        if(sVA>EP) {MessageBox(NULL,mbEPAErr,mbErrTitle,MB_ICONERROR);}
        else {
            DWORD sVS = *(DWORD*)(PEstart+0x100);
            d0 = sVS+sVA;
            if(d0<=EP) {MessageBox(NULL,mbEPAErr,mbErrTitle,MB_ICONERROR);}
            else {

    PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)file_base;
    if (dosHeader->e_magic == IMAGE_DOS_SIGNATURE)
    {
        PIMAGE_NT_HEADERS pNTHeader; 
        pNTHeader = (PIMAGE_NT_HEADERS)(dosHeader + dosHeader->e_lfanew);

        if (pNTHeader->Signature == IMAGE_NT_SIGNATURE)
        {
            PIMAGE_SECTION_HEADER  pSectionHeader;
            pSectionHeader = (PIMAGE_SECTION_HEADER)(pNTHeader + sizeof(IMAGE_NT_HEADERS));
            DWORD EP = pNTHeader->OptionalHeader.BaseOfCode;
            DWORD sVA = pSectionHeader->Misc.VirtualSize;

            if (sVA > EP) 
            {
                MessageBox(NULL, mbEPAErr, mb_title, MB_ICONERROR);
            }
            else 
            {

K>    HANDLE file = CreateFile(file_name, 
K>    if (file == INVALID_HANDLE_VALUE) 
K>        return 0;
K>    HANDLE file_mapping = CreateFileMapping(file, NULL, PAGE_READONLY, NULL, NULL, NULL);
K>    if (file_mapping == 0)
K>    {
K>        CloseHandle(file);
K>        return 0;
K>    }
K>    void*  file_base = MapViewOfFile(file_mapping, FILE_MAP_READ, NULL, NULL, NULL);
K>    if ( file_base == 0 )
K>    {
K>        CloseHandle(file_mapping);
K>        CloseHandle(file);
K>        return 0;
K>    }
K>    void* vmem = VirtualAlloc(NULL, file_size + 4096, MEM_COMMIT, PAGE_READWRITE);
K>    if (vmem == 0)
K>    {
K>        UnmapViewOfFile(file_base);
K>        CloseHandle(file_mapping);
K>        CloseHandle(file);
K>        return 0;
K>    }
K>

HANDLE hfile = CreateFile(...);
if (INVALID_HANDLE_VALUE == hfile) //Кстати, уважаемый начинающий, догадаетесь, почему я hfile написал справа от знака сравнения.
  return 0;

HANDLE hMap = CreateFileMapping(...);
CloseHandle(hfile); //BEEF! <-- Здесь можно так сделать!!! Дело в том что Винда не отпустит хендл, пока он используется.

if (!hMap)
  return 0;

PVOID pMap = MapViewOfFile(...);
CloseHandle(hMap); //BEEF! <-- Здесь можно так сделать!!! Дело в том что Винда не отпустит хендл, пока он используется.

if (!pMap)
  return 0;

//... наши великие дела ...

//Внутри все работает на счетчиках ссылок. Отпустили mapping и хендлы освободились автоматически Виндой.
UnmapViewOfFile(pMap);

//Бесит что держите семеро :)
#define WIDTH 800
#define HEIGHT 600
//А вот так нравится...
#define DIMX 800
#define DIMY 600
//И к какому врачу идти не знаю....

//Кстати, уважаемый начинающий, догадаетесь, почему я hfile написал справа от знака сравнения.

if(FAIL == {здесь какое-то длинное выражение}) // если что? исключительная ситуация?
if(FAIL == promptUser("Format drive C:?", RETRY | IGNORE | FAIL)) // а-а, это кнопка!

if(promptUser({здесь строки всякие, константы}... // ага, задаем какой-то вопрос, и в зависимости от реакции делаем то или иное
if(promptUser("Format drive C:?", RETRY | IGNORE | FAIL) == FAIL) // понятно

if(SOME_VALUE == f()) // это еще можно понять...

if(SOME_THRESHOLD <= readItTenTimesToUnderstand()) // ??!
if(thisIsJustABitSimpler() >= SOME_THRESHOLD) // а это расходится со стратегией для ==.

D>>HANDLE hfile = CreateFile(...);
D>>if (INVALID_HANDLE_VALUE == hfile) //Кстати, уважаемый начинающий, догадаетесь, почему я hfile написал справа от знака сравнения.
D>>

A>Ну ладно мы мучаеся, читая наизнанку, но молодежи-то зачем это грузить?

class A
{
   int _num;
   int _totalSize;
   //so on...
};

D>class A
D>{
D>   int _num;
D>   int _totalSize;
D>   //so on...
D>};
D>

class X
{
. . .
private:
    int i_;
    std::deque<std::string> strings_;
    Y allTheMembersAreCalledThisWay_;

public:
    void regularMemberFunction();
    void _somethingQuestionable(); // «handle with care!»
};

template <class ClassBeingTested>
class InvariantCheckHelper: public InvariantCheckHelperBase
{
public:
    InvariantCheckHelper(ClassBeingTested const& obj): obj_(obj)
    {
    }

    ~InvariantCheckHelper()
    {
        obj_._checkInvariants();
    }

private:
    ClassBeingTested const& obj_;
};

template <class ClassBeingTested>
InvariantCheckHelper<ClassBeingTested> makeInvariantCheckHelper(ClassBeingTested const& obj)
{
    return InvariantCheckHelper<ClassBeingTested>(obj);
}

#define CHECK_INVARIANTS_NOW_AND_ON_EXIT() \
    ; \
    this->_checkInvariants(); \
    InvariantCheckHelperBase const& invariantCheckHelper = makeInvariantCheckHelper(*this); \
    (void)invariantCheckHelper;

class X
{
    void _checkInvariants() const
    {
        assert(abc);
        assert(xyz);
    }

    void whatever()
    {
        CHECK_INVARIANTS_NOW_AND_ON_EXIT();
        doSomething();
    }
};

;Давно не практиковался а асме, не пинайте сильно. Но суть ясна.
dw  word_size_var; ;2 bytes
dd  dword_var;     ;4 bytes

;...

;Забыли что переменная 2 байта, но компилятор съест - возьмет лишних 2 байта.
mov eax, DWORD PTR word_size_var;