1. Produkter
  2.   PDF
  3.   C++
  4.   PDFio
 
  

Gratis C++ PDF-bibliotek för läsning och skrivning av PDF-filer

Ett enkelt öppet källkod C-baserat PDF-bibliotek som möjliggör att läsa, skriva och manipulera PDF-dokument. Det stöder konvertering av bild till PDF, extrahering av innehåll, ström-baserad PDF-läsning och mer, i C-appar.

Vad är PDFio-biblioteket?

PDFio är ett lättviktigt, öppen källkod C-bibliotek som är speciellt utformat för att läsa och skriva PDF-filer utan komplexiteten i rendering eller visning. Skapat av Michael R Sweet och licensierat under Apache License Version 2.0, ger detta bibliotek utvecklare ett enkelt tillvägagångssätt för PDF-manipulation som fokuserar på innehållsskapande, extraktion och transformation snarare än visuell presentation. Biblioteket är mycket enkelt att hantera och erbjuder flera sätt att manipulera PDF-filer, såsom extrahering och sammanslagning av PDF-sidor, automatiserade rapporter från databaser, vattenstämpling och stämpling, skapande av certifikat och diplom, inbäddning av teckensnitt för arkivering, modifiering av metadata och mycket mer.

PDFio fokuserar på de grundläggande I/O‑operationerna, vilket gör det perfekt för applikationer som behöver extrahera data från PDF‑filer eller skapa nya utan den extra bördan från mer komplexa bibliotek. Biblioteket stöder kraftfulla konverteringsfunktioner och möjliggör för mjukvaruutvecklare att konvertera markdown till PDF, bild till PDF, HTML till PDF samt generera streckkoder i PDF‑filer i C‑applikationer. Dess fokus på kärnfunktionalitet utan renderingens overhead gör det idealiskt för server‑side‑applikationer, kommandoradsverktyg och inbäddade system där PDF‑skapande eller -behandling behövs utan visuell display. Oavsett om du bygger dokumenthanteringssystem, skapar automatiska rapportgeneratorer eller utvecklar verktyg för PDF‑analys, erbjuder PDFio den nödvändiga funktionaliteten för professionell PDF‑hantering i C‑applikationer.

Previous Next

Komma igång med PDFio

Det rekommenderade sättet att installera PDFio är att använda NuGet. Använd följande kommando för en smidig installation.

Installera PDFio via NuGet

Install-Package pdfio_native

Installera PDFio via GitHub

 git clone  https://github.com/michaelrsweet/pdfio.git

Du kan också installera det manuellt; ladda ner de senaste versionsfilerna direkt från GitHub-repositoriet.

Skapa en PDF från grunden via C

Det öppna PDFio-biblioteket har inkluderat fullständigt stöd för att skapa nya PDF-dokument från grunden i C-applikationer. Att skapa ett nytt PDF-dokument är lika enkelt och med bara ett par rader C-kod kan mjukvaruutvecklare lägga till nya sidor, rita text och enkla former, lägga till bilder (JPEG-, PNG-format), applicera färger och transformationer, bygga tabeller och strukturerade layouter och mycket mer. Här är ett enkelt exempel som visar hur man skapar ett nytt PDF-dokument med anpassad sidstorlek och innehåll med C-kod.

Hur man skapar ett enkelt PDF-dokument med anpassad sidstorlek och innehåll via C-biblioteket?

#include 
#include 

int main(void) {
    pdfio_file_t *pdf;
    pdfio_dict_t *dict;
    pdfio_stream_t *page;
    pdfio_obj_t *font;
    pdfio_rect_t media_box = {0.0, 0.0, 612.0, 792.0};  // US Letter
    pdfio_rect_t crop_box = {36.0, 36.0, 576.0, 756.0}; // 0.5\" margins
    
    // Create PDF file
    pdf = pdfioFileCreate("output.pdf", "2.0", 
                          &media_box, &crop_box,
                          NULL, NULL);
    
    if (!pdf) {
        fprintf(stderr, "Unable to create PDF\n");
        return 1;
    }
    
    // Create a font object (Helvetica)
    font = pdfioFileCreateFontObjFromBase(pdf, "Helvetica");
    
    // Create page dictionary
    dict = pdfioDictCreate(pdf);
    pdfioPageDictAddFont(dict, "F1", font);
    
    // Create the page
    page = pdfioFileCreatePage(pdf, dict);
    
    // Draw text
    pdfioContentSetFillColorDeviceGray(page, 0.0);  // Black color
    pdfioContentTextBegin(page);
    pdfioContentSetTextFont(page, "F1", 24.0);
    pdfioContentTextMoveTo(page, 100.0, 700.0);
    pdfioContentTextShow(page, false, "Hello, PDFio!");
    pdfioContentTextEnd(page);
    
    // Close page and file
    pdfioStreamClose(page);
    pdfioFileClose(pdf);
    
    printf("PDF created successfully!\n");
    return 0;
}

Bild till PDF-konvertering via C-biblioteket

Att konvertera bilder till PDF-format är en av de vanligaste dokumentbehandlingsuppgifterna. PDFio-biblioteket gör detta enkelt samtidigt som det ger fin kontroll över sidstorlek, bildplacering, skalning och metadata. Mjukvaruutvecklare kan bygga en komplett bild-till-PDF-omvandlare som hanterar både enskilda bilder och batchkonverteringar. Följande exempel visar hur utvecklare kan konvertera en bild till en PDF i C-appar.

