int _tmain(int argc, _TCHAR* argv[])
{
	HINSTANCE hinstLib; 
	MYPROC ProcAdd; 
    BOOL fFreeResult, fRunTimeLinkSuccess = FALSE; 
     // Get a handle to the DLL module.
 
    hinstLib = LoadLibrary(TEXT("DBConn.dll")); 	
	//HINSTANCE dbc = LoadLibrary();

	//  00001790      1   0041  BDEQuery(std::vector<record, std::allocator<record> > *, const char *, const char *)
	if (hinstLib != NULL) 
    { 
		ProcAdd = (MYPROC)((char*)hinstLib + 0x1790);//GetProcAddress(hinstLib, "BDEQuery"); 
        // If the function address is valid, call the function.
        if (NULL != ProcAdd) 
        {
            fRunTimeLinkSuccess = TRUE;
			std::cout<<"work"; 
			const char* query = "select * from bar.db";// where cardarticul like \'SIXOJ499/9539OO/125\'";
			const char * dbase = "pnshop";
			std::vector<record> res;
			int rest = (*ProcAdd)(&res, query, dbase);
			std::cout<<rest<<'\t';
			if(res.size())
				std::cout<<static_cast<char(*)[16]>(res.front().begin());
        }
        // Free the DLL module.
        fFreeResult = FreeLibrary(hinstLib); 
    // If unable to call the DLL function, use an alternative.
    if (! fRunTimeLinkSuccess) 
        printf("Message via alternative method\n");
	}
	//int test = BDEQuery(&res,query,dbase);
	return  0 ;

//---------------------------------------------------------------------------

#include <vcl.h>
#include <windows.h>
#include <vector.h>
#include <iostream>
#include "record.h"
#include <extctrls.hpp>
#include <DBTables.hpp>
#pragma hdrstop
//---------------------------------------------------------------------------
//   Important note about DLL memory management when your DLL uses the
//   static version of the RunTime Library:
//
//   If your DLL exports any functions that pass String objects (or structs/
//   classes containing nested Strings) as parameter or function results,
//   you will need to add the library MEMMGR.LIB to both the DLL project and
//   any other projects that use the DLL.  You will also need to use MEMMGR.LIB
//   if any other projects which use the DLL will be performing new or delete
//   operations on any non-TObject-derived classes which are exported from the
//   DLL. Adding MEMMGR.LIB to your project will change the DLL and its calling
//   EXE's to use the BORLNDMM.DLL as their memory manager.  In these cases,
//   the file BORLNDMM.DLL should be deployed along with your DLL.
//
//   To avoid using BORLNDMM.DLL, pass string information using "char *" or
//   ShortString parameters.
//
//   If your DLL uses the dynamic version of the RTL, you do not need to
//   explicitly add MEMMGR.LIB as this will be done implicitly for you
//---------------------------------------------------------------------------
typedef vector<record> v_rec;
typedef vector<char> v_char;

#pragma argsused
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void* lpReserved)
{
	return  1 ;
}
//---------------------------------------------------------------------------

int _export BDEQuery(vector<record>* ptrRes, const char* ptrQry, const char* alias)
{
	TQuery* myQ = new TQuery((TComponent*)NULL);
	myQ->Active = false;
	myQ->DatabaseName = AnsiString(alias);
	myQ->SQL->Clear();
	myQ->SQL->Add(AnsiString(ptrQry));
	myQ->Active = true;
	myQ->First();
	try
	{
	for(int i= 0 ;i<myQ->RecordCount;i++)
	{
		for(int j= 0 ;j<myQ->FieldCount;j++)
		{
			record iter;
			iter.resize(myQ->Fields->operator [](j)->Size);
			myQ->Fields->operator [](j)->GetData(iter.begin(),true);
			ptrRes->push_back(iter);
		}
		myQ->Next();
	}
	myQ->~TQuery();
	return  0 ;
	}
	catch(...)
	{
		return - 1 ;
	}
}

#include <malloc.h>

class record
{
	void* ptrData;
	size_t size;

public:
	record();
	record(size_t);

	void*	resize(size_t);
	void*	begin()			{return ptrData;}
	void*	shift(size_t v)	{return (char*)ptrData+v;}
	void*	move(void* iter, size_t v)	{return (char*)iter+v;}
	void*	end()			{return (char*)ptrData+size;}
	size_t	retsize()			{return size;}

	~record();
};

#include "record.h"

record::record()
{
	size =  1 ;
	ptrData = malloc(size);
}

record::record(size_t sz)
{
	size = sz;
	ptrData = malloc(size);
}

void* record::resize(size_t sz)
{
	size = sz;
	ptrData = realloc(ptrData, sz);
	return ptrData;
}

record::~record()
{
	free(ptrData);
}

	void* iter = ptrRes.begin();
 //	std::vector<record>::iterator it = ptrRes.begin();
//	ptrRes.empty();
	ptrRes.resize(myQ->RecordCount*myQ->RecordSize);
	int Total( 0 );
	try
	{
	for(int i= 0 ;i<myQ->RecordCount;i++)
	{
		for(int j= 0 ;j<myQ->FieldCount;j++)
		{
			iter = ptrRes.move(iter,myQ->Fields->operator [](j)->Size);
			myQ->Fields->operator [](j)->GetData(iter,true);
			Total+=myQ->Fields->operator [](j)->Size;
			std::cout<<"end address: "<<ptrRes.end()<<"\t\tcurrent address: "<<iter<<'\n';
//			std::cout<<myQ->Fields->operator [](j)->AsString.c_str()<<' ';
//			ptrRes.push_back(iter);
//			std::cout<<"\nvector size = "<<ptrRes.size()<<'\n';
		}
		myQ->Next();
		std::cout<<'\n';
	}