C++ jpg内存中绘制图片，字体并以char*的形式输出

最新推荐文章于 2023-05-12 16:45:38 发布
最新推荐文章于 2023-05-12 16:45:38 发布
阅读量922 收藏
点赞数
分类专栏： C++、Qt 文章标签： Gdi  jpg 绘图
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16628589/article/details/103028739
版权

1.Gdi的调用

链接附加依赖项：gdiplus.lib

#include <comdef.h>//（不加这个可能会报错）
#include <GdiPlus.h>

//开始调用

ULONG_PTR                        g_pGdiToken = NULL;
Gdiplus::GdiplusStartupInput    g_gdiplusStartupInput;

Gdiplus::GdiplusStartup(&g_pGdiToken, &g_gdiplusStartupInput, NULL);

//结束调用

Gdiplus::GdiplusShutdown(g_pGdiToken);

2.Jpg转Gdi bitmap

在开始之前事先申请内存（临时new的时候不行，不知道为啥）

m_hImageMemPic = GlobalAlloc(GMEM_FIXED, MAXPICBUF);

// Jpg转换为Image;
bool JPG2Image(void *szBuf, DWORD dwBufSize)
{
    HGLOBAL hMem = m_hImageMemPic;
    Gdiplus::Image** ppImage = &m_pImagePic;
    
    m_sizePicOut.cx = 0;
    m_sizePicOut.cy = 0;

    int nMaxLen = MAXPICBUF;
    BOOL bAlloc = FALSE;
    if (hMem == NULL)
    {
        bAlloc = TRUE;
        hMem = GlobalAlloc(GMEM_FIXED, nMaxLen);
    }

    if (*ppImage != NULL)
    {
        delete *ppImage;
        *ppImage = NULL;
    }

    if (dwBufSize != 0)
    {
        IStream* pStmBmp = NULL;
        CreateStreamOnHGlobal(hMem, FALSE, &pStmBmp);
        BYTE* pbyBmp = (BYTE *)GlobalLock(hMem);
        memset(pbyBmp, 0, nMaxLen);
        memcpy(pbyBmp, szBuf, dwBufSize);
        ::GlobalUnlock(hMem);
        *ppImage = Gdiplus::Image::FromStream(pStmBmp, FALSE);
        if ((*ppImage) != NULL)
        {
            m_sizePicOut.cx = (*ppImage)->GetWidth();
            m_sizePicOut.cy = (*ppImage)->GetHeight();
        }
    }

    if (bAlloc)
    {
        GlobalFree(hMem);
    }

    return ((*ppImage) != NULL);

    /*CLSID pngClsid;
    GetEncoderClsid(L"image/bmp", &pngClsid);
    m_pImagePic->Save(L"Mosaic245.bmp", &pngClsid, NULL);*/
}

3.Gdi绘制图片

   HDC hdc = GetDC(NULL);
    HDC hTempMemDC = ::CreateCompatibleDC(NULL);
    HBITMAP bmpTmpDraw = ::CreateCompatibleBitmap(hdc, m_sizePicOut.cx, m_sizePicOut.cy);//hdc
    if (bmpTmpDraw == NULL) bmpTmpDraw = ::CreateCompatibleBitmap(hdc, m_sizePicOut.cx, m_sizePicOut.cy);
    if (bmpTmpDraw == NULL)
    {
        return;
    }
    HGDIOBJ oldObj = ::SelectObject(hTempMemDC, bmpTmpDraw);
    RECT rc;
    rc.left = 0;
    rc.top = 0;
    rc.right = m_sizePicOut.cx;
    rc.bottom = m_sizePicOut.cy;

 if (pImage)
    {
        Gdiplus::Graphics g(hdc);
        Gdiplus::ImageAttributes ImgAtt;
        ImgAtt.SetWrapMode(Gdiplus::WrapModeTileFlipXY);
        g.DrawImage(pImage, Gdiplus::Rect(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top),
            0, 0, pImage->GetWidth(), pImage->GetHeight(),
            Gdiplus::UnitPixel, &ImgAtt, NULL, NULL);
    }

