C++ 类模板 (一)

【一天一篇CPP】类模板 1.有时对类而言,两个或多个类,其功能是相同的,仅仅是数据类型不同。 请看下面两个类: class Compare_int{ public: Compare_int( int a, int b) {x = a; y = b;} int max(){return (x>y)? x : y;} int min(){return (x<y)? x : y;} private: int 阅读详情

本章节主要记录针对C++类模板相关的编程技术知识,以方便随时回顾预览。如有涉及到其它问题,请随时联系进行处理。

一、概述

1.1 前因说明

继承(公有、私有或保护)和包含并不总是能够满足重用代码的需要。

举例,前面几节提到的Stack类设计只用于存储unsigned long值。也可以定义专门用于存储double值或string对象的Stack类,但是除了存储的对象类型不同之外,这两种Stack类的代码是相同的。

针对重用代码的方式,Stack类示例代码中使用typedef处理这种需求,然而这种方法有两个缺点:

  • 1、 首先,每次修改类型时都需要编辑头文件
  • 2、 其次,在每个程序中只能使用这种技术生成一种栈,即不能让typedef同时代表两种不同的类型,比方不能在同一个程序中同时定义int栈和string栈。
1.2 解决方式

针对上述代码相同,但存储类型不同的情况,与其编写新的类声明,不如编写一个 泛型(即独立于类型的)栈,然后将 具体的类型作为参数传递给这个类。这样就可以使用通用的代码生成存储不同类型值的栈。

1.3 类模板简述

C++的类模板为生成通用的类声明提供了一种更好的方法。

模板提供 参数化(parameterized)类型,即能够将类型名作为参数传递给接收方来建立类或函数。例如,将类型名int传递给Queue模板,可以让编译器构造一个对int进行排队的Queue类。

二、定义类模板

2.1 Stack类非模板类示例代码

以下示例代码是Stack类原来的示例代码,后面的将会在Stack类的基础上来建立模板。如下所示:

typedef unsigned long Item;

class Stack
{
private:
    /* constant specific to class */
    // 类特定常量
    enum { MAX = 10 };
    /* holds stack items*/
    Item items[MAX];
    /* index for top stack item */
    int top;
public:
    Stack();
    bool isempty() const;
    bool isfull() const;
    // push() returns false if stack already is full, true otherwise
    // add item to stack
    bool push(const Item& item);
    // pop() returns false if stack already is empty, true otherwise
    // pop top into item
    bool pop(Item& item);
};
2.2 类模板声明规则

同模板函数一样,模板类采用下面的代码开头,模板开头方式说明:

// 旧方式
// 1、这里使用class并不意味着Type必须是一个类
// 2、而只是表明Type是一个通用的类型说明符,在使用模板时,将使用实际的类型替换它
template <class Type>
// 新方式
// 3、较新的C++实现允许使用不太容易混淆的关键字typename代替class
template <typename Type>
  • 1、 关键字template告诉编译器,将要定义一个模板。
  • 2、 尖括号中的内容相当于函数的参数列表.
  • 3、 可以把关键字class或关键字typename看作是变量的类型名,可以把Type看做是变量的名称,Type变量接受类型作为其值。
  • 4、 可以使用个人定义的泛型名代替Type,其命名规则与其它标识符相同。当前流行的选项包括T和Type。
2.3 类模板声明说明

(1) 当模板被调用时,Type将被具体的类型值(如int或string)取代。

(2) 在模板定义中,可以使用泛型名来标识要存储在栈中的类型。对于Stack类来说,这意味着应将声明中所有的typedef标识符Item替换为Type。如下示例代码:

Item items[MAX];
// 更改为
Type items[MAX];

(3) 在模板类定义中,同样可以使用模板成员函数替换原有类的类方法。每个模板成员函数头都将以相同的模板声明打头,也将类限定符从Stack::改为Stack::,如下所示:

template <typename Type>
bool Stack<Type>::push(const Type& item)
{
    
}

(4) 如果在类声明中定义了方法(内联定义),则可以省略模板前缀和类限定符

2.4 类模板之Stack类

下面是Stack模板类,具体如下所示:

template <typename T>
class Stack
{
private:
    enum {
        MAX = 10,
    };
    T items[MAX];
    int top;

public:
    Stack();
    bool isempty();
    bool isfull();
    bool push(const T& item);
    bool pop(T& item);
};

template <typename T>
Stack<T>::Stack()
{
    top = 0;
}

template <typename T>
bool Stack<T>::isempty()
{
    return top == 0;
}

template <typename T>
bool Stack<T>::isfull()
{
    return top == MAX;
}

template <typename T>
bool Stack<T>::push(const T& item)
{
    if (top < MAX) {
        items[top++] = item;
        return true;
    } else {
        return false;
    }
}

template <typename T>
bool Stack<T>::pop(T &item)
{
    if (top > 0) {
        item = items[--top];
        return true;
    } else {
        return false;
    }
}
2.4.1 Stack模板类说明

(1) Stack类中列出了类模板和函数模板,明白这些模板不是类和成员函数定义至关重要。它们是C++编译器指令,说明了如何生成类和成员函数定义。

(2) 模板的具体实现:如用来处理string对象的栈类,被称为 实例化(instantiation) 或 具体化(specialization)

(3) 不能将模板成员函数放在独立的实现文件(源文件)中(注:C++标准中最开始支持export关键字,可以使得模板成员函数实现放在独立的实现文件中,但现在C++11之后不再使用这样的关键字,而是将export关键字用于其它用途)

(4) 由于模板不是函数,不能单独被编译,模板必须与特定的模板实例化请求一起使用。

(5) 简单的方法是:将所有模板信息放在一个头文件中,并在要使用这些模板的文件中包含该头文件。

2.4.2 模板类使用

(1) 仅在程序包含模板并不能生成模板类,而必须请求实例化。为此,需要声明一个类型为模板类的对象,方法是使用所需的具体类型替换泛型名。如下示例所示:

// 用于存储int类型对象
// 类声明Stack<Type>将使用int替换模板中所有的Type
Stack<int> kernels;

// 用于存储string类型对象
// 类声明Stack<Type>将使用string替换模板中所有的Type
Stack<string> colonels;

(2) 看到(1)小节的实例声明后,编译器将按照Stack模板来生成两个独立的类声明和两组独立的类方法。

(3) 类声明Stack将使用int或string替换模板中所有的Type,使用的算法必须与类型一致。比如,Stack类假设可以将一个对象赋值给另一个对象,这种假设对于基本类型、结构体和类来说是成立的(除非将赋值运算符设置成私有的),这种假设对于数组则不成立。

(4) 泛型标识符: 例如这里的T,称为类型参数(type parameter),这意味着它们类似于变量,但是赋值给它们的不能是数值,而只能是类型。如Stack Kernels中,类型参数T的值为int。

注意:

必须显式的提供所需的类型,这与常规的函数模板是不同的,因为编译器可以根据函数的参数类型来确定要生成哪种函数。

以下示例代码是对Stack类模板的使用:

#incluce <iostream>
#include <string>
#include <cctype>

int main() 
{
    Stack<std::string> st;
    char ch;
    std::string po;
    std::cout << "Please enter A to add a purchase order,\n"
              << "p to process a PO, or Q to quit.\n";

    // std::toupper(int c): 
    //     描述:把小写字母转换为大写字母
    //     返回:如果参数有相对应的大写字母,则该函数返回参数的大写字母,否则保持不变。返回值是一个可被隐式转换为 char 类型的 int 值。          
    while (std::cin >> ch && std::toupper(ch) != 'Q') {
        while (std::cin.get() != '\n')
            continue;

        // std::isalpha(int c): 
        //     描述:检查字符是否是字母
        //     返回:如果参数是字符,它返回一个不等于零的值;否则,返回0.
        if (!std::isalpha(ch)) {
            std::cout << '\a';
            continue;
        }

        switch (ch) {
            case 'A':
            case 'a': {
                std::cout << "Enter a PO number to add: ";
                std::cin >> po;
                if (st.isfull()) {
                    std::cout << "stack already full\n";
                } else {
                    st.push(po);
                }
            }
                break;
            case 'P':
            case 'p': {
                if (st.isempty()) {
                    std::cout << "stack already empty\n";
                } else {
                    st.pop(po);
                    std::cout << "PO #" << po << " popped\n";
                }
            }
                break;
        }

        std::cout << "Please enter A to add a purchase order,\n"
                  << "p to process a PO, or Q to quit.\n";
    }

    return 0;
}

三、深入探究类模板

3.1 指针栈

问题: 可以将内置类型或自定义类型用作类模板Stack类型。那指针可以吗?

答案: 是可以创建指针栈,但如果不对前面声明的Stack类模板做重大修改,则将无法正常工作。

3.1.1 不正确地使用指针栈

简述前面声明的Stack类模板不适用指针栈的原因,将通过3个修改后可以使用指针栈的简单示例(是有缺陷的)说明:

示例1:

将Stack类模板使用示例中的std::string po替换为char* po

Stack<std::string> st;
char ch;
std::string po;
std::cout << "Please enter A to add a purchase order,\n"
    << "p to process a PO, or Q to quit.\n";

// std::string po替换为char* po
char* po;

不正确处说明:

<1>: 此处仅仅声明了指针,但是没有申请用于保存输入字符串的内存空间

<2>: 程序将通过编译,但是程序运行时在cin试图将输入保存在某些不合适的内存单元中时崩溃。

示例2:

Stack<std::string> st;
char ch;
std::string po;
std::cout << "Please enter A to add a purchase order,\n"
    << "p to process a PO, or Q to quit.\n";

// std::string po替换为char* po
char po[50];

不正确处说明:

<1>: 此处为输入的字符创分配了空间。po的类型为char*,也可以被放在栈中。但是数组完全与Stack类模板的pop()函数设计冲突。

template <typename T>
bool Stack<T>::pop(T &item)
{
    if (top > 0) {
        item = items[--top];
        return true;
    } else {
        return false;
    }
}

<2>: 在pop函数实现中,引用变量item必须引用某种类型的左值,而不是数组名。

<3>: 原设计代码假设可以给item赋值。但是替换成char数组后,该假设赋值方式就错误了,因为不能为数组名赋值。

示例3:

Stack<std::string> st;
char ch;
std::string po;
std::cout << "Please enter A to add a purchase order,\n"
    << "p to process a PO, or Q to quit.\n";

// std::string po替换为char* po
char* po = new char[50];

不正确处说明:

<1>: 此方式虽然为po申请了内存空间,但是只有一个po变量,该变量总是指向相同的内存单元。

<2>: 当读取新字符串时,内存的内容都将发生变化,但是每次执行压入操作时,加入到栈中的地址都相同。

<3>: 当对栈执行弹出操作时,得到的地址总是相同的,它总是指向读入的最后一个字符创。

3.1.2正确使用指针栈

使用指针栈的方法之一: 让程序提供一个指针数组,其中每个指针都指向不同的字符串。

需要注意之处:

<1>: 创建不同指针是调用程序的职责,而不是栈的职责。栈的任务是管理指针,而不是创建指针。

// 说明1:
// 1、本StackDynamic类模板设计栈大小可变,在内部使用动态数组。设计方式是构造函数中接受一个设定数组大小的默认参数

template<typename T>
class StackDynamic {
private:
    enum {
        SIZE = 10,
    };
    int stacksize;
    T *items;
    int top;

public:
    explicit StackDynamic(int ss = SIZE);

    StackDynamic(const StackDynamic &sd);

    ~StackDynamic() {
        delete[] items;
    }

    bool isempty() {
        return top == 0;
    }

    bool isfull() {
        return top == stacksize;
    }

    bool push(const T &item);

    bool pop(T &item);

    // 说明2:
    // 1、将赋值运算符的返回类型声明为StackDynamic,而实际的模板函数定义中将返回类型声明为StackDynamic<T>
    // 2、StackDynamic是StackDynamic<T>的缩写,但只能在类中使用。
    // 3、可以在模板声明或模板函数定义内使用StackDynamic缩写。但是在类外,指定返回类型或使用作用域解析运算符时,必须使用完整的StackDynamic<T>
    
    StackDynamic &operator=(const StackDynamic &sd);
};

template<typename T>
StackDynamic<T>::StackDynamic(int ss)
        : stacksize(ss), top(0) {
    items = new T[stacksize];
}

template<typename T>
StackDynamic<T>::StackDynamic(const StackDynamic &sd) {
    stacksize = sd.stacksize;
    top = sd.top;
    items = new T[stacksize];
    for (int i = 0; i < stacksize; ++i) {
        items[i] = sd.items[i];
    }
}

template<typename T>
bool StackDynamic<T>::push(const T &item) {
    if (top < stacksize) {
        items[top++] = item;
        return true;
    } else {
        return false;
    }
}

template<typename T>
bool StackDynamic<T>::pop(T &item) {
    if (top > 0) {
        item = items[--top];
        return true;
    } else {
        return false;
    }
}

template<typename T>
StackDynamic<T> &StackDynamic<T>::operator=(const StackDynamic<T> &sd) {
    if (this == sd)
        return this;
    delete[] items;
    stacksize = sd.stacksize;
    top = sd.top;
    items = new T[stacksize];
    for (int i = 0; i < stacksize; ++i) {
        items[i] = sd.items[i];
    }

    return *this;
}

指针栈的使用示例:

#include <iostream>
#include <cstdlib>
#include <ctime>

const int NUM = 10;

int main
{
    std::srand(std::time(0));
    std::cout << "Please enter stack size: ";
    int stacksize;
    std::cin >> stacksize;

    // 根据输入的stacksize大小创建一个空的StackDynamic对象
    StackDynamic<const char*> sd(stacksize);

    // 输入
    // 指针数组被初始化为一组字符串常量
    const char* in[NUM] = {
            " 1: Hank Gilgamesh", " 2: Kiki Ishtar",
            " 3: Betty Rocker", " 4: Ian Flagranti",
            " 5: Wolfgang Kibble", " 6: Portia Koop",
            " 7: Joy Almondo", " 8: Xaverie Paprika",
            " 9: Juan Moore", " 10: Misha Mache"
    };

    // 输出
    const char* out[NUM];

    int processed = 0;
    int nextin = 0;
    while (processed < NUM) {
        if (sd.isempty()) {
            sd.push(in[nextin++]);
        } else if (sd.isfull()) {
            sd.pop(out[processed++]);
        } else if (std::rand() % 2 && nextin < NUM) {\
            // 使用rand()、srand()、time()来生成随机数,此处是随机生成0或1
            sd.push(in[nextin++]);
        } else {
            sd.pop(out[processed++]);
        }
    }

    for (int i = 0; i < NUM; ++i) {
        std::cout << out[i] << std::endl;
    }
}
3.2 数组模板示例和非类型参数

模板常用作容器类,这是因为类型参数的概念非常适用于将相同的存储方案用于不同的类型。下面将深入探究非类型(或表达式)参数,以及如何使用数组来处理继承族。

允许指定数组大小的简单数组模板的几种方法:

<1>: 在类中使用动态数组和构造函数参数来提供元素数目,3.1.2章节的StackDynamic类模板就是这种设计。

<2>: 使用模板参数来提供常规数组的大小,C++11新增的模板array就是这种方式。

以下是使用模板参数来设定数组大小的示例:

// 说明

<typename T, int n>
class ArrayTP {
private:
    T ar[n];

public:
    ArrayTP() {}

    explicit ArrayTP(const T &v);

    virtual T &operator[](int i);

    virtual T operator[](int i) const;
};

template<typename T, int n>
ArrayTP<T, n>::ArrayTP(const T &v) {
    for (int i = 0; i < n; ++i) {
        ar[i] = v;
    }
}

template<typename T, int n>
T &ArrayTP<T, n>::operator[](int i) {
    if (i < 0 || i >= n) {
        std::cerr << "Error in array limits: "
                  << i
                  << " is out of range.\n";
        std::exit(EXIT_FAILURE);
    }

    return ar[i];
}

template<typename T, int n>
T ArrayTP<T, n>::operator[](int i) const {
    if (i < 0 || i >= n) {
        std::cerr << "Error in array limits: "
                  << i
                  << " is out of range.\n";
        std::exit(EXIT_FAILURE);
    }

    return ar[i];
}

程序说明:

<1>: 类模板开头的<typename T, int n>,typename指出T为类型参数;int指出n为int类型参数,这种参数(指定特殊的类型而不是用作泛型名)称为非类型(non-type)或表达式(expression)参数。

<2>: 根据使用示例说明,如下所示,并对这行代码进行说明:

ArrayTP<double, 12> eggweights;
  • 编译器定义名为ArrayTP<double, 12>的类
  • 并创建一个类型为ArrayTP<double, 12>的eggweights对象
  • 定义类时,编译器将使用double替换T,使用12替换n

表达式参数限制:

<1>: 表达式参数可以是整型、枚举、引用或指针。因此,double m不合法,而double* pm是合法的。

<2>: 模板代码不能修改参数的值,也不能使用参数的地址。因此,不能在ArrayTP中使用n++或&n等表达式。

<3>: 实例化模板时,用作表达式参数的值必须是常量表达式。

使用模板参数来提供常规数组的大小的优缺点:

优点:

<1>: 构造函数方法使用的是通过new和delete管理的堆内存,而表达式参数方法使用的是为自动变量维护的内存栈

<2>: 因此,表达式参数方法执行速度将更快,尤其是在使用了很多小型数组时。

缺点:

<1>: 每种数组大小都将生成自己的模板,如下示例:

// 将生成两个独立的类声明
ArrayTP<double, 12> eggweights;
ArrayTP<double, 13> donuts;

// 只生成一个类声明,并将数组大小信息传递给类的构造函数
StackDynamic<int> eggs(12);
StackDynamic<int> dunkers(13);

<2>: 构造函数方法更通用,这是因为数组大小是作为类成员(而不是硬编码)存储在定义中的。这样可以将一种尺寸的数组赋给另一种尺寸的数组,也可以创建允许数组大小可变的类。

3.3 模板多功能性

可以将用于常规类的技术用于模板类:

(1) 模板类可用作基类

(2) 模板类可用作组件类

(3) 模板类可用作其它模板的类型参数

如下示例所示:

template <typename T>
class Array
{
private:
	T entry;    
};

template <typename T>
class GrowArray : public Array<T>
{
    // do something
    ...
};

template <typename T>
class Stack
{
    Array<T> ar;
};

// 1、C++98要求使用至少一个空白字符将两个>符号分开
// 2、c++11不要求这样
Array< Stack<int> > asi;
3.3.1 递归使用模板

另一个模板多功能性的例子是:可以递归使用模板。如对于前面章节的数组模板定义,可如下示例应用:

// twodee是一个包含10个元素的数组,其中每个元素都是一个包含5个int元素的数组
ArrayTP< ArrayTP<int, 5>, 10 > twodee;
// 与此声明等价的常规数组声明
int twodee[10][5];

说明:

<1>: 在模板语法中,二维的顺序与等价的二维数组相反。下述示例代码详细展示

#include <iostream>

int main()
{
    // 创建sums一维数组,保存这10个组的总数
    ArrayTP<int, 10> sums;
    // 创建sums一维数组,保存这10个组的平均值
    ArrayTP<double, 10> aves;
    ArrayTP<ArrayTP<int, 5>, 10> twodee;

    int i, j;
    for (i = 0; i < 10; ++i) {
        sums[i] = 0;
        for (j = 0;j < 5;++j) {
            twodee[i][j] = (i + 1) * (j + 1);
            sums[i] += twodee[i][j];
        }
        aves[i] = (double)sums[i] / 10;
    }

    for (i = 0;i < 10;++i) {
        for (j = 0;j < 5;++j) {
            // 以两个字符的宽度显示下一个条目,假设整个数字的宽度不超过两个字符
            std::cout.width(2);
            std::cout << twodee[i][j] << ' ';
        }

        std::cout << ": sum = ";
        std::cout.width(3);
        std::cout << sums[i] << ", average = " << aves[i] << std::endl;
    }
    
    return 0;
}
3.3.2 使用多个类型参数

模板可以包含多个类型参数。例如想保存两种值,则可以创建并保存多个值的模板,比如标准模板库中提供的pair类模板。根据下面示例代码详细说明:

template<typename T1, typename T2>
class Pair {
private:
    T1 a;
    T2 b;

public:
    T1 &first();

    T2 &second();

    T1 first() const { return a; }

    T2 second() const { return b; }

    Pair(const T1 &aval, const T2 &bval) : a(aval), b(bval) {}

    Pair() {}
};

// 返回类型为引用,可通过赋值重新设置存储的值
template<typename T1, typename T2>
T1 &Pair<T1, T2>::first() {
    return a;
}

// 返回类型为引用,可通过赋值重新设置存储的值
template<typename T1, typename T2>
T2 &Pair<T1, T2>::second() {
    return b;
}


int main()
{
    Pair<std::string, int> ratings[4] =
    {
        Pair<std::string, int>("The Purpled Duck", 5),
        Pair<std::string, int>("Jaquie's Frisco A1 Fresco", 4),
        Pair<std::string, int>("Cafe Souffle", 5),
        Pair<std::string, int>("Bertie's Eats", 3)
    };

    int joints = sizeof(ratings) / sizeof(Pair<std::string, int >);
    std::cout << "Rating:\t Eatery\n";
    for (int i = 0; i < joints; ++i) {
        std::cout << ratings[i].second() << ":\t" << ratings[i].first() << std::endl;
    }
    std::cout << "Oops! Revised rating:\n";
    ratings[3].first() = "Bertie's Fab Eats";
    ratings[3].second() = 6;
    std::cout << ratings[3].second() << ":\t" << ratings[3].first() << std::endl;
}

示例代码说明:

<1>: main函数中,必须使用Pair<std::string, int>来调用构造函数,并将它作为sizeof的参数。这是因为类名是Pair<std::string, int>,而不是pair。

<2>: 另外说明下,Pair<char*, double>是另一个完全不同的类的名称。

3.3.3 默认类型模板参数

类模板另一项新特性是:可以为类型参数提供默认值,该默认类型设置为类。如下示例:

template <typename T1, typename T2 = int>
class Topo{
    // do something
    ...
};

示例代码说明:

<1>: 如果省略T2的值,编译器将使用int。如下示例所示:

// T1是double类型,T2是double类型
Topo<double, double> m1;
// T1是double类型,T2是int类型
Topo<double> m2;

<2>: 虽然可以为类模板类型参数提供默认值,但 不能为函数模板参数提供默认值。

<3>: 可以为非类型参数提供默认值,这对于类模板和函数模板都是适用的。

Unity集成阿里云语音AI:从麦克风录音到实时语音合成的全流程实现 本文详细介绍了在Unity中集成阿里云语音AI服务,实现从麦克风录音到实时语音合成的完整流程。通过调用阿里云的语音转文字和文字转语音接口,开发者可以快速为游戏或应用添加语音交互功能,提升用户体验。文章涵盖了环境配置、签名认证、音频处理及项目集成等核心步骤,并提供了实用的调试技巧。 阅读详情

相关推荐

基于Java+SpringBoot+Vue的中小企业设备管理系统的设计与开发(源码+lw+部署文档+讲解等)

💗博主介绍:✌新人博主,工作经验两年+、专注于Java、小程序技术领域和毕业项目实战✌💗🌟文末获取源码+数据库🌟

2301_76502068的博客 1385

一. c++ 中的类模板

C++ 除了支持函数模板,还支持类模板(Class Template)。 函数模板中定义的类型参数可以用在函数声明和函数定义中, 类模板中定义的类型参数可以用在类声明和类实现中。类模板的目的同样是将数据的类型参数化。 1.1 类模板的定义 声明类模板的语法为: template<typename 类型参数1 , typename 类型参数2 , …> class 类名{ //TODO: }; 类模板和函数模板都是以 template 开头(当然也可以使用 class,目前来.

chumingqian的博客 603

MaPLe: Multi-modal Prompt Learning

具体而言,我们在语言分支中附加可学习的上下文标记,并通过耦合函数显式地将视觉 Prompt 置于语言 Prompt 上,以建立它们之间的交互。使用 Prompt 来适应CLIP (语言或视觉) 的单个分支中的表示是次优的,因为它不允许在下游任务上动态调整两个表示空间的灵活性。由此,提出了一种分支感知的多模态 Prompt,通过在两种模态之间共享提示来协调 CLIP 的视觉和语言分支。在 Prompt Tuning 中,必须采取多模态方法获得同时适应 CLIP 的视觉和语言分支,以实现上下文优化的完整性。

weixin_48907099的博客 1055

C++类模板(一)

C++ 除了支持函数模板,还支持类模板(Class Template)。函数模板中定义的类型参数可以用在函数声明和函数定义中,类模板中定义的类型参数可以用在类声明和类实现中。类模板的目的同样是将数据的类型参数化。 声明类模板的语法为: template<typename 类型参数1 , typename 类型参数2 , …> class 类名{ //TODO: }; 类模板和函数模板都是以 template 开头(当然也可以使用 class,目前来讲它们没有任何区别),后跟类型参数;类

luoganttcc的博客 494

手把手教你用STM32H743+FreeRTOS+LWIP搭建物联网网关(附完整工程)

本文详细介绍了如何使用STM32H743微控制器结合FreeRTOS实时操作系统和LWIP协议栈构建高性能物联网网关。内容涵盖硬件配置、FreeRTOS任务设计、LWIP协议栈优化及物联网协议集成,提供完整工程示例,助力开发者快速实现稳定可靠的网络通信枢纽。

weixin_42623010的博客 503

《YOLOv8实例分割实战:训练自己的数据集 》(视频课程)

本课程将手把手地教大家使用labelme标注和使用YOLOv8训练自己的数据集,完成一个多目标实例分割实战项目。

bai666ai的博客 790

类模板函数的三种表达描述方式(具体实现)

第一种(所有的类模板函数写在类的内部)在上一篇博客 所有的类模板函数写在类的外部,在一个cpp中 #include <iostream> using namespace std; template <typename T> class A { public: A(T t = 0); T& getT(); A operator +(const A& other); void print(); private: T t; }; /* class

weifc-wei 的博客 970

Python抓取摄像头图像,进行AI识别(一)

本文介绍了如何用Python获取海康威视摄像头的图像并进行AI识别。主要内容包括:1)准备工作,包括摄像头IP设置和密码重置方法;2)使用Python的Requests库通过ISAPI接口获取实时图像;3)示例代码展示如何保存摄像头图像。整个过程为后续AI图像识别提供了基础,通过简单的Python代码即可实现专业监控设备的图像采集功能。

