2. 程式人生 > >Qt顯示pdf系列4——封裝pdfium庫為動態庫，顯示pdf

Qt顯示pdf系列4——封裝pdfium庫為動態庫，顯示pdf

阿新 • • 發佈：2019-02-08

 承接上篇，pdfium的lib檔案是已經編譯出來了，理論上已經可以開始直接用了，官方提供的測試demo中基本上介紹了用法的整套流程，你可以選擇匯出一頁頁的（圖片）檔案，也可以直接取出Buffer丟給支援圖形庫去渲染。

序

 但是需要注意的是，他在實際使用中依舊有很多不便：
1、我們能夠編譯出來的只有vs2015或以上版本的lib，如果我們需要在別的ide中引用，那麼就可能不行。
2、編譯出來的lib一共24個，所以確定要在專案中，光pdf庫就引用這麼多個嗎= =。

 解決方式：基於這些lib的基礎上，再包一層，把他編譯成動態庫，介面用純C語言，不僅簡潔，而且理論上說是跨平臺的。

 關於動態庫，只簡單說幾句，不瞭解可以自己查：靜態連結庫（.lib）cpp裡所有程式碼被被編譯成2進位制檔案，使用時直接會連線到你的專案中，而動態連結庫，裡面是你專案的程式碼，也不會編譯進你的程式中。

 開發環境：windows7+vs2015

一、新建專案:

 開啟vs2015，新建一個c++的win32專案，當然，你也可以直接新建成空專案，然後在設定裡手動修改輸出方式為dll。這裡我的專案叫pdf
這裡寫圖片描述
這裡寫圖片描述

二、封裝pdfium庫:

1、把上篇編譯出來的pdfium庫的lib和標頭檔案整理好，並新增到剛才新建的專案中去：
這裡寫圖片描述
這裡寫圖片描述
2、在專案中新建PdfManager.h,PdfManager.cpp。開始寫程式碼：
PdfManager.h：

#ifndef _PDF_MANAGER_H_
#define _PDF_MANAGER_H_
//filename是檔名，需要唯一，dat是開啟的pdf的內容（可以用fstream開啟，以二進位制形式），length是pdf長度
 

extern "C" _declspec(dllexport) bool __stdcall PDFMANAGER_Loadpdf(const char* filename, char* dat, int length); //載入pdf(即載入已經開啟的pdf)
//filename是檔名，關閉該pdf
extern "C" _declspec(dllexport) bool __stdcall PDFMANAGER_Closepdf(const char* filename); //關閉pdf
//filename是檔名，關閉該pdf，page是需要顯示頁數，width是寬，height是高，size是當前頁的大小，outBmp是是否匯出bmp檔案，返回該頁buffer
 

extern "C" _declspec(dllexport) char* __stdcall PDFMANAGER_LoadPage(const char* filename, int page, float& width, float& height, int& size, bool OutBmp);//載入頁面
//filename是檔名，關閉該頁面，開啟後需要關閉，否則會記憶體洩漏
extern "C" _declspec(dllexport) void __stdcall PDFMANAGER_ClosePage(const char* filename, int page); //關閉頁面
//獲取總頁數
extern "C" _declspec(dllexport) int __stdcall PDFMANAGER_GetPageCount(const char* filename);
//獲取下一頁該渲染的頁
extern "C" _declspec(dllexport) int __stdcall PDFMANAGER_GetCurrentPage(const char* filename);
#endif

PdfManager.cpp：

#include "PdfManager.h"

#include "fpdfview.h"
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <memory>
#include <map>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#include "fpdf_dataavail.h"
#include "fpdf_edit.h"
#include "fpdf_ext.h"
#include "fpdf_formfill.h"
#include "fpdf_text.h"

#include <functional>
#include <fstream>



enum OutputFormat
{
    OUTPUT_STR,
    OUTPUT_BMP,
};

struct Options
{
    Options() :pages(false), output_format(OUTPUT_BMP) {}
    bool pages; //是否指定範圍
    OutputFormat output_format;
    int first_page = 0; //起始頁數
    int last_page = 0; //終止頁數
    int currentpage = 0; //要列印的頁面
    float width = 0; //目標寬度
    float height = 0; //目標高度
};


