neovim+cpp/c

Neovim 多语言开发环境使用手册

一个功能完整的 Neovim 开发环境，支持 C/C++、Python 和 Go 语言的智能编码、调试和构建

📖 目录

概述
目录结构
插件管理器：vim-plug
安装的插件
配置模块说明
快捷键速查
C/C++ 开发指南
Python 开发指南
Go 开发指南
构建系统
安装和配置
故障排除
高级技巧

概述

核心特性

🚀 一键操作：F6-F10 快捷键完成编译、运行、调试
🧠 智能代码补全：基于 LSP 的代码智能功能
🐛 可视化调试：集成 DAP 调试器，支持断点、变量查看
🔧 自动构建检测：智能识别 CMake、Makefile、go.mod 等
⚡ 使用 clang/LLVM：现代 C/C++ 编译工具链

支持的语言

语言	编译器/解释器	LSP 服务器	调试器	构建系统
C/C++	clang/clang++	clangd	gdb/lldb	CMake, Makefile
Python	python3	pyright	debugpy	setup.py, pip
Go	go	gopls	delve (dlv)	go.mod, go build

目录结构

配置文件位置

~/.config/nvim/
├── init.lua                    # 主入口文件
├── init.lua.backup             # 原始配置备份
├── README_ZH.md                # 本文档（中文）
└── lua/                        # Lua 配置模块
    ├── plugins.lua            # 插件定义
    ├── settings.lua           # 编辑器设置
    ├── lsp.lua                # LSP 配置
    ├── keymaps.lua            # 快捷键映射
    ├── dap/                   # 调试器配置
    │   ├── init.lua          # DAP 核心和 UI
    │   ├── cpp.lua           # C/C++ 调试
    │   ├── python.lua        # Python 调试
    │   └── go.lua            # Go 调试
    └── build/                 # 构建系统
        ├── init.lua          # 模块加载器
        ├── detect.lua        # 构建系统检测
        └── runners.lua       # 构建/运行命令

数据文件位置

~/.local/share/nvim/
├── site/                       # Neovim 运行时文件
│   └── autoload/
│       └── plug.vim           # vim-plug 本身（83KB 单文件）
├── plugged/                    # vim-plug 管理的插件目录
│   ├── nvim-lspconfig/
│   ├── nvim-dap/
│   ├── nvim-dap-ui/
│   ├── nvim-dap-virtual-text/
│   ├── nvim-nio/
│   ├── mason.nvim/
│   ├── mason-lspconfig.nvim/
│   ├── asyncrun.vim/
│   ├── nvim-treesitter/
│   ├── plenary.nvim/
│   └── catppuccin/            # 主题
└── mason/                      # Mason 安装的工具
    ├── bin/                   # LSP 服务器二进制
    │   ├── clangd -> ...
    │   ├── pyright -> ...
    │   └── gopls -> ...
    └── packages/              # 已安装的包

系统工具位置

/usr/bin/
├── clang                       # C 编译器
├── clang++                     # C++ 编译器
├── gdb                         # GNU 调试器
├── lldb                        # LLVM 调试器
└── python3                     # Python 解释器

~/go/bin/                       # Go 工具（需手动安装）
└── dlv                         # Delve 调试器

~/.local/lib/python3.*/site-packages/
└── debugpy/                    # Python 调试适配器

插件管理器：vim-plug

什么是 vim-plug？

vim-plug 是一个极简的 Vim/Neovim 插件管理器，负责下载、更新和管理所有插件。

自动安装

本配置会在首次启动时自动安装 vim-plug，无需手动操作：

-- init.lua 中的自动安装逻辑
local vim_plug_path = vim.fn.stdpath('data') .. '/site/autoload/plug.vim'
if vim.fn.empty(vim.fn.glob(vim_plug_path)) > 0 then
  print('Installing vim-plug...')
  vim.fn.system({
    'curl', '-fLo', vim_plug_path, '--create-dirs',
    'https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim'
  })
  vim.cmd('autocmd VimEnter * PlugInstall --sync | source $MYVIMRC')
end

vim-plug 文件位置

~/.local/share/nvim/site/autoload/plug.vim

单个文件（约 83KB）
自动下载自 GitHub
无需额外依赖

插件安装目录

所有通过 vim-plug 安装的插件存放在：

~/.local/share/nvim/plugged/

常用命令

在 Neovim 中使用以下命令管理插件：

