Obsługa otwierania folderów dla systemów kompilacji języka C++ w programie Visual Studio

Funkcja Otwórz folder jest dostępna w programie Visual Studio 2017 lub nowszym.

W programie Visual Studio 2017 lub nowszym funkcja "Otwórz folder" umożliwia otwarcie folderu plików źródłowych i natychmiastowe rozpoczęcie kodowania z obsługą funkcji IntelliSense, przeglądania, refaktoryzacji, debugowania itd. Podczas edytowania, tworzenia, przenoszenia lub usuwania plików program Visual Studio śledzi zmiany automatycznie i stale aktualizuje indeks funkcji IntelliSense. Nie są ładowane żadne pliki .sln ani .vcxproj; w razie potrzeby można określić zadania niestandardowe, a także parametry kompilacji i uruchamiania za pomocą prostych plików .json. Ta funkcja umożliwia zintegrowanie dowolnego systemu kompilacji innej firmy z programem Visual Studio. Aby uzyskać ogólne informacje na temat otwierania folderu, zobacz Programowanie kodu w programie Visual Studio bez projektów lub rozwiązań.

CMake i Qt

Narzędzie CMake jest zintegrowane w środowisku IDE programu Visual Studio jako składnik obciążenia pulpitu C++. Przepływ pracy narzędzia CMake nie jest identyczny z przepływem pracy opisanym w tym artykule. Jeśli używasz narzędzia CMake, zobacz Projekty CMake w programie Visual Studio. Możesz również użyć narzędzia CMake do kompilowania projektów Qt lub użyć rozszerzenia Qt programu Visual Studio dla programu Visual Studio 2015 lub Visual Studio 2017.

Inne systemy kompilacji

Aby użyć środowiska IDE programu Visual Studio z systemem kompilacji lub zestawem narzędzi kompilatora, który nie jest bezpośrednio obsługiwany w menu głównym, wybierz pozycję Plik | Otwórz | Folder lub naciśnij Ctrl + Shift + Alt + O. Przejdź do folderu zawierającego pliki kodu źródłowego. Aby skompilować projekt, skonfiguruj funkcję IntelliSense i ustaw parametry debugowania, dodaj trzy pliki JSON:

Konfigurowanie nawigacji kodu przy użyciu CppProperties.json

Aby funkcja IntelliSense i zachowanie przeglądania, takie jak Przechodzenie do definicji działało poprawnie, program Visual Studio musi wiedzieć, którego kompilatora używasz, gdzie znajdują się nagłówki systemu i gdzie znajdują się dodatkowe pliki dołączania, jeśli nie znajdują się bezpośrednio w otwartym folderze (folder roboczy). Aby określić konfigurację, możesz wybrać pozycję Zarządzaj konfiguracjami z listy rozwijanej na głównym pasku narzędzi:

Program Visual Studio oferuje następujące konfiguracje domyślne:

Jeśli na przykład wybierzesz pozycję x64-Debug, program Visual Studio utworzy plik o nazwie CppProperties.json w głównym folderze projektu:

{
  "configurations": [
    {
      "inheritEnvironments": [
        "msvc_x64"
      ],
      "name": "x64-Debug",
      "includePath": [
        "${env.INCLUDE}",
        "${workspaceRoot}\\**"
      ],
      "defines": [
        "WIN32",
        "_DEBUG",
        "UNICODE",
        "_UNICODE"
      ],
      "intelliSenseMode": "windows-msvc-x64"
    }
  ]
}

Ta konfiguracja dziedziczy zmienne środowiskowe wiersza polecenia programu Visual Studio x64 Developer. Jedną z tych zmiennych jest INCLUDE i możesz odwoływać się do niej tutaj przy użyciu makra ${env.INCLUDE} . Właściwość includePath informuje program Visual Studio, gdzie szukać wszystkich źródeł potrzebnych dla funkcji IntelliSense. W tym przypadku jest wyświetlany komunikat "wyszukaj we wszystkich katalogach określonych przez zmienną środowiskową INCLUDE, a także wszystkie katalogi w bieżącym drzewie folderów roboczych". Właściwość name jest nazwą, która będzie wyświetlana na liście rozwijanej i może być dowolny element. Właściwość defines udostępnia wskazówki dotyczące funkcji IntelliSense w przypadku napotkania bloków kompilacji warunkowej. Właściwość intelliSenseMode udostępnia kilka dodatkowych wskazówek na podstawie typu kompilatora. Dostępnych jest kilka opcji MSVC, GCC i Clang.

