Einleitung

Aspose.PDF FOSS für C++ ist eine Open-Source C++20-Bibliothek zur Arbeit mit PDF-Dokumenten. Die API-Oberfläche umfasst Dokument- und Seitenverwaltung, Textextraktion, Rasterrendering, Verschlüsselung, Anmerkungen und interaktive AcroForm-Felder – die Vorgänge, die am häufigsten benötigt werden, wenn eine C++-Anwendung PDF-Dateien erstellen, inspizieren oder transformieren muss, ohne von einer externen PDF-Engine oder einem kommerziellen SDK abhängig zu sein.

Die Bibliothek bindet nur an die C++-Standardbibliothek. Interne Komponenten wie die BMP-, JPEG- und TIFF-Raster-Encoder und der Seiten-Rasterisierer werden von Grund auf im Projekt implementiert, sodass keine Abhängigkeit von einem systemeigenen PDF-Renderer, einer kommerziellen PDF-Komponente oder einem Drittanbieter-Bildcodec besteht. Das hält den Abhängigkeits-Footprint bei null, abgesehen von einem C++20-konformen Compiler und der Standardbibliothek.

Aspose.PDF FOSS für C++ wird unter der MIT-Lizenz veröffentlicht. Dieser Beitrag führt durch die wichtigsten Funktionsbereiche, die von der Document-Klasse und ihren unterstützenden Typen bereitgestellt werden, gefolgt von einem Schnellstart-Beispiel und der derzeit bestätigten Formatunterstützung.

Hauptfunktionen

Dokumenten- und Seitenverwaltung

Die Document-Klasse ist der Einstiegspunkt zum Öffnen, Inspizieren und Speichern von PDF-Dateien. Auf Seiten wird über Document.Pages() zugegriffen, das ein PageCollection zurückgibt, das Count(), Add(), Insert(pageNumber) und Delete(pageNumber) unterstützt. Metadaten auf Dokumentebene werden über Document.Info() (eine DocumentInfo-Instanz) gelesen und aktualisiert oder direkt mit Document.SetTitle() gesetzt.

#include <aspose/pdf/document.hpp>
#include <aspose/pdf/page_collection.hpp>
#include <iostream>

int main() {
    Aspose::Pdf::Document doc("input.pdf");
    std::cout << "Page count: " << doc.Pages().Count() << "\n";

    // Insert a blank page after page 1, then drop the last page
    doc.Pages().Insert(2);
    doc.Pages().Delete(doc.Pages().Count());

    doc.SetTitle("Generated Report");
    doc.Save("output.pdf");
}

Document.Optimize() und Document.OptimizeResources() reduzieren die Ausgabedateigröße, indem sie ungenutzte Ressourcen konsolidieren und entfernen, bevor sie gespeichert werden.

Textextraktion

Aspose::Pdf::Text::TextAbsorber extrahiert den Klartextinhalt eines gesamten Dokuments oder einer einzelnen Seite. Visit() durchläuft das Ziel und Text() gibt die akkumulierte Zeichenkette zurück. TextFragmentAbsorber arbeitet auf einer feineren Granularität und stellt einzelne Textabschnitte über ein TextFragmentCollection bereit.

#include <aspose/pdf/document.hpp>
#include <aspose/pdf/text_absorber.hpp>
#include <aspose/pdf/text_fragment_absorber.hpp>
#include <iostream>

int main() {
    Aspose::Pdf::Document doc("input.pdf");

    // Extract all text from the document
    Aspose::Pdf::Text::TextAbsorber absorber;
    absorber.Visit(doc);
    std::cout << absorber.Text() << "\n";

    // Extract text fragments from page 1
    Aspose::Pdf::Text::TextFragmentAbsorber fragmentAbsorber;
    fragmentAbsorber.Visit(doc.Pages()[1]);
    auto fragments = fragmentAbsorber.TextFragments();
    std::cout << "Fragments on page 1: " << fragments.Count() << "\n";
}

Rendern zu Rasterbildern

Seiten werden in Rasterformate über geräteabhängige Klassen pro Format gerendert — PngDevice, JpegDevice, BmpDevice und TiffDevice — die jeweils Process(page, output) implementieren. Die Ausgaberesolution wird mit der Klasse Resolution gesteuert.

#include <aspose/pdf/document.hpp>
#include <aspose/pdf/png_device.hpp>
#include <aspose/pdf/bmp_device.hpp>
#include <aspose/pdf/resolution.hpp>
#include <fstream>

int main() {
    Aspose::Pdf::Document doc("input.pdf");
    auto page = doc.Pages()[1];

    Aspose::Pdf::Devices::PngDevice png(Aspose::Pdf::Devices::Resolution(150));
    std::ofstream pngOut("page1.png", std::ios::binary);
    png.Process(page, pngOut);

    Aspose::Pdf::Devices::BmpDevice bmp(Aspose::Pdf::Devices::Resolution(150));
    std::ofstream bmpOut("page1.bmp", std::ios::binary);
    bmp.Process(page, bmpOut);
}

JpegDevice folgt dem gleichen Process(page, output)-Muster für JPEG-Ausgabe. TiffDevice unterstützt zusätzlich die Mehrseitenausgabe in einem einzigen Aufruf über Process(document, fromPage, toPage, output) und stellt RenderingOptions() zur Verfügung, um zu steuern, wie Formularfelder in die Rasterausgabe gerendert werden.