FPDF_BOOL Is_Data_Avail(FX_FILEAVAIL* avail, size_t offset, size_t size)
{
    return true;
}

class PDFManager
{
    static std::string WriteBmp(int num,
        const void* buffer,
        int stride,
        int width,
        int height)
    {
        if (stride < 0 || width < 0 || height < 0)
            return false;
        if (height > 0 && width > INT_MAX / height)
            return false;

        int out_len = stride * height;
        if (out_len > INT_MAX / 3)
            return "";

        char filename[256];
        snprintf(filename, sizeof(filename), "%d.bmp", num);
        FILE* fp = fopen(filename, "wb");
        if (!fp)
            return "";

        BITMAPINFO bmi = {};
        bmi.bmiHeader.biSize = sizeof(bmi) - sizeof(RGBQUAD);
        bmi.bmiHeader.biWidth = width;
        bmi.bmiHeader.biHeight = -height;  // top-down image
        bmi.bmiHeader.biPlanes = 1;
        bmi.bmiHeader.biBitCount = 32;
        bmi.bmiHeader.biCompression = BI_RGB;
        bmi.bmiHeader.biSizeImage = 0;

        BITMAPFILEHEADER file_header = {};
        file_header.bfType = 0x4d42;
        file_header.bfSize = sizeof(file_header) + bmi.bmiHeader.biSize + out_len;
        file_header.bfOffBits = file_header.bfSize - out_len;

        fwrite(&file_header, sizeof(file_header), 1, fp);
        fwrite(&bmi, bmi.bmiHeader.biSize, 1, fp);
        fwrite(buffer, out_len, 1, fp);
        fclose(fp);
        return std::string(filename);
    }


    struct FPDF_FORMFILLINFO_PDFiumTest : public FPDF_FORMFILLINFO
    {
        // Hold a map of the currently loaded pages in order to avoid them
        // to get loaded twice.
        std::map<int, FPDF_PAGE> loaded_pages;
        // Hold a pointer of FPDF_FORMHANDLE so that PDFium app hooks can
        // make use of it.
        FPDF_FORMHANDLE form_handle;
    };

    struct AvailDeleter
    {
        inline void operator()(FPDF_AVAIL avail) const
        {
            FPDFAvail_Destroy(avail);
        }
    };

    static FPDF_FORMFILLINFO_PDFiumTest* ToPDFiumTestFormFillInfo(FPDF_FORMFILLINFO* form_fill_info)
    {
        return static_cast<FPDF_FORMFILLINFO_PDFiumTest*>(form_fill_info);
    }

    FPDF_PAGE GetPageForIndex(FPDF_FORMFILLINFO* param,
        FPDF_DOCUMENT& doc,
        int index)
    {
        FPDF_FORMFILLINFO_PDFiumTest* form_fill_info =
            ToPDFiumTestFormFillInfo(param);
        auto& loaded_pages = form_fill_info->loaded_pages;

        auto iter = loaded_pages.find(index);
        if (iter != loaded_pages.end())
            return iter->second;
        FPDF_PAGE page = FPDF_LoadPage(doc, index);
        if (!page)
            return nullptr;

        FPDF_FORMHANDLE& form_handle = form_fill_info->form_handle;

        FORM_OnAfterLoadPage(page, form_handle);
        FORM_DoPageAAction(page, form_handle, FPDFPAGE_AACTION_OPEN);

        loaded_pages[index] = page;
        return page;
    }

    char* RenderPage(FPDF_DOCUMENT& doc,
        FPDF_FORMFILLINFO_PDFiumTest& form_fill_info
        , float& width, float& height,
        const Options& options,
        int& size)
    {
        FPDF_PAGE page = GetPageForIndex(&form_fill_info, doc, options.currentpage);
        if (!page)
        {
            return nullptr;
        }
        FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page);
        double scale = 1.0;
        int widthdraw = static_cast<int>(FPDF_GetPageWidth(page) * scale);
        int heightdraw = static_cast<int>(FPDF_GetPageHeight(page) * scale);
        if (options.width > 0 && options.height > 0)
        {
            if (options.width > options.height)
            {
                double scalewidth = (double)options.height / (double)heightdraw;
                heightdraw = options.height;
                widthdraw = scalewidth * widthdraw;
            }
            else
            {
                double scaleheight = (double)options.width / (double)widthdraw;
                widthdraw = options.width;
                heightdraw = scaleheight * heightdraw;
            }
        }
        //else
        //{
        //  widthdraw = static_cast<int>(FPDF_GetPageWidth(page) * scale);
        //  heightdraw = static_cast<int>(FPDF_GetPageHeight(page) * scale);
        //}

