C++ const 用法全面总结与深度解析

作者：oioihoii日期：2025/10/10

1. const 基础概念

const 关键字用于定义不可修改的常量，是C++中确保数据只读性和程序安全性的核心机制。它可以应用于变量、指针、函数参数、返回值、成员函数等多种场景，深刻影响代码的正确性和性能。

1.1 本质与编译期处理

const变量在编译时会被编译器严格检查，任何修改尝试都会导致编译错误。与C语言不同，C++中的const变量（尤其是全局const）通常不会分配内存，而是直接嵌入到指令中（类似#define），但在以下情况会分配内存：

  • 取const变量地址时
  • const变量为非整数类型（如double、字符串）
  • 使用extern声明的const变量

const与#define的关键区别：

特性const#define
类型检查有完整类型检查无类型检查，仅文本替换
作用域遵循块作用域规则从定义处到文件结束
内存分配通常不分配（除非取地址）不分配，仅预处理替换
调试支持可被调试器识别调试器中不可见

1.2 基本语法与初始化要求

1const int MAX_SIZE = 100;      // 正确：编译期常量，必须初始化
2const double PI;               // 错误：const变量必须初始化
3int x = 5;
4const int SIZE = x;            // 正确：C++11起支持运行时常量
5

注意：全局const变量默认具有内部链接（仅当前文件可见），如需多文件共享，需显式声明为extern const int MAX_SIZE = 100;

2. const 的各种用法深度解析

2.1 常量变量

功能详解：

  • const变量一旦初始化，其值在生命周期内不可修改
  • 局部const变量存储在栈区，全局const变量通常存储在只读数据段（.rodata）
  • 基本类型的const变量可用于数组大小（C++11起）

常见问题与坑点：

1const int x = 10;
2int* px = (int*)&x;  // 危险：通过强制类型转换绕过const检查
3*px = 20;            // 未定义行为！可能导致程序崩溃或异常结果
4
5// 正确用法示例
6const int BUFFER_SIZE = 256;
7char buffer[BUFFER_SIZE];  // 正确：编译期常量可用于数组大小
8

2.2 const 与指针

2.2.1 三种const指针类型对比

类型语法指针本身指向内容记忆口诀
指向常量的指针const int* ptr可修改不可修改左定值（const在*左，值不可变）
常量指针int* const ptr不可修改可修改右定向（const在*右，指针不可变）
指向常量的常量指针const int* const ptr不可修改不可修改左右定值定向

2.2.2 指针转换规则

1int a = 10, b = 20;
2const int* p1 = &a;  // 正确：非const -> const（安全转换）
3int* p2 = p1;        // 错误：const -> 非const（危险，需显式转换）
4int* p3 = const_cast<int*>(p1);  // 允许但危险
5
6int* const p4 = &a;
7p4 = &b;             // 错误：常量指针不可修改指向
8
9// 实际应用场景：函数参数保护
10void printData(const int* data, int size) {
11    // data[0] = 5;  // 错误：保护数据不被修改
12    for(int i=0; i<size; i++) cout << data[i];
13}
14

最佳实践：函数参数优先使用const T*而非T*，除非确实需要修改指针指向的数据

2.3 const 与函数参数

2.3.1 三种参数传递方式对比

传递方式语法适用场景优势
值传递void func(const int x)基本类型小数据调用者无需担心数据被修改
指针传递void func(const T* ptr)大对象，需传递nullptr避免拷贝，保护指向内容
引用传递void func(const T& ref)大对象，无需传递nullptr避免拷贝和指针语法，保护对象

2.3.2 const引用的特殊特性

const引用可以绑定到临时对象，并延长其生命周期：

1#include <string>
2
3std::string getString() { return "temporary string"; }
4
5void processString(const std::string& str) {
6    // str生命周期被延长至函数结束
7    std::cout << str.length();
8}
9
10int main() {
11    processString(getString());  // 正确：临时对象绑定到const引用
12    // std::string& str = getString();  // 错误：非const引用不能绑定临时对象
13    return 0;
14}
15

