掘根宝典之C++类模板大全

已于 2024-03-13 16:11:21 修改
阅读量1.5k 收藏 17
点赞数 34
文章标签： c++ 算法 开发语言
于 2024-02-17 10:56:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80224556/article/details/136132159
版权

1 类模板语法

类模板的作用：建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表

语法：

template<typename T>
模板类声明


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

示例：

#include<iostream>
using namespace std;
//类模板
template<class NameType, class AgeType>
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->m_Age = age;
        this->m_Name = name;
    }

    void showPerson()
    {
        cout << "name: " << this->m_Name << "age: " << this->m_Age << endl;
    }

    NameType m_Name;
    AgeType m_Age;
};


void test01()
{
    Person<string, int> p1("孙悟空", 999);
   //先创建了<string,int>版本的类定义，再将括号里的东西传进去
    p1.showPerson();
}
   
int main()
{
    test01();
    return 0;
}

运行结果是

name：孙悟空age：999

我们必须注意的一个点是仅在程序包含模板并不会生成模板类，必须请求实例化。也就是说，必须要将模板的泛型换为具体类型 

我们可能有点懵，来看个例子

#include<iostream>
using namespace std;
//类模板
template<class NameType, class AgeType>
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->m_Age = age;
        this->m_Name = name;
    }

    void showPerson()
    {
        cout << "name: " << this->m_Name << "age: " << this->m_Age << endl;
    }

    NameType m_Name;
    AgeType m_Age;
};

   
int main()
{
    int a=10;
    return 0;
}

上面这个例子没有生成类定义，他只是告诉编译器如何生成类定义 ，这一点和函数模板是相同的


2 类模板与函数模板的区别

类模板与函数模板区别主要有两点：

1.类模板没有自动类型推导的使用方式
2.类模板在模板参数列表中可以有默认参数

示例：//类模板与函数模板的区别

先看类模板的

template<class NameType, class AgeType = int> //指定默认参数
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->m_Age = age;
        this->m_Name = name;
    }

    void showPerson()
    {
        cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
    }

    NameType m_Name;
    AgeType m_Age;
};


void test01()
{
    //Person p("孙悟空", 1000);错误的，类模板无法用自动类型推导
    Person<string, int>p("孙悟空", 1000);//正确，只能用显式指定类型推导
    p.showPerson();
}

void test02()
{
    Person<string>p("猪八戒", 999); //类模板在参数列表中有默认参数
}
   
int main()
{
    test01();
    system("pause");
    return 0;
}

再来看函数模板的

#include<iostream>
using namespace std;

//其实可以这么写template<class T=int>，但是不建议
template<class T>
void A(T a)
{
	cout << a << endl;
}
void B()
{
	A(3.0);//自动类型推断
}
int main()
{
	B();
}


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

类模板中成员函数和普通类中成员函数创建时机是有区别的：

1，普通类中的成员函数一开始就可以创建
2，类模板中的成员函数在调用时才创建（因为我们写下模板类，只是告诉编译器如何去定义一个类，但是又不会创建类对象出来，只是一团虚的东西）

示例：

//类模板中成员函数的创建时机
class Person1
{
public:
    void showPerson1()
    {
        cout << "Person1 show" << endl;
    }
};

class Person2
{
public:
    void showPerson2()
    {
        cout << "Person2 show" << endl;
    }
};

template<class T>
class Myclass
{
public:
    T obj;
    
    //类模板中的成员函数在调用的时候才创建，所以不会报错
    void func1()
    {
        obj.showPerson1();
    }

    void func2()
    {
        obj.showPerson2();
    }
};

void test01()
{
    Myclass<Person1>m;
    m.func1();
    //因为我们没有创建Person2的版本啊，所以也没有showPerson2这个函数啊
    //m.func2(); 无法调用
}

int main()
{
    test01();
    system("pause");
    return 0;
}


4 类模板对象做函数参数

学习目标：类模板实例化出的对象，向函数传参的方式