Hahafantuan的博客 1517

C++ 类模板“无法解析的外部符号”错误解决方案

C++使用类模板时,按照通用的.h文件与.cpp文件分开方式会报“无法解析的外部符号”错误,其根本原因在于编译器针对类模板不支持分离编译(利用VC助手产生函数实现时,也会自动加到.h文件而非.cpp文件)。 针对此问题,解决方案有: 将函数申明和实现全部写在.h文件中; 如果非要.h文件与.cpp文件分开,则可在使用类模板的文件中,同时包含类模板的.h文件和.cpp文件 #include "MyVector.h" #include "MyVector.cpp" ...

KOBO_24的博客 2844

LaTeX小白必看:TeX Live+TeXstudio保姆级安装教程(附清华镜像加速)

本文为LaTeX新手提供了一份详尽的TeX Live和TeXstudio安装指南。通过清华大学镜像站实现高速下载,并详细讲解了从下载、定制化安装到配置优化的每一步,帮助用户快速搭建稳定高效的本地LaTeX写作环境,轻松处理学术文档排版。

weixin_29214559的博客 415

从数字后端角度谈谈occ电路(一)

摘要:本文介绍了芯片测试中OCC(On-Chip Clock Control)电路的设计与应用。随着工艺进步,芯片制造面临Stuck-at、Bridging和Delay等故障类型,需要不同时钟频率进行测试。OCC电路通过Clock Selection、Clock Chopping Control和Clock Gating三个模块,实现ATE时钟与PLL时钟的切换控制,支持慢速时钟检测Stuck-at故障和快速时钟检测Delay故障。文章详细解析了OCC电路结构及各模块功能,包括同步单元、移位寄存器等关键组件

