# InfIng - GCC & Visual Studio Code - Installationsanleitung Dieses Dokument erläutert wie Sie Ihren Computer (oder einen Pool-Account) zum Programmieren mit C++ aufsetzen können. Dazu benötigen Sie: * den C++ Compiler - wir nutzen [GCC](https://gcc.gnu.org/) * einen Editor, wir nutzen [Visual Studio Code](https://code.visualstudio.com/) Beide Tools müssen erst installiert werden. Starten Sie dazu mit der spezifischen Installationsanweisung für Ihr System. Anschließend müssen Sie [Visual Studio Code "einrichten"](#Visual-Studio-Code-%E2%80%9Ceinrichten%E2%80%9D). Bei *Problemen* schauen Sie zuerst in die [FAQ](https://writemd.rz.tuhh.de/#FAQ-und-Probleme) oder fragen Sie Ihren Tutor. **<span style="color: red;">Hinweis:</span>** Sollten Sie Windows on ARM (z.B bei einem Surface Pro X) verwenden, helfen wir gerne bei der Installation im Tutorium weiter. **Privater Rechner** * [MacOS](#Mac-Privat-Rechner) * [Windows](#Windows-Privat-Rechner) * [Linux](#Linux-Privat-Rechner) **Pool-Rechner** * [Windows-Pool](#Windows-Pool-Rechner) * [Linux-Pool](#Linux-Pool-Rechner) ## Mac-Privat-Rechner Zum Programmieren auf dem Mac, ist es am einfachsten XCode (für den mitgelieferten Compiler) zu installieren: 1. [XCode runterladen und installieren](https://apps.apple.com/us/app/xcode/id497799835?mt=12) (Kann etwas dauern, da es vergleichweise groß ist) 2. [VS Code](https://code.visualstudio.com/download) als Installer für den Mac runterladen und installieren Nach der Installation von Xcode öffnen Sie das MacOS-Terminal (Terminal in die Spotlight-Suche eingeben) und führen Sie ```g++``` aus. Es kann sein, dass Sie hier den Befehl ```xcode-select --install```aus. Bestätigen Sie entsprechende Rückfragen. **Anmerkung:** Wenn Sie das erste Mal mit Visual Studio Code arbeiten, könnten Pop-Ups kommen, in welchen Sie VS Code Zugriff auf Dateien geben müssen. Diese Fragen sind normal und müssen bestätigt werden. ## Windows-Privat-Rechner ### GCC Als Compiler installieren wir MinGW64 (dies funktioniert nur auf 64-Bit x86 Windows-System). Hierfür nutzen Sie MSYS2 als Installationtool. 1. [Installer runterladen](https://www.msys2.org) 2. Installer starten und den gewählten Installationspfad merken (z.B. ```C:\msys64```). Am besten den voreingestellten Pfad nehmen. 3. Im MSYS2-Terminal folgenden Befehl ausführen und jeweils im Verlauf die Installationsabsichten mit einem ```Y``` bestätigen: ```pacman -S mingw-w64-x86_64-gcc mingw-w64-x86_64-gdb``` 4. Ende der Installation abwarten. ### GCC dem Pfad hinzufügen Nun müssen Sie den installierten Compiler noch dem Ausführungspfad hinzufügen, damit dieser von Visual Studio Code gefunden werden kann. 1. In die Windows-Suche ```Umgebungsvariablen``` eintippen und auf die Option ```Systemumgebungsvariablen bearbeiten``` klicken. 2. In dem neuem Fenster den Knopf ```Umgebungsvariablen``` drücken und ein weiteres Fenster sollte sich öffnen. Dort auf den Eintrag ```Path``` doppelklicken. 3. In dem neuen Fenster auf den Knopf ```Neu``` drücken und dort den Pfad zu dem ```bin``` Unterordner der MinGW Installation einfügen (z.B. ```C:\My Documents\InfIng\msys2\mingw64\bin```). 4. Alle drei geöffneten Fenster in umgekehrter Reihenfolge durch Drücken auf ```Ok``` schließen. 5. Prüfen, ob Installation des Compilers und Hinzufügen das Pfades erfolgreich war, dazu: * Powershell starten: Windows-Taste drücken, ```Powershell``` tippen und auf ```Windows Powershell``` klicken * Im neuen Fenster ```g++.exe``` tippen. * Nun sollte diese Ausgabe erfolgen ```g++.exe: fatal error: no input files``` ```compilation terminated.``` * Bei einer anderen Ausgabe wurde ein Schritt nicht richtig ausgeführt -- also erst überprüfen, was nicht funktioniert hat!! ### Visual Studio Code 1. [Download VS Code](https://code.visualstudio.com/download) als Installer 2. Installer ausführen und die Schritte durchgehen. Darauf achten, dass im Installationspfad keine Umlaute (ä, ö, ü, ß, ...) vorkommen. ## Linux-Privat-Recher GCC (g++) und Visual Studio Code können in der Regel über die Distribution installiert werden. Suchen Sie dazu nach dem passenden Paket auf Ihrer Distribution. Sollten Sie die Pakete nicht finden, so fragen Sie ihren Tutor. ## Windows-Pool-Rechner Auf den Windows-Pool-Rechnern gibt es zwar über das Software-Managementtool ein Visual Studio Code aber von dessen Benutzung wird abgeraten, da dies sehr alt ist. Daher muss auf den Windows-Rechnern ein Visual Studio Code und ein g++ manuell installiert werden. ### GCC Als Compiler installieren wir MinGW64 mit Hilfe von MSYS2 (dies funktioniert nur auf 64-Bit x86 Windows-System). 1. [Installer runterladen](https://www.msys2.org) 2. Installer starten und ```H:\msys2``` als Installationspfad auswählen. 3. In der MinGW-Shell den Befehl ```notepad /etc/pacman.conf``` ausführen. 4. In der Datei die Zeilen ```cmd #SigLevel = Never SigLevel = Required ``` finden und zu ```cmd SigLevel = Never #SigLevel = Required ``` modifizieren. 5. In der MinGW-Shell den Befehl ```pacman -S mingw-w64-x86_64-gcc mingw-w64-x86_64-gdb``` ausführen. ### GCC dem Pfad hinzufügen Nun müssen wir den gerade installierten Compiler noch einmal dem Pfad hinzufügen, damit dieser von Visual Studio Code gefunden werden kann. 1. In die Windows Suche Enviroment eintippen und auf die Option ```Edit the system enviroment variables``` klicken. 2. In dem neuem Fenster den Knopf ```Enviroment Variables``` drücken und ein weiteres Fenster sollte sich öffnen. Dort auf den Eintrag ```Path``` doppelklicken 3. In dem neuen Fenster auf den Knopf ```Neu``` drücken und dort den Pfad zu dem ```bin``` Unterordner der MinGW Installation einfügen (daher solltet ihr euch den oben merken, z.B. ```H:\msys2\mingw64\bin```) 4. Alle drei geöffneten Fenster in umgekehrter Reihenfolge durch Drücken auf ```Ok``` schließne ### Visual Studio Code 1. [Download VS Code](https://code.visualstudio.com/download) als ```zip```-Archiv 2. Verzeichnis ```H:\My Documents\InfIng``` anlegen 3. ```zip```-Archiv nach ```H:\My Documents\InfIng``` kopieren 4. Rechte Maustaste auf .zip und ```Extract all ...```. Ordername: ```H:\My Documents\InfIng\VSCode``` 5. Ordner ```H:\My Documents\InfIng\VSCode\data``` anlegen 6. Starten mit ```code --no-sandbox --disable-gpu-sandbox```. Hierzu kann auch das Skript ```code.cmd``` in ```H:\My Documents\InfIng\VSCode``` mit dem folgenden Inhalt angelegt werden, welches aus dem Datei-Explorer gestartet werden kann. ```cmd Code.exe --no-sandbox --disable-gpu-sandbox ``` ## Linux-Pool-Rechner Nur auf "neueren" Poolrechnern ist ein hinreichend neuer g++ installiert. Liefert ```g++ --version``` einen zu alten Compiler (vor 2018), per remote Login auf einen neueren Rechner einloggen: * Rechnernamen: l00p31-l11p31, l00p32-l11p32, l00p33-l11p33 Zum Beispiel ```ssh -X l00p31.rz.tu-harburg.de``` * Dort sollte auch Visual Studio Code installiert sein -- per ```code``` im Login-Terminal starten. Die Installation auf einem Linux-Pool-Rechner erfordert nur die Installation von Visual Studio Code, da auf diesen Rechnern der ```g++``` bereits vorinstalliert ist. Der Installationvorgang ist der Folgende: 1. Anmelden 2. Datei-Browser öffnen (```Activities > Files```) 3. Lege im Home-Ordner einen neuen Ordner ```InfIng``` an (```Rechte Maustaste > New Folder```). Zusätzlich noch den Ordner ```InfIng/Projekte``` anlegen. 4. [Download](https://code.visualstudio.com/download) ```64Bit-Linux Release``` für Linux von Visual Studio Code. Bitte wählt hierbei das ```.tar.gz```-Archiv aus. 5. Verschiebe runtergeladene Datei (liegt i.d.R. unter ```~/Downloads```) nach ```~/InfIng```. 6. Datei entpacken (```Rechte Maustaste > Extract Here```) 7. Neuen Ordner in ```VSCode``` umbenennen 8. Verzeichnis ```~/InfIng/VSCode/data``` anlegen 9. Im Terminal ```~/InfIng/VSCode/VSCode-linux-x64/code``` ausführen 10. Sollte die Fehlermeldung ```The SUID sandbox helper binary was found, but is not configured correctly``` erscheinen, dann müsst ihr den Befehl ```~/InfIng/VSCode/code --no-sandbox```ausführen.- ## Visual Studio Code "einrichten" 1. Visual Studio Code starten 2. Neuen Ordner auswählen. Hierfür eignet sich zum Beispiel (```~/InfIng/Projekte/setup``` unter Linux oder ```H:\My Documents\InfIng\Projekte\setup``` unter Windows 3. Bestätigen, dass Sie sich selber trauen ("Yes, I trust the authors"). 4. Neue Datei ```main.cpp``` anlegen und öffnen 5. Ein Popup fragt euch: "Do you want to install the recommended extensions for C++". Bitte mit ```Install``` bestätigen. 6. Nach der Installation wieder die Datei öffnen. 7. Oben rechts auf den ```Play-Button``` klicken 8. Wählen Sie bitte die Option ```Detected Task (compiler: /usr/bin/g++)``` aus. ## FAQ und Probleme * __Windows: Sonderzeichen im Namen des Ordners__ *Problem:* Sollte der Name des Ordners, in dem die Quelldateien abgelegt sind, Sonderzeichen haben, z.B. "c:/users/Görschwin Fey/meineProgramme" oder "c:/tmpö", funktioniert das voreingestellte Vorgehen von Visual Studio Code zum Compilieren nicht. *Lösung:* Einen anderen Ordner anlegen und nutzen, der keine Sonderzeichen enthält. * __Windows: Option g++ ist nach Drücken des Play-Buttons nicht verfügbar__ *Problem:* Visual Studio Code kann den gerade installierten MinGW-Compiler nicht finden *Lösung:* Den Installationsordner dem "Pfad" hinzufügen, damit der Compiler einfacher gefunden werden kann: 1. In die Windows Suche Umgebungsvariablen eintippen und auf die Option ```Systemumgebungsvariablen bearbeiten``` klicken. 2. In dem neuem Fenster den Knopf ```Umgebungsvariablen``` drücken und ein weiteres Fenster sollte sich öffnen. Dort auf den Eintrag ```Path``` doppelklicken 3. In dem neuen Fenster auf den Knopf ```Neu``` drücken und dort den Pfad zu dem ```bin``` Unterordner der MinGW Installation einfügen (z.B. ```H:\My Documents\InfIng\msys2\mingw64\bin```) 4. Alle drei geöffneten Fenster in umgekehrter Reihenfolge durch Drücken auf ```Ok``` schließen * __Windows: ```#include<iostream.h>``` ist rot unterstrichen__ *Problem:* Visual Studio Code probiert während des Programmierens herauszufinden, ob die Datei kompilierbar wäre. Selbst mit dieser "Fehlermeldung" kannst du die Datei jedoch problemlos kompilieren und ausführen! Das liegt daran, dass Visual Studio Code nicht weiß, welche Dateien mit deinem Compiler mitgeliefert werden. *Lösung:* Damit Visual Studio Code diese Dateien kennenlernt, klicke in der blauen, unteren Leiste auf die Option ```Win32``` und wähle danach ```Konfigurationen bearbeiten (Benutzeroberfläche)``` aus. In dem sich öffnendem Tab unter ```Compilerpfad``` aus der Liste die Option welche mit ```g++.exe``` endet auswählen (z.B. ```H:\My Documents\InfIng\msys2\mingw64\bin\g++.exe```). Der neue Tab kann nun geschlossen werden und die "Fehlermeldung" sollte verschwinden. * __Windows: Can not open output file / Permission denied__ *Problem:* Einige Antivirenprogramme (zB. Avira) verhindern Schreibvorgänge im Dokumenten-Ordner *Lösung:* Antiviren-App öffnen und den betroffenen Order aus dem Antiviren-Scann ausschließen ([Beispiel Avira](https://support.avira.com/hc/de/articles/360002884254-Wie-schlie%C3%9Fe-ich-Dateien-oder-Prozesse-vom-Scan-aus-)) * __Windows: Trotz vollständiger Installation wird der Compiler nicht gefunden__ *Problem:* Der Installationsanleitung wurde vollständig gefolgt. Trotzdem findet Visual Studio Code keine C++ Compiler. ```g++ -v``` im Terminal gibt eine Fehlermeldung, dass g++ nicht bekannt ist. *Lösung:* Die Umgebungsvariablen öffnen und ``` H:\My Documents\InfIng\msys2\mingw64\bin ``` zum Pfad hinzufügen. Danach VSCode schließen und neu öffnen. * **MacOS: Compilieren mit BitmapPlusPlus.hpp funktioniert nicht.** *Problem:* Erster Compiler-Fehler ist ``` 'constexpr does not name a type' ``` *Lösung:* g++ benutzt einen alten C++-Standard, beim Compilieren muss ``` g++ --std=C++20 main.cpp ``` angegeben werden. Dies kann auch in .vscode\tasks.json eingetragen werden und muss für jedes neue Programm entsprechend gemacht werden. * **MacOS: Programm kann keine Eingaben lesen** *Problem:* Unter MacOS kann ein Programm, welches mit der Standard-Konfiguration gestartet wird keine Eingaben von der Kommandzeile lesen. *Lösung:* Es gibt zwei Dateien, die das Bauen und Ausführen von ```C++```-Dateien in Visual Studio Code regelt. Diese liegen im Projektordner unter ```.vscode```. Die Datei ```tasks.json``` regelt den Übersetzungsprozess. Der hier definierte Task wird für die Ausführung benötigt. ```json { "tasks": [ { "type": "cppbuild", "label": "C/C++: g++ Aktive Datei kompilieren", "command": "/usr/bin/g++", "args": [ "-fdiagnostics-color=always", "-g", "${fileDirname}/*.cpp", "-o", "${fileBasenameNoExtension}" ], "options": { "cwd": "${fileDirname}" }, "problemMatcher": [ "$gcc" ], "group": { "kind": "build", "isDefault": true }, "detail": "Vom Debugger generierte Aufgabe." } ], "version": "2.0.0" } ``` Die Datei ```launch.json``` regelt die Ausführung des Programms: ```json { "version": "0.2.0", "configurations": [ { "name": "g++ - Bauen und Ausführen der aktiven Datei.", "type": "cppdbg", "request": "launch", "program": "${fileDirname}/${fileBasenameNoExtension}", "args": [], "stopAtEntry": false, "cwd": "${workspaceFolder}", "environment": [], "externalConsole": true, "MIMode": "lldb", "preLaunchTask": "C/C++: g++ Aktive Datei kompilieren" } ] } ``` Wichtig ist hierbei, dass das Attribut ```externalConsole``` den Wert ```true```hat, damit das Programm in einer externen Konsole geöffnet wird. Diese externe Konsole bietet dann auch die Option einer Ein- und Ausgabe mit Hilfe des Terminals. *Achtung*: Unter MacOS wird die ```launch.json``` oft nicht automatisch im ``.vscode`` Ordner generiert. Um also ``externalConsole`` auf ``true`` zu setzen muss diese Datei erst erstellt werden. Dafür klickt man auf das Zahnrad rechts neben dem Debug/Run-Knopf (mit dem Ihr euer Programm startet) und wählt - *wie bei der ersten Programmausführung* - die Option mit ``...g++.exe build and debug...`` im Namen aus. Nun solltet Ihr eine ``launch.json`` in eurem ``.vscode`` Ordner haben, die Ihr bearbeiten könnt. * __Windows Pool: ```//nap.rz.tu-harburg.de/.../ld.exe: cannot find ...```__ Der neuste MinGW Kompiler - den wir über MSYS2 installieren - funktioniert auf den Windows-Pool Rechnern leider nicht. Bitte einen älteren Kompiler mit Hilfe [dieser Anleitung](https://writemd.rz.tuhh.de/p-ReHLEvR7qd70aOcN72AQ?both) herunterladen. *Achtung*: Bitte darauf achten, im dritten Schritt von ["GCC dem Pfad hinzufügen"](https://writemd.rz.tuhh.de/p-ReHLEvR7qd70aOcN72AQ#GCC-dem-Pfad-hinzuf%C3%BCgen) den Eintrag zu der fehlerhaften MSYS2 MinGW Installation zu entfernen. * __Windows Pool: Code 18 "launch-failed" beim Starten von VS Code__ In einer früheren Version dieser Anleitung war der Inhalt der code.cmd in [diesem Schritt](#Visual-Studio-Code1) fehlerhaft. Bitte kontrollieren, dass Folgendes in der code.cmd steht: ```cmd Code.exe --no-sandbox --disable-gpu-sandbox ```