4.  绘制字体

 LOGFONTW lfont;
    memset(&lfont, 0, sizeof(lfont));
    int emSize = 70;
    lfont.lfHeight = -emSize; //   nHeight   注意使用负值，表示character height,  正值表示 cell height
    lfont.lfWeight = 400;//100;//FW_NORMAL,  //nWeight
    lfont.lfCharSet = GB2312_CHARSET;//;//ANSI_CHARSET
    wcscpy(lfont.lfFaceName, (L"微软雅黑"));  //   lpszFacename
    Gdiplus::Font gdifont(hdc, &lfont);
    
    Gdiplus::StringFormat strformat;
    strformat.SetAlignment(Gdiplus::StringAlignmentNear);//水平居左  
    strformat.SetLineAlignment(Gdiplus::StringAlignmentCenter);//垂直居中 
    Gdiplus::Font gFont(hdc, &lfont);
    Gdiplus::Color clr1(255, 255, 255);
    Gdiplus::SolidBrush    br1(clr1);
    Gdiplus::Graphics gdiGraphics(hdc);
    wchar_t tempText[256] = { 0 };
    int nLen = 0;
    for (int i = 0; i < HVCR_CUSTOM_OSD_NUM; i++)
    {
        nLen = strlen(m_osdcfg.StOSDItems[i].szOSD_CHAR);
        if (nLen == 0)
        {
            continue;
        }
        Gdiplus::RectF rec(50, 50 + 100 * i, 2000, 100);
        memset(tempText, 0, 256);
        char2wchar(tempText, m_osdcfg.StOSDItems[i].szOSD_CHAR);
        gdiGraphics.DrawString(tempText, -1, &gdifont, rec, &strformat, &br1);
    }

5.Image转Byte*

char* AddOSdInfo::Image2Byte(HGLOBAL mem, HBITMAP bmpTmpDraw)
{
    Gdiplus::Bitmap bm2((HBITMAP)bmpTmpDraw, NULL);
    CLSID Clsid2;
    GetEncoderClsid(L"image/jpeg", &Clsid2);//GetEncoderClsid函数在文末
    //bm2.Save(sNewPath2, &Clsid2);

    IStream *stream = NULL;
    HRESULT hr2 = CreateStreamOnHGlobal(mem, TRUE, &stream);
    bm2.Save(stream, &Clsid2);
    LARGE_INTEGER seekPos = {0};
    ULARGE_INTEGER imageSize;
    HRESULT hr = stream->Seek(seekPos, STREAM_SEEK_CUR, &imageSize);
    if (m_pBody)
    {
        delete m_pBody;
        m_pBody = NULL;
    }
    m_pBody = new BYTE[imageSize.LowPart];
    hr = stream->Seek(seekPos, STREAM_SEEK_SET, 0);
    hr = stream->Read(m_pBody, imageSize.LowPart, 0);
    m_nFileSize = imageSize.LowPart;
    
    //KOSA_fileWriteFile("SSSA.jpg", (UINT8*)m_pBody, imageSize.LowPart, false);
    return (char*)m_pBody;
}

6.封装的类

//头文件

#ifndef ADDOSDINFO_H
#define ADDOSDINFO_H
#include "kosa_file.h"
#include "kosa_dir.h"
#include <comdef.h>
#include <GdiPlus.h>
#include "Define.h"
#define MAXPICBUF                    6144000            // 最大图片缓冲区大小
class AddOSdInfo
{
public:
    
    ~AddOSdInfo();

    static AddOSdInfo* GetInstance();

    void SetOriginPicInfo(void *szBuf, DWORD dwBufSize, HVCR_OSD_CFG* osdcfg = NULL);

    bool JPG2Image(void *szBuf, DWORD dwBufSize);
    /*
    GetOsdPicInfo 返回图片的buffer， nFileLen图片长度
    */
    void* GetOsdPicInfo(Uint32* nFileLen);

    char* Image2Byte(HGLOBAL mem, HBITMAP bmpTmpDraw);

    void DrawImageEx(HDC hdc, Gdiplus::Image* pImage, RECT rc);

    void DrawInfo(HDC hdc, void *oldObj, HBITMAP bmpTmpDraw, HDC  hTempMemDC);

    Uint32 GetFileLen();

    void*  GetBuffer();

    void  SetOsdInfo(HVCR_OSD_CFG *osdcfg);
private:
    static AddOSdInfo* m_instance;
    
    AddOSdInfo();

    HGLOBAL        m_hImageMemPic;

    Gdiplus::Image* m_pImagePic;
    SIZE    m_sizePicOut;
    Uint32    m_nFileSize;
    void *    m_pBody;
    HVCR_OSD_CFG m_osdcfg;
    
};

#endif
 

//CPP文件

