Debuggen Sie C ++ - Code in Vim? Wie?

Die Frage richtet sich an alle, die Vim zur Entwicklung von C ++ - Anwendungen verwenden.

Es gab eine Zeit in meinem Leben, die als "Ich hasse Vim !!!" beschrieben werden kann. "Vim ist nett!"

Da ich jedoch hauptsächlich mit Microsoft-Entwicklungs-IDEs aufgewachsen bin, habe ich mich an diese gewöhnt F5- F11Verknüpfungen beim Debuggen von Code, Überwachungsfenster, Aufrufstapel und Hauptcode -, die alle sichtbar sind, ohne dass GDB-Befehle eingegeben werden müssen.

Hier ist also die Frage:

Verwenden Sie Vim auch zum Debuggen? Oder wechseln Sie zu diesem Zweck zu einer IDE? Welcher?

Für diejenigen, die Vim zum Debuggen von Code verwenden: Gibt es Plugins zum Setzen von Haltepunkten im Editor, markieren Sie die Zeile, die wir gerade debuggen, automatische Navigation während Schritt, Schritt in, Schritt aus?

Bitte sagen Sie mir nicht, dass Sie GDB als Befehlszeile verwenden, sehen Sie nur eine Zeile, die debuggt ist usw.

Im Gegensatz zu den anderen Antworten gibt es mindestens drei Optionen, die genau das tun, was Sie benötigen: clewn , pyclewn und vimgdb .

Alle drei Projekte sind miteinander verbunden. vimgdb ist ein Patch gegen Vim und erfordert eine Neukompilierung von Vim. clewn ist ein eigenständiges Programm, das über die Netbeans-Socket-Schnittstelle mit Vim kommuniziert. Dies erfordert, dass Vim mit der +netbeansOption erstellt wird (dies ist in neueren Linux-Distributionen der Fall, daher sollte dies kein Problem sein).

Um von der Website der Clewn zu zitieren:

Clewn implementiert die vollständige GDB-Unterstützung im VIM-Editor: Haltepunkte, Überwachungsvariablen, Abschluss des GDB-Befehls, Assembly-Fenster usw.

Ich denke, Sie sollten es auf jeden Fall versuchen.

Die Homepage der pyclewn-Website zeigt einen Vergleich zwischen den drei Projekten.

Vor ein paar Monaten habe ich Pyclewn ausprobiert. Es war ein bisschen schwierig einzurichten, aber es sieht gut aus und ist vielversprechend. Ich habe gerade einige Tests durchgeführt und Sie konnten Lesezeichen usw. setzen, die üblichen Dinge, die Sie von einem grafischen Debugger erwarten würden. Ich habe es aus zufälligen Gründen nicht benutzt, aber ich möchte es unbedingt noch einmal versuchen.

Vim hat offiziell einen integrierten Debugger in Version 8.1 hinzugefügt, der im Mai 2018 veröffentlicht wurde. Die Funktion war bereits in einigen Versionen von Version 8.0 bereits im August 2017 vorhanden.

Die folgenden vim-Befehle laden das Plugin und starten den Debugger.

:packadd termdebug
:Termdebug

Der letztere Befehl verwendet ein Programm als optionales Argument, oder alternativ kann gdbmit dem fileBefehl ein Programm aus dem Fenster geladen werden .

Mit dem geladenen Plugin gdbkann interaktiv im entsprechenden Fenster verwendet werden. Beispielsweise können Haltepunkte gesetzt, Code durchlaufen und Variablen überprüft werden.

Vim-Befehle können für die Interaktion mit ausgegeben werden gdb. Einige relevante Befehle enthalten :Step, :Over, :Finish, :Continue, :Stop, :Break, :Clear, und :Evaluate.

Darüber hinaus gibt es oben im Editorfenster anklickbare Schaltflächen für die Interaktion gdb.

Das Editorfenster wird aktualisiert, um den Status des Debuggens widerzuspiegeln. Haltepunkte werden mit angezeigt >>und die aktuelle Zeile wird hervorgehoben.

Die integrierte Hilfeseite enthält eine ausführliche Dokumentation.

:help terminal-debug

Ich habe kürzlich einen Blog-Beitrag geschrieben, der eine Beispielsitzung durchläuft.

https://www.dannyadam.com/blog/2019/05/debugging-in-vim/