        int alpha = FPDFPage_HasTransparency(page) ? 1 : 0;
        FPDF_BITMAP bitmap = FPDFBitmap_Create(widthdraw, heightdraw, alpha);
        const char* buffer = nullptr;
        char* rtnBuffer = nullptr;
        int out_len = 0;
        if (bitmap)
        {
            FPDF_DWORD fill_color = alpha ? 0x00000000 : 0xFFFFFFFF;
            FPDFBitmap_FillRect(bitmap, 0, 0, widthdraw, heightdraw, fill_color);
            FPDF_RenderPageBitmap(bitmap, page, 0, 0, widthdraw, heightdraw, 0, FPDF_ANNOT | FPDF_REVERSE_BYTE_ORDER);
            //FPDF_FFLDraw(form, bitmap, page, 0, 0, width, height, 0, FPDF_ANNOT | FPDF_REVERSE_BYTE_ORDER);
            int stride = FPDFBitmap_GetStride(bitmap);
            int strheight = FPDFBitmap_GetHeight(bitmap);
            buffer = reinterpret_cast<const char*>(FPDFBitmap_GetBuffer(bitmap));
            //開闢新記憶體
            size = stride * strheight;
            rtnBuffer = new char[size];
            memset(rtnBuffer, 0, size);
            memcpy(rtnBuffer, buffer, size);

            width = FPDFBitmap_GetWidth(bitmap);
            height = FPDFBitmap_GetHeight(bitmap);
            Pages_.insert(std::make_pair(options.currentpage, rtnBuffer));
            switch (options.output_format)
            {
            case OUTPUT_BMP:
                WriteBmp(options.currentpage, buffer, stride, widthdraw, heightdraw);
                break;
            default:
                break;
            }
            FPDFBitmap_Destroy(bitmap);
        }
        /*else
            fprintf(stderr, "Page was too large to be rendered.\n");*/
        form_fill_info.loaded_pages.erase(options.currentpage);
        /*FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_CLOSE);
        FORM_OnBeforeClosePage(page, form);*/
        FPDFText_ClosePage(text_page);
        FPDF_ClosePage(page);
        return rtnBuffer;
    }

    class TestLoader
    {
    public:
        TestLoader(const char* buff, size_t len)
        {
            m_pBuf = new char[len];
            memcpy(m_pBuf, buff, len);
            m_Len = len;
        }
        ~TestLoader()
        {
            delete[]m_pBuf;
        }

        static int GetBlock(void* param,
            unsigned long pos,
            unsigned char* pBuf,
            unsigned long size)
        {
            TestLoader* pLoader = static_cast<TestLoader*>(param);
            if (pos + size < pos || pos + size > pLoader->m_Len)
                return 0;
            memcpy(pBuf, pLoader->m_pBuf + pos, size);
            return 1;
        }
    private:
        char* m_pBuf;
        size_t m_Len;
    };

    void RenderPdf(const char* pBuf, size_t len, const Options& options)
    {
        memset(&platform_callbacks_, '\0', sizeof(platform_callbacks_));
        platform_callbacks_.version = 3;

        form_callbacks_.version = 1;
        form_callbacks_.m_pJsPlatform = &platform_callbacks_;

        Loader_ = std::move(std::unique_ptr<TestLoader>(new TestLoader(pBuf, len)));
        File_access_ = std::make_unique<FPDF_FILEACCESS>();
        memset(File_access_.get(), '\0', sizeof(File_access_.get()));
        File_access_->m_FileLen = static_cast<unsigned long>(len);
        File_access_->m_GetBlock = TestLoader::GetBlock;
        File_access_->m_Param = Loader_.get();

        memset(&File_avail_, '\0', sizeof(File_avail_));
        File_avail_.version = 1;
        File_avail_.IsDataAvail = Is_Data_Avail;

        memset(&Hints_, '\0', sizeof(Hints_));
        Hints_.version = 1;

        int nRet = PDF_DATA_NOTAVAIL;

        Pdf_avail_ = FPDFAvail_Create(&File_avail_, File_access_.get());
        std::unique_ptr<void, PDFManager::AvailDeleter> scoped_pdf_avail_deleter(Pdf_avail_);

        if (FPDFAvail_IsLinearized(Pdf_avail_) == PDF_LINEARIZED)
        {
            this->PdfDoc_ = FPDFAvail_GetDocument(Pdf_avail_, nullptr);
            if (this->PdfDoc_)
            {
                while (nRet == PDF_DATA_NOTAVAIL)
                    nRet = FPDFAvail_IsDocAvail(Pdf_avail_, &Hints_);
                if (nRet == PDF_DATA_ERROR)
                {
                    fprintf(stderr, "Unknown error in checking if doc was available.\n");
                    FPDF_CloseDocument(this->PdfDoc_);
                    return;
                }
                nRet = FPDFAvail_IsFormAvail(Pdf_avail_, &Hints_);
                if (nRet == PDF_FORM_ERROR || nRet == PDF_FORM_NOTAVAIL)
                {
                    fprintf(stderr,
                        "Error %d was returned in checking if form was available.\n",
                        nRet);
                    FPDF_CloseDocument(this->PdfDoc_);
                    return;
                }
                this->bIsLinearized_ = true;
            }
        }
        else
        {
            this->PdfDoc_ = FPDF_LoadCustomDocument(File_access_.get(), nullptr);
        }
        if (!this->PdfDoc_)
        {
            unsigned long err = FPDF_GetLastError();
            return;
        }
        (void)FPDF_GetDocPermissions(this->PdfDoc_);
        PageCount = FPDF_GetPageCount(this->PdfDoc_);
    }