#include "AddOSdInfo.h"
#include "kosa_file.h"
#include "kosa_dir.h"
AddOSdInfo* AddOSdInfo::m_instance = NULL;
ULONG_PTR                        g_pGdiToken = NULL;
Gdiplus::GdiplusStartupInput    g_gdiplusStartupInput;

int GetEncoderClsid(const WCHAR * format, CLSID * pClsid)
{
    int nRet = -1;
    Gdiplus::ImageCodecInfo * pCodecInfo = NULL;
    UINT nNum = 0, nSize = 0;
    Gdiplus::GetImageEncodersSize(&nNum, &nSize);

    if (nSize < 0)
    {
        return nRet;
    }

    pCodecInfo = new Gdiplus::ImageCodecInfo[nSize];

    if (pCodecInfo == NULL)
    {
        return nRet;
    }

    Gdiplus::GetImageEncoders(nNum, nSize, pCodecInfo);

    for (UINT i = 0; i < nNum; i++)
    {
        if (wcscmp(pCodecInfo[i].MimeType, format) == 0)
        {
            *pClsid = pCodecInfo[i].Clsid;
            nRet = i;
            delete[] pCodecInfo;
            return nRet;
        }
        else
        {
            continue;
        }
    }

    delete[] pCodecInfo;
    return nRet;
}

bool char2wchar(wchar_t* pwsz, const char* psz)
{
    int len = MultiByteToWideChar(CP_ACP, 0, psz, -1, NULL, 0);
    if (!pwsz)
    {
        return false;
    }
    memset(pwsz, 0, len + 1);
    MultiByteToWideChar(CP_ACP, 0, psz, -1, pwsz, len);

    return true;
}


AddOSdInfo::AddOSdInfo()
{
    m_pImagePic = NULL;
    Gdiplus::GdiplusStartup(&g_pGdiToken, &g_gdiplusStartupInput, NULL);
    m_hImageMemPic = GlobalAlloc(GMEM_FIXED, MAXPICBUF);
    m_pBody = NULL;
    memset(&m_osdcfg, 0, sizeof(m_osdcfg));
}

AddOSdInfo *AddOSdInfo::GetInstance()
{
    if (m_instance == NULL)
    {
        m_instance = new AddOSdInfo;
        
    }
    return m_instance;
}


AddOSdInfo::~AddOSdInfo()
{
    if (m_hImageMemPic != NULL)
    {
        GlobalFree(m_hImageMemPic); 
        m_hImageMemPic = NULL; 
    }

    if (g_pGdiToken)
    {
        Gdiplus::GdiplusShutdown(g_pGdiToken);
        g_pGdiToken = 0;
    }

}

void* AddOSdInfo::GetOsdPicInfo(Uint32 *pSize)
{    
    *pSize = m_nFileSize;
    return m_pBody;
}

void AddOSdInfo::SetOriginPicInfo(void *szBuf, DWORD dwBufSize, HVCR_OSD_CFG* osdcfg)
{
    if (osdcfg)
    {
        memcpy(&m_osdcfg, osdcfg, sizeof(HVCR_OSD_CFG));
    }
    JPG2Image(szBuf, dwBufSize);

    HDC hdc = GetDC(NULL);
    HDC hTempMemDC = ::CreateCompatibleDC(NULL);
    HBITMAP bmpTmpDraw = ::CreateCompatibleBitmap(hdc, m_sizePicOut.cx, m_sizePicOut.cy);//hdc
    if (bmpTmpDraw == NULL) bmpTmpDraw = ::CreateCompatibleBitmap(hdc, m_sizePicOut.cx, m_sizePicOut.cy);
    if (bmpTmpDraw == NULL)
    {
        return;
    }
    HGDIOBJ oldObj = ::SelectObject(hTempMemDC, bmpTmpDraw);
    RECT rc;
    rc.left = 0;
    rc.top = 0;
    rc.right = m_sizePicOut.cx;
    rc.bottom = m_sizePicOut.cy;
    DrawImageEx(hTempMemDC, m_pImagePic, rc);

    DrawInfo(hTempMemDC, oldObj, bmpTmpDraw, hTempMemDC);

    Image2Byte(m_hImageMemPic, bmpTmpDraw);

    if (bmpTmpDraw != NULL)
    {
        DeleteObject(bmpTmpDraw);
        bmpTmpDraw = NULL;
    }
    if (hTempMemDC != NULL)
    {
        DeleteObject(hTempMemDC);
        hTempMemDC = NULL;
    }
}