芯冰乐 587

C++ 类模板一(类模板的定义)

//类模版语法 #include<iostream> using namespace std; /* 类模板和函数模板深入理解 1.编译器并不是把函数模板处理成能处理任何类型的函数 2.编译器从函数模板通过具体类型产生不同的函数 3.编译器会对函数模板进行两次编译 4.在声明的地方对模板代码进行编译 5.在调用的地方对参数替换后的代码进行编译 对于类模板...

weixin_30949361的博客 98

智能体开发套件(ADK)介绍

city } ---") city_normalized = city . lower() . replace(" " , "") # 模拟天气数据库 mock_weather_db = {

lpfasd123的博客 1414

专题:一看就会的C++类模板讲解 (1)

一.类模板的作用 二.类模板的定义: 三.类模板的声明格式: 四.类模板对象 五.再举一个例子 一.类模板的作用 面向对象的程序设计编程实践中,我们可能会面临这样的问题:要实现比较两个数的大小。明明比较两个数的方法都一样,但是仅仅因为数据类型的不同,导致想要实现同一目标,我们就需要写好多个只有数据类型不同、其他内容都相同的类。这无疑是费时耗力、臃肿繁琐的。 在C++中,为了解决这样的问题,引入了类模板的概念。就像泥塑的胚子一样,每次注入石膏陶土,最后都会按照要

