Wie man ein C++-Vorstellungsgespräch besteht: Top-Fragen und Antworten

Wie man ein C++-Vorstellungsgespräch besteht: Die Top-Fragen mit Beispielen analysiert

Ein Vorstellungsgespräch für eine C++-Entwicklerposition testet nicht nur die Syntax, sondern auch das tiefe Verständnis dafür, wie Speicher, Compiler und die Standardbibliothek funktionieren. In diesem Artikel analysieren wir die häufigsten Fragen, die in Interviews in den Jahren 2024-2025 gestellt werden. Sie lernen nicht nur die richtigen Antworten, sondern sehen auch Codebeispiele, die Ihnen helfen, das technische Interview souverän zu bestehen.

1. Virtuelle Funktionen und Polymorphie

Das ist ein Klassiker. Interviewer möchten sicherstellen, dass Sie den Unterschied zwischen statischer und dynamischer Bindung sowie den Mechanismus der vtable (Tabelle der virtuellen Funktionen) verstehen.

Frage: Was passiert, wenn eine virtuelle Funktion aus einem Konstruktor oder Destruktor aufgerufen wird?

Antwort: Der Aufruf einer virtuellen Funktion aus dem Konstruktor einer Basisklasse ist nicht polymorph. Zum Zeitpunkt des Aufrufs des Konstruktors der Basisklasse existiert das Objekt der abgeleiteten Klasse noch nicht, daher wird die Version der Funktion der Basisklasse aufgerufen. Analog dazu wird im Destruktor – nach dem Aufruf des Destruktors der abgeleiteten Klasse – das Objekt auf die Basisklasse "herabgestuft".

#include <iostream>

class Base {public:    Base() { print(); }  // Aufruf einer virtuellen Funktion im Konstruktor    virtual void print() { std::cout << "Base"; }    virtual ~Base() = default;};

class Derived : public Base {public:    Derived() { print(); }    void print() override { std::cout << "Derived"; }};

int main() {    Derived d;    // Ausgabe: Base (aus dem Konstruktor von Base)    //        Derived (aus dem Konstruktor von Derived)    return 0;}

2. Smart Pointer

Kein modernes Vorstellungsgespräch kommt ohne dieses Thema aus. Smart Pointer sind die Grundlage von RAII und Ressourcenverwaltung in C++.

Frage: Was ist der Unterschied zwischen std::unique_ptr, std::shared_ptr und std::weak_ptr? Wann verwendet man was?

Antwort:

• unique_ptr — Alleinbesitz. Nicht kopierbar, nur verschiebbar. Ideal für Ressourcen, die beim Verlassen des Gültigkeitsbereichs freigegeben werden sollen.
• shared_ptr — Geteilter Besitz. Verwendet einen Referenzzähler. Löscht das Objekt, wenn der Zähler null erreicht.
• weak_ptr — "Beobachter" für shared_ptr. Erhöht den Referenzzähler nicht. Wird verwendet, um zyklische Abhängigkeiten zu verhindern.

#include <memory>#include <iostream>

class Resource {public:    Resource() { std::cout << "Resource acquired"; }    ~Resource() { std::cout << "Resource released"; }};

int main() {    // unique_ptr    std::unique_ptr<Resource> uptr = std::make_unique<Resource>();        // shared_ptr    std::shared_ptr<Resource> sptr1 = std::make_shared<Resource>();    std::shared_ptr<Resource> sptr2 = sptr1;  // Referenzzähler = 2        // weak_ptr    std::weak_ptr<Resource> wptr = sptr1;  // Erhöht den Zähler nicht        if (auto locked = wptr.lock()) {        std::cout << "Resource is still alive";    }        return 0;}

3. Move-Semantik und Rvalue-Referenzen

Move-Semantik ist eine der Schlüsselfunktionen von C++11. Im Vorstellungsgespräch könnten Sie gebeten werden, einen Move-Konstruktor zu schreiben oder zu erklären, was eine forwarding reference ist.

Frage: Was ist Move-Semantik und wozu wird sie benötigt? Geben Sie ein Beispiel, bei dem sie den Code beschleunigt.

Antwort: Move-Semantik ermöglicht es, den Besitz von Ressourcen (z. B. dynamischem Speicher) zu übertragen, ohne sie zu kopieren. Anstatt einer tiefen Kopie "verschieben" wir die Zeiger und setzen das ursprüngliche Objekt zurück. Dies ist für die Leistung bei der Arbeit mit großen Containern von entscheidender Bedeutung.