Verschlüsselung und Zugriffsberechtigungen

Document.Encrypt() schützt ein Dokument mit einem Benutzer- und Eigentümerpasswort und wählt den Verschlüsselungsalgorithmus über das CryptoAlgorithm-Enum aus: RC4x40, RC4x128, AESx128 oder AESx256. Gewährte Berechtigungen werden mit dem Typ Permissions beschrieben, dessen Flag-Werte PrintDocument, ModifyContent, ExtractContent, ModifyTextAnnotations, FillForm, ExtractContentWithDisabilities, AssembleDocument und PrintingQuality umfassen.

#include <aspose/pdf/document.hpp>

int main() {
    Aspose::Pdf::Document doc("input.pdf");

    doc.Encrypt("user-password", "owner-password",
                Aspose::Pdf::Permissions(),
                Aspose::Pdf::CryptoAlgorithm::AESx256);

    doc.Save("encrypted.pdf");
}

Ein bereits geöffnetes verschlüsseltes Dokument wird mit Document.Decrypt() vor Ort entschlüsselt. Document.IsEncrypted() berichtet, ob ein geladenes Dokument derzeit ein Verschlüsselungs-Dictionary enthält.

Anmerkungen

Seitenbezogene Annotationen — Textnotizen, Formen und Markup — werden über Page.Anmerkungen() erreicht, das ein AnnotationCollection zurückgibt. Einzelne Einträge stellen gemeinsame Eigenschaften wie Contents(), Rect(), Color(), Border() und AnnotationType() bereit und können von der Seite entfernt oder in statischen Inhalt flachgelegt werden.

#include <aspose/pdf/document.hpp>
#include <iostream>

int main() {
    Aspose::Pdf::Document doc("input.pdf");
    auto& annotations = doc.Pages()[1].Annotations();

    std::cout << "Annotation count: " << annotations.Count() << "\n";
    for (int i = 0; i < static_cast<int>(annotations.Count()); ++i) {
        std::cout << "Contents: " << annotations[i].Contents() << "\n";
    }

    // Remove the first annotation on the page
    if (annotations.Count() > 0) {
        annotations.Delete(annotations[0]);
    }

    doc.Save("output.pdf");
}

Jedes einzelne Annotation kann ebenfalls direkt mit seiner eigenen Flatten()-Methode in statischen Seiteninhalt umgewandelt werden, unabhängig vom unten beschriebenen Formular-Flatten-Workflow.

Interaktive Formulare

AcroForm-Felder in einem Dokument werden über Document.Form() verwaltet, das eine Form-Instanz zurückgibt, die Count(), HasField(fieldName), Delete(fieldName) und Flatten() unterstützt. Neue Felder werden mit Form.Add(field, pageNumber) angehängt, wobei field ein konkreter Field-Untertyp wie TextBoxField, CheckboxField, ChoiceField oder ButtonField ist.

#include <aspose/pdf/document.hpp>
#include <iostream>

int main() {
    Aspose::Pdf::Document doc("input.pdf");
    auto& form = doc.Form();

    std::cout << "Form fields: " << form.Count() << "\n";

    if (form.HasField("Signature1")) {
        form.Delete("Signature1");
    }

    // Convert every remaining field into static page content
    form.Flatten();
    doc.Save("flattened.pdf");
}

Schnellstart

Fügen Sie die Bibliothek als CMake-Unterverzeichnis hinzu und linken Sie gegen das aspose_pdf_foss-Ziel:

add_subdirectory(aspose.pdf-foss-for-cpp)
target_link_libraries(your_app PRIVATE aspose_pdf_foss)

Öffnen Sie ein Dokument, extrahieren Sie dessen Text und rendern Sie die erste Seite als PNG:

#include <aspose/pdf/document.hpp>
#include <aspose/pdf/text_absorber.hpp>
#include <aspose/pdf/png_device.hpp>
#include <aspose/pdf/resolution.hpp>
#include <fstream>
#include <iostream>

int main() {
    Aspose::Pdf::Document doc("input.pdf");
    std::cout << "Pages: " << doc.Pages().Count() << "\n";

    Aspose::Pdf::Text::TextAbsorber absorber;
    absorber.Visit(doc);
    std::cout << absorber.Text() << "\n";

    Aspose::Pdf::Devices::PngDevice png(Aspose::Pdf::Devices::Resolution(150));
    std::ofstream out("page1.png", std::ios::binary);
    png.Process(doc.Pages()[1], out);
}

Unterstützte Formate

FormatErweiterungLesenSchreiben
BMPbmp—✓
JPEGjpeg—✓
TIFFtiff—✓
Texttxt—✓
SVGsvg✓—

Open Source & Lizenzierung

Aspose.PDF FOSS für C++ wird unter der MIT-Lizenz veröffentlicht, die kommerzielle Nutzung, Modifikation und Weiterverteilung ohne Lizenzgebühren erlaubt. Der Quellcode ist verfügbar unter github.com/aspose-pdf-foss/Aspose.PDF-FOSS-for-Cpp.

Kommerzielle Nutzung ist gemäß den Bedingungen der MIT-Lizenz erlaubt. Wenn Ihr Projekt Enterprise-Support, erweiterte Formatunterstützung oder Cloud-Integration benötigt, ist Aspose.PDF — Enterprise Product Family ein separates kommerzielles Angebot.

Erste Schritte

Verwandte Ressourcen