C++复习笔记--模板的使用

已于 2023-03-06 17:31:56 修改
阅读量386 收藏 1
点赞数
分类专栏： C++复习笔记 文章标签： c++ 算法 开发语言
于 2023-03-03 01:26:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43863869/article/details/129311981
版权
本文详细介绍了C++中的模板机制，包括函数模板的基本知识、代码实例、相关知识，以及类模板的语法、与函数模板的区别、成员函数创建时机、对象作为函数参数等方面。通过示例代码展示了模板如何提高代码复用性和泛型编程的能力。
摘要由CSDN通过智能技术生成

目录

1--基本概念

2--函数模板

2-1--基本知识

2-2--代码实例：

2-3--相关知识

3--类模板

3-1--类模板的语法

3-2--类模板和函数模板的区别

3-3--类模板中成员函数的创建时机

3-4--类模板对象作为函数参数

3-5--类模板与继承

3-6--类模板成员函数的类外实现

3-7--类模板分文件编写

3-8--类模板与友元

3-9--类模板实例

1--基本概念

        模板是C++泛型编程的重要支撑技术，C++提供两种模板机制：函数模板 和 类模板；

2--函数模板

2-1--基本知识

        函数模板的作用：建立一个 通用函数，其 函数返回值类型 和 形参类型 不需要进行具体指定，只需用一个 虚拟的类型 来表示；

        使用模板有两种方式：自动类型推导 和 显示指定类型；

        自动类型推导，必须推导出一致的数据类型T；        

        模板必须确定出 T 的数据类型，才可正常使用；

        模板的目的：提高复用性，将类型参数化；

        基本语法：

// 函数声明或定义
template<typename T>

// template --- 声明创建模板
// typename --- 表明其符号是一种数据类型，可以用 class 代替
// T --- 通用的数据类型，名称可以替换，通常为大写字母

2-2--代码实例：

        利用函数模板实现数值交换功能：

#include <iostream>

// 函数模板
template<typename T>
// 利用函数模板实现交换函数
void mySwap(T &a, T &b){
    T temp = a;
    a = b;
    b = temp;
}

int main(){
    int a = 10;
    int b = 20;
    std::cout << "before change: " << std::endl;
    std::cout << "a: " << a << " b: " << b << std::endl;
    mySwap(a, b); // 隐式指定模板类型
    std::cout << "After change: " << std::endl;
    std::cout << "a: " << a << " b: " << b << std::endl;

    double c = 10.0;
    double d = 20.0;
    std::cout << "before change: " << std::endl;
    std::cout << "c: " << c << " d: " << d << std::endl;
    mySwap<double>(c, d); // 显示指定模板类型
    std::cout << "After change: " << std::endl;
    std::cout << "c: " << c << " d: " << d << std::endl;

    return 0;
}

        从大到小排列数组：

#include <iostream>

//交换
template<typename T>
void mySwap(T &a, T &b){
    T temp = a;
    a = b;
    b = temp; 
}

// 排序算法
template<typename T>
void mySort(T arr[], int len){
    for(int i = 0; i < len; i++){
        int max = i;
        for(int j = i+1; j < len; j++){
            if(arr[max] < arr[j]){
                max = j;
            }
        }

        if (max != i){
            mySwap(arr[max], arr[i]);
    }
    }
}