Hur konverterar man en enda bild till en PDF via C-bibliotek?

#include 
#include 
#include 

bool create_pdf_from_image(const char *image_path, 
                           const char *pdf_path,
                           const char *title) {
    pdfio_file_t *pdf;
    pdfio_obj_t *image;
    pdfio_dict_t *page_dict;
    pdfio_stream_t *page_stream;
    pdfio_rect_t media_box;
    double img_width, img_height;
    double page_width, page_height;
    double scale_x, scale_y, scale;
    double x, y;
    
    // Create the image object first to get dimensions
    // We'll use a temporary PDF for this
    pdfio_rect_t temp_box = {0, 0, 612, 792};
    pdf = pdfioFileCreate(pdf_path, "2.0", &temp_box, NULL, NULL, NULL);
    
    if (!pdf) {
        fprintf(stderr, "Error: Cannot create PDF file\n");
        return false;
    }
    
    // Set PDF metadata
    if (title) {
        pdfioFileSetTitle(pdf, title);
    }
    pdfioFileSetAuthor(pdf, "PDFio Image Converter");
    pdfioFileSetCreator(pdf, "image2pdf v1.0");
    
    // Load and embed the image
    image = pdfioFileCreateImageObjFromFile(pdf, image_path, true);
    
    if (!image) {
        fprintf(stderr, "Error: Cannot load image file: %s\n", image_path);
        pdfioFileClose(pdf);
        return false;
    }
    
    // Get image dimensions in pixels
    img_width = pdfioImageGetWidth(image);
    img_height = pdfioImageGetHeight(image);
    
    printf("Image dimensions: %.0f x %.0f pixels\n", img_width, img_height);
    
    // Create page sized to image (assuming 72 DPI)
    // This creates a PDF page that exactly fits the image
    page_width = img_width;
    page_height = img_height;
    
    media_box.x1 = 0.0;
    media_box.y1 = 0.0;
    media_box.x2 = page_width;
    media_box.y2 = page_height;
    
    // Create page dictionary and add image resource
    page_dict = pdfioDictCreate(pdf);
    pdfioDictSetRect(page_dict, "MediaBox", &media_box);
    pdfioPageDictAddImage(page_dict, "IM1", image);
    
    // Create the page
    page_stream = pdfioFileCreatePage(pdf, page_dict);
    
    // Draw image at full size (no scaling)
    pdfioContentDrawImage(page_stream, "IM1", 0, 0, 
                         page_width, page_height);
    
    // Close and save
    pdfioStreamClose(page_stream);
    pdfioFileClose(pdf);
    
    printf("Successfully created PDF: %s\n", pdf_path);
    return true;
}

int main(int argc, char *argv[]) {
    if (argc < 3) {
        fprintf(stderr, "Usage: %s   [title]\n", 
                argv[0]);
        return 1;
    }
    
    const char *title = (argc > 3) ? argv[3] : NULL;
    
    if (!create_pdf_from_image(argv[1], argv[2], title)) {
        return 1;
    }
    
    return 0;
}

Läs PDF och extrahera text via C-bibliotek

En av de vanligaste uppgifterna är att läsa och extrahera text från en PDF-fil. Det öppna källkodsbiblioteket PDFio gör denna process intuitiv genom att låta utvecklare iterera genom sidor och deras innehållsströmmar. Biblioteket erbjuder fullt stöd för att extrahera användbar information från befintliga PDF-filer, såsom enkel text, metadata, inbäddade typsnitt, siffror, bilder, druvor, namn och mer. Följande exempel visar hur man öppnar en befintlig PDF och extraherar grundläggande information från den med C-biblioteket.

Hur extraherar man enkel text från en PDF-fil via C-bibliotek?

#include 
#include 
#include 

// Callback function to handle text objects
static bool text_cb(const pdfio_text_t *text, void *data) {
    // Simply print the text to stdout
    printf("%s", text->utf8);
    return true;
}

int main(void) {
    pdfio_file_t *pdf;
    pdfio_page_t *page;

    // Open the PDF file for reading
    pdf = pdfioFileOpen("example.pdf", NULL, NULL, NULL);
    if (!pdf) {
        fprintf(stderr, "Failed to open example.pdf\n");
        return 1;
    }

    printf("PDF has %d pages.\n", pdfioFileGetNumPages(pdf));

    // Read the first page (pages are 1-indexed)
    page = pdfioFileGetPage(pdf, 1);
    if (!page) {
        fprintf(stderr, "Failed to read page 1\n");
        pdfioFileClose(pdf);
        return 1;
    }

    // Parse the page content and call our text_cb for each text object
    if (!pdfioPageParseContents(page, text_cb, NULL, NULL, NULL)) {
        fprintf(stderr, "Failed to parse page contents\n");
    }

    // Clean up
    pdfioFileClose(pdf);
    return 0;
}

Effektiv, ström-baserad läsning

PDFio är utformat för effektivitet. Vid läsning laddar det inte in hela filen i minnet på en gång. Istället använder det en pull‑parsningsmetod, vilket låter dig bearbeta filen i bitar. Detta är avgörande för att hantera mycket stora PDF-filer utan att tömma systemminnet. Funktionen pdfioPageParseContents från det första exemplet är ett utmärkt exempel på denna strömbaserade modell. Den läser sidans innehållsström sekventiellt och avger händelser (som vår text‑callback) medan den går.

 Svenska