Подтвердить что ты не робот

Как запустить программу C из VIM?

Есть ли способ скомпилировать и запустить программу C из VIM без ввода имени файла?

4b9b3361

ОТВЕТЫ

Ответ 1

:!gcc -o somename % && ./somename
При использовании :!,% будет заменено именем открытого в данный момент файла.

Когда ваш проект станет больше, вы также можете написать makefile и скомпилировать текущий проект с помощью :make, если есть какие-либо ошибки, vim автоматически перейдет к ним.

Ответ 2

Используйте следующий код преобразования в вашем файле .vimrc для компиляции и запуска файла программирования c.

 map <F8> : !gcc % && ./a.out <CR>

Ключ F8 предназначен для запуска сопоставления. "%" - взять текущее имя файла.

Или, если вы хотите сохранить текущий файл перед его компиляцией, используйте

map <F8> :w <CR> :!gcc % && ./a.out <CR>

Или, что более идеально, если вы хотите использовать базовое имя файла не по умолчанию "a.out" в качестве имени исполняемого файла, используйте следующее:

map <F8> :w <CR> :!gcc % -o %< && ./%< <CR>

В приведенной выше команде "<" после "%" удаляет расширение и точку (foo.c = > foo), поэтому "% <" это базовое имя файла.

Вы можете найти эту и аналогичную информацию в файле cmdline.txt. Команда в vim: help: cmdline.txt. Вы также можете найти конкретные сведения об использовании "%" , используя :help filename-modifiers в vim.

Ответ 3

TL; DR Make файл не требуется, настройка &makeprg также совершенно бесполезна, и все же :make %< достаточно для компиляции из Vim.

Длинный ответ:

Я дублирую ответ, который дал в закрытом "дублирующем вопросе".

Учитывая, что мы используем vim, а не vi, :make - путь.

В Linux-подобных (это также относится к cygwin, но не к mingw на windows - в случае mingw, посмотрите другие ответы, которые меняют &makeprg, оставьте его в покое в противном случае)) системы, где установлен gnumake, если у вас нет Makefile в вашем проекте, и если ваш проект состоит только из одного файла, просто введите :make %<. Этого будет достаточно (вы можете играть с $CXXFLAGS, $CFLAGS и $LDFLAGS, чтобы настроить параметры компиляции). Затем, чтобы запустить программу, введите :!./%< или с более поздними версиями vim запустите :terminal ./%<.

Если ваш проект состоит из нескольких файлов, вам понадобится Makefile, чтобы воспользоваться :make.

Если вы управляете своим проектом с помощью CMake, и если вы компилируете свой проект в каталоге (или нескольких → debug, release,...) вне дерева исходных текстов, то для интеграции потребуется плагин. AFAIK, я единственный, кто предлагает такой плагин: BuildToolsWrapper интегрирует управление CMake (выбор каталога сборки, возможность выбора между отладкой, выпуском или любым другим каталогом сборки). Он должен быть связан с одним из плагинов local_vimrc.

Во всех случаях, вызывая напрямую компилятор из (или снаружи) Vim с :!g++ -o %< % или с чем-то, что мы делали 15 лет назад на vi. У Vim есть замечательная особенность: он может интегрировать (да, как в IDE) компилятор. Смотрите :h quickfix. Навигация между ошибками непосредственно из редактора намного проще, чем извлечение одной строки ошибки нашими глазами, ввод номера строки обратно в редактор, возврат к оболочке, чтобы увидеть, что именно было отклонено,... Этого может быть достаточно в C, но в C++, когда мы "пытаемся вызвать перегрузку, которая не существует", мы не можем работать таким образом (переключаясь между редактором и оболочкой).

Наконец, если вы хотите скомпилировать эти монофайловые проекты одним нажатием клавиши, вы можете добавить в .vimrc:

nnoremap <silent> <f7> :make %<<cr>

Если вы хотите автоматически адаптировать команду компиляции в зависимости от типа проекта: монофайловый проект или многофайловый проект в реальном мире, ну, вам нужно больше проводки, и именно это BTW делает - он читает различные варианты, чтобы знать, что делать.