public:
    PDFManager();
    ~PDFManager();
    void Init(char *dat, int length);
    void Close();
    char* GetPdfPage(int page, float& width, float& height, int& size, bool OutBmp = false);//返回長度
    void ClosePdfPage(int page);
    int PageCount = 0;
    int PageCurrent = 0;
    int PageBad = 0;
private:
    FPDF_DOCUMENT PdfDoc_ = nullptr;//文件
    //FPDF_FORMHANDLE Form_ = nullptr;
    bool bIsLinearized_ = false; //是否線性化
    FPDF_FORMFILLINFO_PDFiumTest form_callbacks_;
    IPDF_JSPLATFORM platform_callbacks_;
    FX_DOWNLOADHINTS Hints_;//
    FX_FILEAVAIL File_avail_;
    std::unique_ptr<FPDF_FILEACCESS> File_access_;
    FPDF_AVAIL Pdf_avail_;
    std::unique_ptr<TestLoader> Loader_;
    char* File_contents_ = nullptr;
    int File_length_ = 0;
    std::map<int, char*> Pages_; //儲存頁面資料

};

PDFManager::PDFManager()
{

}

PDFManager::~PDFManager()
{
    for (auto &buffer : Pages_)
    {
        delete[]buffer.second;
    }
    Pages_.clear();
    this->Close();
}

void PDFManager::Init(char *dat, int length)
{
    File_contents_ = dat;
    File_length_ = length;
    Options options;
    options.output_format = OutputFormat::OUTPUT_BMP;

    if (!File_contents_)
        return;
    RenderPdf(File_contents_, File_length_, options);
}

char* PDFManager::GetPdfPage(int page, float& width, float& height, int& size, bool OutBmp)
{
    if (this->bIsLinearized_)
    {
        this->Close();
        return 0;
    }
    if (page < 0)
        return 0;
    Options options;
    options.currentpage = page;
    options.width = width;
    options.height = height;
    if (!OutBmp)
        options.output_format = OUTPUT_STR;
    PageCurrent = page;
    PageCurrent++;
    return RenderPage(this->PdfDoc_, form_callbacks_, width, height, options, size);
}

