C++ 模板：泛型编程的核心利器

最新推荐文章于 2026-08-19 10:51:35 发布
原创 最新推荐文章于 2026-08-19 10:51:35 发布 · 1.5w 阅读 · 60 ·
本内容遵循CC 4.0 BY-SA版权协议
@星河耀银海
GEO检测
收录于
C++ 教程

当前文章被收录于：

C++ 教程
50 篇文章 8 人学习

兼顾 C++ 基础语法与进阶特性，从数据类型、类与对象、继承多态，到 STL 容器、智能指针、模板编程。结合算法竞赛真题与工程开发案例，拆解核心难点，帮你打通 “语法 - 算法 - 项目” 任督二脉，轻松掌握 C++ 开发技能。

订阅专栏 查看详情

C++ 模板：泛型编程的核心利器

在这里插入图片描述

💡 学习目标：掌握模板的基本语法与分类，理解函数模板和类模板的实现原理，能够利用模板实现通用化、可复用的代码，提升开发效率。
💡 学习重点：函数模板的定义与实例化、类模板的使用方法、模板特化的应用场景、模板的编译机制与注意事项。

一、模板的概念与核心价值

✅ 结论：模板是 C++ 泛型编程的基础，通过参数化类型的方式，让函数或类能够独立于具体数据类型工作，实现代码的高度复用。

1.1 泛型编程的思想

泛型编程的核心是**“参数化类型”**，简单来说就是将数据类型作为参数传递给函数或类。

  • 传统编程：一个函数只能处理一种数据类型，如 int 类型的交换函数只能交换整数。
  • 泛型编程：通过模板定义通用函数，可处理 int、float、string 等任意类型的数据。

1.2 模板的核心优势

  1. 代码复用：一份模板代码可适配多种数据类型，避免重复编写相似功能的代码。
  2. 类型安全：编译阶段进行类型检查，避免隐式类型转换带来的错误。
  3. 高效灵活：模板实例化发生在编译期，不会带来运行时性能开销。

⚠️ 注意事项：模板不是函数或类，而是生成函数或类的蓝图，只有在被调用或实例化时，编译器才会生成具体类型的代码。

二、函数模板：通用函数的实现

💡 函数模板是能够处理多种数据类型的通用函数定义，使用关键字 template 声明，通过类型参数 typename 或 class 定义类型占位符。

2.1 函数模板的语法格式

template <typename T>  // 模板参数列表，T 是类型参数
返回值类型 函数名(参数列表) {
    // 函数体：使用 T 作为数据类型
}
  • template：声明模板的关键字，必须放在函数定义最前面。
  • typename：用于定义类型参数的关键字，也可以用 class 替代，二者作用完全相同。
  • T：类型参数的占位符，可以是任意合法标识符，通常用 T、U、V 等表示。

2.2 函数模板的基础案例：通用交换函数

传统写法需要为每种类型写一个交换函数，模板写法只需一份代码：

#include <iostream>
#include <string>
using namespace std;

// 函数模板：通用交换函数
template <typename T>
void swapData(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    // 实例化 int 类型的交换函数
    int x = 10, y = 20;
    swapData(x, y);
    cout << "int 交换后：x = " << x << ", y = " << y << endl;

    // 实例化 float 类型的交换函数
    float f1 = 3.14f, f2 = 6.28f;
    swapData(f1, f2);
    cout << "float 交换后：f1 = " << f1 << ", f2 = " << f2 << endl;

    // 实例化 string 类型的交换函数
    string s1 = "Hello", s2 = "C++";
    swapData(s1, s2);
    cout << "string 交换后：s1 = " << s1 << ", s2 = " << s2 << endl;

    return 0;
}
2.2.1 运行结果
int 交换后：x = 20, y = 10
float 交换后：f1 = 6.28, f2 = 3.14
string 交换后：s1 = C++, s2 = Hello
2.2.2 核心原理：模板实例化

当调用 swapData(x, y) 时，编译器会自动推导类型参数 T 为 int，并生成 int 版本的函数：