//打印
template<typename T>
void printArray(T arr[], int len){
    for(int i = 0; i < len; i++){
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

int main(){
    char charArr[] = "bacdfe";
    int num1 = sizeof(charArr) / sizeof(char);
    mySort(charArr, num1);
    printArray(charArr, num1);

    int intArr[] = {6, 5, 2, 3, 1, 4};
    int num2 = sizeof(intArr) / sizeof(int);
    mySort(intArr, num2);
    printArray(intArr, num2);

    return 0;
}

2-3--相关知识

        ① 普通函数和函数模板的区别：

        A. 普通函数调用可以发生隐式类型转换；

        B. 函数模板使用自动类型推导时，不能发生隐式类型转换；

        C. 函数模板使用显式类型推导时，可以发生隐式类型转换；

#include <iostream>

// 普通函数
int myAdd01(int a, int b){
    return a + b;
}

// 函数模板
template<typename T>
T myAdd02(T a, T b){
    return a + b;
}

int main(){
    int a = 10;
    int b = 20;
    int c = 'c'; // 99
    std::cout << myAdd01(a, c) << std::endl; // 发生隐式类型转换
    // std::cout << myAdd02(a, c) << std::endl; // 不能发生隐式类型转换
    std::cout << myAdd02<int>(a, c) << std::endl; // 可以发生隐式类型转换
    return 0;
}

        ② 普通函数和函数模板的调用规则：

        A. 如果函数模板和普通函数都可以实现，优先调用普通函数；

        B. 可以通过空模板参数列表来强制调用函数模板；

        C. 函数模板可以发生重载；

        D. 如果函数模板可以产生更好的匹配，则会优先调用函数模板；

#include <iostream>

// 普通函数
void myPrint(int a, int b){
    std::cout << "Using normal function" << std::endl;
}

// 函数模板
template<typename T>
void myPrint(T a, T b){
    std::cout << "Using template function" << std::endl;
}

// 重载函数模板
template<typename T>
void myPrint(T a, T b, T c){
    std::cout << "Using overloaded template function" << std::endl;
}

int main(){
    int a = 10;
    int b = 20;

    myPrint(a, b); // 优先调用普通函数
    myPrint<>(a, b); // 使用空模板参数列表来强制调用函数模板
    myPrint(a, b, 100); // 调用重载的函数模板

    char c = 'c';
    char d = 'd';
    myPrint(c, d); // 因为普通函数需要发生隐式类型转换，而函数模板不需要，所以函数模板更适配，将调用函数模板
    return 0;
}

         ③ 模板的局限性：

        下面代码中，如果传入的 a 和 b 是数组类型或自定义数据类型，就无法正常运行；

        可以为特定情形的数据类型定义重载函数来解决上述问题；

template<typename T>
void f(T a, T b){
    a = b;
}
#include <iostream>

class Person{
public:
    Person(std::string name, int age){
        this->Name = name;
        this->Age = age;
    }

    std::string Name;
    int Age;
};

// 判断两数是否相等
template<typename T>
bool myCompare(T &a, T &b){
    if (a == b){
        return true;
    }
    else{
        return false;
    }
}

// 为类的比较重载一个新的函数
template<> bool myCompare(Person &p1, Person &p2){
    if(p1.Name == p2.Name && p1.Age == p2.Age){
        return true;
    }
    else{
        return false;
    }
}

void test01(){
    int a = 10;
    int b = 20;
    bool ret = myCompare(a, b);
    if(ret){
        std::cout << "a == b" << std::endl;
    }
    else{
        std::cout << "a != b" << std::endl;
    }
}

void test02(){
    Person p1("Tom", 18);
    Person p2("Tom", 18);
    bool ret = myCompare(p1, p2);
    if(ret){
        std::cout << "p1 == p2" << std::endl;
    }
    else{
        std::cout << "p1 != p2" << std::endl;
    }
}

int main(){
    test01();
    test02();
    return 0;
}

3--类模板

3-1--类模板的语法

        基本语法：

template<class Type1, class Type2>

        简单实例：

# include <iostream>
# include <string>

template<class NameType, class AgeType>
class Person{
public:
    Person(NameType name, AgeType age){
        this->Name = name;
        this->Age = age;
    }

    void show(){
        std::cout << "Name: " << Name << " Age: " << Age << std::endl;
    }
    NameType Name;
    AgeType Age;
};

int main(){

    Person<std::string, int> p1("ZhangSan", 18);
    p1.show();

    return 0;
}

3-2--类模板和函数模板的区别

        类模板和函数模板的区别：

① 类模板不能使用自动类型推导；

② 类模板在模板参数列表中可以有默认参数；

        简单实例：

# include <iostream>
# include <string>

template<class NameType, class AgeType = int> // 使用默认参数
class Person{
public:
    Person(NameType name, AgeType age){
        this->Name = name;
        this->Age = age;
    }

    void show(){
        std::cout << "Name: " << Name << " Age: " << Age << std::endl;
    }
    NameType Name;
    AgeType Age;
};

int main(){

    // Person p1("ZhangSan", 18); // 错误使用，不能进行自动类型推导；
    Person<std::string> p1("ZhangSan", 18); // 使用了默认类型 AgeType = int
    p1.show();

    return 0;
}

3-3--类模板中成员函数的创建时机

在普通类中，其成员函数在最初就被创建；

在类模板中，其成员函数只有在被调用时才会创建；

3-4--类模板对象作为函数参数

        三种传递方式：

① 指定传入的类型：直接显示对象的数据类型；（最常用）

② 参数模板化： 将对象中的参数变为模板进行传递；

③ 整个类模板化：将对象进行模板化后再传递；

# include <iostream>
# include <string>

template<class T1, class T2>
class Person{
public:
    Person(T1 name, T2 age){
        this -> Name = name;
        this -> Age = age;
    }
    void show(){
        std::cout << "Name: " << Name << " Age: " << Age << std::endl;
    }
    T1 Name;
    T2 Age;
};

// 类模板对象 作为函数参数
void printPerson1(Person<std::string, int> &p){
    p.show();
}

// 参数模板化
template<class T1, class T2>
void printPerson2(Person<T1, T2> &p){
    p.show();
    std::cout << "T1.Type: " << typeid(T1).name() << std::endl;
    std::cout << "T2.Type: " << typeid(T2).name() << std::endl;
}

// 整个类模板化
template<class T>
void printPerson3(T &p){
    p.show();
    std::cout << "T.Type: " << typeid(T).name() << std::endl;
}

int main(){

    Person<std::string, int>p1("Zhangsan", 18); // 实例化对象

    // 类模板对象p1 作为函数参数
    printPerson1(p1);
    // 参数模板化
    printPerson2(p1);
    // 整个类模板化
    printPerson3(p1);

    return 0;
}

3-5--类模板与继承

在类模板中，子类继承父类时，需要指定父类的模板类型；

# include <iostream>
# include <string>

template<class T>
class Base{
    T m;
};

// 需要明确指定父类的模板类型，才能正常继承
class Son1: public Base<int>{ 

};

// 将子类设为类模板，可以不明确指定父类的模板类型
template<class T1, class T2>
class Son2: public Base<T1>{ // T1指定父类T的类型，T2是子类特有的类型模板
    T2 obj;
};

int main(){

    return 0;
}

3-6--类模板成员函数的类外实现

        类模板成员函数的类外实现时，需要加上模板参数列表：

# include <iostream>
# include <string>

template<class T1, class T2>
class Person{
public:
    Person(T1 name, T2 age);
    void showPerson();
    T1 Name;
    T2 Age;
};

// 构造函数的类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){
    this -> Name = name;
    this -> Age = age;
}

// 成员函数的类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson(){
    std::cout << "Name: " << Name << " Age: " << Age << std::endl;
}

