1

  • 不要在两个文件里各自维护一份变量副本
  • 要让它们“同步修改”，就把变量放到一个公共位置，其他文件只引用它

Python

  • 把变量放在一个单独文件里，比如 config.py
  • 其他文件用 import config 读取和修改
  • 修改的是同一个模块对象里的变量，所以能同步
# config.py
value = 10

# a.py
import config
config.value += 1

# b.py
import config
print(config.value)  # 11

注意：

  • from config import value 只是拷贝名字，不适合需要同步修改的场景
  • 推荐用 import config，然后通过 config.value 访问

C++

  • 把变量声明放在头文件里
  • 把变量定义放在一个 .cpp 文件里
  • 其他文件通过 extern 引用它
// config.h
#pragma once
extern int value;

// config.cpp
#include "config.h"
int value = 10;

// a.cpp
#include "config.h"
void f() {
    value += 1;
}

// b.cpp
#include "config.h"
#include <iostream>
void g() {
    std::cout << value << std::endl;
}

注意：

  • extern 只声明，不定义
  • 变量只能在一个 .cpp 里定义一次，否则会重复定义
  • 如果你想让多个文件共享并同步修改，这就是标准做法

补充

  • 如果变量是常量：Python 里也建议放公共模块，C++ 里可用 constexpr 或 const
  • 如果变量比较多：可以封装成一个 Config 类/结构体，再传引用或用单例
  • 如果你说的“当前文件下调用别的文件的变量”是想在笔记里加一句总结，可以写成：

Python 用 import module 共享模块变量，C++ 用 extern + 头文件声明、源文件定义来共享全局变量。要同步修改，就必须引用同一个变量源，而不是复制一份。

2

可以，分 C++ 和 Python 说：

1. C++ 多文件程序怎么编译 假设你有：

  • main.cpp
  • a.cpp
  • b.cpp
  • a.h
  • b.h

最常见的方式是把所有 .cpp 一起编译：

g++ main.cpp a.cpp b.cpp -o app

然后运行：

./app

如果你有头文件在别的目录，还要加包含路径：

g++ main.cpp a.cpp b.cpp -Iinclude -o app

如果你想分步编译，再链接，也可以：

g++ -c main.cpp
g++ -c a.cpp
g++ -c b.cpp
g++ main.o a.o b.o -o app

关键规则

  • .h 里放声明
  • .cpp 里放定义
  • 多个 .cpp 可以互相通过 #include "xxx.h" 共享接口
  • main.cpp 只负责入口，其他逻辑拆到别的文件

2. Python “多文件程序”怎么处理 Python 不需要“编译多个文件”，它是直接运行入口文件：

python main.py

如果 main.py 里要用别的文件的变量或函数：

# a.py
value = 10

# main.py
import a
print(a.value)

也就是说：

  • Python 是 import
  • C++ 是 #include + 编译多个 cpp

3. 最实用的总结

  • C++: g++ main.cpp other.cpp -o app
  • Python: python main.py，其他文件通过 import 引入

3

launch.json 放在项目根目录的 .vscode/launch.json，用于配置 VS Code 的“运行/调试”。

1. 基本结构

{
  "version": "0.2.0",
  "configurations": []
}

2. Python 配置 先装好 VS Code 的 Python 扩展，然后可以这样写：

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Python: 当前文件",
      "type": "python",
      "request": "launch",
      "program": "${file}",
      "console": "integratedTerminal"
    }
  ]
}

常用字段：

  • program: 要运行的文件
  • ${file}: 当前打开的文件
  • console: integratedTerminal 一般更方便输入
  • cwd: 工作目录，常设成 ${workspaceFolder}

比如：

"cwd": "${workspaceFolder}"

3. C++ 配置 C++ 一般分两步：

  • tasks.json 负责编译
  • launch.json 负责调试运行

一个常见的 launch.json 示例：

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "C++: 调试当前程序",
      "type": "cppdbg",
      "request": "launch",
      "program": "${workspaceFolder}/app",
      "args": [],
      "stopAtEntry": false,
      "cwd": "${workspaceFolder}",
      "externalConsole": false,
      "MIMode": "gdb",
      "preLaunchTask": "build"
    }
  ]
}

这里：

  • program: 你的可执行文件路径
  • cwd: 程序运行时的工作目录
  • preLaunchTask: 调试前先执行的编译任务名
  • MIMode: Linux/macOS 常用 gdb，Windows 视环境而定

4. 如果你要调试多文件 C++ 通常 launch.json 不直接写编译命令，而是配合 tasks.json：

launch.json 只负责运行：

{
  "name": "C++: 调试",
  "type": "cppdbg",
  "request": "launch",
  "program": "${workspaceFolder}/app",
  "cwd": "${workspaceFolder}",
  "preLaunchTask": "build"
}

tasks.json 负责编译：

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "build",
      "type": "shell",
      "command": "g++",
      "args": [
        "main.cpp",
        "a.cpp",
        "b.cpp",
        "-g",
        "-o",
        "app"
      ],
      "group": "build",
      "problemMatcher": []
    }
  ]
}

5. 常见变量

  • ${workspaceFolder}: 当前工作区根目录
  • ${file}: 当前文件
  • ${fileDirname}: 当前文件所在目录
  • ${fileBasenameNoExtension}: 当前文件名，不带扩展名

6. 最常用的结论

  • Python：launch.json 直接跑当前文件
  • C++：tasks.json 编译，launch.json 调试
  • 多文件程序：编译时把所有 .cpp 一起放进 g++ 命令里

4

C++ 里做“用文件测试标准输入/输出”的最常用方式是 freopen。

1. 直接把标准输入输出重定向到文件

#include <bits/stdc++.h>
using namespace std;

int main() {
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);

    int n;
    cin >> n;
    cout << n * 2 << '\n';
    return 0;
}

这样之后：

  • cin 会从 input.txt 读
  • cout 会写到 output.txt

适合算法题本地测试。

2. 常见写法：只在本地启用文件读写

提交到 OJ 时不能一直读文件，所以一般这样写：

#include <bits/stdc++.h>
using namespace std;

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif

    int n;
    cin >> n;
    cout << n * 2 << '\n';
    return 0;
}

意思是：

  • 本地调试时，用文件
  • 在线评测时，不启用 freopen

3. 如果你想直接读写普通文件 也可以用 ifstream / ofstream：

#include <bits/stdc++.h>
using namespace std;

int main() {
    ifstream fin("input.txt");
    ofstream fout("output.txt");

    int n;
    fin >> n;
    fout << n * 2 << '\n';
    return 0;
}

不过做算法题时，一般还是 freopen 更方便，因为代码里的 cin/cout 不用改。

4. 本地测试时常见流程

  • 准备 input.txt
  • 程序里加 freopen
  • 运行程序
  • 看 output.txt

5. 小建议

  • 输出后用 '\n'，别老用 endl，更快
  • 文件名最好和 .cpp 在同一目录，路径最省事
  • 调试完记得把 freopen 关掉，或者用 #ifndef ONLINE_JUDGE