void PDFManager::ClosePdfPage(int page)
{
    std::map<int, char*>::iterator itor = Pages_.find(page);
    if (itor != Pages_.end())
    {
        delete[]itor->second;
        Pages_.erase(page);
    }
}

void PDFManager::Close()
{
    if (!this->PdfDoc_)
        return;
    FPDF_CloseDocument(this->PdfDoc_);
}



//介面函式
std::map<std::string, PDFManager*> g_pdfmanagersmap;
bool __stdcall PDFMANAGER_Loadpdf(const char* filename, char* dat, int length)
{
    if (!filename)
    {
        return false;
    }
    if (g_pdfmanagersmap.size() == 0)
    {
        FPDF_LIBRARY_CONFIG config;
        config.version = 2;
        config.m_pUserFontPaths = nullptr;
        config.m_pIsolate = nullptr;
        config.m_v8EmbedderSlot = 0;
        FPDF_InitLibraryWithConfig(&config);
    }
    std::string file = filename;
    std::map<std::string, PDFManager*>::iterator itor = g_pdfmanagersmap.find(file);
    if (itor != g_pdfmanagersmap.end())
    {
        itor->second->Init(dat, length);
    }
    else
    {
        PDFManager* pdfmanager = new PDFManager();
        g_pdfmanagersmap.insert(std::make_pair(file, pdfmanager));
        pdfmanager->Init(dat, length);
    }
    return true;
}

bool __stdcall PDFMANAGER_Closepdf(const char* filename)
{
    if (!filename)
    {
        return false;
    }
    std::string file = filename;
    std::map<std::string, PDFManager*>::iterator itor = g_pdfmanagersmap.find(file);
    if (itor != g_pdfmanagersmap.end())
    {
        delete itor->second;
        g_pdfmanagersmap.erase(file);
        if (g_pdfmanagersmap.size() == 0)
        {
            FPDF_DestroyLibrary();
        }
    }
    return true;
}

char* __stdcall PDFMANAGER_LoadPage(const char* filename, int page, float& width, float& height, int& size, bool OutBmp)
{
    if (!filename)
    {
        return nullptr;
    }
    std::string file = filename;
    std::map<std::string, PDFManager*>::iterator itor = g_pdfmanagersmap.find(file);
    if (itor != g_pdfmanagersmap.end())
    {
        return itor->second->GetPdfPage(page, width, height, size, OutBmp);
    }
    return nullptr;
}

void __stdcall PDFMANAGER_ClosePage(const char* filename, int page)
{
    if (!filename)
    {
        return;
    }
    std::string file = filename;
    std::map<std::string, PDFManager*>::iterator itor = g_pdfmanagersmap.find(file);
    if (itor != g_pdfmanagersmap.end())
    {
        itor->second->ClosePdfPage(page);
    }
}

int __stdcall PDFMANAGER_GetPageCount(const char* filename)
{
    if (!filename)
    {
        return 0;
    }
    std::string file = filename;
    std::map<std::string, PDFManager*>::iterator itor = g_pdfmanagersmap.find(file);
    if (itor != g_pdfmanagersmap.end())
    {
        return itor->second->PageCount;
    }
    return 0;
}

int __stdcall PDFMANAGER_GetCurrentPage(const char* filename)
{
    if (!filename)
    {
        return 0;
    }
    std::string file = filename;
    std::map<std::string, PDFManager*>::iterator itor = g_pdfmanagersmap.find(file);
    if (itor != g_pdfmanagersmap.end())
    {
        return itor->second->PageCurrent;
    }
    return 0;
}

註釋說的比較清楚，就不解釋了。

3、新增模組檔案：

這裡寫圖片描述
我取名為PdfManager.def，在裡面新增如下程式碼：

LIBRARY "Pdf"
EXPORTS
PDFMANAGER_Loadpdf @ 1
PDFMANAGER_Closepdf @ 2
PDFMANAGER_LoadPage @ 3
PDFMANAGER_ClosePage @ 4
PDFMANAGER_GetPageCount @ 5
PDFMANAGER_GetCurrentPage @ 6

即指定要編譯成dll的介面函式。