void swapData(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

这个过程称为模板的隐式实例化，编译器会根据传入的实参类型自动推导 T 的类型。

2.3 函数模板的显式实例化

当编译器无法自动推导类型参数时，需要手动指定类型，这就是显式实例化：

#include <iostream>
using namespace std;

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    // 隐式实例化：自动推导 T 为 int
    cout << add(10, 20) << endl;

    // 显式实例化：手动指定 T 为 double
    cout << add<double>(10, 20.5) << endl;

    return 0;
}
2.3.1 运行结果
30
30.5

2.4 函数模板的重载

函数模板可以和普通函数重载，也可以和其他模板重载，编译器会优先调用普通函数：

#include <iostream>
using namespace std;

// 函数模板
template <typename T>
T add(T a, T b) {
    cout << "模板函数调用：";
    return a + b;
}

// 普通函数
int add(int a, int b) {
    cout << "普通函数调用：";
    return a + b;
}

int main() {
    // 调用普通函数
    cout << add(10, 20) << endl;

    // 调用模板函数（显式实例化）
    cout << add<double>(10.5, 20.5) << endl;

    return 0;
}
2.4.1 运行结果
普通函数调用：30
模板函数调用：31

三、类模板：通用类的实现

💡 类模板是能够处理多种数据类型的通用类定义，语法与函数模板类似，适用于实现容器类（如数组、栈、队列）等通用数据结构。

3.1 类模板的语法格式

template <typename T>  // 模板参数列表
class 类名 {
public:
    // 成员变量和成员函数，可使用 T 作为类型
    T data;
    void setData(T value);
    T getData();
};

// 类模板的成员函数定义，必须在外部添加模板参数列表
template <typename T>
void 类名<T>::setData(T value) {
    this->data = value;
}

template <typename T>
T 类名<T>::getData() {
    return this->data;
}

⚠️ 注意事项：类模板的成员函数如果在类外定义，必须添加 template <typename T> 模板参数列表，并且类名要加上 <T>。

3.2 类模板的基础案例：通用栈

实现一个支持任意数据类型的栈结构：

#include <iostream>
#include <string>
using namespace std;

// 类模板：通用栈
template <typename T>
class Stack {
private:
    T* arr;        // 动态数组存储数据
    int topIndex;  // 栈顶索引
    int capacity;  // 栈的容量
public:
    // 构造函数
    Stack(int cap = 10) {
        capacity = cap;
        arr = new T[capacity];
        topIndex = -1;
    }

    // 析构函数
    ~Stack() {
        delete[] arr;
    }

    // 入栈操作
    void push(T value) {
        if (topIndex >= capacity - 1) {
            cout << "⚠️  栈满，无法入栈" << endl;
            return;
        }
        arr[++topIndex] = value;
        cout << "✅ 入栈成功：" << value << endl;
    }

    // 出栈操作
    T pop() {
        if (topIndex < 0) {
            cout << "⚠️  栈空，无法出栈" << endl;
            return T(); // 返回 T 类型的默认值
        }
        return arr[topIndex--];
    }

    // 判断栈是否为空
    bool isEmpty() {
        return topIndex == -1;
    }
};

int main() {
    // 实例化 int 类型的栈
    Stack<int> intStack;
    intStack.push(10);
    intStack.push(20);
    cout << "出栈：" << intStack.pop() << endl;

    // 实例化 string 类型的栈
    Stack<string> strStack;
    strStack.push("Hello");
    strStack.push("Template");
    cout << "出栈：" << strStack.pop() << endl;

    return 0;
}
3.2.1 运行结果
✅ 入栈成功：10
✅ 入栈成功：20
出栈：20
✅ 入栈成功：Hello
✅ 入栈成功：Template
出栈：Template

3.3 类模板的模板参数

类模板的模板参数可以是类型参数，也可以是非类型参数（如整数常量）：

#include <iostream>
using namespace std;

// 非类型参数 N：栈的固定容量
template <typename T, int N>
class FixedStack {
private:
    T arr[N];
    int topIndex;
public:
    FixedStack() : topIndex(-1) {}

    void push(T value) {
        if (topIndex >= N - 1) {
            cout << "⚠️  栈满" << endl;
            return;
        }
        arr[++topIndex] = value;
    }

    T pop() {
        if (topIndex < 0) {
            cout << "⚠️  栈空" << endl;
            return T();
        }
        return arr[topIndex--];
    }
};

int main() {
    // 实例化：T 为 int，N 为 5
    FixedStack<int, 5> stack;
    stack.push(1);
    stack.push(2);
    cout << stack.pop() << endl;
    return 0;
}
3.3.1 运行结果
2

