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

Gratis C++ PDF-bibliotheek voor het lezen en schrijven van PDF-bestanden

Een eenvoudige open-source, op C gebaseerde PDF-bibliotheek die het lezen, schrijven en manipuleren van PDF-documenten mogelijk maakt. Het ondersteunt afbeelding-naar-PDF conversie, het extraheren van inhoud, stream-gebaseerd PDF-lezen en meer, binnen C-applicaties.

Wat is de PDFio-bibliotheek?

PDFio is een lichte, open-source C-bibliotheek die specifiek is ontworpen voor het lezen en schrijven van PDF‑bestanden zonder de complexiteit van renderen of bekijken. Gecreëerd door Michael R Sweet en gelicentieerd onder de Apache License Versie 2.0, biedt deze bibliotheek ontwikkelaars een eenvoudige aanpak voor PDF-manipulatie die zich richt op het creëren, extraheren en transformeren van inhoud in plaats van visuele presentatie. De bibliotheek is zeer gemakkelijk te gebruiken en biedt verschillende mogelijkheden voor het manipuleren van PDF‑bestanden, zoals het extraheren en samenvoegen van PDF‑pagina's, geautomatiseerde rapporten uit databases, watermerken en stempelen, het maken van certificaten en diploma's, het insluiten van lettertypen voor archivering, het wijzigen van metadata en nog veel meer.

PDFio richt zich op de essentiële I/O‑bewerkingen, waardoor het perfect is voor toepassingen die gegevens uit PDF's moeten extraheren of nieuwe moeten maken zonder de overhead van complexere bibliotheken. De bibliotheek ondersteunt krachtige conversiefuncties en stelt softwareontwikkelaars in staat om markdown naar PDF, afbeelding naar PDF, HTML naar PDF te converteren, evenals barcode‑generatie in PDF's binnen C‑toepassingen. De focus op kernfunctionaliteit zonder de overhead van rendering maakt het ideaal voor server‑side applicaties, command‑line tools en embedded systemen waar PDF‑creatie of -verwerking nodig is zonder visuele weergave. Of je nu documentbeheersystemen bouwt, geautomatiseerde rapportgeneratoren maakt, of tools ontwikkelt voor PDF‑analyse, PDFio biedt de essentiële functionaliteit die nodig is voor professionele PDF‑verwerking in C‑applicaties.

Previous Next

Aan de slag met PDFio

De aanbevolen manier om PDFio te installeren is via NuGet. Gebruik alstublieft de volgende opdracht voor een soepele installatie.

Installeer PDFio via NuGet

Install-Package pdfio_native

Installeer PDFio via GitHub

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

U kunt het ook handmatig installeren; download de nieuwste release‑bestanden rechtstreeks van GitHub repository.

Een PDF vanaf nul maken via C

De open source PDFio-bibliotheek biedt volledige ondersteuning voor het maken van nieuwe PDF-documenten vanaf nul binnen C-toepassingen. Het creëren van een nieuw PDF-document is even eenvoudig en met slechts een paar regels C-code kunnen softwareontwikkelaars nieuwe pagina's toevoegen, tekst en eenvoudige vormen tekenen, afbeeldingen (JPEG-, PNG-formaten) toevoegen, kleuren en transformaties toepassen, tabellen en gestructureerde lay-outs bouwen en nog veel meer. Hier is een eenvoudig voorbeeld dat laat zien hoe je een nieuw PDF-document maakt met een aangepaste paginagrootte en inhoud met behulp van C-code.

Hoe maak je een eenvoudig PDF-document met aangepaste paginagrootte en inhoud via een C-bibliotheek?

#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;
}

Afbeelding naar PDF-conversie via C-bibliotheek

Het converteren van afbeeldingen naar PDF-formaat is een van de meest voorkomende documentverwerkingstaken. De PDFio-bibliotheek maakt dit eenvoudig, terwijl het fijne controle biedt over paginagrootte, afbeeldingsplaatsing, schaling en metadata. Softwareontwikkelaars kunnen een volledige afbeelding-naar-PDF-converter bouwen die zowel enkele afbeeldingen als batchconversies aankan. Het volgende voorbeeld laat zien hoe ontwikkelaars één afbeelding naar een PDF kunnen converteren binnen C-applicaties.

Hoe converteer je een enkele afbeelding naar een PDF via een C-bibliotheek?

#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;
}

PDF lezen & tekst extraheren via C-bibliotheek

Een van de meest voorkomende taken is het lezen en extraheren van tekst uit een PDF‑bestand. De open‑source PDFio‑bibliotheek maakt dit proces intuïtief door ontwikkelaars toe te staan door pagina's en hun content‑streams te itereren. De bibliotheek biedt volledige ondersteuning voor het extraheren van nuttige informatie uit bestaande PDF's, zoals eenvoudige tekst, metadata, ingebedde lettertypen, cijfers, afbeeldingen, druiven, namen en meer. Het volgende voorbeeld laat zien hoe je een bestaand PDF‑bestand opent en basisinformatie eruit haalt met behulp van de C‑bibliotheek.

Hoe haal je eenvoudige tekst uit een PDF-bestand via een C-bibliotheek?

#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;
}

Efficiënt, streamgebaseerd lezen

PDFio is ontworpen voor efficiëntie. Bij het lezen laadt het niet het volledige bestand in één keer in het geheugen. In plaats daarvan gebruikt het een pull‑parsing‑benadering, waardoor je het bestand in delen kunt verwerken. Dit is cruciaal voor het omgaan met zeer grote PDF's zonder het systeemgeheugen uit te putten. De functie pdfioPageParseContents uit het eerste voorbeeld is een uitstekend voorbeeld van dit op streams gebaseerde model. Het leest de content‑stream van de pagina sequentieel en zendt gebeurtenissen (zoals onze tekst‑callback) uit terwijl het voortgaat.

 Dutch