int main(){

    Person<std::string, int> p1("Zhangsan", 18);
    p1.showPerson();
    return 0;
}

3-7--类模板分文件编写

        将头文件和 cpp 文件写在一起，后缀名为 .hpp

        代码实例：

// person.hpp

#pragma once
#include <iostream>

template<class T1, class T2>
class Person{
public:
    Person(T1 name, T2 age);
    void showPerson();
    T1 Name;
    T2 Age;
};

// 构造函数的分文件实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){
    this -> Name = name;
    this -> Age = age;
}

// 成员函数的分文件实现
template<class T1, class T2>
void Person<T1, T2>::showPerson(){
    std::cout << "Name: " << Name << " Age: " << Age << std::endl;
}
// Test.cpp

# include <iostream>
# include <string>
# include <person.hpp>

int main(){

    Person<std::string, int> p1("Zhangsan", 18);
    p1.showPerson();
    return 0;
}
# CMakeLists.txt

cmake_minimum_required(VERSION 3.0)

project(Test)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")

set(CMAKE_BUILD_TYPE Debug)

include_directories(include)

add_executable(test Test.cpp include/person.hpp)

3-8--类模板与友元

        类内和类外实现友元函数：

# include <iostream>
# include <string>

// 全局函数 类外实现 (要让编译器提前知道，所以放在最上面)
template<class T1, class T2>
class Person;