常见问题：

1void func(const int& x) {
2    // x = 5;  // 错误：不能修改const引用
3}
4
5int main() {
6    int a = 10;
7    const int& ref = a;
8    a = 20;
9    std::cout << ref;  // 输出20：const引用跟踪原变量变化
10    return 0;
11}
12

2.4 const 与函数返回值

2.4.1 返回const值的意义

1const int getValue() { return 10; }
2
3int main() {
4    getValue() = 20;  // 错误：不能修改返回的临时常量
5    const int x = getValue();  // 正确
6    return 0;
7}
8

对基本类型而言，返回const值意义不大，但对类类型可防止意外赋值：

1class BigNumber {
2public:
3    BigNumber operator+(const BigNumber& other) const;
4};
5
6BigNumber a, b, c;
7(a + b) = c;  // 如果返回非const，这行会意外通过编译！
8

2.4.2 返回常量指针/引用

功能详解：

  • 返回const指针/引用可防止外部修改内部数据
  • 常用于类的getter方法，提供只读访问
  • 避免返回内部临时对象的引用（悬空引用风险）

正确示例：

1class StringList {
2private:
3    std::vector<std::string> items;
4public:
5    // 返回const引用：避免拷贝，同时防止修改
6    const std::string& get(int index) const {
7        if (index >= 0 && index < items.size())
8            return items[index];
9        throw std::out_of_range("Index out of bounds");
10    }
11    
12    // 返回const指针：指向内部静态数据
13    const char* getDefaultString() const {
14        static const char* defaultStr = "default";
15        return defaultStr;  // 安全：静态变量生命周期长
16    }
17};
18

常见错误：

1const int& getTemporaryValue() {
2    int x = 10;
3    return x;  // 危险：返回局部变量引用，函数结束后变为悬空引用
4}
5

2.5 const 成员函数

2.5.1 功能与实现机制

const成员函数是C++常量正确性的核心机制，具有以下特性：

  • 不能修改非mutable成员变量
  • 不能调用非const成员函数
  • 可以被const对象和非const对象调用
  • 非const成员函数只能被非const对象调用

编译器实现原理： const成员函数的this指针类型为const Class* const，而非const成员函数为Class* const，因此在const成员函数中无法修改成员变量。

2.5.2 mutable关键字的正确使用

mutable关键字允许const成员函数修改特定成员变量，通常用于：

  • 缓存计算结果
  • 跟踪对象访问次数
  • 实现线程同步的互斥量
1class Cache {
2private:
3    mutable std::map<std::string, Data> cache;  // 缓存可在const函数中修改
4    mutable std::mutex mtx;                     // 互斥量可在const函数中锁定
5    mutable int accessCount = 0;                // 访问计数可修改
6    
7public:
8    const Data& get(const std::string& key) const {
9        std::lock_guard<std::mutex> lock(mtx);  // 正确：锁定mutable互斥量
10        accessCount++;                          // 正确：修改mutable成员
11        
12        auto it = cache.find(key);
13        if (it != cache.end()) {
14            return it->second;
15        }
16        
17        // 计算并缓存结果（修改mutable缓存）
18        Data result = computeData(key);
19        cache[key] = result;
20        return cache[key];
21    }
22    
23    int getAccessCount() const { return accessCount; }
24};
25

2.5.3 成员函数const重载

1class TextEditor {
2private:
3    std::string text;
4public:
5    // const版本：供const对象调用，返回const引用
6    const std::string& getText() const {
7        std::cout << "const getText() called\n";
8        return text;
9    }
10    
11    // 非const版本：供非const对象调用，返回非const引用
12    std::string& getText() {
13        std::cout << "non-const getText() called\n";
14        return text;
15    }
16};
17
18int main() {
19    TextEditor editor;
20    const TextEditor constEditor;
21    
22    editor.getText() = "new text";  // 正确：调用非const版本
23    // constEditor.getText() = "text";  // 错误：const版本返回const引用
24    
25    return 0;
26}
27