// Jpg转换为Image;
bool AddOSdInfo::JPG2Image(void *szBuf, DWORD dwBufSize)
{
    HGLOBAL hMem = m_hImageMemPic;
    Gdiplus::Image** ppImage = &m_pImagePic;
    
    m_sizePicOut.cx = 0;
    m_sizePicOut.cy = 0;

    int nMaxLen = MAXPICBUF;
    BOOL bAlloc = FALSE;
    if (hMem == NULL)
    {
        bAlloc = TRUE;
        hMem = GlobalAlloc(GMEM_FIXED, nMaxLen);
    }

    if (*ppImage != NULL)
    {
        delete *ppImage;
        *ppImage = NULL;
    }

    if (dwBufSize != 0)
    {
        IStream* pStmBmp = NULL;
        CreateStreamOnHGlobal(hMem, FALSE, &pStmBmp);
        BYTE* pbyBmp = (BYTE *)GlobalLock(hMem);
        memset(pbyBmp, 0, nMaxLen);
        memcpy(pbyBmp, szBuf, dwBufSize);
        ::GlobalUnlock(hMem);
        *ppImage = Gdiplus::Image::FromStream(pStmBmp, FALSE);
        if ((*ppImage) != NULL)
        {
            m_sizePicOut.cx = (*ppImage)->GetWidth();
            m_sizePicOut.cy = (*ppImage)->GetHeight();
        }
    }

    if (bAlloc)
    {
        GlobalFree(hMem);
    }

    /*CLSID pngClsid;
    GetEncoderClsid(L"image/jpeg", &pngClsid);
    m_pImagePic->Save(L"Mosaic245.jpg", &pngClsid, NULL);*/

    return ((*ppImage) != NULL);
}


void*  AddOSdInfo::GetBuffer()
{
    return m_pBody;
}

Uint32 AddOSdInfo::GetFileLen()
{
    return m_nFileSize;
}

void  AddOSdInfo::SetOsdInfo(HVCR_OSD_CFG *osdcfg)
{
    memcpy(&m_osdcfg, osdcfg, sizeof(HVCR_OSD_CFG));
}

void AddOSdInfo::DrawInfo(HDC hdc, void *oldObj, HBITMAP bmpTmpDraw, HDC hTempMemDC)
{
#if 0
    HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);//CDC::GetCurrentFont(hdc);
    LOGFONT LogFont = { 0 };
    ::GetObject(hFont, sizeof(LOGFONT), &LogFont);
    ::DeleteObject(hFont);

    LogFont.lfHeight = -80; // 字体大小 
    hFont = CreateFontIndirect(&LogFont);
    HFONT hOldFont = (HFONT)::SelectObject(hdc, hFont);
    COLORREF clr = 0xFFFFFF;
    COLORREF clrOld = ::GetTextColor(hdc);
    SetBkMode(hdc, TRANSPARENT);
    ::SetTextColor(hdc, clr);
    
    int nLen = 0;
    for (int i = 0; i < HVCR_CUSTOM_OSD_NUM; i++)
    {
        nLen = strlen(m_osdcfg.StOSDItems[i].szOSD_CHAR);
        if (nLen == 0)
        {
            continue;
        }

        ::TextOut(hdc, 80, 100 * (i + 1), m_osdcfg.StOSDItems[i].szOSD_CHAR, nLen);
    }
    ::SetTextColor(hdc, clrOld);
    //char szTxt[168] = { 0 };
    //sprintf(szTxt, "ddddd大家好的萨芬硒鼓硒鼓", strlen("ddddd大家好的萨芬硒鼓硒鼓"));
    //::TextOut(hdc, 100, 100, szTxt, strlen(szTxt));
    //