4、編譯，最後整理成pdf庫：
這裡寫圖片描述
這裡寫圖片描述
直接編譯release版本就可以了，通用。

三、使用封裝好的pdf動態庫：

1、在vs中使用：

1.1 先新建測試專案
1.2 新增pdf庫
1.2 新增程式碼：
main.cpp：

#include <iostream>
#include <fstream>
#include "PdfManager.h"
#include <memory>

#include <windows.h>
char* GetFileContents(const char* filename, size_t *size)
{
    std::fstream instream;
    instream.open(filename, std::ios::_Nocreate | std::ios::binary);
    if (!instream.is_open())
    {
        std::printf("open file Failed!\n");
        std::printf("%s\n", filename);
        instream.close();
        return nullptr;
    }
    instream.seekg(0, std::ios::end);
    *size = instream.tellg();
    instream.seekg(0, std::ios::beg);
    char *buffer = new char[*size];
    instream.read(buffer, *size);
    instream.close();
    return buffer;
}


int main()
{



    char* name = "test.pdf";
    size_t length;
    std::unique_ptr<char>  filecontents(GetFileContents(name, &length));
    PDFMANAGER_Loadpdf(name, filecontents.get(), length);
    int counts = PDFMANAGER_GetPageCount(name);
    for (int i = 0; i < counts; ++i)
    {

        if (GetAsyncKeyState(VK_F2) & 0x8000)
            break;
        float width, height = 0;
        int length = 0;
        PDFMANAGER_LoadPage(name, i, width, height, length, true);
        PDFMANAGER_ClosePage(name, i);
    }
    PDFMANAGER_Closepdf(name);
    system("pause");

    return 0;
}

結果如圖（數字.bmp是渲染出來的每一頁，我只渲染完三頁就關了）：
這裡寫圖片描述

2、在qt中使用：

2.1新建qt專案
2.2 匯入pdf動態庫
2.3關鍵程式碼（ui邏輯程式碼就不貼了，其實就是主要講怎麼用，怎麼渲染）：

PDFForm::PDFForm(const char *filename, QByteArray &bytearray, QWidget *parent) :
    QWidget(parent),
    ui(new Ui::PDFForm)
{
    ui->setupUi(this);
    FileLength_ = bytearray.length();
    File_ = new char[FileLength_];
    std::memcpy(File_, bytearray.toStdString().c_str(), FileLength_);
    FileName_ = filename;
    Picture_ = new PictureBox();
    Picture_->setMode(PictureBox::PB_MODE::FIX_SIZE_CENTRED );
    this->ui->verticalLayout_2->addWidget(Picture_);
}


void PDFForm::InitFile()
{
    if(HaveLoadPdf_)
        return;

    int length = (int)FileLength_;
    PDFMANAGER_Loadpdf(FileName_.c_str(), File_, length);
    HaveLoadPdf_ = true;
    PageCount_ = PDFMANAGER_GetPageCount(FileName_.c_str());
    this->LoadPage(0);
}

void PDFForm::LoadPage(int page)
{
    if(!HaveLoadPdf_)
        return;
    int length = 0;
    QRect rect = this->ui->verticalLayout_2->geometry();
    float width = rect.width();
    float height = rect.height();
    char* Buffer = PDFMANAGER_LoadPage(FileName_.c_str(),page, width, height, length, false);
    QImage image((uchar*)Buffer, width, height, QImage::Format_RGBA8888);
    this->Picture_->setImage(image);
    PDFMANAGER_ClosePage(FileName_.c_str(),page);//釋放頁面記憶體
    UpdateLabelPage();
}

效果如下圖：
這裡寫圖片描述

到這裡就完成了需要在qt中顯示或開啟pdf的需求，還做了適配，可以直接拉伸縮小，而且最主要的是，因為其本質是點陣圖，放大縮小時重新loadpage可以實現解析度也不斷放大縮小。

四、結語：

1、本系列到此結束，其實還有些東西，比如在qt裡做顯示適配，例如上面的Picture_物件就是自定義的一個image類，在介面上顯示時方便居中，要寫的話還可以寫第五篇，但是我暫時沒空，就打住了，以後會不會補需要再看看。