⚠️ 注意事项：类模板的非类型参数必须是编译期常量，不能是变量。

四、模板特化：处理特殊类型的需求

💡 模板特化是指为特定类型提供定制化的模板实现，分为全特化和偏特化两种，用于解决通用模板无法处理的特殊场景。

4.1 函数模板的全特化

当通用模板对某个类型不适用时，为该类型单独编写特化版本：

#include <iostream>
#include <cstring>
using namespace std;

// 通用函数模板
template <typename T>
int compare(T a, T b) {
    if (a > b) return 1;
    else if (a < b) return -1;
    else return 0;
}

// 函数模板全特化：处理 char* 类型的字符串比较
template <>
int compare<char*>(char* a, char* b) {
    return strcmp(a, b);
}

int main() {
    // 通用模板：int 类型比较
    cout << compare(10, 20) << endl;

    // 特化模板：char* 类型字符串比较
    char str1[] = "Hello";
    char str2[] = "World";
    cout << compare(str1, str2) << endl;

    return 0;
}
4.1.1 运行结果
-1
-15

4.2 类模板的全特化

为类模板的特定类型提供定制化实现：

#include <iostream>
using namespace std;

// 通用类模板
template <typename T>
class MyClass {
public:
    MyClass() {
        cout << "通用模板：T 为 " << typeid(T).name() << endl;
    }
};

// 类模板全特化：T 为 int 类型
template <>
class MyClass<int> {
public:
    MyClass() {
        cout << "全特化模板：T 为 int" << endl;
    }
};

int main() {
    MyClass<double> obj1; // 通用模板
    MyClass<int> obj2;    // 全特化模板
    return 0;
}
4.2.1 运行结果
通用模板：T 为 double
全特化模板：T 为 int

4.3 类模板的偏特化

偏特化是指对模板参数的部分特化，适用于模板有多个参数的场景：

#include <iostream>
using namespace std;

// 通用类模板：两个类型参数
template <typename T, typename U>
class MyPair {
public:
    MyPair() {
        cout << "通用模板：T = " << typeid(T).name() << ", U = " << typeid(U).name() << endl;
    }
};

// 偏特化1：第二个参数为 int
template <typename T>
class MyPair<T, int> {
public:
    MyPair() {
        cout << "偏特化模板1：T = " << typeid(T).name() << ", U = int" << endl;
    }
};

// 偏特化2：两个参数都是指针类型
template <typename T, typename U>
class MyPair<T*, U*> {
public:
    MyPair() {
        cout << "偏特化模板2：T* 和 U*" << endl;
    }
};

int main() {
    MyPair<double, string> p1; // 通用模板
    MyPair<double, int> p2;    // 偏特化1
    MyPair<int*, char*> p3;    // 偏特化2
    return 0;
}
4.3.1 运行结果
通用模板：T = double, U = string
偏特化模板1：T = double, U = int
偏特化模板2：T* 和 U*

五、模板的编译机制与注意事项

5.1 模板的编译机制

模板采用分离编译模式，编译过程分为两个阶段：

  1. 模板定义阶段：编译器只检查模板代码的语法错误，不检查类型相关的错误。
  2. 模板实例化阶段：编译器根据传入的类型参数，生成具体类型的代码，并检查类型相关的错误。

⚠️ 核心问题：模板的声明和实现通常需要放在同一个头文件中，否则会导致链接错误。

  • 原因：模板实例化需要看到完整的实现代码，若实现放在 .cpp 文件中，编译器在实例化时无法找到代码。
  • 解决方案：将类模板的声明和实现都写在 .h 头文件中。

5.2 模板的使用禁忌

  1. 避免滥用模板：模板会增加编译时间和可执行文件体积，简单功能无需使用模板。
  2. 模板参数不能是局部类型：不能用函数内的局部类作为模板参数。
  3. 特化模板必须与原模板参数匹配：特化版本的模板参数数量和类型必须与原模板一致。

六、实战案例：模板实现通用数组排序

💡 需求：设计一个通用的排序函数，利用模板实现对任意类型数组的排序，支持整数、浮点数、字符串等类型。

