---
title: "Web Scraping in C++: Ein Schritt-für-Schritt-Leitfaden"
slug: web-scraping-in-c-plus-plus
date: 2023-05-24T10:05:27+00:00
modified: 2025-11-04T08:56:29+00:00
permalink: https://brightdata.de/blog/wie/web-scraping-in-c-plus-plus
type: blog
---
[ Blog ](https://brightdata.de/blog "Blog") / [How Tos](https://brightdata.de/blog/wie)
[How Tos](https://brightdata.de/blog/wie)
# Web Scraping in C++: Ein Schritt-für-Schritt-Leitfaden
In dieser Schritt-für-Schritt-Leitfaden erfahren Sie, wie Sie mit C++ Websites scrapen können.
13 min lesen
[  ](https://brightdata.com/blog/authors/alen-kalac)
[Alen Kalac
](https://brightdata.com/blog/authors/alen-kalac)
TL; DR: In diesem Tutorial erfahren Sie, wie Sie in C++ Daten aus einer Website extrahieren können und warum C++ eine der effizientesten Sprachen für Scraping ist.
**Dieser Leitfaden behandelt Folgendes:**
- Ist C++ eine gute Sprache für Web Scraping?
- Beste C++-Web-Scraping-Bibliotheken
- Wie man einen Web Scraper in C++ erstellt
## Ist C ++ eine gute Sprache für Web Scraping?
[C++](https://en.wikipedia.org/wiki/C%2B%2B) ist eine statisch typisierte Programmiersprache, die häufig für die Entwicklung von Hochleistungsanwendungen verwendet wird. Der Grund dafür ist, dass sie für ihre Geschwindigkeit, Effizienz und Speicherverwaltungsfähigkeiten bekannt ist. C++ ist eine vielseitige Sprache, die sich in einer Vielzahl von Anwendungen, einschließlich Web Scraping, als nützlich erweist.
C++ ist eine kompilierte Sprache und von Natur aus schneller als interpretierte Sprachen wie Python. Das macht ihn zu einer ausgezeichneten Wahl für den Bau schneller Scraper. C++ ist jedoch nicht für die Webentwicklung konzipiert und es stehen nicht viele Bibliotheken für Web Scraping zur Verfügung. Es gibt zwar einige Pakete von Drittanbietern, aber die Optionen sind nicht so umfangreich wie in Python, Ruby oder Java.
Zusammenfassend lässt sich sagen, dass Web Scraping in C++ möglich und effizient ist, aber im Vergleich zu anderen Sprachen mehr Low-Level-Programmierung erfordert. Lassen Sie uns herausfinden, welche Tools diesen Prozess vereinfachen können!
## **Beste C++-Web-Scraping-Bibliotheken**
**Hier sind einige beliebte Web-Scraping-Bibliotheken für C++:**
- [CPR](https://github.com/libcpr/cpr): Eine moderne C++-HTTP-Client-Bibliothek, inspiriert vom [Python Requests](https://github.com/kennethreitz/requests)-Projekt. Es ist ein Wrapper von [libcurl](http://curl.haxx.se/libcurl), der eine leicht verständliche Oberfläche, eingebaute Authentifizierungsfunktionen und Unterstützung für asynchrone Aufrufe bietet.
- [libxml2](https://gitlab.gnome.org/GNOME/libxml2/-/wikis/home): Eine leistungsstarke Bibliothek mit vollem Funktionsumfang zum Parsen von XML- und HTML-Dokumenten, die ursprünglich für Gnome entwickelt wurde. Es unterstützt die DOM-Manipulation über XPath-Selektoren.
- [Lexbor](https://github.com/lexbor/lexbor): Eine schnelle und leichte HTML-Parsing-Bibliothek, die vollständig in C geschrieben wurde und CSS-Selektoren unterstützt. Es ist nur für Linux verfügbar.
Jahrelang war [Gumbo](https://github.com/google/gumbo-parser) der am häufigsten verwendete HTML-Parser für C++. Dieser wird seit 2016 nicht mehr gepflegt und sogar die [offizielle README](https://github.com/google/gumbo-parser#gumbo---a-pure-c-html5-parser) rät inzwischen von seiner Verwendung ab.
## Voraussetzungen
**Bevor Sie mit dem Programmieren beginnen, müssen Sie:**
1. Einen C++-Compiler haben
2. Den `vcpkg` C++-Paketmanager einrichten
3. [CMake installieren](https://cmake.org/)
Folgen Sie dem nachstehenden Leitfaden für Ihr Betriebssystem und erfahren Sie, wie Sie diese Voraussetzungen erfüllen.
## C++ auf macOS einrichten
Unter macOS ist der beliebteste C-, C++- und Objective-C-Compiler [Clang](https://clang.llvm.org/). Denken Sie daran, dass auf vielen Macs Clang vorinstalliert ist. Um dies zu überprüfen, öffnen Sie ein Terminal und starten Sie den folgenden Befehl:
```none
clang --version
```
Wenn Sie den Fehler `command not found: clang` erhalten, bedeutet das, dass Clang nicht installiert oder richtig konfiguriert ist. In diesem Fall können Sie es über die Xcode-Befehlszeilentools installieren:
```none
xcode-select --install
```
Das kann eine Weile in Anspruch nehmen. Seien Sie also geduldig.
Um `vcpkg` einzurichten, benötigen Sie zuerst die macOS-Entwicklertools. Fügen Sie diese Ihrem Mac hinzu mit:
```none
xcode-select --install
```
Dann müssen Sie `vcpkg` global installieren. Erstellen Sie einen `/dev`-Ordner, geben Sie ihn in das Terminal ein und führen Sie ihn aus:
```none
git clone https://github.com/microsoft/vcpkg
```
Das Verzeichnis wird jetzt den Quellcode enthalten. Erstellen Sie den Paketmanager mit:
```none
./vcpkg/bootstrap-vcpkg.sh
```
Um diesen Befehl auszuführen, benötigen Sie möglicherweise erweiterte Rechte.
Fügen Sie schließlich `/dev/vcpkg` zu Ihrem `$PATH` hinzu und folgen Sie [diesem Leitfaden](https://techpp.com/2021/09/08/set-path-variable-in-macos-guide/).
Um CMake zu installieren, laden Sie das[ Installationsprogramm von der offiziellen Website](https://cmake.org/download/) herunter, starten Sie es und folgen Sie dem Installationsassistenten.
## C++ unter Windows einrichten
Laden Sie das Installationsprogramm [MinGW-x64](https://www.mingw-w64.org/) von [MSYS2](https://www.msys2.org/) herunter, starten Sie es und folgen Sie den Anweisungen. Dieses Paket enthält aktuelle native Builds von GCC, MinGW-W64 und anderen hilfreichen C++-Tools und -Bibliotheken.
Führen Sie im MSYS2-Terminal, das am Ende des Installationsprozesses geöffnet wird, den folgenden Befehl aus, um die Mingw-w64-Toolchain zu installieren:
```none
pacman -S --needed base-devel mingw-w64-x86_64-toolchain
```
Warten Sie, bis der Vorgang beendet ist, und fügen Sie dann MinGW zur `PATH`-Umgebung hinzu, wie [hier](https://code.visualstudio.com/docs/languages/cpp#_add-the-mingw-compiler-to-your-path) erklärt.
Als Nächstes müssen Sie `vcpkg` global installieren. Erstellen Sie einen `C:/dev`-Ordner, öffnen Sie ihn in PowerShell und führen Sie ihn aus:
```none
git clone https://github.com/microsoft/vcpkg
```
Erstellen Sie den Quellcode des Paketmanagers, der sich im Unterordner `vcpkg` befindet, mit:
```none
./vcpkg/bootstrap-vcpkg.bat
```
Fügen Sie nun wie zuvor `C:/dev/vcpkg` zu Ihrem `PATH` hinzu.
Jetzt müssen Sie nur noch CMake installieren. Laden Sie das [Installationsprogramm](https://cmake.org/download/) herunter, klicken Sie doppelt darauf und achten Sie darauf, während der Installation die unten stehende Option zu überprüfen.
C++ auf Linux einrichten
Installieren Sie auf Debian-basierten Distributionen [GCC ](https://gcc.gnu.org/)(GNU Compiler Collection), CMake und andere nützliche Pakete für die Entwicklung mit:
```none
sudo apt install build-essential cmake
```
Das kann einige Zeit in Anspruch nehmen. Seien Sie also geduldig.
Als Nächstes müssen Sie `vcpkg`global installieren. Erstellen Sie ein `/dev`-Verzeichnis, öffnen Sie es im Terminal und geben Sie ein:
```none
git clone https://github.com/microsoft/vcpkg
```
Das `vcpkg`-Unterverzeichnis wird jetzt den Quellcode des Paketmanagers enthalten. Erstellen Sie das Tool mit:
```none
./vcpkg/bootstrap-vcpkg.sh
```
Beachten Sie, dass für diesen Befehl möglicherweise Administratorrechte erforderlich sind.
Fügen Sie dann `/dev/vcpkg` zu Ihren `$PATH`-Umgebungsvariablen hinzu, indem Sie [diesem ](https://phoenixnap.com/kb/linux-add-to-path)Leitfaden folgen.
Perfekt! Sie haben jetzt alles, was Sie brauchen, um mit C++ Web Scraping zu beginnen!
## **So erstellen Sie einen Web Scraper in C++**
In diesem Kapitel erfahren Sie, wie man einen C++-Web-Spider programmiert. Die Zielseite wird die [Startseite von Bright Data](/) sein und das Skript kümmert sich um:
- Verbindungsherstellung zur Webseite
- Auswahl der gewünschten HTML-Elemente aus dem DOM
- Abrufen von Daten von diesen
- Exportieren der gescrapten Daten nach CSV
Im Moment sehen Besucher Folgendes, wenn sie die Zielseite erkunden:
Denken Sie daran, dass sich die Startseite von BrightData häufig ändert. Sie könnte sich also geändert haben, während Sie diesen Artikel lesen.
Einige interessante Daten, die Sie aus der Seite extrahieren können, sind die Brancheninformationen, die in diesen Karten enthalten sind:
Das Scraping-Ziel für dieses Schritt-für-Schritt-Tutorial wurde definiert. Mal sehen, wie man Web Scraping mit C ++ macht!
## Schritt 1: Initialisieren Sie ein C++-Scraping-Projekt.
Zuerst benötigen Sie einen Ordner, in dem Sie Ihr C++-Projekt platzieren können. Öffnen Sie das Terminal und erstellen Sie das Projektverzeichnis mit:
```none
mkdir c++-web-scraper
```
Dies wird Ihr Scraping-Skript enthalten.
Wenn Sie Software in C++ erstellen, sollten Sie sich für eine Visual Studio IDE entscheiden. Im Detail werden Sie sehen, wie Sie [Visual Studio Code](https://code.visualstudio.com/) (VS Code) für die C++-Entwicklung mit `vcpkg` als Paketmanager einrichten. Beachten Sie, dass ähnliche Verfahren auf andere C++-IDEs angewendet werden können.
VS Code bietet keine integrierte Unterstützung für C++, daher müssen Sie zuerst das [C/C++](https://code.visualstudio.com/docs/languages/cpp)-Plugin hinzufügen. Starten Sie Visual Studio Code, klicken Sie auf das Symbol „Erweiterungen“ in der linken Leiste und geben Sie „C++“ in das Suchfeld oben ein.
Klicken Sie auf die Schaltfläche „Installieren“ im ersten Element, um C++-Entwicklungsfunktionen zu VS Code hinzuzufügen. Warten Sie, bis die Erweiterung eingerichtet ist, und öffnen Sie dann den Ordner `c++-web-scraper` mit `"``File``"` `>` `"``Open Folder...``"`.
Klicken Sie mit der rechten Maustaste auf den Abschnitt „**EXPLORER**“, wählen Sie „New File… (Neue Datei …)“ und initialisieren Sie eine `scraper.cpp`-Datei wie folgt:
```none
#include
int main()
{
std::cout << "Hello World" << std::endl;
}
```
Sie haben jetzt ein C++-Projekt!
## Schritt 2: Installieren Sie die Scraping-Bibliotheken.
Die umständliche C++-Syntax und ihre begrenzten Webfunktionen können ein Hindernis beim Erstellen eines Web-Scrapers darstellen. Um alles einfacher zu gestalten, sollten Sie einige C++-Bibliotheken für Web Scraping verwenden. Wie bereits erwähnt, ist die Auswahl ziemlich begrenzt. Daher sollten Sie sich für die beliebtesten entscheiden: `cpr` und `libxml2`.
Sie können sie unter Windows über `vcpkg` installieren mit:
```none
vcpkg install cpr libxml2 --triplet=x64-windows
```
Ersetzen Sie unter macOS die [Triplettoption](https://learn.microsoft.com/en-us/vcpkg/users/triplets) durch `x64-osx` . Verwenden Sie unter Linux `x64-linux`.
Im Visual Studio Code-Terminal müssen Sie außerdem den folgenden Befehl im Stammverzeichnis Ihres Projekts ausführen:
```none
vcpkg integrate install
```
Dies ermöglicht die Verknüpfung von `vcpkg`-Paketen mit dem Projekt.
Starten Sie VS Code neu und Sie können jetzt jede installierte Bibliothek mit `#include` importieren. Fügen Sie also die folgenden drei Zeilen zu Ihrer `scraper.cpp`-Datei hinzu:
```none
#include "cpr/cpr.h"
#include "libxml/HTMLparser.h"
#include "libxml/xpath.h"
```
Stellen Sie sicher, dass die IDE keine Fehler meldet.
## Schritt 3: Finalisieren Sie die Initialisierung des C++-Projekts.
Um das C++-Scraping-Skript zu erstellen und den Projektinitialisierungsprozess abzuschließen, müssen Sie die Erweiterung [CMake ](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cmake-tools)Tools zu VS Code hinzufügen:
Wenn Ihr Projekt über keinen `.vscode`-Ordner verfügt, erstellen Sie ihn. Dort sucht VS Code nach Konfigurationen, die sich auf das aktuelle Projekt beziehen.
Konfigurieren Sie CMake Tools so, dass `vcpkg` als Toolchain verwendet wird, indem Sie eine `settings.json`-Datei im `.vscode`-Ordner wie folgt erstellen:
```none
{
"cmake.configureSettings": {
"CMAKE_TOOLCHAIN_FILE": "c:/dev/vcpkg/scripts/buildsystems/vcpkg.cmake"
}
}
```
Korrigieren Sie unter macOS und Linux das Feld `CMAKE_TOOLCHAIN_FILE` entsprechend dem Pfad, in dem Sie `vcpkg` installiert haben. Wenn Sie der obigen Installationsanleitung gefolgt sind, sollte es `/dev/vcpkg/scripts/buildsystems/vcpkg.cmake` lauten.
Geben Sie in der Hauptsuchleiste von VS Code „>cmake“ ein und wählen Sie die Option „CMake: Configure“:
Dadurch können Sie die Zielkompilierungsplattform auswählen. Wählen Sie unter Windows „Visual Studio Build Tools 2019 Release – x86\_amd64“:
Fügen Sie die `CMakeLists.txt`-Datei im Stammordner Ihres Projekts hinzu, um CMake einzurichten:
```none
cmake_minimum_required(VERSION 3.0.0)
project(main VERSION 0.1.0)
INCLUDE_DIRECTORIES(
C:/dev/vcpkg/installed/x86-windows/include
)
LINK_DIRECTORIES(
C:/dev/vcpkg/installed/x86-windows/lib
)
add_executable(main scraper.cpp)
target_compile_features(main PRIVATE cxx_std_20)
find_package(cpr CONFIG REQUIRED)
target_link_libraries(main PRIVATE cpr::cpr)
find_package(LibXml2 REQUIRED)
target_link_libraries(main PRIVATE LibXml2::LibXml2)
```
Beachten Sie, dass es sich um die beiden zuvor installierten Pakete handelt. Stellen Sie sicher, dass Sie `INCLUDE_DIRECTORIES` und `LINK_DIRECTORIES` entsprechend Ihrem `vcpkg`-Installationsordner aktualisieren.
Damit Visual Studio Code das C++-Programm ausführen kann, benötigen Sie eine Startkonfigurationsdatei. Initialisieren Sie im `.vscode`-Ordner `launch.json` wie folgt:
```none
{
"configurations": [
{
"name": "C++ Launch (Windows)",
"type": "cppvsdbg",
"request": "launch",
"program": "${workspaceFolder}/build/Debug/main.exe",
"args": [],
"stopAtEntry": false,
"cwd": "${workspaceFolder}",
"environment": []
}
]
}
```
Beim Starten des Befehls zum Ausführen oder Debuggen führt VS Code die Datei nun im von CMake erstellten Pfad des `Programms` aus. Beachten Sie, dass es unter macOS und Linux keine `.exe`-Datei sein wird.
Die Konfiguration ist fertig!
Jedes Mal, wenn Sie Ihre App debuggen oder erstellen möchten, geben Sie „>cmake: Build“ in das obere Eingabefeld ein und wählen Sie die Option „CMake: Build“.
Warten Sie, bis der Build-Prozess beendet ist, und führen Sie das kompilierte Programm aus dem Abschnitt „Run & Debug (Ausführen und Debuggen)“ aus oder drücken Sie F5. Sie werden das Ergebnis Ihrer Anwendung in der VSC-Debug-Konsole sehen.
Großartig! Es ist Zeit, mit dem Scrapen einiger Daten in C ++ zu beginnen!
## Schritt 4: Laden Sie die Zielseite mit CPR herunter.
Wenn Sie Daten von einer Seite extrahieren möchten, müssen Sie zuerst ihr HTML-Dokument über eine HTTP-`GET`-Anfrage abrufen.
Verwenden Sie CPR, um die Zielseite herunterzuladen mit:
```none
cpr::Response response = cpr::Get(cpr::Url{"https://brightdata.com/"});
```
Im Hintergrund führt die Methode `Get()` eine `GET`-Anfrage an die als Parameter übergebene URL aus. `response.text` enthält die Zeichenkettendarstellung des vom Server zurückgegebenen HTML-Codes.
Beachten Sie, dass die Ausführung automatisierter HTTP-Anfragen Anti-Bot-Technologien auslösen kann. Diese können Ihre Anfragen abfangen und verhindern, dass Ihr Skript auf die Zielseite zugreift. Insbesondere blockieren die grundlegendsten Anti-Scraping-Lösungen eingehende Anfragen ohne einen gültigen `User-Agent` HTTP-Header. Weitere Informationen finden Sie in unserem Leitfaden zu `User-`[`Agent`s für Web Scraping](https://brightdata.de/blog/wie/user-agents-for-web-scraping-101).
Wie jeder andere HTTP-Client verwendet CPR einen Platzhalterwert für `User-Agent`. Da sich dies stark von den Agents unterscheidet, die in gängigen Browsern verwendet werden, können Anti-Bot-Systeme Sie leicht erkennen. Um zu verhindern, dass Sie aus diesem Grund blockiert werden, können Sie in CPR einen gültigen `User-Agent` setzen mit:
```none
cpr::Header headers = {{"User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36"}};
cpr::Response response = cpr::Get(cpr::Url{"https://brightdata.com/121.21.21.da/31/3das/32/1"}, headers);
```
Die HTTP-Anfrage, die über `Get()` gestellt wurde, wird nun so aussehen, als käme sie von Google Chrome 113.
Das ist, was `scraper.cpp` derzeit enthält:
```none
#include
#include "cpr/cpr.h"
#include "libxml/HTMLparser.h"
#include "libxml/xpath.h"
int main()
{
// define the user agent for the GET request
cpr::Header headers = {{"User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36"}};
// make the HTTP request to retrieve the target page
cpr::Response response = cpr::Get(cpr::Url{"https://brightdata.com/"}, headers);
// scraping logic...
}
```
## Schritt 5: Parsen Sie den HTML-Inhalt mit libxml.
Um das vom Server zurückgegebene HTML-Dokument leicht durchsuchbar zu machen, sollten Sie es zuerst parsen.
Um dies zu erreichen, übergeben Sie dazu seine C-String-Darstellung an die Funktion libxml2 `htmlReadMemory()`:
```none
htmlDocPtr doc = htmlReadMemory(response.text.c_str(), response.text.length(), nullptr, nullptr, HTML_PARSE_NOWARNING | HTML_PARSE_NOERROR);
```
Die Variable `doc` macht jetzt die von libxml2 angebotene DOM-Exploration-API verfügbar. Im Einzelnen können Sie HTML-Elemente auf der Seite über XPath-Selektoren abrufen. Zum Zeitpunkt der Erstellung dieses Artikels unterstützt libxml2 keine CSS-Selektoren.
## Schritt 6: Definieren Sie die XPath-Selektoren, um die gewünschten HTML-Elemente zu erhalten.
Um eine effektive XPath-Auswahlstrategie für die HTML-Nodes von Interesse zu definieren, müssen Sie das DOM der Zielseite analysieren. Öffnen Sie die Startseite von Bright Data im Browser, klicken Sie mit der rechten Maustaste auf eine der Branchenkarten und wählen Sie „Inspect (Prüfen)“. Dadurch wird der DevTools-Bereich geöffnet:
Erkunden Sie den HTML-Code und Sie werden feststellen, dass jede Branchenkarte ein `