2、本次研究說實話讓我提升很多，很多是思維和經驗上的改變，獨立能力稍微有點加強，希望能早日成為大牛。

17.05.19更新：
程式碼地址：
傳送門

17.07.27更新：
大家不用留郵箱了，我不是經常上這個帳號，下載連線也貼了，也不花積分，直接下載就好了（ps：我自己下了，也叫別人下了，檔案沒問題，下載下來有問題重新試試，csdn是經常抽風，網路不是很穩定）

17.08.09更新：
鑑於很多人問我要在QT中開啟的demo，現在補上（如果覺得不錯，不妨點個頂或者關注，你的鼓勵是對我最大的支援）：
傳送門
另外 需要1積分，不知道為啥，現在csdn資源最少1積分，包括我以前的0分資源全部自動調整為1分，特此說明。

相關推薦

Qt顯示pdf系列4——封裝pdfium庫為動態庫，顯示pdf

 承接上篇，pdfium的lib檔案是已經編譯出來了，理論上已經可以開始直接用了，官方提供的測試demo中基本上介紹了用法的整套流程，你可以選擇匯出一頁頁的（圖片）檔案，也可以直接取出Buffer丟給支援圖形庫去渲染。 序  但是需要注意的是，他在

數據庫控制動態菜單顯示（SSM框架）

fun ppi mapping menu 數據庫 ring int ride success ① 數據庫設計： 數據庫映射的POJO類 @JsonIgnoreProperties(ignoreUnknown = true) @Table(name="MENU") publi

QtEmbedded-4.8.6-arm 從動態庫到靜態庫-釋出小記

    以前是動態庫，現在要換成靜態庫。步驟如下。    1.重新配置編譯器。 在autoconf.sh指令碼中，將-release -shared修改 -release -static 。 ./autoconf.sh make clean make

linux 程式碼封裝成靜態庫和動態庫使用（待續）

問題是這樣的，自己的程式碼實現了一個數據分類的功能，如何把這部分程式碼完全打包成動態庫和標頭檔案，提供API給別人呼叫呢？如果沒有使用其它的依賴庫或者其它開原始碼，那麼可以直接按照gcc編譯器生成和使用靜態/動態庫的方式。可以參考部落格：按照這篇部落格裡面的操作，基本可以完成

QT 載入靜態庫和動態庫的方法

載入動態庫 LIBS += -L./opencv249/vc10/bin -lopencv_core249 LIBS += -L./opencv249/vc10/bin -lopencv_highgui249 LIBS += -L./opencv249/vc10/bin

ffmpeg的ubuntu的編譯過程（編譯靜態庫和動態庫）

ffmpeg第一步源碼下載通過git下載git clone https://git.ffmpeg.org/ffmpeg.git ffmpeg或者直接下載wget http://ffmpeg.org/releases/ffmpeg-3.3.tar.bz2如果是下載的ffmpeg-3.3.tar.bz2 需要進

關於Linux靜態庫和動態庫的分析

所在 mis color 先後 main 技術 哪些 共享 協議 關於Linux靜態庫和動態庫的分析 關於Linux靜態庫和動態庫的分析 1.什麽是庫 在windows平臺和linux平臺下都大量存在著庫。 本質上來說庫是一種可運行代碼的二進制形式。能夠被操作系

靜態庫和動態庫的使用

window != 函數調用 img clas 處理 dllexport void 再看 1.靜態庫使用比較簡單，就兩步 @1包含靜態庫頭文件#include "文件名" @2預處理加載靜態庫 #pragma comment(lib,"庫文件名") 2.再看動態庫 @1首先

靜態庫與動態庫的簡單說明

外部程序 endif ldconfig 開始 director 有時 鏈接 現在 con 　　一.靜態庫和動態庫的簡單介紹 　　程序設計的模塊化是人們一直在追求的目標，因為當一個系統十分復雜的時候，將系統模塊化既可以並行開發，又可以增強程序的可用性，降低程序間的耦合度。在一

Windows靜態庫和動態庫的創建和使用（VS2005）