一共有三种传入方式：

指定传入的类型：直接显示对象的数据类型
参数模板化：将对象中的参数变为模板进行传递
整个类模板化：将这个对象类型模板化进行传递
示例：

//类模板对象做函数参数
template<class T1,class T2>
class Person
{
public:
    Person(T1 name,T2 age)
    {
        this->m_Age = age;
        this->m_Name = name;
    }

    void showPerson()
    {
        cout << "name: " << this->m_Name << " age:" << this->m_Age << endl;
    }

    T1 m_Name;
    T2 m_Age;
};

//1、指定传入类型
void printPerson1(Person<string, int>&p)
{
    p.showPerson();
}
void test01()
{
    Person<string, int>p("孙悟空", 199);
    printPerson1(p);
}

   
// 2、参数模板化
template<class T1,class T2>
void printPerson2(Person<T1,T2>&p)
{
    p.showPerson();
    cout << "T1的类型为:" << typeid(T1).name() << endl;
    cout << "T2的类型为:" << typeid(T2).name() << endl;
}
void test02()
{
    Person<string, int>p("猪八戒", 90);
    printPerson2(p);
}

// 3、整个类模板化
template<class T>
void printPerson3(T &p)
{
    p.showPerson();
    cout << "T的类型为:" << typeid(T).name() << endl;
}
void test03()
{
    Person<string, int>p("唐僧", 60);
    printPerson3(p);
}

int main()
{
    test01();
    test02();
    test03();
    system("pause");
    return 0;
}


运行结果：

注：使用比较广泛的是指定传入类型的传参方式

5 类模板与继承

当类模板碰到继承时，需要注意以下几点：

当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
如果不指定，编译器无法给子类分配内存
如果想灵活指定出父类中T的类型，子类也需为类模板
示例：

//类模板与继承
template<class T>
class Base
{
    T m;
};

//class Son: public Base //错误，必须要知道父类中的T类型，才能继承给子类
class Son :public Base<int>
{

};

void test01()
{
    Son s1;
}

//如果想灵活指定父类中T的类型，子类也需要变成类模板
template<class T1,class T2>
class Son2 : public Base<T2>
{
public:
    Son2()
    {
        cout << "T1的类型为:" << typeid(T1).name() << endl;
        cout << "T2的类型为:" << typeid(T2).name() << endl;

    }
    T1 obj;
};

void test02()
{
    Son2<int,char> s2;
}

int main()
{
    test02();
    
    system("pause");
    return 0;
}


6 类模板成员函数类外实现

示例：

//类模板成员类外实现
template<class T1, class T2>
class Person
{
public:
    Person(T1 name, T2 age);
    /*{
        this->m_Name = name;
        this->m_Age = age;
    }*/

    void showPerson();
    /*{
        cout << "姓名:" << this->m_Name << " 年龄:" << this->m_Age << endl;
    }*/

    T1 m_Name;
    T2 m_Age;
};

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


//成员函数的类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
    cout << "姓名:" << this->m_Name << " 年龄:" << this->m_Age << endl;
}

void test01()
{
    Person<string, int>p("Tom", 30);
    p.showPerson();
}


int main()
{
    test01();
    
    system("pause");
    return 0;
}


7 类模板分文件编写

如果工程中需要利用多个类模板，那么将这些类模板都写在同一个文件中将会导致代码可读性变差，所以有必要对类模板进行分文件编写，但是类模板的分文件编写面临着一些问题，以下是类模板分文件编写面临的问题及解决方法。

问题：类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：

解决方式1：直接包含.cpp源文件
解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp,hpp是约定的名称，并不是强制的
示例1：（未进行分文件编写）

template<class T1, class T2>
class Person
{
public:
    Person(T1 name, T2 age);
    /*{
        this->m_Name = name;
        this->m_Age = age;
    }*/

    void showPerson();
    /*{
        cout << "姓名:" << this->m_Name << " 年龄:" << this->m_Age << endl;
    }*/