北邮22级信通一枚 936

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

使用类模板时出现LNK2019报错的解决方案

在程序中使用类模板时,会出现类似于: 错误 LNK2019 无法解析的外部符号 “public: __thiscall Bottle::Bottle(int)” (??0?$Bottle@H@@QAE@H@Z),该符号在函数 _main 中被引用 Project9bottle F:\projects\main.obj 1 这样的报错。 解决方案: 1.如果你的类模板分为.h和.cpp两个部分实现时,和普通类调用不同。在主函数main中,要包含.cpp文件而不是.h文件,即:#include “Bottle

qq_42499821的博客 768

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

C++中template的.h文件和.cpp文件的问题

在C++中,用到类模板时,如果类似一般的类声明定义一样,把类声明放在.h文件中,而具体的函数定义放在.cpp文件中的话,会发现编译器会报错。如类似下面代码: //test.h文件 #ifndef TEST_H_ #define TEST_H_ template <class T> class test { private: T a; public: ...

weixin_30480651的博客 467

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

【C++进阶笔记一】函数模板与类模板

【C++进阶】(1)函数模板的声明及使用一、函数模板 `template < class T>`1. 简单的函数模板示例2. 实现通用数据类型排序算法示例3. 能过空模板参数列表 强制调用模板函数4. 模板函数 也可 以实现函数重载 最近在搞FFmpeg 音视频开发,后面大量涉及音视频图形等界面开发(比如视频播放器), 利用C语言也可以实现 ,但相对麻烦,在这方面C++会方便很多,记得上一次学C++还是在大二的时候了, 刚好也算趁着这一次机会,把C++ 的知识全部重新捡起来巩固一遍, 也算逼自已