2.6 constexpr (C++11/14/17扩展)

2.6.1 constexpr与const的区别

特性constconstexpr (C++17)
计算时机通常运行时（除非编译期常量）强制编译期计算（可能退化为运行时）
初始化允许运行时初始化必须编译期可计算
函数能力无可编写编译期执行的复杂函数

2.6.2 constexpr的高级应用

1// constexpr函数（C++14起支持复杂逻辑）
2constexpr int factorial(int n) {
3    if (n <= 1) return 1;
4    return n * factorial(n - 1);  // C++14起支持递归
5}
6
7// constexpr变量（编译期计算）
8constexpr int FACT_5 = factorial(5);  // 编译期计算为120
9
10// constexpr构造函数与对象
11class Point {
12public:
13    constexpr Point(double x, double y) : x(x), y(y) {}
14    constexpr double distance() const { return x*x + y*y; }
15    
16private:
17    double x, y;
18};
19
20constexpr Point ORIGIN(0, 0);
21constexpr double ORIGIN_DISTANCE = ORIGIN.distance();  // 编译期计算
22
23// constexpr if (C++17)：编译期条件分支
24template<typename T>
25constexpr auto getValue(T t) {
26    if constexpr (std::is_integral_v<T>) {
27        return t * 2;  // 整数类型处理
28    } else {
29        return t + 2;  // 其他类型处理
30    }
31}
32

常见问题：

1// C++11中constexpr函数限制（单return语句）
2constexpr int sum(int a, int b) {
3    // if (a < 0) a = -a;  // C++11错误：constexpr函数不允许if语句
4    return a + b;
5}
6
7// 正确：C++14起支持完整控制流
8constexpr int absoluteSum(int a, int b) {
9    if (a < 0) a = -a;
10    if (b < 0) b = -b;
11    return a + b;
12}
13

3. const 正确性与最佳实践

3.1 完整的const正确性体系

const正确性指一套编程规范，确保：

  1. 不应修改的对象声明为const
  2. 不修改成员变量的成员函数声明为const
  3. 不修改参数的函数参数声明为const

const正确性的好处：

  • 编译期检测错误，提高程序可靠性
  • 明确接口意图，提高代码可读性
  • 允许编译器进行更多优化
  • 支持const对象的使用

3.2 实战最佳实践

3.2.1 参数传递策略

参数类型传递方式适用场景
基本类型（int, double等）值传递 int x小数据，无需修改
大型对象const引用 const BigObject& obj避免拷贝，无需修改
字符串const char* 或 const std::string&C风格或C++风格字符串
数组const T* arr + size 或 const std::array&原始数组或标准数组

3.2.2 成员函数设计原则

  • 三法则：对每个成员函数问三个问题
    1. 该函数是否修改对象状态？→ 非const
    2. 该函数是否不修改对象状态？→ const
    3. 该函数是否需要在const对象上调用且修改某些成员？→ const + mutable
1class DataProcessor {
2private:
3    std::vector<int> data;
4    mutable int processCount = 0;  // 跟踪处理次数（mutable合理使用）
5    
6public:
7    // 非const成员函数：修改对象状态
8    void loadData(const std::vector<int>& newData) {
9        data = newData;
10    }
11    
12    // const成员函数：不修改对象状态，可调用const对象
13    int getDataSize() const {
14        return data.size();
15    }
16    
17    // const成员函数：修改mutable成员
18    int process() const {
19        processCount++;  // 正确：mutable成员可修改
20        // data.push_back(0);  // 错误：不能修改非mutable成员
21        return computeResult(data);
22    }
23};
24

3.2.3 const与多线程安全

const对象在多线程环境中具有天然优势：

  • const对象状态不可变，无需额外同步机制
  • 只读操作天生线程安全