    T1 m_Name;
    T2 m_Age;
};

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


//成员函数的类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
    cout << "姓名:" << this->m_Name << " 年龄:" << this->m_Age << endl;
}

void test01()
{
    Person<string, int>p("Tom", 30);
    p.showPerson();
}


int main()
{
    test01();
    
    system("pause");
    return 0;
}


实例2：（进行分文件编写,利用.cpp）

1.创建头文件person.h，写一些声明

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

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

    T1 m_Name;
    T2 m_Age;
};


2.创建person.cpp，写具体实现

#include "person.h"

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


//成员函数的类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
    cout << "姓名:" << this->m_Name << " 年龄:" << this->m_Age << endl;
}


3.main函数编写
错误代码：

#include <iostream>
using namespace std;
#include <string>
#include "person.h"

void test01()
{
    Person<string, int>p("Tom", 30);
    p.showPerson();
}


int main()
{
    test01();
    
    system("pause");
    return 0;
}


注：因为如果包含person.h文件，那么编译器将会看到person.h中的代码。但是由于类模板中的成员函数一开始是不创建的，导致编译器没有看到person.cpp中的代码，所以执行test01时，无法解析其中的代码。

正确代码：(不常用)

#include <iostream>
using namespace std;
#include <string>
#include "person.cpp"

void test01()
{
    Person<string, int>p("Tom", 30);
    p.showPerson();
}


int main()
{
    test01();
    
    system("pause");
    return 0;
}


注：就是将person.h文件改成了person.cpp代码。编译器首先看到了person.cpp文件，因为person.cpp文件中有person.h文件，编译器又看到了person.h文件，所以能够解析test01中的代码。但是一般很少直接包含.cpp文件的，所以这个方法不常用。

实例3：（分文件编写，利用.hpp）
将person.h和person.cpp的内容写到一起，并将后缀名改为.hpp，这是类模板分文件编写最常用的方式

1.编写person.hpp文件：

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

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

    T1 m_Name;
    T2 m_Age;
};

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


//成员函数的类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
    cout << "姓名:" << this->m_Name << " 年龄:" << this->m_Age << endl;
}


2.编写main函数

#include <iostream>
using namespace std;
#include <string>
#include "person.hpp"

void test01()
{
    Person<string, int>p("Tom", 30);
    p.showPerson();
}


int main()
{
    test01();
    
    system("pause");
    return 0;
}


8 类模板与友元

非模板友元

为模板类提供非模板友元函数，像下面这样子做就可以了

#include<iostream>
using namespace std;
void A(int a)//非模板友元函数
{
	cout << a << endl;
}
template<class T>
class AA
{
private:
	T a_;
public:
	AA(T a):a_(a){}
	friend void A(int a);//友元声明
};
int main()
{
	A(2);//正常使用
	//AA a(2);模板类不能自动类型推断
	AA<int> a(2);//OK
}

上面这个友元函数将成为所以模板实例化的友元 。例如它将是AA<float>和AA<char>等版本的友元函数。

假如我们要为友元函数提供模板类参数，可以像下面这样子做吗？

friend void A(AA&t);

答案是不行的，要提供模板类参数，必须指明具体化，像下面这两种做法都是可以的

template<class T>
class AA
{
friend void A(AA<T>&t);
friend void B(AA<int>&t);
....
}

模板类的约束模板友元函数

说白了就是来使类的每一个具体化都获得一个与友元匹配的具体化

全局函数类内实现：直接在类内声明友元即可
全局函数类外实现：需要提前让编译器知道全局函数的存在

1.全局函数的类内实现