Последнее примечание: &makeprg лучше оставить в покое, по крайней мере, не устанавливать g++/gcc/clang/clan g++/gfortran/... Потому что каждый раз, когда вы меняете свой язык, вам придется его менять (если вы не используете :setlocal). С решением, которое я рекомендую, если я хочу использовать клан g++ вместо g++, все, что мне нужно сделать, это установить: :let $CXX='clang++' (или $CC в C), а затем вызвать :make %<. Я даже могу определить :let $CXXFLAGS='-std=c++11' для компиляции в C++ 11 - эта же переменная будет использоваться для включения предупреждений, использования дезинфицирующего средства и т.д.

Ответ 4

так как большую часть времени вы будете использовать Makefile, в дополнение к данным ответам, мне также нравится видеть мои результаты на "очищенном" экране:

map <F10> :w<CR> :!clear; make<CR> :!./%<<CR>

  • :w<CR> сохраняет файл

  • :!clear; make<CR> очищает экран и запускает make

  • :!./%<<CR> запускает программу (%) без расширения (<)

Ответ 5

Добавьте эту строку в свой vimrc файл

nnoremap <silent> <F8> :!clear;gcc % -o % && ./%<CR>

Теперь вам нужно нажать клавишу f8 для компиляции и запуска вашей c-программы.

Ответ 6

Это 2018 год, vim 8 выпускается в течение 2 лет и поставляется со всеми дистрибутивами Linux и Mac OS X. Но многие руководства по vim все еще учат людей чему-то десять лет назад.

Вы можете скомпилировать свои программы C++/Java в vim для удобства, например, Sublime Text или NotePad++, с помощью некоторых специальных плагинов для Vim 8 или NeoVim.

Например, плагин AsyncRun позволит вам запускать команды оболочки в фоновом режиме и считывать вывод из окна быстрого исправления в реальном времени. См. снимок экрана.

Как и при компиляции программ в IDE, ошибки компиляции будут сопоставляться по формату ошибки, выделяться и становиться доступными для выбора. Вы можете перемещаться по ошибкам в окне быстрого исправления или продолжить редактирование во время компиляции.

Быстрая настройка

Копировать и вставьте строки ниже в ваш vimrc:

Plug 'skywind3000/asyncrun.vim'

" open quickfix window automatically when AsyncRun is executed
" set the quickfix window 6 lines height.
let g:asyncrun_open = 6

" ring the bell to notify you job finished
let g:asyncrun_bell = 1

" F10 to toggle quickfix window
nnoremap <F10> :call asyncrun#quickfix_toggle(6)<cr>

Когда вы вводите ': AsyncRun echo hello' в командной строке:

увидеть захват здесь

Вы увидите вывод команды реального времени в открытом окне быстрого исправления.

Скомпилируйте и запустите один файл

Компиляция одного файла с помощью AsyncRun намного проще, чем система сборки Sublime Texts. Мы можем настроить F9 для этого:

noremap <silent> <F9> :AsyncRun gcc -Wall -O2 "$(VIM_FILEPATH)" -o "$(VIM_FILEDIR)/$(VIM_FILENOEXT)" <cr>

Макросы в форме $(..) будут расширены как настоящее имя файла или каталога, а затем у нас будет F5 для запуска исполняемого файла:

noremap <silent> <F5> :AsyncRun -raw -cwd=$(VIM_FILEDIR) "$(VIM_FILEDIR)/$(VIM_FILENOEXT)" <cr>

Двойная кавычка используется для обработки имен путей, содержащих пробелы. Опция -cwd=$(VIM_FILEDIR) означает запуск файла в каталоге файлов. Абсолютный путь $(VIM_FILEDIR)/$(VIM_FILENOEXT) используется, потому что linux нужен префикс ./ для запуска исполняемых файлов в текущем каталоге, а Windows - нет. Использование абсолютного пути к двоичному файлу может справиться с этой проблемой пересечения платформы.

Другая опция -raw означает, что вывод не будет совпадать с vim errorformat, и будет отображаться в формате быстрого исправления как есть. Теперь вы можете скомпилировать свой файл с помощью F9, проверить ошибки компиляции в окне быстрого исправления и нажать F5, чтобы запустить двоичный файл.

Проекты сборки C/C++