命令	功能	说明
:PlugInstall	安装插件	安装 `lua/plugins.lua` 中定义的所有插件
:PlugUpdate	更新插件	更新所有已安装的插件到最新版本
:PlugClean	清理插件	删除未在配置中列出的插件
:PlugStatus	查看状态	显示所有插件的安装状态
:PlugUpgrade	升级 vim-plug	更新 vim-plug 本身
:PlugDiff	查看变更	查看上次更新后的变更

首次启动流程

首次打开 Neovim：
```
nvim
```
自动执行：
- 检测 vim-plug 是否存在
- 如不存在，自动下载到 ~/.local/share/nvim/site/autoload/plug.vim
- 自动运行 :PlugInstall 安装所有插件
等待安装完成：
- 会显示安装进度窗口
- 安装完成后自动重载配置

手动重新安装插件

如果插件出现问题，可以手动重新安装：

" 1. 打开 Neovim
nvim

" 2. 清理现有插件
:PlugClean

" 3. 重新安装所有插件
:PlugInstall

" 4. 更新插件
:PlugUpdate

添加新插件

如果要添加新插件，编辑 lua/plugins.lua：

vim.call('plug#begin', vim.fn.stdpath('data') .. '/plugged')

-- 添加新插件
Plug 'tpope/vim-fugitive'  -- 例如：Git 集成插件

vim.call('plug#end')

然后在 Neovim 中运行：

:source $MYVIMRC
:PlugInstall

安装的插件

LSP 相关 (语言服务器协议)

1. nvim-lspconfig

用途：LSP 客户端配置框架
提供：代码补全、跳转定义、错误诊断
配置文件：lua/lsp.lua

2. mason.nvim

用途：LSP 服务器和 DAP 适配器的包管理器
命令：:Mason 打开管理界面
自动安装：clangd, gopls, pyright

3. mason-lspconfig.nvim

用途：连接 mason 和 lspconfig
功能：自动安装缺失的 LSP 服务器

调试相关 (Debug Adapter Protocol)

4. nvim-dap