1// 线程安全的配置对象
2class Config {
3private:
4    std::unordered_map<std::string, std::string> settings;
5    
6public:
7    // 构造时初始化，之后不可修改
8    Config(const std::unordered_map<std::string, std::string>& initial) 
9        : settings(initial) {}
10    
11    // const成员函数：线程安全的读取操作
12    std::string getSetting(const std::string& key) const {
13        auto it = settings.find(key);
14        return (it != settings.end()) ? it->second : "";
15    }
16};
17
18// 多线程共享const对象（安全）
19const Config appConfig(loadConfigFile());
20
21void workerThread() {
22    std::string value = appConfig.getSetting("log_level");  // 安全读取
23}
24

4. 常见const错误与解决方案

错误类型代码示例解决方案
试图修改const变量const int x=5; x=10;移除修改操作或使用非const变量
非const引用绑定临时对象std::string& s = getString();使用const引用 const std::string& s = getString();
const成员函数调用非const成员函数void func() const { otherFunc(); }将otherFunc()声明为const或移除func()的const
返回局部对象的引用const std::string& getStr() { std::string s; return s; }返回值而非引用，或使用static变量
const_cast滥用const int x=5; const_cast<int&>(x)=10;重新设计避免修改const对象
constexpr函数包含非法操作constexpr int f() { return rand(); }确保constexpr函数仅包含编译期可计算操作

5. 高级应用与现代C++扩展

5.1 const与模板编程

1#include <type_traits>
2
3// 模板参数为const类型示例
4template<typename T>
5void process(T param) {
6    if constexpr (std::is_const_v<std::remove_reference_t<T>>) {
7        std::cout << "Processing const object\n";
8    } else {
9        std::cout << "Processing non-const object\n";
10    }
11}
12
13int main() {
14    const int x = 5;
15    int y = 10;
16    process(x);  // 输出"Processing const object"
17    process(y);  // 输出"Processing non-const object"
18    return 0;
19}
20

5.2 const与lambda表达式

1int main() {
2    int x = 10;
3    
4    // const lambda（C++17）：捕获的变量视为const
5    auto constLambda = [x]() mutable {
6        x = 20;  // 正确：mutable lambda可修改捕获变量
7        std::cout << x;
8    };
9    
10    const auto lambda = [x]() {
11        // x = 20;  // 错误：const lambda不能修改捕获变量
12        std::cout << x;
13    };
14    
15    return 0;
16}
17

5.3 STL中的const用法

1#include <vector>
2#include <string>
3
4int main() {
5    std::vector<std::string> fruits = {"apple", "banana", "cherry"};
6    
7    // const迭代器：不能修改指向元素
8    for (std::vector<std::string>::const_iterator it = fruits.begin(); 
9         it != fruits.end(); ++it) {
10        // *it = "orange";  // 错误：不能修改const迭代器指向元素
11        std::cout << *it << std::endl;
12    }
13    
14    // C++11起推荐使用cbegin()/cend()获取const迭代器
15    for (auto it = fruits.cbegin(); it != fruits.cend(); ++it) {
16        std::cout << *it << std::endl;
17    }
18    
19    return 0;
20}
21

6. 综合示例：const正确性完整实践