Независимо от того, какой инструмент сборки вы используете, make или cmake, сборка проекта означает обработку группы файлов. Требуется найти корневой каталог проекта. AsyncRun использует простой метод, называемый корневыми маркерами, для определения корня проекта. Корень проекта определяется как каталог ближайшего предка текущего файла, который содержит один из следующих каталогов или файлов:

let g:asyncrun_rootmarks = ['.svn', '.git', '.root', '_darcs']

Если ни один из родительских каталогов не содержит этих корневых маркеров, в качестве корневого каталога проекта используется каталог текущего файла. Это позволяет нам использовать либо <root>, либо $(VIM_ROOT) для представления корня проекта. и F7 можно настроить для построения текущего проекта:

noremap <silent> <F7> :AsyncRun -cwd=<root> make <cr>

Что если ваш текущий проект отсутствует в репозитории git или subversion? Как узнать, где находится мой проект? Решение очень простое, просто поместите пустой файл .root в корень вашего проекта, он будет легко расположен.

Давайте продолжим, настройте F8 для запуска текущего проекта:

noremap <silent> <F8> :AsyncRun -cwd=<root> -raw make run <cr>

Проект будет работать в своем корневом каталоге. Конечно, вам нужно определить правило запуска в вашем собственном make файле. затем переназначить F6 для проверки:

noremap <silent> <F6> :AsyncRun -cwd=<root> -raw make test <cr>

Если вы используете cmake, F4 может быть картой для обновления вашего Makefile:

nnoremap <silent> <F4> :AsyncRun -cwd=<root> cmake . <cr>

Из-за реализации среды выполнения c, если процесс выполняется не в tty-среде, все данные в stdout будут буферизироваться до завершения процесса. Итак, после вашего оператора printf должен быть fflush(stdout), если вы хотите видеть вывод в реальном времени. или вы можете закрыть буфер stdout в начале, нажав

setbuf(stdout, NULL);

В то же время, если вы пишете код C++, std::endl может быть добавлен в конец std::cout. Это может принудительно очистить буфер stdout. Если вы разрабатываете в Windows, AsyncRun может открыть новое окно cmd для дочернего процесса:

nnoremap <silent> <F5> :AsyncRun -cwd=$(VIM_FILEDIR) -mode=4 "$(VIM_FILEDIR)/$(VIM_FILENOEXT)" <cr>
nnoremap <silent> <F8> :AsyncRun -cwd=<root> -mode=4 make run <cr>

Использование опции -mode=4 в окнах откроет новое окно с приглашением для запуска команды, так же как и запуск программ командной строки в Visual Studio. Наконец, у нас есть следующие сопоставления клавиш:

  • F4: обновить Makefile с помощью cmake.
  • F5: запустить один файл
  • F6: запустить тест проекта
  • F7: построить проект
  • F8: запустить проект
  • F9: скомпилировать один файл
  • F10: переключить окно быстрого исправления

Это больше похоже на систему сборки в NotePad++ и GEdit. Если вы интенсивно используете cmake, вы можете написать простой скрипт оболочки, расположенный в ~/.vim/script/build.sh, чтобы объединить F4 и F7: он обновит Makefile, если CMakeList.txt был изменен, а затем выполнит make.

Расширенное использование

Вы также можете определить сценарии оболочки в вашем репозитории dotfiles и выполнить сценарий с помощью F3:

nnoremap <F3> :AsyncRun -cwd=<root> sh /path/to/your/dotfiles/script/build_advanced.sh <cr>

Следующие переменные среды оболочки определены в AsyncRun:

$VIM_FILEPATH  - File name of current buffer with full path
$VIM_FILENAME  - File name of current buffer without path
$VIM_FILEDIR   - Full path of current buffer without the file name
$VIM_FILEEXT   - File extension of current buffer
$VIM_FILENOEXT - File name of current buffer without path and extension
$VIM_CWD       - Current directory
$VIM_RELDIR    - File path relativize to current directory
$VIM_RELNAME   - File name relativize to current directory 
$VIM_ROOT      - Project root directory
$VIM_CWORD     - Current word under cursor
$VIM_CFILE     - Current filename under cursor
$VIM_GUI       - Is running under gui ?
$VIM_VERSION   - Value of v:version
$VIM_COLUMNS   - How many columns in vim screen
$VIM_LINES     - How many lines in vim screen
$VIM_SVRNAME   - Value of v:servername for +clientserver usage