用途：调试适配器协议客户端
支持：gdb, lldb, debugpy, delve
配置文件：lua/dap/*.lua

5. nvim-dap-ui

用途：调试界面 UI
功能：变量查看、调用栈、断点管理、REPL
布局：左侧面板（变量、断点）+ 底部面板（控制台）

6. nvim-dap-virtual-text

用途：在代码中内联显示变量值
效果：调试时在行尾显示变量的当前值

7. nvim-nio

用途：nvim-dap-ui 的依赖库
功能：提供异步 I/O 支持

工具类插件

8. asyncrun.vim

用途：异步执行 shell 命令
功能：编译、运行程序时不阻塞编辑器
特点：自动打开 quickfix 窗口显示输出

9. nvim-treesitter

用途：增强语法高亮
功能：基于树形语法解析的精确高亮
支持：代码折叠、增量选择

10. plenary.nvim

用途：Lua 工具库
作用：为其他插件提供常用 Lua 函数

主题插件

11. catppuccin/nvim

用途：Catppuccin 主题
变体：使用 mocha 风格（深色主题）
特点：柔和的色彩，护眼

配置模块说明

lua/plugins.lua - 插件定义

-- 使用 vim-plug 管理插件
-- 定义了所有需要安装的插件及其配置

关键配置：

vim.g.asyncrun_open = 8：自动打开 8 行高的 quickfix 窗口

lua/settings.lua - 编辑器设置

-- 基础编辑器配置
vim.opt.number = true              -- 显示行号
vim.opt.relativenumber = true      -- 相对行号
vim.opt.expandtab = true           -- 用空格替代 Tab
vim.opt.shiftwidth = 4             -- 缩进宽度
vim.opt.tabstop = 4                -- Tab 宽度

lua/lsp.lua - LSP 配置

功能：

自动安装 LSP 服务器（通过 Mason）
配置 clangd、gopls、pyright
设置 LSP 快捷键
配置诊断信息显示

clangd 参数：

"--background-index"        -- 后台索引
"--clang-tidy"             -- 启用静态分析
"--header-insertion=iwyu"   -- 自动插入头文件
"--completion-style=detailed" -- 详细补全

lua/dap/*.lua - 调试器配置

dap/init.lua

DAP UI 布局配置
自动打开/关闭 UI
虚拟文本配置
调试快捷键

dap/cpp.lua

配置 gdb/lldb
自动查找可执行文件
支持命令行参数

dap/python.lua

配置 debugpy
自动检测虚拟环境
支持模块调试

dap/go.lua

配置 delve
支持程序和测试调试
监听端口配置

lua/build/*.lua - 构建系统

build/detect.lua

功能：检测项目构建系统

向上遍历目录树
查找标记文件（CMakeLists.txt、go.mod 等）
返回构建系统类型和项目根目录

build/runners.lua

功能：生成构建/运行命令

build_all(): 构建整个项目
run_all(): 运行项目主程序
build_single(): 编译单个文件
run_single(): 运行单个文件

lua/keymaps.lua - 快捷键映射

功能：

定义 F6-F10 快捷键
集成构建系统检测
调用构建/运行命令
显示通知信息

快捷键速查

核心快捷键（F6-F10）

快捷键	功能	说明
F6	🐛 调试当前文件	自动编译（C/C++）并启动调试器
F7	🔨 构建项目	检测并使用项目构建系统（CMake/Make/go build）
F8	▶️ 运行项目	执行项目的主程序
F9	🔧 编译当前文件	使用 clang/clang++/go build 编译单个文件
F10	▶️ 运行当前文件	直接运行当前文件

LSP 快捷键（代码智能）

快捷键	功能	说明
gd	跳转到定义	跳转到函数/变量定义处
gD	跳转到声明	跳转到函数/变量声明处
gi	跳转到实现	跳转到接口实现
gr	查找引用	列出所有引用位置
K	显示文档	显示函数/变量的文档
Ctrl+k	签名帮助	显示函数签名
<leader>rn	重命名符号	重命名变量/函数（所有引用）
<leader>ca	代码操作	显示可用的代码操作
<leader>f	格式化代码	格式化当前缓冲区

诊断导航：

快捷键	功能
[d	上一个诊断
]d	下一个诊断
<leader>e	浮动窗口显示诊断
<leader>q	诊断列表

DAP 调试快捷键

主要控制

快捷键	功能	说明
F5	继续执行	启动调试或继续到下一个断点
F6	调试文件	开始调试当前文件
Shift+F9	单步跳过	执行下一行（不进入函数）
Shift+F11	单步进入	进入函数内部
Shift+F12	单步跳出	跳出当前函数

断点管理

快捷键	功能
<leader>db	切换断点
<leader>dB	条件断点

调试窗口

快捷键	功能
<leader>dr	打开 REPL
<leader>dl	重新运行上次调试
<leader>dh	悬停查看变量
<leader>dp	预览变量

AsyncRun 快捷键

命令	功能
:AsyncStop	停止正在运行的任务
:copen	打开 quickfix 窗口
:cclose	关闭 quickfix 窗口
:cn	下一个错误
:cp	上一个错误

C/C++ 开发指南

编译器：clang/clang++

本配置使用 clang/LLVM 工具链，而不是 gcc/g++。

编译参数：

C++: clang++ -std=c++17 -g
C: clang -std=c11 -g
-g: 包含调试符号

单文件开发

1. 创建并编辑文件

nvim hello.cpp

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

2. 编译和运行

操作	快捷键	等效命令
编译	F9	`clang++ -std=c++17 -g hello.cpp -o hello`
运行	F10	`./hello`
调试	F6	编译后启动 gdb

3. LSP 功能

打开文件后，LSP 自动激活：

#include <vector>
#include <algorithm>

int main() {
    std::vector<int> nums = {3, 1, 4, 1, 5};

    // 输入 std:: 会显示自动补全
    std::sort(nums.begin(), nums.end());

    // 光标放在 sort 上按 K 显示文档
    // 按 gd 跳转到 sort 的定义

    return 0;
}

LSP 提供：

自动补全标准库函数
错误和警告提示
函数签名帮助
代码格式化

4. 调试示例

#include <iostream>

int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);  // ← 在这里按 <leader>db 设置断点
}

int main() {
    int result = factorial(5);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

调试步骤：

按 <leader>db 在第 4 行设置断点
按 F6 开始调试
程序会在断点处暂停
按 Shift+F11 进入 factorial 函数
查看左侧面板的变量值（n 的值）
按 F5 继续执行

CMake 项目开发

项目结构

my_project/
├── CMakeLists.txt
├── src/
│   ├── main.cpp
│   └── utils.cpp
└── include/
    └── utils.h

CMakeLists.txt 示例

cmake_minimum_required(VERSION 3.10)
project(MyProject)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_BUILD_TYPE Debug)  # 包含调试信息

include_directories(include)

add_executable(my_app
    src/main.cpp
    src/utils.cpp
)

构建和运行

cd my_project
nvim src/main.cpp

操作	快捷键	执行的命令
构建	F7	`mkdir -p build && cd build && cmake .. && cmake --build .`
运行	F8	`./build/my_app`
调试	F6	调试 build 目录中的可执行文件

自动检测：

Neovim 检测到 CMakeLists.txt 自动使用 CMake
F7 会自动创建 build 目录并执行 CMake

Makefile 项目

Makefile 示例

CXX = clang++
CXXFLAGS = -std=c++17 -g -Wall

TARGET = my_program
SOURCES = main.cpp utils.cpp
OBJECTS = $(SOURCES:.cpp=.o)

$(TARGET): $(OBJECTS)
	$(CXX) $(CXXFLAGS) -o $@ $^

%.o: %.cpp
	$(CXX) $(CXXFLAGS) -c $<

clean:
	rm -f $(OBJECTS) $(TARGET)

run: $(TARGET)
	./$(TARGET)

使用方式

操作	快捷键	执行的命令
构建	F7	`make`
运行	F8	`make run` 或 `./my_program`

常见 C++ 任务

生成编译数据库（compile_commands.json）

对于 CMake 项目：

cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=1 ..
ln -s build/compile_commands.json .

这会让 clangd 获得更准确的项目信息。

格式化代码

" 格式化当前文件
:lua vim.lsp.buf.format()

" 或使用快捷键
<leader>f

查看错误

" 打开诊断列表
<leader>q

" 在 quickfix 窗口中导航
:cn  " 下一个错误
:cp  " 上一个错误

Python 开发指南

解释器：python3

配置使用系统的 python3，自动检测虚拟环境。

单文件脚本

1. 创建脚本

nvim script.py

def greet(name):
    return f"Hello, {name}!"

if __name__ == "__main__":
    message = greet("World")
    print(message)

2. 运行和调试

操作	快捷键	等效命令
运行	F10	`python3 script.py`
调试	F6	启动 debugpy

F9 对 Python 的作用：

编译检查：python3 -m py_compile script.py

3. LSP 功能示例

import requests  # 自动补全 import 语句

def fetch_data(url: str) -> dict:  # 类型提示
    """获取 URL 数据"""  # 文档字符串
    response = requests.get(url)
    return response.json()

# 输入 fetch_data( 会显示函数签名
# 按 K 在函数名上显示文档
# 按 gd 跳转到定义

pyright 提供：

类型检查
自动导入
函数签名提示
重构支持

4. 调试示例

def calculate_sum(numbers):
    total = 0
    for num in numbers:  # ← 设置断点
        total += num
    return total

if __name__ == "__main__":
    result = calculate_sum([1, 2, 3, 4, 5])
    print(f"Sum: {result}")

调试步骤：

按 <leader>db 在循环行设置断点
按 F6 开始调试
在左侧面板查看 num 和 total 的值
按 Shift+F9 单步执行
在底部 REPL 中输入 num * 2 查看表达式

虚拟环境支持

使用 venv

# 创建虚拟环境
python3 -m venv myenv

# 激活虚拟环境
source myenv/bin/activate

# 在虚拟环境中打开 Neovim
nvim script.py

自动检测：

debugpy 会自动使用 $VIRTUAL_ENV/bin/python
LSP 会识别虚拟环境中的包

Python 项目（setup.py）

项目结构

my_package/
├── setup.py
├── requirements.txt
├── my_package/
│   ├── __init__.py
│   ├── main.py
│   └── utils.py
└── tests/
    └── test_utils.py

setup.py 示例

from setuptools import setup, find_packages

setup(
    name="my_package",
    version="0.1.0",
    packages=find_packages(),
    install_requires=[
        "requests",
        "numpy",
    ],
)

开发安装

# 以可编辑模式安装
pip install -e .

构建和运行

cd my_package
nvim my_package/main.py

操作	快捷键	执行的命令
构建	F7	`python3 setup.py build`
运行	F8	寻找 main.py 并执行

常见 Python 任务

安装依赖

pip install -r requirements.txt

类型检查

" pyright 会自动进行类型检查
" 查看类型错误
<leader>q

代码格式化

" 使用 pyright 格式化
<leader>f

Go 开发指南

注意：Go 支持需要先安装 Go 工具链

安装 Go 工具

# 安装 Go
sudo dnf install golang

# 安装 Delve 调试器
go install github.com/go-delve/delve/cmd/dlv@latest

# 添加到 PATH
echo 'export PATH="$HOME/go/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

# 安装 gopls（通过 Mason）
nvim +'MasonInstall gopls' +qall

单文件程序

1. 创建 Go 文件

nvim hello.go

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}

2. 运行和调试

操作	快捷键	等效命令
编译	F9	`go build -o hello hello.go`
运行	F10	`go run hello.go`
调试	F6	启动 delve

Go 模块项目

初始化项目

mkdir my_app
cd my_app
go mod init github.com/username/my_app

项目结构

my_app/
├── go.mod
├── go.sum
├── main.go
├── pkg/
│   └── utils/
│       └── helper.go
└── cmd/
    └── app/
        └── main.go

main.go 示例

package main

import (
    "fmt"
    "github.com/username/my_app/pkg/utils"
)

func main() {
    result := utils.Add(3, 4)
    fmt.Printf("Result: %d\n", result)
}

pkg/utils/helper.go

package utils

// Add 将两个整数相加
func Add(a, b int) int {
    return a + b
}

构建和运行

cd my_app
nvim main.go

操作	快捷键	执行的命令
构建	F7	`go build ./...`
运行	F8	`go run .`
调试	F6	使用 delve 调试

自动检测：

Neovim 检测到 go.mod 自动使用 Go modules

LSP 功能（gopls）

package main

import (
    "fmt"
    "strings"  // 自动导入补全
)

func processText(text string) string {
    // 输入 strings. 显示所有函数
    result := strings.ToUpper(text)
    return result
}

func main() {
    // 按 K 在函数名上显示文档
    output := processText("hello")
    fmt.Println(output)
}

gopls 提供：

自动导入管理
代码补全
重构支持（重命名、提取函数）
代码格式化（gofmt）

调试示例

package main

import "fmt"

func fibonacci(n int) int {
    if n <= 1 {
        return n  // ← 设置断点
    }
    return fibonacci(n-1) + fibonacci(n-2)
}

func main() {
    result := fibonacci(10)
    fmt.Printf("Fibonacci(10) = %d\n", result)
}

调试步骤：

按 <leader>db 设置断点
按 F6 开始调试
查看调用栈
查看 n 的值变化

Go 测试

测试文件（utils_test.go）

package utils

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Add(2, 3) = %d; want 5", result)
    }
}

运行测试

# 命令行运行
go test ./...

# 或在 Neovim 中
:AsyncRun go test ./...

调试测试

在 DAP 中选择 "Debug test" 配置，然后按 F6。

常见 Go 任务

添加依赖

go get github.com/gin-gonic/gin

更新依赖

go mod tidy

格式化代码

" gopls 会自动使用 gofmt 格式化
<leader>f

查看文档

" 在函数名上按 K
K

构建系统

自动检测优先级

Neovim 按以下优先级检测构建系统：

CMakeLists.txt → CMake
go.mod → Go modules
Makefile → Make
setup.py / pyproject.toml → Python
无构建系统 → 直接编译

检测机制

从当前文件目录开始，向上遍历：

/home/user/project/src/main.cpp
  ↓ 检查 /home/user/project/src/
  ↓ 检查 /home/user/project/
  ↓ 检查 /home/user/
  ↓ 检查 /home/
  ↓ 检查 /

找到第一个包含标记文件的目录作为项目根目录。

各构建系统的行为

CMake

操作	命令
F7	`cd <root> && mkdir -p build && cd build && cmake .. && cmake --build .`
F8	`cd <root>/build && ./<project_name>`

特点：

自动创建 build 目录
Out-of-source 构建
支持多配置（Debug/Release）

Makefile

操作	命令
F7	`cd <root> && make`
F8	`cd <root> && (make run \|\| ./<project_name>)`

特点：

首先尝试 make run
失败则直接运行可执行文件

Go modules

操作	命令
F7	`cd <root> && go build ./...`
F8	`cd <root> && go run .`

特点：

构建所有包
运行 main 包

Python

操作	命令
F7	`cd <root> && python3 -m pip install -e .`
F8	`cd <root> && python3 main.py`（查找 main.py/app.py）

特点：

以可编辑模式安装
自动查找主入口文件

回退行为（无构建系统）

当没有检测到构建系统时：

C/C++

F7：查找所有 .cpp/.c 文件并编译

clang++ -std=c++17 -g file1.cpp file2.cpp ... -o program

F8：运行 ./program
F9：编译当前文件
F10：运行当前文件的可执行文件

Go

提示需要 go mod init
F9：go build current_file.go
F10：go run current_file.go

Python

F7：无操作（显示提示）
F8：运行当前文件
F9：编译检查
F10：运行当前文件

安装和配置

系统要求

操作系统：Linux（Fedora/RHEL 系列）
Neovim：>= 0.9.0
网络：需要下载插件和 LSP 服务器

已安装的组件

✅ 已完成：

vim-plug：插件管理器（自动安装）
- 位置：~/.local/share/nvim/site/autoload/plug.vim
- 命令：:PlugInstall, :PlugUpdate, :PlugStatus
所有插件（通过 vim-plug 自动安装）：
- 12 个插件安装在 ~/.local/share/nvim/plugged/
- 包括：nvim-lspconfig, nvim-dap, mason.nvim 等
LSP 服务器（通过 Mason 自动安装）：
- clangd (C/C++)
- pyright (Python)
调试器：
- debugpy（Python 调试器）
- gdb/lldb（系统自带）
Neovim 配置文件

需要手动安装

⚠️ Go 相关（如需 Go 支持）：

# 1. 安装 Go
sudo dnf install golang

# 2. 安装 Delve 调试器
go install github.com/go-delve/delve/cmd/dlv@latest

# 3. 添加 Go 工具到 PATH
echo 'export PATH="$HOME/go/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

# 4. 安装 gopls
nvim +'MasonInstall gopls' +qall

# 5. 验证安装
go version
dlv version

可选组件

clang-tools-extra（系统 clangd）

sudo dnf install clang-tools-extra

如果 Mason 的 clangd 有问题，可以使用系统版本。

Node.js（某些 LSP 需要）

sudo dnf install nodejs npm

验证安装

检查 vim-plug

首先确认 vim-plug 已安装：

# 检查 vim-plug 文件是否存在
ls -lh ~/.local/share/nvim/site/autoload/plug.vim

# 应该显示：
# -rw-r--r-- 1 user user 83K ... plug.vim

在 Neovim 中：

:PlugStatus

应该显示所有插件已安装（Finished 或已加载状态）。

检查插件目录

# 查看已安装的插件
ls ~/.local/share/nvim/plugged/

# 应该看到 12 个目录：
# asyncrun.vim  catppuccin  mason-lspconfig.nvim  mason.nvim
# nvim  nvim-dap  nvim-dap-ui  nvim-dap-virtual-text
# nvim-lspconfig  nvim-nio  nvim-treesitter  plenary.nvim

检查 LSP 服务器

:Mason

应该看到：

✓ clangd
✓ pyright
✓ gopls（如果安装了 Go）

检查 LSP 状态

打开一个 C++ 文件：

:LspInfo

应该显示 clangd 正在运行。

测试调试器

C++：

echo 'int main() { return 0; }' > /tmp/test.cpp
nvim /tmp/test.cpp
# 按 F6，应该打开 DAP UI

Python：

echo 'print("test")' > /tmp/test.py
nvim /tmp/test.py
# 按 F6，应该启动 debugpy

更新配置

更新 vim-plug 本身

" 更新 vim-plug 插件管理器
:PlugUpgrade

或者手动更新：

curl -fLo ~/.local/share/nvim/site/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

更新插件

" 更新所有插件
:PlugUpdate

" 查看更新的变更
:PlugDiff

" 更新后查看状态
:PlugStatus

更新 LSP 服务器

:MasonUpdate

更新 Treesitter 解析器

:TSUpdate

故障排除

常见问题

0. vim-plug 未安装或损坏

症状：启动 Neovim 时提示 :PlugInstall 命令不存在

检查：

# 检查 vim-plug 是否存在
ls ~/.local/share/nvim/site/autoload/plug.vim

解决方案：

# 手动下载 vim-plug
curl -fLo ~/.local/share/nvim/site/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

# 重新启动 Neovim
nvim

# 安装所有插件
:PlugInstall

插件安装失败

症状：:PlugInstall 后某些插件显示错误

检查：

:PlugStatus

解决方案：

" 1. 清理失败的插件
:PlugClean

" 2. 重新安装
:PlugInstall

" 3. 如果特定插件仍然失败，手动删除并重试
" 退出 Neovim，然后：

# 删除特定插件目录
rm -rf ~/.local/share/nvim/plugged/nvim-lspconfig

# 重新启动 Neovim 并安装
nvim +'PlugInstall' +qall

1. LSP 不工作

症状：没有自动补全，gd 不起作用

检查：

:LspInfo

解决方案：

" 重启 LSP
:LspRestart

" 检查 Mason
:Mason

" 重新安装 LSP 服务器
:MasonUninstall clangd
:MasonInstall clangd

2. DAP UI 不打开

症状：按 F6 后没有调试界面

检查：

:DapShowLog

解决方案：

# 检查调试器是否安装
which gdb          # C/C++
python3 -m debugpy # Python
which dlv          # Go

# 重新安装 debugpy
python3 -m pip install --user --upgrade debugpy

3. F7/F8 没有反应

症状：按 F7/F8 后没有任何输出

检查：

" 打开 quickfix 窗口
:copen

" 检查 AsyncRun 是否运行
:AsyncStop

解决方案：

" 手动运行构建命令查看错误
:AsyncRun make

" 查看输出
:copen

4. 编译错误：找不到头文件

症状：clangd 报错找不到 #include 的文件

解决方案（CMake 项目）：

# 生成 compile_commands.json
cd build
cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=1 ..
ln -s build/compile_commands.json ../

解决方案（非 CMake）：
创建 .clangd 文件：

CompileFlags:
  Add: [-std=c++17, -I/path/to/include]

5. Go 相关功能不可用

症状：gopls 未运行，delve 调试失败

检查：

go version
which dlv
which gopls

解决方案：

# 重新安装 Go 工具
go install github.com/go-delve/delve/cmd/dlv@latest

# 在 Neovim 中重新安装 gopls
nvim +'MasonInstall gopls' +qall

# 检查 PATH
echo $PATH | grep go

6. Python 虚拟环境未识别

症状：导入的包显示未找到

解决方案：

# 激活虚拟环境后再启动 Neovim
source venv/bin/activate
nvim script.py

# 或在 Neovim 中重启 LSP
:LspRestart

调试配置问题

启用详细日志

编辑 init.lua：

-- 在文件开头添加
vim.lsp.set_log_level("debug")

查看日志：

tail -f ~/.local/state/nvim/lsp.log

重置配置

如果配置完全损坏：

# 恢复备份
cd ~/.config/nvim
cp init.lua.backup init.lua
rm -rf lua/

# 重启 Neovim
nvim

性能问题

LSP 太慢

-- 在 lua/lsp.lua 中调整
vim.g.lsp_diagnostics_enabled = false  -- 禁用实时诊断

Treesitter 太慢

" 禁用 Treesitter
:TSDisable highlight

高级技巧

多文件编辑

分屏

" 水平分屏
:split file2.cpp

" 垂直分屏
:vsplit file3.cpp

" 切换窗口
Ctrl+w h/j/k/l

" 关闭当前窗口
:q

标签页

" 新标签
:tabnew file.cpp

" 切换标签
gt  " 下一个
gT  " 上一个

" 关闭标签
:tabclose

项目级搜索

" 在项目中搜索
:grep -r "function_name" .

" 打开结果
:copen

" 跳转
:cn  " 下一个
:cp  " 上一个

自定义构建命令

在项目根目录创建 .nvim.lua：

-- 自定义 F7 行为
vim.keymap.set('n', '<F7>', function()
  vim.cmd('AsyncRun make debug')
end)

条件断点高级用法

" 在循环中设置条件断点
<leader>dB
" 输入：i == 5

" 只在 i 等于 5 时暂停

DAP 配置文件

在项目根目录创建 .nvim/launch.json（类似 VSCode）：

{
  "configurations": [
    {
      "name": "Debug with args",
      "type": "cppdbg",
      "request": "launch",
      "program": "${workspaceFolder}/build/my_app",
      "args": ["--verbose", "--config=debug"],
      "cwd": "${workspaceFolder}"
    }
  ]
}

LSP 代码操作示例

C++：添加缺失的 #include

std::vector<int> nums;  // ← 光标放在 vector 上

<leader>ca  " 选择 "Add #include <vector>"

Python：自动导入

requests.get(url)  # ← requests 未导入

<leader>ca  " 选择 "Import requests"

格式化配置

C++ (.clang-format)

项目根目录创建 .clang-format：

BasedOnStyle: Google
IndentWidth: 4
ColumnLimit: 100

Python (pyproject.toml)

[tool.black]
line-length = 100
target-version = ['py310']

工作区管理

保存会话

" 保存当前会话
:mksession! ~/.config/nvim/sessions/project.vim

" 恢复会话
nvim -S ~/.config/nvim/sessions/project.vim

快速修复（Quickfix）技巧

" 构建后快速修复错误
:AsyncRun make
:copen

" 在 quickfix 中
Enter  " 跳转到错误
:cn    " 下一个错误
:cp    " 上一个错误
:cc N  " 跳到第 N 个错误

" 关闭 quickfix
:cclose

代码片段（Snippets）

虽然本配置未包含片段插件，但可以使用：

LuaSnip + friendly-snippets
UltiSnips

添加到 lua/plugins.lua：

Plug 'L3MON4D3/LuaSnip'
Plug 'rafamadriz/friendly-snippets'

Telescope（可选增强）

添加模糊查找器：

-- 在 lua/plugins.lua 中
Plug 'nvim-telescope/telescope.nvim'

-- 快捷键
vim.keymap.set('n', '<leader>ff', '<cmd>Telescope find_files<cr>')
vim.keymap.set('n', '<leader>fg', '<cmd>Telescope live_grep<cr>')
vim.keymap.set('n', '<leader>fb', '<cmd>Telescope buffers<cr>')

快速参考卡片

插件管理（vim-plug）

:PlugInstall  → 安装插件
:PlugUpdate   → 更新插件
:PlugClean    → 清理未使用的插件
:PlugStatus   → 查看插件状态
:PlugUpgrade  → 更新 vim-plug 本身
:PlugDiff     → 查看更新变更

编译和运行

F9  → 编译当前文件
F10 → 运行当前文件
F7  → 构建整个项目
F8  → 运行项目程序

调试

F6          → 开始调试
F5          → 继续执行
Shift+F9    → 单步跳过
Shift+F11   → 单步进入
Shift+F12   → 单步跳出
<leader>db  → 切换断点

LSP

gd         → 跳转定义
K          → 显示文档
<leader>rn → 重命名
<leader>ca → 代码操作
<leader>f  → 格式化

文件导航

:e file.cpp    → 打开文件
:w             → 保存
:q             → 退出
:wq            → 保存并退出

获取帮助

Neovim 内置帮助

:help nvim-lsp
:help dap
:help lua

插件文档

:help lspconfig
:help mason
:help nvim-dap
:help asyncrun

检查健康状态

:checkhealth
:checkhealth lsp
:checkhealth mason

总结

这个 Neovim 配置提供了：

✅ 完整的 IDE 体验：代码补全、跳转、重构
✅ 强大的调试功能：可视化断点、变量查看、单步执行
✅ 智能构建系统：自动检测项目类型和构建工具
✅ 多语言支持：C/C++、Python、Go 一应俱全
✅ 简单易用：F6-F10 快捷键覆盖常用操作

从简单的脚本到复杂的项目，这个配置都能胜任！

配置版本：1.0.0
最后更新：2025-12-12
维护者：Claude + User

如有问题，请检查故障排除部分或参考插件官方文档。

posted @ 2025-12-12 15:29 游翔阅读(138) 评论(0) 收藏举报

刷新页面返回顶部

learncpp

neovim+cpp/c

Neovim 多语言开发环境使用手册

📖 目录

概述

核心特性

支持的语言

目录结构

配置文件位置

数据文件位置

系统工具位置

插件管理器：vim-plug

什么是 vim-plug？

自动安装

vim-plug 文件位置

插件安装目录

常用命令

首次启动流程

手动重新安装插件

添加新插件

安装的插件

LSP 相关 (语言服务器协议)

1. nvim-lspconfig

2. mason.nvim

3. mason-lspconfig.nvim

调试相关 (Debug Adapter Protocol)

4. nvim-dap

5. nvim-dap-ui

6. nvim-dap-virtual-text

7. nvim-nio

工具类插件

8. asyncrun.vim

9. nvim-treesitter

10. plenary.nvim

主题插件

11. catppuccin/nvim

配置模块说明

lua/plugins.lua - 插件定义

lua/settings.lua - 编辑器设置

lua/lsp.lua - LSP 配置

lua/dap/*.lua - 调试器配置

dap/init.lua

dap/cpp.lua

dap/python.lua

dap/go.lua

lua/build/*.lua - 构建系统

build/detect.lua

build/runners.lua

lua/keymaps.lua - 快捷键映射

快捷键速查

核心快捷键（F6-F10）

LSP 快捷键（代码智能）

DAP 调试快捷键

主要控制

断点管理

调试窗口

AsyncRun 快捷键

C/C++ 开发指南

编译器：clang/clang++

单文件开发

1. 创建并编辑文件

2. 编译和运行

3. LSP 功能

4. 调试示例

CMake 项目开发

项目结构

CMakeLists.txt 示例

构建和运行

Makefile 项目

Makefile 示例

使用方式

常见 C++ 任务

生成编译数据库（compile_commands.json）

格式化代码

查看错误

Python 开发指南

解释器：python3

单文件脚本

1. 创建脚本

2. 运行和调试