So bestehst du das C++-Vorstellungsgespräch: Top-Fragen für Fortgeschrittene

So bestehst du das C++-Vorstellungsgespräch: Top-Fragen für Fortgeschrittene

Ein Vorstellungsgespräch für eine C++-Entwicklerposition ist immer eine Herausforderung. Wenn du die grundlegenden Fragen (Unterschied zwischen new und malloc, was ist ein virtueller Destruktor) wahrscheinlich kennst, erfordert die fortgeschrittene Ebene ein tiefes Verständnis der inneren Funktionsweise der Sprache. In diesem Artikel analysieren wir die wichtigsten Themen, die in einem technischen Interview für Middle- und Senior-Positionen mit Sicherheit aufkommen werden. Wir listen nicht nur die Fragen auf, sondern geben auch ausführliche Antworten mit Codebeispielen.

1. Smart Pointer und ihr innerer Aufbau

Frage: "Erklären Sie den Unterschied zwischen std::unique_ptr und std::shared_ptr? Wie ist die Threadsicherheit des Referenzzählers implementiert?"

Das ist ein Klassiker. Der Interviewer möchte sehen, dass du nicht nur die Syntax, sondern auch die Semantik der Ressourcenverwaltung verstehst.

• std::unique_ptr — exklusiver Besitz. Nicht kopierbar, nur verschiebbar. Ideal für Ressourcen mit einem einzigen Besitzer.
• std::shared_ptr — geteilter Besitz. Verwendet einen Referenzzähler (Control Block). Wenn der Zähler auf Null fällt, wird die Ressource zerstört.
• std::weak_ptr — "Beobachter". Erhöht den Referenzzähler nicht. Wird verwendet, um zyklische Abhängigkeiten in shared_ptr aufzulösen.

Fortgeschrittener Aspekt: Der Referenzzähler in shared_ptr ist threadsicher (es werden atomare Operationen verwendet), aber das macht das verwaltete Objekt selbst nicht threadsicher. Es gibt außerdem zwei Zähler: einen für starke Referenzen (strong) und einen für schwache Referenzen (weak). Solange mindestens eine schwache Referenz existiert, wird der Control Block nicht gelöscht, selbst wenn das Objekt bereits zerstört ist.

#include <memory>#include <iostream>

class Resource {public:    Resource() { std::cout << "Resource acquired"; }    ~Resource() { std::cout << "Resource destroyed"; }    void doWork() { std::cout << "Working..."; }};

int main() {    std::unique_ptr<Resource> uptr = std::make_unique<Resource>();    uptr->doWork();    // std::unique_ptr<Resource> uptr2 = uptr; // Compiler-Fehler!    std::unique_ptr<Resource> uptr2 = std::move(uptr); // OK

    std::shared_ptr<Resource> sptr1 = std::make_shared<Resource>();    std::shared_ptr<Resource> sptr2 = sptr1; // Referenzzähler = 2    sptr1.reset(); // Zähler = 1    sptr2.reset(); // Zähler = 0, Objekt zerstört    return 0;}

2. Virtuelle Tabellen (vtable) und der Mechanismus der späten Bindung

Frage: "Wie funktioniert eine virtuelle Funktion auf Speicherebene? Wo wird die vtable gespeichert?"

Diese Frage testet nicht nur das Verständnis von Polymorphismus, sondern auch der Speicherstruktur in C++.

• Für jede Klasse, die mindestens eine virtuelle Funktion hat, erstellt der Compiler eine statische Tabelle (vtable). Sie enthält Zeiger auf die virtuellen Funktionen.
• Jedes Objekt einer solchen Klasse enthält einen versteckten Zeiger __vptr, der auf die vtable seiner Klasse zeigt.
• Beim Aufruf einer virtuellen Funktion über einen Zeiger oder eine Referenz generiert der Compiler Code, der über __vptr in die vtable geht, die gewünschte Funktion anhand des Offsets findet und sie aufruft.
• Die vtable wird im statischen Speicher (wie eine globale Variable) gespeichert, nicht auf dem Stack oder Heap.

Fortgeschrittener Aspekt: Komplexitäten bei Mehrfachvererbung. In diesem Fall kann ein Objekt mehrere __vptr haben, und es entsteht die Notwendigkeit von Thunk-Funktionen (Korrektur des this-Zeigers). Dies ist einer der Gründe, warum Mehrfachvererbung in C++ als gefährlich und langsam gilt.

#include <iostream>

class Base {public:    virtual void foo() { std::cout << "Base::foo"; }    virtual ~Base() = def