Vim ist ein netter Editor, aber zum Debuggen verwende ich einen Debugger (wie GDB).

Sie müssen GDB jedoch nicht im Textmodus verwenden. Sie können ein grafisches Frontend wie KDbg , DDD oder Insight verwenden .

Es gibt Möglichkeiten, GDB in Vim zu integrieren (aber dann erhalten Sie textbasiertes Debugging).

GDB- editBefehl

Öffnet einen Editor in der aktuellen Zeile mit dem folgenden Befehl:

$EDITOR +<current-line> <current-file>

Die Standardeinstellung editorist ex, versteht aber vimauch das +<current-line>Format.

Wenn Sie den Editor verlassen, kehren Sie zurück gdb.

Dies ermöglicht Ihnen das freie Durchsuchen der Quelle und ist besonders leistungsfähig, wenn Sie eine ctagsIntegration haben.

Dies ist die integrierte Einweg-GDB-zu-Vim-Integration eines armen Mannes: Das wichtigste, was fehlt, ist das Setzen von Haltepunkten von Vim.

edit und zentrieren

editzentriert Vim standardmäßig nicht um die Quelle, daher habe ich ein Python-Skript erstellt, das dies tut: Wie öffne ich die aktuelle Datei in der aktuellen Zeile in einem Texteditor von GDB?

Haltepunktbefehl an Zwischenablage-Helfer

Dieser vim-Befehl kopiert einen Haltepunktspezifizierer vom Typ:

b <file-path>:<line-number>

in die Zwischenablage:

command! Xg :let @+ = 'b ' . expand('%:p') . ':' . line('.')

Dann können Sie das einfach einfügen gdb.

Dies ist die Vim-to-GDB-Integration eines armen Mannes, um das Setzen von Haltepunkten zu vereinfachen.

GDB-Dashboard

https://github.com/cyrus-and/gdb-dashboard

Dies hat nichts mit Vim zu tun, aber es ist eine leichte Lösung, die viel leistet und möglicherweise für andere Vimmer da draußen geeignet ist.

Andere haben GDB TUI erwähnt, aber ich fand es zu kaputt und nicht mächtig genug, um erträglich zu sein.

Also wechselte ich stattdessen zu Python API-basierten Lösungen wie GDB Dashboard.

Ich habe verwendet und Begründung ausführlicher beschrieben unter: gdb split view with code

Hier ist ein Screenshot von dem, was es Ihnen gibt:

Siehe auch: /vi/2046/how-can-i-integrate-gdb-with-vim

Gib auf und benutze eine echte IDE

Trotz alledem ist dies die beste Lösung für die meisten Menschen, einschließlich mir. Die meisten Leute werden nur eine Menge Zeit gewinnen, wenn sie in der Lage sind, Definitionen in einer C ++ - klassenbewussten Weise zu umgehen, ohne selbst mehrere verschiedene Plugins auszuwählen und zu installieren, und dazu gehört auch das schrittweise Debuggen von Dingen. Ab 2020 war Eclipse für mich das am wenigsten schlimmste: https://www.slant.co/topics/1411/~best-ides-for-c-on-linux

Die Verwendung eines Debuggers auf Quellenebene ist nur eine von vielen Möglichkeiten, um ein fehlerhaftes Programmverhalten zu diagnostizieren, und ich stelle selten fest, dass ich einen starte - trotz der Tatsache, dass dies sehr einfach ist.

Für mich ist die Verwendung eines Texteditors, der zufällig auch ein Debugger ist, einfach kein inhärenter Vorteil . Stattdessen verwende ich den von mir bevorzugten Texteditor - unabhängig davon, welchen Debugger ich verwende. Im Moment benutze ich meistens gedit und kdbg für diese Zwecke, aber diese Entscheidungen entwickeln sich im Laufe der Zeit unabhängig voneinander.

Update 2020: Es gibt ein neues Plugin vimspector , das das Debug Adapter Protocol verwendet

1. Installieren Sie das Plugin https://github.com/puremourning/vimspector#installation

2. Konfigurieren (schreiben .vimspector.json)

3. Kompilieren Sie mit dem Debug-Symbol g++ cpp.cpp -ggdb -o cpp

4. Drücken Sie F4, um das Debuggen zu starten