Все перечисленные выше переменные окружения могут быть использованы в вашем build_advanced.sh. Использование файла сценария внешней оболочки может сделать более сложную работу, чем одна команда.

Grep символы

Иногда, если в вашем удаленном linux-окружении нет хорошо настроенной среды, grep - самый дешевый способ поиска определения символов и ссылок среди источников. Теперь у нас будет F2 для поиска по ключевому слову под курсором:

if has('win32') || has('win64')
    noremap <F2> :AsyncRun! -cwd=<root> grep -n -s -R <C-R><C-W> --include='*.h' --include='*.c*' '<root>' <cr>
else
    noremap <F2> :AsyncRun! -cwd=<root> findstr /n /s /C:"<C-R><C-W>" "\%CD\%\*.h" "\%CD\%\*.c*" <cr>
endif

Приведенный выше скрипт запускает grep или findstr в корневом каталоге вашего проекта и находит символы только в файлах .c, .cpp и .h. Теперь мы перемещаем курсор и нажимаем F2, ссылки на символы в текущем проекте будут немедленно отображаться в окне быстрого исправления.

Этой простой раскладки клавиатуры достаточно для большей части времени. И вы можете улучшить этот скрипт для поддержки большего количества типов файлов или других инструментов grep в вашем vimrc.

Это практический способ создания/запуска C/C++ проектов в Vim 8 или NeoVim. Так же, как система сборки Sublime Texts и NppExec NotePad++.

Больше никаких устаревших уроков vim, попробуйте что-то новое.

Ответ 7

Просто подумал, что я добавлю это к этим ответам здесь. Как уже упоминалось, вы можете использовать команду :make в vim. Что еще не упоминалось, это то, что :make может вызывать другие программы, кроме make.

:set makeprg=gcc\ %

Вызывает :make выполнение gcc с замененным символом % текущим именем файла.

Затем вы можете получить фантазию и сделать

:set makeprg=gcc\ %\ &&\ ./a.out

и просто набрав :make будет компилировать и выполнять вашу программу. Вы также можете сделать это для других языков.

:set makeprg=cabal\ repl
:set makeprg=python\ %

Ответ 8

После некоторых исследований (включая эту самую страницу) я решил добавить этот ярлык:

map <F9> :w<CR> :!gcc % -o %<.x -Wall -Wextra 2>errors.err; cat errors.err<CR>

Вы также можете включить -ansi -pedantic-errors, если хотите.

Файл errors.err поможет вам с быстрым vi.

Ответ 9

Я просмотрел все эти решения и обнаружил, что они не работают (насколько я могу судить) для случая редактирования файла в другом каталоге - я написал некоторый vimscript, который делает это довольно неуклюжим образом, но, надеюсь, кто-то найдет это полезным:

let mycommand = ':!gcc % -o %< && echo "%<" && [ $(pwd) == "." ] && %< || ./%< '
nnoremap <silent> <F8> :execute mycommand <CR>

или если указанные выше команды работают для вас в нескольких каталогах, не стесняйтесь просто игнорировать это.

Ответ 10

Добавьте эти три строки в ваш .vimrc файл

au FileType c set makeprg=gcc\ % 

au FileType cpp set makeprg=g++\ %

map <F7>:make && ./a.out<CR>

Вы можете скомпилировать и запустить свою программу, нажав кнопку F7.

Ответ 11

Возможно, стоит добавить, что плагин SingleCompile предлагает эту возможность для C и других языков, как указано автором:

SingleCompile - это плагин Vim, целью которого является сделать его более удобным для скомпилируйте или запустите один исходный файл, не выходя из Vim. Учти это ситуация: вы только что написали небольшой исходный файл C для крошечного проверить, но вы должны написать Makefile для его компиляции или выйти из Vim скомпилируйте или скомпилируйте, используя "! gcc" без функции быстрого исправления потому что команда Vim make использует только команду "make"? Этот плагин поможет вам.

Предлагаемые сопоставления для F9 и F10:

nmap <F9> :SCCompile<cr>
nmap <F10> :SCCompileRun<cr>