Domyślna konfiguracja minGW-w64

Jeśli dodasz konfigurację MinGW-W64, kod JSON wygląda następująco:

{
  "configurations": [
    {
      "inheritEnvironments": [
        "mingw_64"
      ],
      "name": "Mingw64",
      "includePath": [
        "${env.INCLUDE}",
        "${workspaceRoot}\\**"
      ],
      "intelliSenseMode": "linux-gcc-x64",
      "environments": [
        {
          "MINGW64_ROOT": "C:\\msys64\\mingw64",
          "BIN_ROOT": "${env.MINGW64_ROOT}\\bin",
          "FLAVOR": "x86_64-w64-mingw32",
          "TOOLSET_VERSION": "9.1.0",
          "PATH": "${env.BIN_ROOT};${env.MINGW64_ROOT}\\..\\usr\\local\\bin;${env.MINGW64_ROOT}\\..\\usr\\bin;${env.MINGW64_ROOT}\\..\\bin;${env.PATH}",
          "INCLUDE": "${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION};${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION}\\tr1;${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION}\\${env.FLAVOR}",
          "environment": "mingw_64"
        }
      ]
    }
  ]
}

Zanotuj environments blok. Definiuje właściwości, które zachowują się jak zmienne środowiskowe i są dostępne nie tylko w pliku CppProperties.json , ale także w innych plikach konfiguracji task.vs.json i launch.vs.json. Konfiguracja Mingw64 dziedziczy mingw_w64 środowisko i używa jej INCLUDE właściwości do określenia wartości .includePath W razie potrzeby można dodać inne ścieżki do tej właściwości tablicy.

Właściwość jest ustawiona intelliSenseMode na wartość odpowiednią dla GCC. Aby uzyskać więcej informacji na temat wszystkich tych właściwości, zobacz CppProperties schema reference (Dokumentacja schematu CppProperties).

Gdy wszystko działa prawidłowo, funkcja IntelliSense będzie widoczna w nagłówkach GCC po umieszczeniu wskaźnika myszy na typie:

Włączanie diagnostyki funkcji IntelliSense

Jeśli nie widzisz oczekiwanej funkcji IntelliSense, możesz rozwiązać problemy, przechodząc do pozycji Narzędzia>Opcje>Edytor>tekstów C/C++>Advanced i ustawienie Włącz rejestrowanie na .true Aby rozpocząć od, spróbuj ustawić poziom rejestrowania na 5, a filtry rejestrowania na 8.

Dane wyjściowe są przesyłane potokowo do okna danych wyjściowych i są widoczne po wybraniu pozycji *Pokaż dane wyjściowe z: dziennik visual C++. Dane wyjściowe zawierają między innymi listę rzeczywistych ścieżek, których funkcja IntelliSense próbuje użyć. Jeśli ścieżki nie są zgodne z tymi w CppProperties.json, spróbuj zamknąć folder i usunąć podfolder vs , który zawiera buforowane dane przeglądania.

Definiowanie zadań kompilacji przy użyciu tasks.vs.json

Skrypty kompilacji lub inne operacje zewnętrzne można zautomatyzować na plikach w bieżącym obszarze roboczym, uruchamiając je jako zadania bezpośrednio w środowisku IDE. Nowe zadanie można skonfigurować, klikając prawym przyciskiem myszy plik lub folder i wybierając polecenie Konfiguruj zadania.

Spowoduje to utworzenie (lub otwarcie) pliku tasks.vs.json w folderze .vs, który program Visual Studio tworzy w folderze projektu głównego. W tym pliku można zdefiniować dowolne zadanie, a następnie wywołać je z menu kontekstowego Eksplorator rozwiązań. Aby kontynuować przykład GCC, poniższy fragment kodu przedstawia kompletny plik tasks.vs.json z pojedynczym zadaniem, które wywołuje g++.exe w celu skompilowania projektu. Załóżmy, że projekt zawiera jeden plik o nazwie hello.cpp.

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskLabel": "build hello",
      "appliesTo": "/",
      "type": "default",
      "command": "g++",
      "args": [
        "-g",
        "-o",
        "hello",
        "hello.cpp"
      ]
    }
  ]
}

Plik JSON jest umieszczany w podfolderze .vs . Aby wyświetlić ten folder, kliknij przycisk Pokaż wszystkie pliki w górnej części Eksplorator rozwiązań. To zadanie można uruchomić, klikając prawym przyciskiem myszy węzeł główny w Eksplorator rozwiązań i wybierając polecenie build hello. Po zakończeniu zadania powinien zostać wyświetlony nowy plik, hello.exe w Eksplorator rozwiązań.