|~~~热爱生活、努力学习的小伙汁~~~| 2044

63. 类模板的分文件编写问题以及解决

类模板中的成员函数分文件编写.cpp。

Oracle/MySQL 到 国产信创数据库|迁移 · 调优 · 信创替换 394

C++中类模板分文件编写

需要解决的问题: 类模板中成员函数创建的时机是在调用阶段,导致分文件编写时会链接不到 解决方法: 直接包含.cpp源文件 将声明和实现写在同一个文件中,并更改后缀名为.hpp,hpp是约定的名称,并不是强制 .hpp文件 #pragma once #include <iostream> using namespace std; template<class T1, class T2> class Person { public: Person(T1 name, T2

m0_49694943的博客 472

C++提高编程一(函数模板、类模板)

普通类中的成员函数一开始就可以创建,类模板中成员函数在调用时才去创建。T — 通用的数据类型,名称可以替换,通常为大写字母。建立一个通用类,类中的成员 数据类型可以不具体制定,用一个。1、如果函数模板和普通函数都可以调用,优先调用普通函数。基于b站黑马c++视频做的笔记,仅供参考和复习!2、函数模板 用自动类型推导,不可以发生隐式类型转换。4、如果函数模板可以产生更好的匹配,优先调用函数模板。3、函数模板 用显示指定类型,可以发生隐式类型转换。3、函数模板可以发生函数重载。

