内存映射（支持一写多读）

#pragma once
#include <vector>
#include <opencv2/opencv.hpp>

class FileMapClass
{
public:
	enum FileMapClassFlag
	{
		ReadMode = 0,
		WriteMode = 1,
		CreateNew = 0x10,
		CreateAlways = 0x20,
		OpenExisting = 0x30,
		OpenAlways = 0x40,
		TruncateExisting = 0x50,
	};
	FileMapClass();
	~FileMapClass();
	int open(const char* fliename, int openMode, int64 datasize = 0);
	int close();
	int write(const void* src, size_t len,int offset);
	int read(void* dst, size_t len, int offset);
	int getFileSize() { return fileSize; }
	bool isOpen();
	bool writeMode();
	const char* data();
protected:
	void* hFile;//HANDLE
	void* hMapFile;//HANDLE
	void* pMapView;//LPVOID
	int mode = 0;
	int64 fileSize = 0;
	int64 pos = 0;
};

#include <windows.h>
#include "FileMapClass.h"
#include <iostream>

FileMapClass::FileMapClass()
{
    hFile = INVALID_HANDLE_VALUE;//HANDLE
    hMapFile = INVALID_HANDLE_VALUE;//HANDLE
    pMapView = nullptr;//LPVOID
}

FileMapClass::~FileMapClass()
{
    close();
}

int FileMapClass::open(const char* fliename, int _mode, INT64 datasize)
{
    close();
    fileSize = datasize; 
    mode = _mode;
#ifdef UNICODE
    WCHAR fname[256] = {0};
    MultiByteToWideChar(CP_ACP, 0, fliename, strlen(fliename) + 1, fname, 256);
#else
    LPCSTR fname = fliename;
#endif
    if (writeMode())
        hFile = CreateFile(fname, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, nullptr, mode >> 4, FILE_ATTRIBUTE_NORMAL, nullptr);
	else
        hFile = CreateFile(fname, GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ, nullptr, mode >> 4, FILE_ATTRIBUTE_NORMAL, nullptr);
    if (hFile == INVALID_HANDLE_VALUE) {
        std::cout << "Failed to create file." << std::endl;
        return -1;
	}
	if (writeMode())
	{
        SetFilePointer(hFile, fileSize, nullptr, FILE_BEGIN);
        SetEndOfFile(hFile);
	}
    else
    {
        fileSize = GetFileSize(hFile, NULL);//暂时不考虑大于4G的文件
        if (fileSize == INVALID_FILE_SIZE) {
            std::cerr << "无法获取文件大小" << std::endl;
            CloseHandle(hFile);
            return 1;
        }
    }
    hMapFile = CreateFileMapping(hFile, nullptr, writeMode() ? PAGE_READWRITE : PAGE_READONLY, 0, fileSize, nullptr);
    if (hMapFile == nullptr) {
        std::cout << "Failed to create file mapping." << std::endl;
        CloseHandle(hFile);
        return -2;
    }

    pMapView = MapViewOfFile(hMapFile, writeMode() ? FILE_MAP_WRITE : FILE_MAP_READ, 0, 0, fileSize);
    if (pMapView == nullptr) {
        std::cout << "Failed to map view of file." << std::endl;
        CloseHandle(hMapFile);
        CloseHandle(hFile);
        return -3;
    }
	return 0;
}

int FileMapClass::close()
{
    if (pMapView == nullptr) {
        UnmapViewOfFile(pMapView);
        pMapView = nullptr;
    }
    if (hMapFile == INVALID_HANDLE_VALUE) {
        CloseHandle(hFile);
        hMapFile = INVALID_HANDLE_VALUE;
    }
    if (hFile == INVALID_HANDLE_VALUE) {
        CloseHandle(hMapFile);
        hFile = INVALID_HANDLE_VALUE;
    }
    fileSize = 0;
    pos = 0;
    return 0;
}

bool FileMapClass::isOpen()
{
    return pMapView != nullptr;
}

bool FileMapClass::writeMode()
{
    return  mode & WriteMode;
}

int FileMapClass::write(const void* src, size_t len, int offset)
{
    if (!isOpen() || !writeMode())
        return -1;
    if (offset + len > fileSize)
        return -2;//再次SetFilePointer可能会进行磁盘操作影响效率
    char* pData = (char*)pMapView;
    memcpy(pData + offset, src, len);
    return 0;
}
int FileMapClass::read(void* dst, size_t len, int offset)
{
    if (!isOpen() || offset + len > fileSize)
        return -2;
    char* pData = (char*)pMapView;
    memcpy(dst, pData + offset, len);
    return 0;
}


const char* FileMapClass::data()
{
    return (const char*)pMapView;
}