spec 占用內存 庫文件 工程 存在 中間 開發程序 文件的 系統 偶們在實際的編程開發中，經常會遇到運行時無法找到某個DLL文件或者鏈接時無法找到某個LIB文件。然後，我們就開始亂GOOGLE一下，然後將VS2005的設置改變一下，或許就Ok了，我們將別人開發的DLL或

linux下的靜態庫和動態庫

列表 可執行文件 運行時 打包 文件的 ade 命令 div library 一、linux下的靜態庫 靜態庫中的被調用的函數的代碼會在編譯時一起被復制到可執行文件中去的！！可執行文件在運行不需要靜態庫的存在！ 二、linux下動態庫的構建和使用 1、動態庫的構建

深入探討Linux靜態庫與動態庫的詳解（轉）

share 分享 命名 one .com 過程 程序 簡單介紹 mage 2.生成動態庫並使用 linux下編譯時通過 -shared 參數可以生成動態庫（.so）文件，如下 庫從本質上來說是一種可執行代碼的二進制格式，可以被載入內存中執行。庫分靜態庫和動態庫兩種。

linux+vs2013編譯靜態庫和動態庫

cal 控制 文件 urn 運行時 names c++ spec using Linux下創建與使用靜態庫 Linux靜態庫命名規則 Linux靜態庫命名規範，必須是"lib[your_library_name].a"：lib為前綴，中間是靜態庫名，擴展名為.a。 創建靜態

linux 靜態庫和動態庫(共享庫)的制作與使用（註意覆蓋問題）

png 環境變量 src bfile idt 鏈接器 問題 靜態 插入 一、linux操作系統支持的函數庫分支 　　靜態庫：libxxx.a，在編譯時就將庫編譯進可執行程序 　　　　優點：程序的運行環境中不需要外部的函數庫 　　　　缺點：可執行程序大 　　動態庫：又

靜態庫和動態庫的兩種不同的Makefile寫法

不同 .so code lib pic 動態庫 sha stat 靜態 動態庫 PROG=add BIN=$(PROG).bin SOADD= lib$(PROG).so SHAREDOBJS= $(PROG).o OBJS= main.o CC=gcc $(PROG)

靜態庫和動態庫編程技術

c++ 動態庫 靜態庫 (1)庫一、什麽是庫 庫從本質上來說是一種代碼重用的方式,即預先編譯可執行代碼的二進制格式,可以被載入內存中,執行,比如C運行庫,裏面實現了基本的函數,我們無需在寫一遍,直接調用接口即可.庫分為靜態庫和動態庫兩種,二、靜態庫和動態庫區別1.靜態函數庫這類庫名字一般是x

Linux下靜態庫與動態庫

Linux 靜態庫 動態庫 靜態庫 先說說我們為什麽需要庫？當有些代碼我們大量會在程序中使用比如（scanf，printf等）這些函數我們需要在程序中頻繁使用，於是我們就把這些代碼編譯為庫文件，在需要使用時我們直接鏈接即可。 定義： ?程序在編譯時把靜態庫的代碼鏈接到可執行程序中，在代碼運行時不再

Windows系統下靜態庫和動態庫的使用方法

系統 comment 入庫 自己 動態庫 lib windows系統 window ont 使用靜態庫時，我們需要別人提供的頭文件和lib文件，然後在自己的工程的源文件（.cpp文件）中添加頭文件和#pragma comment(lib, "靜態庫的路徑") 使用動態庫時

Windows系統下靜態庫和動態庫的生成方法

fine end def imp XP fin windows 靜態 style 靜態庫的生成方法：直接創建靜態庫項目，寫好功能後，編譯生成即可，把頭文件和靜態庫提供給別人即可使用 動態庫的生成方法：創建動態庫項目，在頭文件中寫入： #ifdef DLLEXPORT #de

靜態庫和動態庫的區別和win平臺和linux平臺代碼實現

linux動態庫 聲明 CP 控制臺程序 後綴 差異 創建 SM mes 什麽是庫 　　庫是寫好的，現有的，成熟的，可以復用的代碼。現實中每個程序都要依賴很多基礎的底層庫，不可能每個人的代碼都從零開始，因此庫的存在意義非同尋常。 　　本質上來說，庫是一種可