1#include <vector>
2#include <string>
3#include <mutex>
4#include <stdexcept>
5
6// 线程安全的学生成绩管理系统
7class StudentGradeManager {
8private:
9    struct Student {
10        std::string name;
11        std::vector<int> grades;
12        mutable std::mutex mtx;  // 保护单个学生数据的互斥量
13        
14        // Student的const成员函数
15        double getAverage() const {
16            if (grades.empty()) return 0.0;
17            int sum = 0;
18            for (int grade : grades) sum += grade;
19            return static_cast<double>(sum) / grades.size();
20        }
21        
22        // Student的非const成员函数
23        void addGrade(int grade) {
24            if (grade < 0 || grade > 100) 
25                throw std::invalid_argument("Invalid grade");
26            grades.push_back(grade);
27        }
28    };
29    
30    std::vector<Student> students;
31    mutable std::mutex globalMtx;  // 保护students容器的互斥量
32    
33public:
34    // 添加学生（非const成员函数）
35    void addStudent(const std::string& name) {
36        std::lock_guard<std::mutex> lock(globalMtx);
37        students.push_back({name, {}});
38    }
39    
40    // 添加成绩（非const操作）
41    void addGrade(int studentIndex, int grade) {
42        std::lock_guard<std::mutex> lock(globalMtx);
43        if (studentIndex < 0 || studentIndex >= students.size())
44            throw std::out_of_range("Student index out of range");
45            
46        std::lock_guard<std::mutex> studentLock(students[studentIndex].mtx);
47        students[studentIndex].addGrade(grade);
48    }
49    
50    // 获取平均分（const成员函数，线程安全）
51    double getStudentAverage(int studentIndex) const {
52        std::lock_guard<std::mutex> lock(globalMtx);
53        if (studentIndex < 0 || studentIndex >= students.size())
54            throw std::out_of_range("Student index out of range");
55            
56        std::lock_guard<std::mutex> studentLock(students[studentIndex].mtx);
57        return students[studentIndex].getAverage();
58    }
59    
60    // 获取学生数量（const成员函数）
61    size_t getStudentCount() const {
62        std::lock_guard<std::mutex> lock(globalMtx);
63        return students.size();
64    }
65    
66    // 获取学生姓名（const成员函数，返回const引用）
67    const std::string& getStudentName(int studentIndex) const {
68        std::lock_guard<std::mutex> lock(globalMtx);
69        if (studentIndex < 0 || studentIndex >= students.size())
70            throw std::out_of_range("Student index out of range");
71        return students[studentIndex].name;
72    }
73};
74
75// 使用const引用参数的分析函数
76void analyzeStudentPerformance(const StudentGradeManager& manager) {
77    // 只能调用manager的const成员函数
78    size_t count = manager.getStudentCount();
79    std::cout << "Analyzing " << count << " students:\n";
80    
81    for (size_t i = 0; i < count; ++i) {
82        std::cout << manager.getStudentName(i) << ": " 
83                  << manager.getStudentAverage(i) << "\n";
84    }
85}
86
87int main() {
88    try {
89        StudentGradeManager manager;
90        manager.addStudent("Alice");
91        manager.addStudent("Bob");
92        
93        manager.addGrade(0, 95);
94        manager.addGrade(0, 88);
95        manager.addGrade(1, 76);
96        manager.addGrade(1, 92);
97        
98        analyzeStudentPerformance(manager);
99        
100        // const对象只能调用const成员函数
101        const StudentGradeManager& constManager = manager;
102        std::cout << "Const manager student count: " 
103                  << constManager.getStudentCount() << "\n";
104        // constManager.addStudent("Charlie");  // 错误：不能调用非const成员函数
105    } catch (const std::exception& e) {
106        std::cerr << "Error: " << e.what() << std::endl;
107        return 1;
108    }
109    return 0;
110}
111

7. 总结与思维导图

7.1 const用法全景图

1const
2├── 变量修饰
3│   ├── 基本类型常量
4│   ├── 自定义类型常量
5│   └── 全局/局部常量
6├── 指针修饰
7│   ├── 指向常量的指针 (const T*)
8│   ├── 常量指针 (T* const)
9│   └── 指向常量的常量指针 (const T* const)
10├── 引用修饰 (const T&)
11├── 函数相关
12│   ├── 参数修饰 (const T, const T*, const T&)
13│   ├── 返回值修饰 (const T, const T*, const T&)
14│   └── 成员函数修饰 (void func() const)
15├── 类相关
16│   ├── const成员变量
17│   ├── const成员函数
18│   ├── const对象
19│   └── mutable成员
20└── 现代扩展
21    ├── constexpr变量
22    ├── constexpr函数
23    ├── constexpr构造函数
24    └── constexpr if
25