6.1 需求分析

  1. 使用函数模板定义排序函数，支持任意数据类型。
  2. 采用冒泡排序算法，核心逻辑与数据类型无关。
  3. 支持自定义比较规则，实现升序和降序排序。

6.2 完整代码实现

#include <iostream>
#include <string>
using namespace std;

// 通用冒泡排序模板
template <typename T>
void bubbleSort(T arr[], int size, bool ascending = true) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            bool swapFlag = ascending ? (arr[j] > arr[j+1]) : (arr[j] < arr[j+1]);
            if (swapFlag) {
                T temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

// 打印数组模板
template <typename T>
void printArray(T arr[], int size) {
    for (int i = 0; i < size; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main() {
    // 测试 int 数组排序
    int intArr[] = {3, 1, 4, 1, 5, 9};
    int intSize = sizeof(intArr) / sizeof(int);
    cout << "int 数组排序前：";
    printArray(intArr, intSize);
    bubbleSort(intArr, intSize);
    cout << "int 数组升序排序后：";
    printArray(intArr, intSize);

    // 测试 string 数组排序
    string strArr[] = {"Banana", "Apple", "Cherry", "Date"};
    int strSize = sizeof(strArr) / sizeof(string);
    cout << "string 数组排序前：";
    printArray(strArr, strSize);
    bubbleSort(strArr, strSize, false);
    cout << "string 数组降序排序后：";
    printArray(strArr, strSize);

    return 0;
}

6.3 运行结果

int 数组排序前：3 1 4 1 5 9
int 数组升序排序后：1 1 3 4 5 9
string 数组排序前：Banana Apple Cherry Date
string 数组降序排序后：Date Cherry Banana Apple

七、本章总结

✅ 模板是 C++ 泛型编程的核心，通过参数化类型实现代码复用，分为函数模板和类模板两大类。
✅ 函数模板通过隐式或显式实例化生成具体类型的函数，支持重载和特化。
✅ 类模板适用于实现通用容器类，支持类型参数和非类型参数，可通过特化处理特殊类型。
✅ 模板特化分为全特化和偏特化，用于为特定类型提供定制化实现。
✅ 模板的声明和实现通常需要放在头文件中，避免链接错误。

标签
#c++ #java #开发语言
C++模板编程实战：从泛型思想到智能指针实现
weixin_34205826的博客
08-04 581
泛型编程是一种编程范式，其核心思想是编写与具体数据类型无关的通用代码，以此提升代码的复用性和可维护性。其原理在于通过类型参数化，让编译器在编译时根据实际使用的类型生成特化代码，从而实现编译时多态。这项技术的核心价值在于能够在保证类型安全的前提下，避免代码冗余，同时不引入运行时开销。它在构建通用库、数据结构和算法时尤为重要，例如C++标准模板库（STL）中的容器和算法就广泛依赖于此。在实际应用中，泛型编程是构建如智能指针等资源管理工具的基础。本文以C++模板为具体载体，深入探讨了函数模板、类模板以及变参模板的
C++模板编程：从泛型思想到实战应用，掌握编译期多态核心技术
weixin_28730131的博客
07-23 207
泛型编程是一种将算法与数据结构分离的编程范式，其核心在于编写不依赖于具体数据类型的可复用代码。C++通过模板技术实现编译时多态，编译器根据类型参数生成针对性的高效代码，实现了零开销抽象。这种参数化多态机制解决了传统宏或void*方案的类型安全问题，是构建高性能、类型安全库的基础。在工程实践中，模板广泛应用于STL容器与算法、编译期策略选择、序列化库等场景，通过特化、类型萃取、变参模板等进阶特性，开发者能够设计出高度灵活且性能优异的通用组件。本文以C++模板为核心，深入探讨其原理与实战应用，帮助读者掌握这一关
C++模板：泛型编程核心利器
q_438141的博客
03-26 352
特性函数模板类模板实例化方式自动类型推导显式指定类型特化支持全特化全特化 + 偏特化默认参数C++11 起支持C++11 起支持典型应用场景通用算法（如排序、交换）容器（如 vector、pair）通过模板实现的泛型编程，使C++在保持高性能的同时获得接近动态语言的灵活性，是现代C++开发的核心技能。
C++模板编程：从泛型思想到STL实战与元编程
07-14 318
泛型编程是一种将数据类型参数化的编程范式，其核心思想是编写与具体类型无关的通用代码，从而提升代码复用性和抽象能力。在C++中，模板是实现泛型编程的关键工具，它通过在编译期生成类型特定的代码，实现了零开销抽象。模板的技术价值在于能够构建高度灵活且高效的通用库，如STL（标准模板库），它通过容器、迭代器和算法的解耦设计，为数据结构和算法提供了统一的接口。在实际应用中，模板不仅用于实现通用容器（如vector、map）和算法（如sort、find），还支撑着现代C++的智能指针、类型萃取等高级特性。通过函数模板、
C++ 模板详解：泛型编程的利器与代价
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！✨
07-25 1177
优点 | 缺点 || 类型安全：编译期检查，消除 void* 和宏 | 编译时间长：每个实例化都是一次完整编译 || 代码复用：一套代码适用所有类型 | 代码膨胀：每种类型组合生成独立代码 || 运行时性能：零成本抽象，可深度内联 | 错误信息复杂：难以定位和理解 || 编译期计算：元编程，运行时零开销 | 必须头文件实现：增加编译依赖 || 泛型编程生态：STL 容器和算法 | 调试困难：断点和栈信息复杂 || 表达力强：支持变参、特化、CRTP | 学习曲线陡：模板语法复杂 |
C++ 泛型编程利器：模板机制
筏的博客
06-20 1403
通过模板，我们可以编写与类型无关的通用代码，在编译时根据具体类型生成相应的实现
【C++模版】泛型编程：代码复用的终极利器
2402_86350387的博客
01-27 1489
函数模板的定义需要使用template返回值类型 函数名(参数列表)// 函数体（与类型无关的通用逻辑）template声明模板的关键字，必须放在函数定义之前；typename定义模板参数的关键字，也可以用class替代（注意：不能用struct代替classT1、T2...Tn模板参数（类型占位符），表示 “待确定的类型”，在函数使用时会被具体类型替换。// 函数模板：通用交换函数这里的T就是模板参数，编译器会根据传入的实参类型，自动将T替换为intdoublechar。
模板进阶：从非类型参数到分离编译，吃透 C++ 泛型编程的核心逻辑
会当凌绝顶，一览众山小
10-27 1861
刚开始学 C++ 模板时，总觉得 “写个template <class T>就能搞定所有场景”—— 直到遇到 “想固定数组大小却只能用宏定义”“比较指针时总是比地址而非内容”“模板分离编译报一堆链接错误” 这些问题，才发现自己对模板的理解只停留在 “入门” 阶段。 其实 STL 能成为 C++ 的 “利器”，背后全靠模板进阶特性支撑。这篇博客就从非类型模板参数“模板特化”“模板分离编译” 三个维度，用 “问题 + 代码 + 解析” 的方式帮你打通模板进阶的关键链路。
探索C++模版奥秘（Template）：从泛型编程到编译期的魔法优化（初阶）
月亮永悬不落，剑指巅峰
05-26 4289
当其他语言还在依赖运行时动态分发时，C++程序员早已手握一把"编译期利器"——模板。它不仅是代码复用的银弹，更是打开元编程世界的密钥。想象一下：让类型自己推导逻辑，让计算在编译时完成，让泛型代码拥有接近硬编码的性能。这并非科幻，而是C++模板的日常！
泛型编程基石：C++ 模板从入门到熟练
say_fall的博客
01-12 850
本文介绍了C++模板编程的核心概念，重点讲解了函数模板和类模板的使用方法。函数模板通过泛型编程实现代码复用，支持隐式和显式实例化，解决了不同类型数据需要重复编写相同逻辑的问题。类模板则通过模板参数定义通用类结构，使用时需显式指定类型参数进行实例化。文章还分析了模板函数与非模板函数的匹配原则，以及模板参数的使用规范，帮助开发者理解如何利用模板提升C++代码的通用性和复用性。
【C++篇】C++模板初阶：从泛型编程到函数模板与类模板的全面解析
Surplus886的博客
04-10 1020
在C++编程中，重复编写功能相同但类型不同的代码既低效又容易出错。例如，实现一个通用的交换函数时，若为每种类型都重载一次，代码将臃肿且难以维护。C++模板技术应运而生，它通过“泛型编程”的思想，允许开发者定义类型无关的代码框架，由编译器自动生成具体类型的版本。本文将深入浅出地解析泛型编程的核心思想函数模板的原理与使用技巧，以及类模板的定义与实例化方法，帮助你掌握这一提升代码复用性与维护性的利器。返回值类型 函数名(参数列表){}
《 C++ 点滴漫谈： 三十四 》从重复到泛型，C++ 函数模板的封神之路
Lenyiin
04-22 2936
C++ 函数模板是泛型编程的基石，它让我们可以编写类型无关、可复用的高效代码。本文从基础语法出发，深入讲解了类型推导、重载机制、特化策略与编译原理，并结合现代 C++（如 auto、lambda、concepts）展示了模板在实际项目中的高级用法。通过实战案例与调试建议，帮助读者全面掌握函数模板的理论与实践，迈入泛型编程的核心领域。
C++中的利器——模板
zcxmjw的博客
03-06 2960
本文主要是讲解一下C++中的利器——模板，相信铁子们在学完这一节后，写代码会更加的得心应手，更加的顺畅。
C++ 泛型编程与完美转发：解锁代码复用与抽象的世界
2301_76564925的博客
05-07 1062
在 C++ 的编程领域中，泛型编程宛如一把神奇的钥匙，为开发者打开了代码复用和抽象的全新大门。它让我们能够编写更加通用、灵活且高效的代码，极大地提升了开发效率和代码质量。接下来，就让我们一同深入探索 C++ 泛型编程的奥秘。
【C++14变量模板特化深度解析】：掌握高效泛型编程的进阶利器
ByteGlow的博客
11-18 374
掌握C++14变量模板的特化技巧，提升泛型编程效率。详解其在类型特征检测、常量定义等场景的应用，结合实例解析全特化与偏特化的实现方法，显著增强代码可读性与复用性，进阶高效编程值得收藏。
C++模板编程：从基础到实战，掌握泛型编程核心
weixin_29230773的博客
07-25 334
泛型编程是现代编程语言中实现代码复用的核心技术，它允许开发者编写与具体类型无关的通用算法和数据结构。其核心原理是通过类型参数化，在编译时由编译器根据实际使用的类型自动生成特化代码，从而实现静态多态。这项技术的核心价值在于提供了强大的抽象能力，同时遵循“零成本抽象”原则，几乎不引入运行时开销。在工程实践中，泛型编程广泛应用于构建通用库、容器和算法，例如C++标准模板库（STL）中的vector、map等组件正是基于此技术。本文将深入解析C++模板的实现机制，涵盖函数模板、类模板、模板特化等关键概念，并通过实际
C++模板深度解析：从泛型编程到高级技巧
Wjxbk344的博客
03-14 637
优势代码复用率提升90%+类型安全强于宏定义STL等基础库的构建基石缺陷代码膨胀（多个实例化版本）编译时间增加约30%-50%错误信息晦涩难懂（例如50行错误提示）
C++函数与函数模板：代码复用与模块化编程的利器
今天比昨天更努力一点！
01-14 9919
本文介绍了C++函数与函数模板的核心概念，重点内容包括：1)函数定义与调用的基本结构；2)三种参数传递方式（值传递、引用传递、指针传递）及其应用场景；3)函数重载与默认参数的灵活使用方法；4)递归函数的实现原理与典型应用。通过具体代码示例，展示了如何利用函数实现代码复用和模块化编程，提升程序的可读性和维护性。掌握这些内容对开发高效、可扩展的C++程序至关重要。
从CVI（C）到Pyside（python）/Qt（C++）/VS（C#）的一点吐槽
最新发布
qq_15084199的博客
08-19 206
Tkinter 布局助手”，是我接触过的基于python原生的图形界面套件Tkinter来做GUI程序的最佳实践，链接是https://www.pytk.net/]，在web上就可以拖拽基础控件到面板，并定义控件的回调函数，完了存盘到本机。我曾经死抱着CVI不放，没有去追逐更现代的IDE，究其原因，主要是以前没有 AI 辅助编程，很多新 IDE 摸都不敢摸，随便一个编译报错或环境配错，就会卡死我半天。所以，遇到我这样，时不时输出一个学习心得的老工程师，也应该算是一种缘分了，很罕见的哦。
评论 49
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值