#else
    
    //create font
    LOGFONTW lfont;
    memset(&lfont, 0, sizeof(lfont));
    int emSize = 70;
    lfont.lfHeight = -emSize; //   nHeight   注意使用负值，表示character height,  正值表示 cell height
    lfont.lfWeight = 400;//100;//FW_NORMAL,  //nWeight
    lfont.lfCharSet = GB2312_CHARSET;//;//ANSI_CHARSET
    wcscpy(lfont.lfFaceName, (L"微软雅黑"));  //   lpszFacename

    Gdiplus::Font gdifont(hdc, &lfont);
    
    Gdiplus::StringFormat strformat;
    strformat.SetAlignment(Gdiplus::StringAlignmentNear);//水平居左  
    strformat.SetLineAlignment(Gdiplus::StringAlignmentCenter);//垂直居中 
    Gdiplus::Font gFont(hdc, &lfont);
    Gdiplus::Color clr1(255, 255, 255);
    Gdiplus::SolidBrush    br1(clr1);
    Gdiplus::Graphics gdiGraphics(hdc);
    wchar_t tempText[256] = { 0 };
    int nLen = 0;
    for (int i = 0; i < HVCR_CUSTOM_OSD_NUM; i++)
    {
        nLen = strlen(m_osdcfg.StOSDItems[i].szOSD_CHAR);
        if (nLen == 0)
        {
            continue;
        }
        Gdiplus::RectF rec(50, 50 + 100 * i, 2000, 100);
        memset(tempText, 0, 256);
        char2wchar(tempText, m_osdcfg.StOSDItems[i].szOSD_CHAR);
        gdiGraphics.DrawString(tempText, -1, &gdifont, rec, &strformat, &br1);
    }
#endif
    /*
    wchar_t *sNewPath2 = L"..\\DevInterfaces\\HVCR_KD_V7_1\\tempDir\\temp.jpg";
    Gdiplus::Bitmap bm2((HBITMAP)bmpTmpDraw, NULL);
    CLSID Clsid2;
    GetEncoderClsid(L"image/jpeg", &Clsid2);//GetEncoderClsid函数在文末
    //bm2.Save(sNewPath2, &Clsid2);

    IStream *stream = NULL;
    HRESULT hr2 = CreateStreamOnHGlobal(m_hImageMemPic, TRUE, &stream);
    bm2.Save(stream, &Clsid2);
    LARGE_INTEGER seekPos = {0};
    ULARGE_INTEGER imageSize;
    HRESULT hr = stream->Seek(seekPos, STREAM_SEEK_CUR, &imageSize);
    if (m_pBody)
    {
        delete m_pBody;
        m_pBody = NULL;
    }
    m_pBody = new BYTE[imageSize.LowPart];
    hr = stream->Seek(seekPos, STREAM_SEEK_SET, 0);
    hr = stream->Read(m_pBody, imageSize.LowPart, 0);
    m_nFileSize = imageSize.LowPart;
    KOSA_fileWriteFile("SSSA.jpg", (UINT8*)m_pBody, imageSize.LowPart, false);
    */
    SelectObject(hTempMemDC, oldObj);
}

char* AddOSdInfo::Image2Byte(HGLOBAL mem, HBITMAP bmpTmpDraw)
{
    Gdiplus::Bitmap bm2((HBITMAP)bmpTmpDraw, NULL);
    CLSID Clsid2;
    GetEncoderClsid(L"image/jpeg", &Clsid2);//GetEncoderClsid函数在文末
    //bm2.Save(sNewPath2, &Clsid2);

    IStream *stream = NULL;
    HRESULT hr2 = CreateStreamOnHGlobal(mem, TRUE, &stream);
    bm2.Save(stream, &Clsid2);
    LARGE_INTEGER seekPos = {0};
    ULARGE_INTEGER imageSize;
    HRESULT hr = stream->Seek(seekPos, STREAM_SEEK_CUR, &imageSize);
    if (m_pBody)
    {
        delete m_pBody;
        m_pBody = NULL;
    }
    m_pBody = new BYTE[imageSize.LowPart];
    hr = stream->Seek(seekPos, STREAM_SEEK_SET, 0);
    hr = stream->Read(m_pBody, imageSize.LowPart, 0);
    m_nFileSize = imageSize.LowPart;
    
    //KOSA_fileWriteFile("SSSA.jpg", (UINT8*)m_pBody, imageSize.LowPart, false);
    return (char*)m_pBody;
}


void AddOSdInfo::DrawImageEx(HDC hdc, Gdiplus::Image* pImage, RECT rc)
{
    if (pImage)
    {
        Gdiplus::Graphics g(hdc);
        Gdiplus::ImageAttributes ImgAtt;
        ImgAtt.SetWrapMode(Gdiplus::WrapModeTileFlipXY);
        g.DrawImage(pImage, Gdiplus::Rect(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top),
            0, 0, pImage->GetWidth(), pImage->GetHeight(),
            Gdiplus::UnitPixel, &ImgAtt, NULL, NULL);
    }
    else
    {
        //绘制背景
        HBRUSH hbrush = CreateSolidBrush(GetBkColor(hdc));
        ::FillRect(hdc, &rc, hbrush);
        ::DeleteObject(hbrush);
    }
}
 

