EXPORT char* SomeTestFunc(char* _data)
{
    char* retDataPtr;
    char retData[] = "1234567890";
    
    retDataPtr = &retData[0];
    
    printf("retDataPtr: %s.\n", retDataPtr); // Вывод "1234567890"
    
    return retDataPtr;
}

BOOL APIENTRY DllMain(HINSTANCE _instance, DWORD _reason, LPVOID _reserved)
{
    return TRUE;
}

#define EXPORT extern "C" __declspec (dllexport)

typedef char* (*ImportFunc)(char *);

/// Точка входа в приложение.
int main()
{
    ImportFunc testFunc;
    
    HINSTANCE myDll = LoadLibrary("MyDLL.dll");
    
    if(myDll == NULL)
    {
         printf("ERROR: unable to load DLL!");
         return 1;
    }
    
    testFunc = (ImportFunc) GetProcAddress(myDll, "SomeTestFunc");
    
    if(testFunc == NULL)
    {
        printf("ERROR: unable to find DLL function!");
        return 1;
    }
    
    printf("Result: %s.\n", testFunc("")); // Ничего не выводит
    
    FreeLibrary(myDll);

    return 0;
}

extern "C" __declspec(dllexport) CHAR * GetHello();

__declspec(dllexport) CHAR * GetHello()
{
    CHAR* str = "Hellow World";

    return str;
}

typedef CHAR* (WINAPI *hHellowFunc)(VOID);

int _tmain(int argc, _TCHAR* argv[])
{
    CHAR* str;
    hHellowFunc hHello=NULL;
    HINSTANCE hUserDLL=NULL;

    hUserDLL=LoadLibrary(_T("WinAPIDLL.dll"));
    if (hUserDLL==NULL)
    {
        printf("Error Load WinAPIDLL");
        return FALSE;
    }
    hHello=(hHellowFunc)GetProcAddress(hUserDLL,"GetHello");
    if (hHello==NULL)
    {
        printf("Error Load hHellow");
        return FALSE;
    }
    str = (*hHello)();
    printf("Result: %s.\n", str);

    ::FreeLibrary(hUserDLL);

    return 0;
}

EXPORT char* SomeTestFunc(const char* _data)
{
    char* retDataPtr;
    char retData[] = "1234567890";
    
    retDataPtr = &retData[0];
    
    return retDataPtr;
}

EXPORT char* SomeTestFunc(const char* _data)
{
    char* retDataPtr;
    char* retData = "1234567890";
    
    retDataPtr = &retData[0];
    
    return retDataPtr;
}

EXPORT char* SomeTestFunc(const char* _data)
{
    char retData[] = "1234567890";
    
    return retData;
}

EXPORT char* SomeTestFunc(const char* _data)
{
    char* retData = "1234567890";
    
    return retData;
}

void* arrayPtr = NULL;
arrayPtr = BufferSet(arrayPtr, 0x01, 0);
arrayPtr = BufferSet(arrayPtr, 0xA0, 1);

// ...

/// Функция записывает в буфер указанный байт на указанную позицию.
void* BufferSet(void* _buff, unsigned char _byte, unsigned long _pos)
{
    _buff = realloc(_buff, _pos + 2);
    
    ((unsigned char*) (_buff))[_pos] = _byte;
    ((unsigned char*) (_buff))[_pos + 1] = '\0';
    
    return _buff;
}

arrayPtr = NULL;
arrayPtr = BufferSet(arrayPtr, 0x01, 0);
arrayPtr = BufferSet(arrayPtr, 0xA0, 1);
printf("arrayPtr: %s.\n", (char*) arrayPtr); // Вывод - два мои байта + левый хвост из 10-12

/// Функция записывает в буфер указанный байт на указанную позицию.
void* BufferSet(void* _buff, unsigned char _byte, unsigned long _pos)
{
    _buff = realloc(_buff, _pos + 1);
    
    ((unsigned char*) (_buff))[_pos] = _byte;
    
    return _buff;
}

#ifndef COMPRESS_H
#define COMPRESS_H