template<class T1, class T2>
class Person
{
    //全局函数类内实现
    friend void printPerson(Person<T1, T2> p)
    {
        cout << "姓名:" << p.m_Name << " 年龄:" << p.m_Age << endl;
    }
public:
    Person(T1 name, T2 age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    
private:
    T1 m_Name;
    T2 m_Age;
};

void test01()
{
    Person<string, int>p("Tom", 30);
    printPerson(p);
}
int main()
{
    test01();
    
    system("pause");
    return 0;
}


2.全局函数类外实现

//提前让编译器知道Person类的存在
template<class T1, class T2>
class Person;

//类外实现
template<class T1, class T2>
void printPerson(Person<T1, T2> p)
{
    cout << "姓名:" << p.m_Name << " 年龄:" << p.m_Age << endl;
}

template<class T1, class T2>
class Person
{
    //全局函数类外实现 
    //加空模板参数列表
    //如果全局函数是类外实现，需要让编译器提前知道这个函数的存在
    friend void printPerson<>(Person<T1, T2> p);
public:
    Person(T1 name, T2 age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    
private:
    T1 m_Name;
    T2 m_Age;
};

void test01()
{
    Person<string, int>p("Tom", 30);
    printPerson(p);
}


int main()
{
    test01();
    
    system("pause");
    return 0;
}


注：需要注意各个函数声明之间的顺序。在Person类模板中有友元的声明friend void printPerson<>(Person<T1, T2> p)，因为类模板中友元的类外实现需要让编译器提前知道这个函数，所以需要将printPerson函数写在前面。而printPerson函数中又涉及Person类，所以在printPerson函数前面需要提前声明Person类模板的存在。
总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别。

模板类的非约束模板友元函数

说白了就是每个函数具体化都是每个类具体化的友元。对于非约束友元，友元模板类型参数与模板类类型参数是不同的

template<class T>
class AA
{
.....
template<class A,class B>feiend void A(A&,B&);
.....
}

模板的具体化

隐式实例化

到目前为止，上面所有例子用的都是隐式实例化，即它们声明一个或多个对象，指出所需类型，而编译器使用通用模板提供的处方生成具体的类声明

AA<int> a;

需要注意的是：需要对象之前，不会生成类的隐式实例化。

AA<int>*t;
t=new AA<int>;
//第二句导致编译器生成类定义，并根据该定义创建一个对象

显式实例化

显式实例化声明必须位于模板定义所在的名称空间里。

格式大概是

template class 类模板名<具体类型>;

我们看个例子

#include<iostream>
using namespace std;
void A(int a)
{
	cout << a << endl;
}
template<class T>
class AA
{
private:
	T a_;
public:
	AA(T a):a_(a){}
	friend void A(int a);
};

template class AA<int>;//注意不能放main函数里面

int main()
{

	A(2);
	//AA a(2);
	AA<int> a(2);
}

显式具体化

显式具体化是指在类模板外部对类模板的特定类型进行具体化。通过显式具体化，我们可以为模板类给出特定类型的定义，以覆盖默认的通用定义。

以下是一个示例，展示如何显式具体化一个类模板：

// 定义一个类模板
template <typename T>
class MyTemplate {
public:
    MyTemplate(T value) : m_value(value) {}

    void print() {
        std::cout << "Generic template: " << m_value << std::endl;
    }

private:
    T m_value;
};

// 显式具体化模板类的特定类型
template<>
class MyTemplate<int> {
public:
    MyTemplate(int value) : m_value(value) {}