7.2 关键知识点速查表

场景正确用法常见错误
函数参数不修改void func(const T& param)void func(T param) 或 void func(T& param)
不修改成员变量的成员函数void func() const忘记添加const
保护返回的内部数据const T& get() const { return data; }返回非const引用或指针
编译期计算constexpr int x = 5*5;使用运行时才能确定的值初始化
多线程安全只读操作const T obj; 或 const T& ref;在多线程中修改共享对象

7.3 进阶学习路径

  1. 基础阶段：掌握const变量、const指针、const引用基本用法
  2. 中级阶段：理解const成员函数、const正确性、mutable关键字
  3. 高级阶段：掌握constexpr编译期计算、模板中的const用法
  4. 专家阶段：深入理解const与编译器优化、内存模型、线程安全的关系

通过系统化学习和实践const的各种用法，能够显著提高代码质量、安全性和性能，是成为C++高级程序员的必备技能。

《C++ const 用法全面总结与深度解析》 是转载文章，点击查看原文。

上一篇：我用亲身经历告诉你，为什么程序员千万别不把英语当回事

下一篇：老题新解|十进制转二进制

相关推荐

php artisan db:seed执行的时候遇到报错
快支棱起来2025/10/9

INFO Seeding database. Illuminate\Database\QueryException SQLSTATE[42S22]: Column not found: 1054 Unknown column 'email_verified_at' in 'field list' (Connection: mysql, SQL: insert into users (name, email, email_verified_at, password, remember_token,

apache POI 万字总结：满足你对报表一切幻想
大鱼七成饱2025/10/7

背景 国庆期间接了个兼职，处理机构的几张Excel报表。初次沟通，感觉挺简单，接入Easyexcel(FastExcel)，然后拼lamda表达式就跑出来了。不过毕竟工作了这些年，感觉没这么简单。后面找业务方详细聊了一次，将需求落到纸面上。逐行研究了下BRD，有点挠头，跑数加各种样式，兼容新老版本，老方案是不行了。综合对比，最终选了老牌的 Apache POI 实现，下面说下为啥选POI，还有POI怎么用，包含样式、公式、动态表头、安全防范、百万级数据导入导出等功能。 一、技术选型 如果实现该

【转载】前验光师如何通过聪明模仿而非蛮干构建月收入3.5万美元的SaaS应用
是魔丸啊2025/10/6

转载 大多数人都认为你需要在科技领域拥有突破性的想法才能成功。 Samuel Rondot的想法与众不同。他的整个行动手册建立在一个简单的规则上：不要重新发明轮子——只要让它变得1%更好。 这种心态帮助他辞去了验光师的工作，从零开始自学编程，并推出了三个现在每月收入3.5万美元的SaaS应用。 以下是他如何做到的。 从验光师到自学程序员 Samuel从未计划成为一名程序员。几年前，他在眼镜行业工作，完全没有编程经验。 什么改变了？他想重建一个自己正在使用的Instagram工具——这一次，完全靠

免费领源码-Spring boot的物流管理系统 |可做计算机毕设Java、Python、PHP、小程序APP、C#、爬虫大数据、单片机、文案
vx_dmxq2112025/10/5

目   录 摘  要 Abstract 1  前言 1.1 设计目的 1.2 设计思路 1.3 国内外研究现状 2  相关技术 2.1  Java语言 2.2 MySQL数据库 2.3 Spring Boot框架 2.4 B/S模式 3  系统分析 3.1  可行性分析 3.2  系统需求分析 3.2.1  功能性分析 3.2.2  非功能性需求分析 3.3  系统用例分析 3.3.1  注

第一章 机器学习基础理论：机器学习概述（一）
FPGA+护理+人工智能2025/10/3

第一章 机器学习基础理论：机器学习概述 文章目录 第一章 机器学习基础理论：机器学习概述具体的专栏内容请参考： 人工智能专栏一、目标二、重点与难点三、内容1. 机器学习概述2. 机器学习在精神病护理领域的应用 前面python的基础内容算是完成了，接下来将要进入机器学习部分了。 具体的专栏内容请参考： 人工智能专栏 一、目标 通过本章学习，能够： 理解机器学习的基本概念和发展历程 了解机器学习在精神病护理领域的应用现状与前

在 Trae 国际版中添加 Chrome Dev MCP Server（Windows 实战指南）
wuhanwhite2025/10/2

前言 最近在折腾 Trae 国际版这类 AI 编程工具的时候，我发现它虽然支持接入 MCP（Model Context Protocol），但是只接受通过 npx 或 uvx 启动的 stdio 模式。 与此同时，Chrome 端的 mcp-chrome 扩展确实很好用，可以让 AI 直接获取浏览器标签页、截图、修改网页样式，甚至做一些自动化操作。但它默认暴露的是 Streamable HTTP 接口，并不符合 Trae 的要求。 这篇文章记录一下我在 Windows 环境下的实践

设计模式——单例模式
舒克起飞了2025/10/2

单例模式是一种创建型设计模式，它可以确保一个类在整个程序运行过程中只有一个实例，并提供一个全局访问点以获取该实例。         单例模式的核心思想就是：控制对象的实例化，防止创建多个实例，从而节省资源并保证行为一致性。 关键点： 单例类：包含单例实例的类，通常将构造函数声明为私有；静态成员变量：用于存储单例实例的静态成员变量；获取实例方法：静态方法，用于获取单例实例；私有构造函数：防止外部直接实例化单例类；线程安全处理：确保在多线程环境下单例实例的创建是安全的。构造函数和析构函数是私有

Python 的内置函数 breakpoint
IMPYLH2025/10/2

Python 内建函数列表 > Python 的内置函数 breakpoint def breakpoint(): ''' 调用位置进入调试器 ''' Python 的内置函数 breakpoint() 是一个用于调试的便捷工具，它会在调用时自动触发调试器，让开发者能够暂停程序执行并检查当前状态。这个函数在 Python 3.7 及更高版本中引入，旨在简化调试过程，特别是在复杂程序中设置断点的场景。 基本用法: def calculate_sum(a, b):

Navicat导入Excel至瀚高数据库
瀚高PG实验室10/1/2025

解决方案：将Excel中没有数据行，执行删除操作。步骤五：将Excel分成若干部分导入，核实为数据库地址信息列字段长度设置小于实际数据长度。步骤三：导入显示成功，且显示行数与Excel行数一致。步骤四：导出数据与Excel进行比对，核实缺失数据。将缺失数据单独导入没有问题。解决客户使用Navicat导入Excel至瀚高数据库数据条数不一致问题。二、导入数据少于Excel数据行及Navicat导入结果显示行。步骤一：导入Excel，配置数据与Excel对应关系。一、导入数据多于Excel数据行。

在JavaScript / Node.js中，SQLite异步查询函数实现
Never_Satisfied9/30/2025

本文展示了一个Node.js中使用SQLite3的异步数据库查询实现。该方案通过Promise封装实现了参数化查询和异常处理，确保数据库连接始终安全关闭。核心功能包括：1）异步建立数据库连接；2）参数化SQL查询；3）使用try-finally保证连接关闭；4）完善的错误处理机制。实现特点包括Promise链式调用、async/await语法、连接关闭错误记录等。使用时需注意SQL参数匹配和错误捕获，该方案适用于需要安全访问SQLite数据库的Node.js应用场景。

上一篇：我用亲身经历告诉你，为什么程序员千万别不把英语当回事

下一篇：老题新解|十进制转二进制

首页编辑器站点地图

Copyright © 2025 聚合阅读

License: CC BY-SA 4.0