#define EXPORT extern "C" __declspec (dllexport)

EXPORT void* RLEEncode(const void* _data, const unsigned long _length);
EXPORT void* RLEDecode(const void* _data, const unsigned long _length);
void* BufferSet(void* _buff, unsigned char _byte, unsigned long _pos);

#endif

#include <windows.h>
#include "Compress.h"

/// Точка входа в DLL.
bool APIENTRY DllMain(HINSTANCE _instance, DWORD _reason, LPVOID _reserved)
{
    return true;
}

/// Функция производит сжатие указанных данных на основе алгоритма кодирования повторов.
EXPORT void* RLEEncode(const void* _data, const unsigned long _length)
{
    unsigned long curDataPos;
    unsigned long bufPos = 0;
    unsigned char count = 1;
    unsigned char curByte;
    unsigned char nextByte;
    void* retData = NULL;
    
    for(curDataPos = 0; curDataPos < _length; curDataPos++)
    {
        curByte = ((unsigned char*) _data)[curDataPos];
        nextByte = (curDataPos == _length - 1 ? ((unsigned char*) _data)[curDataPos - 1] : ((unsigned char*) _data)[curDataPos + 1]); // Если уже на границе массива, сравниваем с предыдущим
        
        if(curByte == nextByte && count < 255 && curDataPos < _length - 1)
        {
            count++;
        }
        else
        {
            retData = BufferSet(retData, count, bufPos++); // Длина повтора
            retData = BufferSet(retData, curByte, bufPos++); // Байт повтора
            count = 1;
        }
    }
    
    return retData;
}

/// Функция производит восстановление данных, сжатых на основе алгоритма кодирования повторов.
EXPORT void* RLEDecode(const void* _data, const unsigned long _length)
{
    unsigned long curDataPos;
    unsigned long bufPos = 0;
    unsigned char count;
    unsigned char curByte;
    void* retData = NULL;
    
    for(curDataPos = 0; curDataPos < _length; curDataPos += 2)
    {
        count = ((unsigned char*) _data)[curDataPos];
        curByte = ((unsigned char*) _data)[curDataPos + 1];
        
        while(count-- > 0)
        {
            retData = BufferSet(retData, curByte, bufPos++);
        }
    }
    
    return retData;
}

/// Функция записывает в буфер указанный байт на указанную позицию.
void* BufferSet(void* _buff, unsigned char _byte, unsigned long _pos)
{
    _buff = realloc(_buff, _pos + 2);
    
    //if(_buff != NULL)
    //{
        ((unsigned char*) (_buff))[_pos] = _byte;
        ((unsigned char*) (_buff))[_pos + 1] = '\0';
    //}
    
    return _buff;
}

#include <stdio.h>
#include <windows.h>

typedef void* (*RLEEncode)(const void* _data, const unsigned long _length);
typedef void* (*RLEDecode)(const void* _data, const unsigned long _length);

/// Точка входа в приложение.
int main(int argc, char* argv[])
{
    char* sTextToEncode = "AAABBCC";
    void* buffer;
    RLEEncode Encode;
    RLEDecode Decode;
    HINSTANCE compressDll = LoadLibrary("Compress.dll");
    
    if(compressDll == NULL)
    {
        printf("ERROR: unable to load DLL!\n");
        system("pause");
        return 1;
    }
    
    Encode = (RLEEncode) GetProcAddress(compressDll, "RLEEncode");
    Decode = (RLEDecode) GetProcAddress(compressDll, "RLEDecode");
    
    if(Encode == NULL || Decode == NULL)
    {
        printf("ERROR: unable to find DLL functions!\n");
        system("pause");
        return 1;
    }
    
    buffer = Encode(sTextToEncode, 7);
    printf("Encoded data: %s\n", (char*) buffer);
    
    buffer = Decode(buffer, 6);
    printf("Decoded data: %s\n", (char*) buffer);
    
    free(buffer);
    delete[] sTextToEncode;
    FreeLibrary(compressDll);
    
    system("pause");
    
    return 0;
}