template<class T1, class T2>
void printPerson(Person<T1, T2> p){
    std::cout << "Name: " << p.Name << " Age: " << p.Age << std::endl;
}

template<class T1, class T2>
class Person{

// 全局函数 类内实现
// friend void printPerson(Person<T1, T2> p){
//     std::cout << "Name: " << p.Name << " Age: " << p.Age << std::endl;
// }

// 全局函数 类外实现
friend void printPerson<>(Person<T1, T2> p);

public:
    Person(T1 name, T2 age){
        this -> Name = name;
        this -> Age = age;
    }

private:
    T1 Name;
    T2 Age;
};

int main(){

    Person<std::string, int> p1("Zhangsan", 18);
    printPerson(p1);
    return 0;
}

3-9--类模板实例

        利用模板实现自定义通用的数组类，实现的需求如下：

① 可以对内置数据类型以及自定义数据类型的数据进行存储；

② 将数组中的数据存储到堆区；

③ 构造函数中可以传入数组的容量；

④ 提供对应的拷贝构造函数以及 operator= 防止浅拷贝问题；

⑤ 提供尾插法和尾删法对数组中的数据进行增加和删除；

⑥ 可以通过下标的方式访问数组中的元素；

⑦ 可以获取数组中当前元素个数和数组的容量；

        代码：

// MyArray.hpp
#pragma once
#include <iostream>

template<class T>
class MyArray{

public:
    // 有参构造
    MyArray(int capacity){
        std::cout << "有参构造调用" << std::endl;
        this->m_Capacity = capacity;
        this->m_Size = 0;
        this->pAddress = new T[this->m_Capacity];
    }

    // 拷贝构造
    MyArray(const MyArray& arr){
        std::cout << "拷贝构造调用" << std::endl;
        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;
        // 深拷贝
        this -> pAddress =  new T[arr.m_Capacity];
        for(int i = 0; i < this-> m_Size; i++){
            this->pAddress[i] = arr.pAddress[i];
        }
    }

    // 防止浅拷贝
    MyArray& operator=(const MyArray& arr){
        std::cout << "operator=调用" << std::endl;
        if(this->pAddress != NULL){
            delete[] this->pAddress;
            this->pAddress = NULL;
            this->m_Capacity = 0;
            this->m_Size = 0;
        }

        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;
        this->pAddress = new T[arr.m_Capacity];
        for(int i = 0; i < this->m_Size; i++){
            this->pAddress[i] = arr.pAddress[i];
        }
        return *this;
    }

    // 尾插法
    void Push_Back(const T& val){
        // 判断容量是否等于数组大小
        if(this->m_Capacity == this->m_Size){
            std::cout << "Error! The array is full!" << std::endl;
            return;
        }
        this->pAddress[this->m_Size] = val;
        this->m_Size++;
    }

    // 尾删法
    void Pop_Back(){
        if(this->m_Size == 0){
            std::cout << "Error! The array is empty!" << std::endl;
            return;
        }
        this->m_Size--;
    }
    
    // 重载，根据 index 输出数组值
    T& operator[](int index){
        return this->pAddress[index];
    }

    // 返回数组的容量
    int getCapacity(){
        return this->m_Capacity;
    }

    // 返回数组的大小
    int getSize(){
        return this->m_Size;
    }

    // 析构函数
    ~MyArray(){
        std::cout << "析构调用" << std::endl;
        if (this->pAddress != NULL){
            delete[] this->pAddress;
            this->pAddress = NULL;
        }
    }

private:
    T * pAddress; // 指针指向堆区开辟的真实数组
    int m_Capacity; // 数组容量
    int m_Size; // 数组大小
};

        test1：

# include <iostream>
# include <string>
# include "MyArray.hpp"

void printIntArray(MyArray <int>& arr){
    for(int i = 0; i < arr.getSize(); i++){
        std::cout << arr[i] << std::endl; // 调用operator[]
    }
}

class Person{
public:
    Person(){};
    Person(std::string name, int age){
        this -> Name = name;
        this -> Age = age;
    }

    std::string Name;
    int Age;
};