• Beachten Sie meine .vimspector.jsonin meinem Home-Verzeichnis (arbeiten Sie also in einem beliebigen Unterverzeichnis)

{
"configurations": {
  "Python - Launch": {
    "adapter": "vscode-python",
    "configuration": {
      "name": "Python: Launch current file",
      "type": "python",
      "request": "launch",
      "stopOnEntry": true,
      "stopAtEntry": true,
      "console": "externalTerminal",
      "debugOptions": [],
      "cwd": "${cwd}",
      "program": "${file}"
    }
  },
  "Perl - Launch": {
    "adapter": "vscode-perl-debug",
    "configuration": {
      "name": "Perl: Launch current file",
      "type": "perl",
      "request": "launch",
      "exec": "/usr/bin/env perl",
      "execArgs": [],
      "stopOnEntry": true,
      "stopAtEntry": true,
      "console": "externalTerminal",
      "sessions": "single",
      "debugOptions": [],
      "cwd": "${cwd}",
      "program": "${file}"
    }
  },
  "C - Launch": {
    "adapter": "vscode-cpptools",
    "configuration": {
      "name": "Cpp: Launch current file",
      "type": "cppdbg",
      "request": "launch",
      "externalConsole": true,
      "logging": {
        "engineLogging": true
      },
      "stopOnEntry": true,
      "stopAtEntry": true,
      "debugOptions": [],
      "MIMode": "gdb",
      "cwd": "${cwd}",
      "program": "${fileDirname}/${fileBasenameNoExtension}"
    }
  },
  "Java - Launch": {
    "adapter": "vscode-java",
    "configuration": {
      "name": "Java: Launch current file",
      "request": "launch",
      "mainClass": "com.vimspector.test.TestApplication",
      "sourcePaths": [ "${workspaceRoot}/src/main/java" ],
      "classPaths": [ "${workspaceRoot}/target/classes" ],
      "args": "hello world!",
      "stopOnEntry": true,
      "console": "integratedTerminal"
    }
  }
} }

Nachdem ich erst vor kurzem lange an einer Anwendung gearbeitet hatte, bei der eine Reihe von Dingen auf der ausgeführten Box vorhanden sein mussten (Appliance eingerichtet), schrieb ich Code in vim und verfügte über Skripte, die das Erstellen automatisierten und auf einen Server übertrugen , die dort ein Skript hatte, um die Sentinel-Datei zu bemerken, die zusammen mit den Binärdateien verschoben wurde. Dies würde dann die entsprechenden Dienste auf der Box neu starten, und in einem anderen SSH-Fenster hatte ich einetail -f meine Protokolldatei ausgeführt.

Kurz gesagt, ich habe überhaupt keinen Debugger verwendet. Wenn etwas unerwartet sterben würde, würde ich einfach die Protokollierungsstufen erhöhen, es wiederholen und sehen, was als letztes protokolliert wurde, bevor es starb, dann das analysieren und das Problem beheben.

Das Schöne war, dass ich bei Problemen in einer Kundenumgebung nur nach einem Protokoll auf Debug-Ebene fragen und das Problem identifizieren konnte, ohne überhaupt Zugriff auf den Server zu benötigen.

... aber ja, es gab Zeiten, in denen es schön gewesen wäre, einen Debugger zu haben.

Nur um oben hinzuzufügen:

IMO vim ist in der Regel ein recht leichter Editor, und das Debuggen erhöht das Gewicht. Es gibt Möglichkeiten, dies zu tun, z. B. mit vim7.4 +

:terminal

und Ausführen eines der folgenden Befehlszeilen-Debugger (Flüche). Einige werden standardmäßig für IDEs verwendet, die Sie nie gekannt haben. dh lldb = xcode.

• (c / c ++ / Ziel c) gdb (Gnu-Debugger) - https://www.gnu.org/software/gdb/
• (c / c ++ / objectiv c / python etc) remake - http://bashdb.sourceforge.net/remake/
• (Java) Oracle Java-Debugger - https://docs.oracle.com/javase/7/docs/technotes/tools/windows/jdb.html
• (c / c ++ / Ziel c) lldb - https://lldb.llvm.org/

offensichtlich gibt es mehr cli-basierte; @all zögern Sie nicht, vorzuschlagen und zur Liste hinzuzufügen. Vielen Dank!