BillyJue
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 将图片转换为字符画 附成品程序
LvTwelve
07-02 3964
原理 数字图片实际上是一个个像素小点拼凑而成的。（一个数字序列表示的图像中的一个最小单位称为像素） 像素的颜色可以由红(RED)、绿(GREEN)、蓝(BLUE)三个颜色通道的变化以及它们相互之间的叠加而形成，这也就是我们常说的RGB色彩模式。 这个标准几乎包括了人类视力所能感知的所有颜色，是运用最广的颜色系统之一。 另外一种颜色表示方式，灰度图，就是我们平常见到的黑白图。 灰度的概念类似于美术中颜色的亮度。 将白色与黑色之间按对数关系分为256阶，并用这些阶数对图像进行表示。 示例 而字符画则在此基础上
C++内存画图，无闪烁
11-07
使用VC++编写的内存画图类，需要的可以拿去借鉴一下
C++实现JPEG格式图片解析（附代码）
weixin_43891802的博客
04-13 4322
在网上看了好多解析JPEG图片的文章，多多少少都有问题，下面是我参考过的文章链接： JPEG格式中信息是以段（数据结构）来存储的。 段的格式如下其余具体信息请见以下链接，我就不当复读机了。 JPEG标记的说明 格式介绍 值得注意的一点是一个字节的高位在左边，而且直流分量重置标记一共有8个，其他的格式说明在第二个链接中已经足够详细了这些段中必须要读取的段：SOS, DHT, DQT, SOF, DRI，其他的只是锦上添花 这里面可能会出现多个SOF段，我们需要拿到这几个段中图片高度和宽度的最大值，和YCbCr
C++ 生成JPEG图片源代码
06-20
跨平台 生成JPG图片的源代码 有库文件 只需要自己编译就可以了
VC中生成文字图片并保存到文件目录
踏莎行的博客
07-17 3139
是不是很羡慕PHP的动态生成验证码图片的功能呢？其实无所不能
C++中string转换为char*类型返回后乱码问题解决
08-18
"C++中string转换为char*类型返回后乱码问题解决" 在C++中，string类型和char*类型之间的转换是非常常见的操作。然而，在将string类型转换为char*类型返回时，经常会出现乱码问题。本文将详细介绍这个问题的解决...
golang调用c++DLL传递char*型参数读取返回char*字符串内容
06-20
golang调用c++DLL返回值为char*参数为const char*，读取返回DLL返回值，传递char*型参数
C++在内存中将bmp转JPG
03-04
在C++编程环境中，将BMP图像转换为JPG格式是一项常见的任务，特别是在处理大量图像或需要节省存储空间时。本篇文章将详细讲解如何在VS2013中使用MFC（Microsoft Foundation Classes）和OpenCV库来实现这个功能。...
浅谈C++中char型变量的地址输出
12-26
在刚开始学习C/C++过程中，我们希望输出各个变量的地址来窥探一些我们“百思不得其解”的现象，例如搞清函数堆栈相关的程序内部秘密。 先看下面示例： #include #include using namespace std; class TestArrange ...
C++入门篇(6)之内存处理
m0_51723227的博客
10-25 786
文章目录前言C/C++内存分布c语言中动态内存管理方式C++内存管理方式new和delete操作基础类型new和delete操作自定义类型基于malloc开辟并初始化的自定义类型new和delete底层实现原理operator new和operator deletenew的底层实现delete的底层实现new[]的底层实现delete[]的原理 前言 兜兜转转,我们终于结束了C++中非常重要的一环**(类和对象),现在来到了C++中的内存管理章节.在此篇文章中,博主将会介绍内存的分布,不同于c的新型申请堆
非常好用的C++图片读取类
07-29
非常好用的C++图片读取、处理类；包括读取常用的jpg、bmp、png等文件格式，非常方便好用！
VC++在BMP位图图片上显示文本
03-15
VC++在BMP图片上显示文本，是一个VC++窗口绘图的例子，JPG格式图片未做测试。显示文字主要是使用TextOut方法，完整的过程是：定义位图对象，加载背景位图，获取位图信息（图像宽度和高度），获取窗口客户区域，获取窗口设备上下文，定义一个内存设备上下文，CreateCompatibleDC方法创建与pDC兼容的设备上下文，选中位图对象在窗口中绘图，设置透明的背景模式，输出文本。 运行环境：Windows/Visual C/C++
VC++控制台应用程序下使用GDI在内存中画图
Bloodwolf的专栏
11-05 2549
控制台应用程序下使用GDI在内存中画图 1      背景 以前写MFC应用程序的时候，就接触到GDI了。只不过那个时候，Visual Studio已经帮你生成了MFC应用的基本框架，在Visual Studio生成的View文件里，存在一个方法::OnDraw(CDC* /*pDC*/)，Visual Studio会添加注释“// TODO: 在此处为本机数据添加绘制代码”，即是说，请在此处
C++设置bmp、jpg、png、Tiff图像打印分辨率DPI
renzhehongyi的专栏
05-12 1027
【代码】C++设置bmp、jpg、png、Tiff图像打印分辨率DPI。
将本地图片二进制读取在char型容器中，发送并接收后重新解码为图片，进行图片数据传输
qq_42541310的博客
12-22 451
//将本地的一张图片转换程二进制形式存入一个vector<char>中 std::string filepath = "d:/6.jpg"; std::ifstream fin(filepath, std::ios::binary); std::vector<char> buf(fin.seekg(0, std::ios::end).tellg()); fin.seekg(0, std::ios::beg).read(&buf[0], static_...
C/C++:如何在Vc程序中加载JPG图片
xiaoGang的专栏
10-13 7748
 问题：如何在Vc6.0程序中加载JPG图片？ 解答：         MFC提供的CWnd只有默认加载BMP文件的接口，对JPG等图像是不支持的，而实际中经常需要用到非BMP的图片，加载它们需要使用COM技术。       以下是引用片段：BOOL LoadMyJpegFile(CString fname,LPPICTURE *lppi){ HANDLE hFil
Gdiplus::Bitmap转HBITMAP与HBITMAP转Gdiplus::Bitmap
学习并记录
03-02 1705
虽然已经有很多文章介绍两者互转了，但是实际使用过程中，仍然可能遇到问题。这里再提取一下过程及核心代码。 Gdiplus::Bitmap转HBITMAP，直接上代码 LPBYTE pBmpBits = NULL; BITMAPINFO bimpi = {0}; bimpi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); bimpi.bmiHeader.biWidth = nCW; bimpi.bmiHeader.biHeight = -nCH;
GDI+ 在Delphi程序的应用 -- GDI+图像与GDI位图的相互转换
闲人阿发伯的业余编程心得
01-08 1万+
        Delphi的TBitmap封装了Windows的GDI位图，因此，TBitmap只支持bmp格式的图像，但是在Delphi应用程序中，常常会遇到图形格式的转换，如将Delphi位图TBitmap的图像转换为其它格式保存，或者将其它图像格式转换为TBitmap等。这时候，我们往往借助一些第三方组件或代码，Delphi自带的TJPEG.pas就是jpeg格式图像转换的第三方代码单元。