void printPersonArray(MyArray<Person>& arr){
    for(int i = 0; i < arr.getSize(); i++){
        std::cout << "Name: " << arr[i].Name << " Age: " << arr[i].Age << std::endl;
    }
}

int main(){
    test3();
    return 0;
}

         test2：

void test2(){
    MyArray<int>arr1(5); // 有参构造
    for(int i = 0; i < 5; i++){
        // 利用尾插法向数组中插入数据
        arr1.Push_Back(i);
    }
    std::cout << "Print arr1: " << std::endl;
    printIntArray(arr1);

    std::cout << "arr1.size: " << arr1.getSize() << std::endl;
    std::cout << "arr1.capacity: " << arr1.getCapacity() << std::endl;

    MyArray<int>arr2(arr1); // 拷贝构造
    std::cout << "Print arr2: " << std::endl;
    printIntArray(arr2);
    arr2.Pop_Back();
    std::cout << "arr2 调用尾删后: " << std::endl;
    std::cout << "arr2.size: " << arr2.getSize() << std::endl;
    std::cout << "arr2.capacity: " << arr2.getCapacity() << std::endl;
    std::cout << "Print arr2: " << std::endl;
    printIntArray(arr2);
}

        test3：

void test3(){
    MyArray<Person> arr(10);
    Person p1("Zhangsan", 18);
    Person p2("Lisi", 19);
    Person p3("Wangwu", 20);
    Person p4("Zhaoliu", 21);

    arr.Push_Back(p1);
    arr.Push_Back(p2);
    arr.Push_Back(p3);
    arr.Push_Back(p4);
    std::cout << "Print PersonArr: " << std::endl;
    printPersonArray(arr);

}

