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

Gratis C++ PDF-bibliotek for lesing og skriving av PDF-filer

Et enkelt åpen kildekode C-basert PDF-bibliotek gjør det mulig å lese, skrive og manipulere PDF-dokumenter. Det støtter konvertering av bilde til PDF, uthenting av innhold, strøm-basert PDF-lesing og mer, i C‑applikasjoner.

Hva er PDFio-biblioteket?

PDFio er et lettvekt, åpen kildekode C-bibliotek designet spesielt for å lese og skrive PDF-filer uten kompleksiteten ved rendering eller visning. Opprettet av Michael R Sweet og lisensiert under Apache License versjon 2.0, gir dette biblioteket utviklere en enkel tilnærming til PDF-manipulering som fokuserer på innholdsopprettelse, -uttrekking og -transformasjon snarere enn visuell presentasjon. Biblioteket er svært enkelt å håndtere og tilbyr flere måter å manipulere PDF-filer på, som sideekstraksjon og sammenslåing av PDF, automatiserte rapporter fra databaser, vannmerking og stempling, opprettelse av sertifikater og diplomer, innbygging av skrifttyper for arkivering, endring av metadata og mye mer.

PDFio fokuserer på de essensielle I/O‑operasjonene, noe som gjør den perfekt for applikasjoner som trenger å hente data fra PDF‑filer eller lage nye uten overhead fra mer komplekse biblioteker. Biblioteket støtter kraftige konverteringsfunksjoner og gjør det mulig for programvareutviklere å konvertere markdown til PDF, bilde til PDF, HTML til PDF samt generere strekkoder i PDF‑er i C‑applikasjoner. Fokus på kjernefunksjonalitet uten renderings‑overhead gjør den ideell for server‑side‑applikasjoner, kommandolinjeverktøy og innebygde systemer hvor PDF‑oppretting eller -behandling er nødvendig uten visuell visning. Enten du bygger dokumenthåndteringssystemer, lager automatiserte rapportgeneratorer eller utvikler verktøy for PDF‑analyse, tilbyr PDFio den nødvendige funksjonaliteten for profesjonell PDF‑håndtering i C‑applikasjoner.

Previous Next

Kom i gang med PDFio

Den anbefalte måten å installere PDFio på er via NuGet. Vennligst bruk følgende kommando for en smidig installasjon.

Installer PDFio via NuGet

Install-Package pdfio_native

Installer PDFio via GitHub

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

Du kan også installere det manuelt; last ned de nyeste utgivelsesfilene direkte fra GitHub-depotet.

Opprette en PDF fra bunnen av via C

Det åpne kildekodebiblioteket PDFio har inkludert full støtte for å lage nye PDF-dokumenter fra bunnen av i C-applikasjoner. Å lage et nytt PDF-dokument er like enkelt, og med bare noen få linjer C-kode kan programvareutviklere legge til nye sider, tegne tekst og enkle former, legge til bilder (JPEG-, PNG-formater), bruke farger og transformasjoner, bygge tabeller og strukturerte oppsett og mye mer. Her er et enkelt eksempel som demonstrerer hvordan man lager et nytt PDF-dokument med tilpasset sidestørrelse og innhold ved hjelp av C-kode.

Hvordan lage et enkelt PDF-dokument med tilpasset sidestørrelse og innhold 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;
}

Bilde til PDF-konvertering via C-biblioteket

Å konvertere bilder til PDF-format er en av de mest vanlige dokumentbehandlingsoppgavene. PDFio-biblioteket gjør dette enkelt samtidig som det gir fin kontroll over sidestørrelse, bildeplassering, skalering og metadata. Programvareutviklere kan bygge en komplett bilde-til-PDF-konverter som håndterer både enkeltbilder og batch-konverteringer. Følgende eksempel demonstrerer hvordan utviklere kan konvertere ett bilde til en PDF i C‑applikasjoner.

Hvordan konvertere ett enkelt bilde til 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;
}

Les PDF og hent ut tekst via C-bibliotek

En av de mest vanlige oppgavene er å lese og hente ut tekst fra en PDF-fil. Det åpne kildekodebiblioteket PDFio gjør denne prosessen intuitiv ved å la utviklere iterere gjennom sider og deres innholdstrømmer. Biblioteket gir full støtte for å hente nyttig informasjon fra eksisterende PDF-er, som enkel tekst, metadata, innebygde skrifttyper, tall, bilder, druer, navn og mer. Følgende eksempel demonstrerer hvordan man åpner en eksisterende PDF og henter grunnleggende informasjon fra den ved hjelp av C-biblioteket.

Hvordan hente ut enkel tekst fra 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-basert lesing

PDFio er designet for effektivitet. Når den leser, laster den ikke hele filen inn i minnet på én gang. I stedet bruker den en pull‑parsing‑tilnærming, som lar deg behandle filen i biter. Dette er avgjørende for å håndtere svært store PDF-er uten å tømme systemminnet. pdfioPageParseContents‑funksjonen fra det første eksemplet er et godt eksempel på denne strøm‑baserte modellen. Den leser sidens innholdstrøm sekvensielt og sender ut hendelser (som vår tekst‑tilbakekalling) underveis.

 Norsk