【C++】存储图像数据的unsigned char*数组
热门推荐
小黑先森的博客
08-01 1万+
存储图像数据的unsigned char*数组 最近研究生成图像的代码时，深入研究了一下osg::Image中的数据存储，一般从该数据结构中获取某一像素的像素值时会用到data(i,j)这个函数，其返回值的类型就是一个unsigned char*数组，而更加神奇的是其返回图像数据的同名函数data()返回的值也是一个unsigned char*数组，也就是说unsigned char*数组里面存储的数据类型还是一个unsigned char*数组（Q_Q），这就很有意思了。于是从这里出发，我们研究一下C语言
C++ char*转 unsigned char*
最新发布
04-02
在C++中，将`char*`类型转换为`unsigned char*`类型可以通过使用类型转换或者使用`reinterpret_cast`来实现。 1. 使用类型转换： ```cpp char* charPtr = "Hello"; unsigned char* unsignedCharPtr = reinterpret_cast<unsigned char*>(charPtr); ``` 2. 使用`reinterpret_cast`： ```cpp char* charPtr = "Hello"; unsigned char* unsignedCharPtr = (unsigned char*)charPtr; ``` 需要注意的是，这种转换可能会导致数据的丢失或截断，因为`char`类型是有符号的，而`unsigned char`类型是无符号的。所以在进行转换时，需要确保数据的正确性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值