晓晓纳兰容若
关注
专栏目录
C++笔记--模板
ljt2724960661的博客
05-08 524
最近在复习C++的基础知识，这一节主要是模板，模板是自动生成新类型的一种机制，也是泛型编程的基础，模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。每个容器都有一个单一的定义，比如 向量，我们可以定义许多不同类型的向量，比如 vector <int> 或 vector <string>。 1 函数模板基本使用: 1.1 template<class/typename T> 告诉编译器1紧跟的代...
C++复习笔记--STL的常见遍历、查找和排序算法的使用
牵一只蜗牛去散步
03-27 925
for_each 常用于遍历容器，其基本用法如下： transform 用于将一个容器的元素搬运到另一个容器中，其函数原型如下： 代码实例： STL 提供的常用查找算法如下： find() 用于查找指定元素，找到则返回指定元素的迭代器，找不到则返回结束迭代器 end()；find() 的函数原型如下： 查找自定义类型元素时，需要重载自定义类型的 == 操作符，便于调用 find() 函数进行比较； f
C++复习笔记--STL的deque容器、stack容器和queue容器
牵一只蜗牛去散步
03-10 489
/ 重新指定容器的长度为 num，若容器变长，则以 elem 值填充新位置，如果容器变短，则末尾超出容器长度的元素将被删除；// 重新指定容器的长度为 num，若容器变长，则以默认值填充新位置。// 在pos位置插入[beg, end)区间的数据，无返回值；// 在pos位置插入一个elem元素的拷贝，返回新数据的位置。// 删除[beg, end)区间的数据，返回下一个数据的位置；// 将 [beg, end) 区间中的数据拷贝赋值给容器。// 构造函数将[beg, end]区间中的元素拷贝到容器。
C++复习笔记
yifengyiyufjq的博客
06-28 626
继承是一种面型对象编程的核心概念，他允许一个类（派生类/子类）获取另一个类（基类/父类）的全部成员变量和成员函数。友元关系不能被继承。基类定义static静态成员，则整个继承体系中只有一个这样的成员多态允许我们使用基类指针或引用来调用派生类的函数（举例：游戏中不同的角色使用同一类技能造成的不同的效果是一种多态）方法重写允许子类改变父类方法的行为。当子类对象调用一个方法时，如果该方法在子类中已经被重写，则执行子类的方法；否则，执行父类的方法。这种行为在运行时确定，因此被称为动态绑定或运行时多态。
C++复习笔记--STL的list容器、set容器、pair对组和map容器
牵一只蜗牛去散步
03-21 526
需要强调的是，map容器对 key 进行排序，所以在构建 pair 对时，需要将自定义数据类型Person 置于 key 的位置，即而不是，才能使用 Person 进行排序！// 重新指定容器的长度为 num，若容器变长则以 elem 值填充，若容器变短则多余的元素会被删除。// 查找 key 是否存在，存在返回该 key 的迭代器，否则返回set.end();// 查找键值为 key 的元素，若存在返回该元素的迭代器，否则返回set.end();
C++复习笔记--STL的基本概念和使用
牵一只蜗牛去散步
03-06 337
在STL中，容器和算法之间通过迭代器进行关联，STL主要基于模板类和模板函数进行实现；容器：包含各种数据结构，如 vector、list、deque、set、map 等，用于存放数据；容器用于存放数据，涵盖常用数据结构的实现，可分为序列式容器和关联式容器两种；STL分为六大组件：容器、算法、迭代器、仿函数、适配器和空间配置器；算法：包含各种常用的算法，如 sort、find、copy、for_each等；非质变算法：在运算过程中不会更改区间内元素的内容，例如查找、计数、遍历等；每个容器拥有其专属的迭代器；
C++学习笔记--概述
weixin_45284414的博客
04-10 1684
文章目录关键词一、C++概述1.C++简介2.C++起源3.C++标准3.C++为什么会成功二、C++程序1.简单的c++程序2.面向过程：程序=数据结构+算法3.面向对象：程序 = 对象 + 对象 + …复习关键词 关键词 预编译指令，包含指令，标准命名空间，插入运算符，面向对象三大特性 一、C++概述 1.C++简介 c++是对C的扩展，是c语言的超集。 C++以C语言为基础并能兼容C语言。 任何有效c程序都是有效的c++程序。 c++程序也可以使用已有的c程序库。 2.C++起源 c++和c语言一
C++语法复习笔记-8. c++编程思想-设计模数-泛型编程
xingzhes_的博客
02-01 168
【代码】C++语法复习笔记-8. c++编程思想-设计模数-泛型编程。
c++复习笔记
m0_62115261的博客
04-13 877
有时间再修改，整点二级标题啥的，先凑合看吧！
C++快速复习笔记.rar
05-07
这份"C++快速复习笔记"旨在帮助程序员迅速回顾和掌握C++的关键概念和技术。以下是对笔记内容的详细解读： 一、基础语法 C++的基础语法包括变量声明、数据类型（如int、char、float、double）、运算符（如算术运算符...
面向对象的程序设计-个人复习笔记
10-26
在C++编程语言中，面向对象编程是一种核心概念，它基于类和对象的概念，使得代码更加模块化和易于管理。...通过阅读和理解这些笔记，可以巩固对C++面向对象编程的理解，为解决实际问题打下坚实基础。
c++开发面试准备复习笔记.zip
01-20
这份"c++开发面试准备复习笔记.zip"包含了一系列的资源，旨在帮助程序员深入理解和熟练运用C++，以便在大厂的面试中脱颖而出。以下是根据描述和标签提炼出的一些关键知识点，以及可能在面试中遇到的问题和相关领域的...
2020年秋招C++岗面试复习笔记.zip
01-20
这份名为“2020年秋招C++岗面试复习笔记.zip”的压缩包文件，显然是一份专门为准备C++岗位面试而编纂的学习资料。它包含了大量的C++相关的面试题目和核心知识，旨在帮助应聘者顺利通过大厂的面试，提升专业技能。...
使用socket编程来实现一个简单的C/S模型（TCP协议）
最新发布
caiji0169的博客
10-02 1400
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 654
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 420
【代码】求n的阶乘的相反数（c语言）
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 393
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
静谧、淡雅
09-29 243
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
C++复习笔记：友元函数与数据结构解析
"C++及数据结构复习笔记，适合C++初学者快速复习和应届生笔试面试准备，涵盖C++基本知识和数据结构内容。" 在C++编程中，友元函数是一个重要的特性，它允许指定的函数或类能够访问另一个类的私有和保护成员。这种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值