Można zdefiniować wiele rodzajów zadań. W poniższym przykładzie przedstawiono plik tasks.vs.json definiujący pojedyncze zadanie. taskLabel definiuje nazwę wyświetlaną w menu kontekstowym. appliesTo definiuje pliki, na których można wykonać polecenie. Właściwość command odnosi się do zmiennej środowiskowej COMSPEC, która identyfikuje ścieżkę dla konsoli (cmd.exe w systemie Windows). Można również odwołać się do zmiennych środowiskowych zadeklarowanych w CppProperties.json lub CMakeSettings.json. Właściwość args określa wiersz polecenia do wywołania. Makro ${file} pobiera wybrany plik w Eksplorator rozwiązań. W poniższym przykładzie zostanie wyświetlona nazwa pliku aktualnie wybranego .cpp.

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskLabel": "Echo filename",
      "appliesTo": "*.cpp",
      "type": "command",
      "command": "${env.COMSPEC}",
      "args": ["echo ${file}"]
    }
  ]
}

Po zapisaniu tasks.vs.json możesz kliknąć prawym przyciskiem myszy dowolny plik .cpp w folderze, wybrać pozycję Echo nazwa pliku z menu kontekstowego i wyświetlić nazwę pliku wyświetlaną w oknie Dane wyjściowe.

Aby uzyskać więcej informacji, zobacz dokumentację schematu Tasks.vs.json.

Konfigurowanie parametrów debugowania przy użyciu launch.vs.json

Aby dostosować argumenty wiersza polecenia programu i instrukcje debugowania, kliknij prawym przyciskiem myszy plik wykonywalny w Eksplorator rozwiązań i wybierz polecenie Debuguj i uruchom ustawienia. Spowoduje to otwarcie istniejącego pliku launch.vs.json lub jeśli nie istnieje, spowoduje utworzenie nowego pliku z zestawem minimalnych ustawień uruchamiania. Najpierw masz wybór rodzaju sesji debugowania, którą chcesz skonfigurować. W celu debugowania projektu MinGw-w64 wybierzemy pozycję Uruchom C/C++ dla polecenia MinGW/Cygwin (gdb). Spowoduje to utworzenie konfiguracji uruchamiania do używania gdb.exe z pewnymi wykształconymi domyślanymi wartościami domyślnymi. Jedną z tych wartości domyślnych jest MINGW_PREFIX. Możesz zastąpić ścieżkę literału (jak pokazano poniżej) lub zdefiniować MINGW_PREFIX właściwość w CppProperties.json:

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "cppdbg",
      "name": "hello.exe",
      "project": "hello.exe",
      "cwd": "${workspaceRoot}",
      "program": "${debugInfo.target}",
      "MIMode": "gdb",
      "miDebuggerPath": "c:\\msys64\\usr\\bin\\gdb.exe",
      "externalConsole": true
    }
  ]
}

Aby rozpocząć debugowanie, wybierz plik wykonywalny na liście rozwijanej debugowania, a następnie kliknij zieloną strzałkę:

Powinno zostać wyświetlone okno dialogowe Inicjowanie debugera , a następnie okno konsoli zewnętrznej z uruchomionym programem.

Aby uzyskać więcej informacji, zobacz dokumentację schematu launch.vs.json.

Uruchamianie innych plików wykonywalnych

Możesz zdefiniować ustawienia uruchamiania dla dowolnego pliku wykonywalnego na komputerze. Poniższy przykład uruchamia 7za i określa dodatkowe argumenty, dodając je do args tablicy JSON:

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "default",
      "project": "CPP\\7zip\\Bundles\\Alone\\O\\7za.exe",
      "name": "7za.exe list content of helloworld.zip",
      "args": [ "l", "d:\\sources\\helloworld.zip" ]
    }
  ]
}

Po zapisaniu tego pliku nowa konfiguracja zostanie wyświetlona na liście rozwijanej Debugowanie elementu docelowego i możesz wybrać go, aby uruchomić debuger. Możesz utworzyć dowolną liczbę konfiguracji debugowania dla dowolnej liczby plików wykonywalnych. Po naciśnięciu F5 debuger zostanie uruchomiony i trafi do dowolnego punktu przerwania, który mógł już zostać ustawiony. Wszystkie znane okna debugera i ich funkcje są teraz dostępne.