DZJ_Nirvana 1120

【C++】模板与泛型编程(一):定义模板,类模板

对 C++ Primer 第五版第十六章第一节第二部分:类模板,进行阅读、学习和记录。

YGGP的博客 991

【C++】类模板(一)被参数化的类型、类模板的定义、模板类型参数的处理

类型的相关信息可从模板定义中剥离,由用户使用时再指定。 template机制帮助我们把“与类型相关”和“独立于类型之外”的两部分分离开来;在一个类模板中,与类型相关的部分会被抽取出来,成为一个或多个参数:

Zoey的博客 335

C++类模板不是一开始就创建的,而是调用时生成

类模板中的成员函数并不是一开始就创建的,再调用时才去创建。

weixin_55741769的博客 482

类模板的分文件编写问题以及解决

类模板分文件编写 问题 类模板中成员函数创建时机是在调用阶段,导致分文件便携式连接不到 解决 解决方式1:直接包含.cpp源文件 解决方式2:将声明和实现写到同一个文件中,并更改后缀名为.hpp,.hpp是约定的名称,而不是强制。 示例 person.hpp中代码: #include<iostream> #include<string> using namespace std; //类模板 template<class T1, class T2> class P

walker_xingruiguo的博客 257

【C++泛型编程】(一)函数模板和类模板

C++泛型编程(Generic Programming)是一种编程范式,它允许程序员编写与参数无关的代码,也就是说这些代码可以在多种数据类型上重用,而无需为每个类型重新编写。函数模板允许程序员编写一个通用的函数,该函数可以接受不同类型的参数,并在编译时根据提供的参数类型生成特定的函数版本。类模板则允许你编写一个通用的类,该类可以在编译时根据提供的类型参数生成特定的类版本。全特化:全特化是指对模板的所有模板参数都进行特化处理。在使用类模板时,需要为模板参数指定具体的类型。这样的具体类型提供特定的实现。

weixin_44378835的博客 540

【C++】总结一:类函数和类模板 的模板和样例代码

一、函数模板 1. 模板 template<函数参数模板> 类型名 函数名(参数表) { 函数体的定义 } 2. 例子 #include using namespace std; template T abs(T x) { return x < 0 ? -x : x; } int main() { int n = 5; double m = -5.5; cout <&lt...

@宁兰 的博客 206
上一篇: (4) 端口号
下一篇: (5) 缓冲区大小及限制
渐进者
博客等级 码龄12年 6粉丝 28原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值