    void print() {
        std::cout << "Specialized template for int: " << m_value << std::endl;
    }

private:
    int m_value;
};

int main() {
    MyTemplate<double> obj1(3.14);
    obj1.print();  // 输出：Generic template: 3.14

    MyTemplate<int> obj2(42);
    obj2.print();  // 输出：Specialized template for int: 42

    return 0;
}

在上述示例中，定义了一个模板类 MyTemplate，它可以用于任意类型的参数 T。然后，通过显式具体化，我们为模板类 MyTemplate 的特定类型 int 提供了特殊化的定义，其中包含一个特定的成员函数 print，用于输出特定类型的值。

在 main 函数中，我们创建了两个 MyTemplate 的对象，一个是 MyTemplate&lt;double> 类型的，另一个是 MyTemplate&lt;int> 类型的。当调用它们的 print 成员函数时，将根据对象类型的特化定义，分别输出不同的结果。

这样，通过显式具体化，我们可以为特定类型提供自定义的定义，以满足特定的需求。

掘根
关注
  • 34
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2024华为OD机试真题指南宝典—持续更新（JAVA&Python&C++&JS）【彻底搞懂算法和数据结构—算法之翼】
一键难忘的博客
12-24 1万+
2024华为OD机试指南宝典—持续更新（JAVA&Python&C++&JS）【彻底搞懂算法和数据结构—算法之翼】 OD全称(Outsourcing Dispacth)模式，目前华为和德科联合招聘的简称。目前华为社招大多数是OD招聘，17级以下都为OD模式，OD模式也是华为提出的一种新的用工形式，定级是13-17级，属于华为储备人才，每年都会从OD项目挑优秀员工转为正编。--考来的，描述的很准确。
C++从入门到进阶的系列书籍推荐
dvlinker的技术专栏
11-05 2万+
要多读书，读好书！一本书要多读几遍才好，每次都可能有新的收获！特别在是有一定的工作年限和工作经验之后！读书百遍，其义自见！ 下面就给大家推荐一下C++程序员进阶需要读的经典书籍： 1、C++入门书籍 C++是在C语言的基础上发展而来的，要学习C++之前需要先学习C语言。有了C语言基础之后再去学习C++。 1.1、C语言程序设计（谭浩强） 该书被公认为学习C语言程序设计的优秀教材，被全国大多数高校选用，是学习C语言的主流用书。本书比较通俗易懂，是初入者必备的书籍。 ........
C/C++面试宝典2024版(最新版)
热门推荐
学无止尽，谨言慎行！
04-02 2万+
面试基础前言new、delete、malloc、free关系delete与 delete []区别C和C++ 的共同点？不同之处？继承的优缺点C++有哪些性质（面向对象特点）子类析构时要调用父类的析构函数吗？多态，虚函数，纯虚函数求下面函数的返回值（微软）什么是“引用”？申明和使用“引用”要注意哪些问题？将“引用”作为函数参数有哪些特点？在什么时候需要使用“常引用”？将“引用”作为函数返回值类型的...
C++中模板类的友元重载
03-10 3350
一个由《程序员面试宝典》引出的问题。 描述模板类的友元重载，用C++代码实现？ 这实际上考察的是下面几个问题： 1.模板类的编写 2.模板类中友元函数的编写 3.什么时候会用到友元重载？答案是各种C++中的运算符。最典型的就是输出操作符 书上给出的答案如下： #include using namespace std; template class Test; template
史上最全的C++面试宝典（合集）
编程之路
08-12 2万+
参考：https://www.runoob.com/cplusplus/cpp-tutorial.html 本教程旨在提取最精炼、实用的C++面试知识点，供读者快速学习及本人查阅复习所用。 目录 第一章 C++基本语法 1.1 C++程序结构 1.2 命名空间 1.3 预处理器 1.4 相关面试题 第二章 C++数据操作 2.1 数据类型 2.2 变量 2.3 常量 2.4 类型限定符 2.5 存储类 2.6 运算符 2.7 相关面试题 第三章 指...
【C++面试宝典】C++11新特性知识总结
DayDayUp
01-08 1763
C++11新特性 auto自动类型推导 用于初始化表达式中推断出变量的数据类型 auto a;//错误，应该是auto i=1; 最常见用在迭代器vector<int>::iterator it = v.begin();auto it = v.begin(); 基于范围的for循环：for(auto x: str){...} 使用限制 auto的使用必须马上初始化，否则无法推导类型 auto a; ...
C++面试宝典（纯干货）
qq_29426201的博客
01-24 2679
之前许多朋友私信问过我整理一篇“C++面试题”，我把自己在面试过程中被问的和自认为重要的面试题整理出来，希望对大家有所帮助。其中一些问题，请关注我的公众号，都有相应的文章。 01 C语言 const的作用有哪些，谈一谈你对const的理解？ 描述char*、const char*、char* const、const char* const的区别？ 指针常量和常量指针有什么区别？ static的作用是什么，什么情况下用到static？ 全局变量与局部变量的.
【C++面试宝典】C++面向对象知识点总结
DayDayUp
01-07 2557
本文为博主准备C++面试所总结归纳的C++面向对象知识点，原文件为脑图形式，见下图。下文则是将知识点脑图转为文字形式的结果，便于读者总结归纳。 目录 面向过程和面向对象 用C 实现 C++ 的面向对象特性 双冒号、using和namespace 对象的引用方式 类默认的六个成员函数 const成员 构造函数 拷贝构造函数 深拷贝与浅拷贝 析构函数 封装 this指针 静态成员 友元 重载(overload)、覆盖(overwrite)和重定义 继承 多态 虚函数 模.
【C++面试宝典】C/C++知识点补充
DayDayUp
01-11 2280
目录 C++补充 补充知识 语言对比 C和C++ Java和C++ Python和C++ C和C++中struct 判断结构体是否相等 可变参数模板 switch中case里不能自定义变量 char和int转换 malloc的底层实现 C语言检索内存情况 异常处理try/catch fork() epoll C/C++ C语言补充 printf switch 动态内存管理 malloc函数 realloc函数 calloc函数 ...
多线程及C++面试宝典
qq_33185566的博客
03-21 1699
史上最全的C++面试宝典（九）—— 多线程_最靓的仔的博客-CSDN博客_c++多线程面试题 史上最全的C++面试宝典（合集）_最靓的仔的博客-CSDN博客_c++面试宝典
C/C++面试宝典大全
02-14
C/C++面试宝典大全
C/C++程序员面试宝典
09-07
文本格式为PDF，带目录，方便查看阅读； 祝愿找工作的同学都能拿到理想offer!
C++修炼宝典C++修炼宝典
11-21
C++修炼宝典，本仓库是面向 C/C++ 技术方向校招求职者、初学者的基础知识总结，包括语言、程序库、数据结构、算法、系统、网络、链接装载库等知识及面试经验、招聘、内推等信息。 详细目录请见README.md文档，非常...
标准C++宝典
09-04
●本书针对那些比较高深难懂的主题也做了深入浅出的介绍，比如模板(包括标准模板库，即STL)、名字空间以及运行时类型信息(BTTI)等，这些功能对开发大型复杂系统的程序设计人员非常重要。 　因此，无论是新手还是有...
标准c++宝典.zip
11-07
标准c++宝典
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
最新发布
Ddddddd_158的博客
06-04 320
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
C语言——指针
weixin_45725380的博客
05-31 794
存储类型 数据类型 *指针变量名；例如：int *p;//定义了一个整数型指针变量pint a=5;int *p=&a;char b='v';char *q=&b;访问指针所指的空间里的内容时，需要用取内容运算符*来获取此时，变量p存放的就是a的地址，变量q存放的就是b的地址；符号*可以访问地址指向的空间里面的内容。指针与变量之间的关系如下：int i=3;本质还是指针，指向的是数组。（又称为行指针）所谓指针数组就是由若干个具有相同类型的指针变量组成的集合。
C++候捷stl-视频笔记2
Mhypnos的博客
05-31 814
候捷stl标准库学习笔记
CF Round 368 (Div. 2) C. Pythagorean Triples【数学 构造】
2301_80089588的博客
05-30 448
数学 构造
程序员面试宝典C++
09-15
程序员面试宝典C是一本通过380余个面试题，对企业招聘C...此外，C语言还支持范式编程，比如模板类、函数模板等。下面是一个基础的C程序示例： #include using namespace std; int main() { cout ; return 0; }

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值