【学习篇】【C++】【模板】

最新推荐文章于 2024-09-18 18:17:57 发布
最新推荐文章于 2024-09-18 18:17:57 发布
阅读量115 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44469133/article/details/112335437
版权

模板

Cpp除了面向对象的编程思想外，还有一种称为泛型编程。主要利用的技术就是模板。提供了两种模板机制：函数模板和类模板

模板不可以直接使用，只是一个框架。模板的通用不是万能的

模板的局限性

  • 利用具体化的模板，可以解决自定义类型的通用化
  • 学习模板的用意是为了使用STL系统提供的模板

一、函数模板

作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法：
template< typename T>
函数声明或定义

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

举例：利用函数模板进行整型数据交换

//函数模版
//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错
//T是一个通用数据类型
template<typename T> 
void mySwap(T& a, T& b) {
	T temp = a;
	a = b;
	b = temp;
}

1.两种方式

  1. 自动类型推导mySwap(a, b);
  2. 显示指定类型mySwap<int>(a, b);
void test01() {
	int a = 10;
	int b = 20;
	//1.自动类型推导
	mySwap(a, b);

	//2.显示指定类型
	mySwap<int>(a, b);
}

【总结】

  • 函数模板利用关键字template
  • 使用函数模板有两种形式：自动类型推导、显示指定类型
  • 模板的目的是为了提高复用性，将类型参数化

【注意事项】

  1. 自动类型推导必须要推导出一致的数据类型T才可以使用
  2. 模板必须要确定出T的数据类型才可以使用

2.普通函数与函数模版的关系

  1. 区别
    • 普通函数调用时可以发生自动类型转换（隐式类型转换）
    • 函数模版调用时，如果利用自动类型推导，不会发生隐式类型转换
    • 如果利用显示指定类型的方式，可以发生隐式类型转换

  2. 调用规则
    • 两者都可以实现时，优先调用普通函数
    • 可以通过空模板参数列表来强制调用函数模板，如：函数名<>(参数列表)
    • 函数模板也可以发生重载
    • 函数模板可以产生更好的匹配，优先调用函数模板

因此，总结是，既然提供了函数模版，就不要提供普通函数，以免出现二义性。

3.函数模板案例

  • 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
  • 排序规则从大到小，排序算法为选择排序
  • 分别利用char数组和int数组进行测试

1) 交换函数模版

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

2) 选择排序算法模版

//排序算法模版
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) {
			//交换max和i元素
			mySwap(arr[max], arr[i]); //此时把最大值放在最前面
		}
	}
}

3) 打印数组模版

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

4) 代码测试

void test01() {
	//测试char数组
	char charArr[] = "ABCDEFabcdef";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	printArr(charArr, num);
}

void test02() {
	//测试int数组
	int intArr[] = { 2,3,0,9,4,7,5,8 };
	int num = sizeof(intArr) / sizeof(int);
	mySort(intArr, num);
	printArr(intArr, num);
}

在这里插入图片描述

二、类模板

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

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

特点：

  1. 类模板没有自动类型推导的使用方式
  • person p("猪八戒", 999)错误，无法用自动类型推导
  • person<string, int>p("猪八戒", 999) 正确，只能用显示指定类型
  1. 类模板在模板参数列表中可以有默认参数
  • template<class Nametype, class Agetype = int>
  • Person<string>p("猪八戒", 999)
    这样写也不会报错。

1.类模板的成员函数

【与普通类的区别】
普通类中的成员函数一开始就可以创建
类模板中的成员函数在调用时（此时才确定了类型）才创建

【类模板的函数类外实现】

先在类内声明

class Person
{
public:
	T1 m_Name;
	T2 m_Age;
public:
	Person(T1 name, T2 age);
	void showPerson();
};
  1. 构造函数的类外实现，语法：类模板名称<类型1，类型2>::构造函数
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
   this->m_Name = name;
   this->m_Age = age;
}
  1. 成员函数的类外实现，语法：类模板名称<类型1，类型2>::成员函数
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;
}

2.类模板对象做函数参数

三种传入方式：

  1. 指定传入的类型 —直接显示对象的数据类型
  2. 参数模板化 —将对象中的参数变为模版进行传递
  3. 整个类模板化 —将这个对象类型模板化进行传递
template<class T1, class T2>
class Person {
public:
	T1 m_name;
	T2 m_age;
public:
	Person(T1 name, T2 age) {
		this->m_name = name;
		this->m_age = age;
	}

	void showPerson() {
		cout << "姓名: " << this->m_name << " 年龄: " << this->m_age << endl;
	}
};

下面然函数模板对象作为函数printPerson()的参数

1.指定传入类型 （最常用）

//1.指定传入类型（最常用）
void printPerson1(Person<string, int>& p) {
	p.showPerson();
}
void test01() {
	Person<string, int>p1("孙悟空", 100);
	printPerson1(p1);
}

2.参数模板化

//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>p2("猪八戒", 90);
	printPerson2(p2);
}

查看某个数据类型typeid(填写要查看的对象).name()
在这里插入图片描述

3.整个类模板化

//3.整个类模板化
template<class T3>
void printPerson3(T3& p) {
	p.showPerson();
	cout << "T3的类型名称： " << typeid(T3).name() << endl;
}
void test03() {
	Person<string, int>p3("唐僧", 30);
	printPerson3(p3);
}

在这里插入图片描述

3.类模板与继承

注意事项：

  1. 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
  2. 如果不指定，编译器无法给子类分配内存
  3. 如果想灵活指定出父类中T的类型，子类也需变成类模板。

给出一个类模板的父类

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

class Son :public Base {}; 错误，必须要知道父类中的T类型，才能继承给子类，如下：

class Son :public Base<int> {};
void test01() {
	Son s1;
}

如果想灵活指定，那么子类也需变成类模板。如下，子类作为类模板，其中T1表示通过子类指定给父类Base的类型，T2表示子类中的成员属性obj的类型。

template<class T1, class T2>
class Son2 :public Base<T1> {
public:
	T2 obj;
public:
	Son2() {
		cout << "T1的类型为： " << typeid(T1).name() << endl;
		cout << "T2的类型为： " << typeid(T2).name() << endl;
	}
};

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

在这里插入图片描述
此时也就意味着，父类Base的类型为int，子类中成员属性obj的类型为char。

4.类模板分文件编写

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

解决办法：

  1. 直接包含.cpp源文件
  2. 将声明和实现写到同一个文件中，并更改后缀名为.hpp （主流方法）

创建一个类模板分文件编写.hpp文件，将类模板的声明和定义都写在里面

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

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

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;
}

然后在.cpp中包含这个.hpp文件#include"类模板分文件编写.hpp"，从而使得编辑器能够识别主文件

#include<iostream>
#include<string>
#include"类模板分文件编写.hpp"
using namespace std;

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

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

5.类模板与友元

  1. 全局函数类内实现：直接在类内声明友元即可 （建议使用）
  2. 全局函数类外实现：需要提前让编辑器知道全局函数的存在 （复杂）

【全局函数类内实现】

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

	//1.全局函数的类内实现
	friend void printPerson(Person<T1, T2>& p)
	{
		cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
	}
};
//通过全局函数打印Person的信息
void test01()
{
	Person<string, int>p1("Tom", 20);
	printPerson(p1);
}

【全局函数类外实现】
需要提前让编译器知道Person类的存在，还需要让编译器知道这个全局函数存在。

template<class T1, class T2>
class Person;

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

在类内声明为友元时还要注意加空模板参数列表<>，如下
friend void printPerson2<>(Person<T1, T2>& p);

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

};
void test02()
{
	Person<string, int>p2("Jerry", 18);
	printPerson2(p2);
}

6.类模板案例

要求：

  • 可以对内置数据类型以及自定义数据类型的数据进行存储
  • 将数组中的数据存储到堆区
  • 构造函数中可以传入数组的容量
  • 提供对应的拷贝构造函数以及operator=防止浅拷贝的问题
  • 提供尾插法和尾刪法对数组中的数据进行增加和删除
  • 可以通过下标的方式访问数组中的元素
  • 可以获取数组中当前元素个数和数组的容量

定义一个通用数组类，该文件保存为.hpp类型。

//自己的通用数组类
#pragma once
#include<iostream>
using namespace std;

template<class T>
class MyArray
{
private:
	T* pAddress; //指针指向堆区开辟的真实数组
	int m_Capacity; //数组容量
	int m_Size; //数组大小
public:
#pragma region 1.
	//有参构造 参数 容量
	MyArray(int capacity)
	{
		cout << "MyArray的 有参构造" << endl;
		this->m_Capacity = capacity;
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];
	}
#pragma endregion 有参构造

#pragma region 2.
	//拷贝构造函数
	MyArray(const MyArray& arr)
	{
		cout << "MyArray的 拷贝构造" << endl;

		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;

		//深拷贝
		this->pAddress = new T[arr.m_Capacity];

		//将arr的数据都拷贝过来
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}
#pragma endregion 拷贝构造

#pragma region 3.
	//operator=防止浅拷贝的问题
	MyArray& operator=(const MyArray& arr)
	{
		cout << "MyArray的operator=的调用" << 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;
	}
#pragma endregion operator=

#pragma region 4.
	//析构函数
	~MyArray()
	{

		if (this->pAddress != NULL)
		{
			cout << "MyArray的 析构函数" << endl;
			delete[] this->pAddress;
			this->pAddress = NULL;
		}

	}
#pragma endregion 析构函数

#pragma region 5.
	void Push_Back(const T& val)
	{
		cout << "尾插法函数调用" << endl;

		//判断容量大小
		if (this->m_Capacity == this->m_Size)
		{
			return;
		}
		this->pAddress[this->m_Size] = val; //在数组末尾插入数据
		this->m_Size++; //更新数组大小
	}
#pragma endregion 尾插法

#pragma region 6.
	void Pop_Back(const T& val)
	{
		cout << "尾删法函数调用" << endl;

		//逻辑删除：让用户访问不到最后一个元素
		if (this->m_Size == 0)
		{
			cout << "该数组已空" << endl;
			return;
		}
		for (int i = 0; i < val; i++)
		{
			this->m_Size--; //更新数组大小
		}

	}
#pragma endregion 尾删法

#pragma region 7.
	//需要先重载一下中括号[]
	T& operator[](int index)
	{
		return this->pAddress[index];
	}

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

	//返回数组的大小
	int getSize()
	{
		return this->m_Size;
	}
#pragma endregion 通过下标方式访问数组中的元素

};

在主文件中，

#include<iostream>
#include<string>
#include"182.类模板案例.hpp"
using namespace std;

#pragma region 1.1
void PrintIntArray(MyArray<int>& arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << arr[i] << endl;
	}
}
#pragma endregion 打印整型数组的函数PrintIntArray()

#pragma region 2.
void test01()
{
	//测试已实现功能
	MyArray<int>arr1(5);
	MyArray<int>arr2(arr1);
	MyArray<int>arr3(100);
	arr3 = arr1;
}
#pragma endregion test01()测试已实现功能

#pragma region 3.
void test02()
{
	MyArray<int>arr4(5);
	for (int i = 0; i < arr4.getCapacity(); i++)
	{
		//利用尾插法向数组插入数据
		arr4.Push_Back(i);
	}
	cout << "arr4的打印输出为： " << endl;
	PrintIntArray(arr4);
	cout << "arr4的容量为：" << arr4.getCapacity() << endl;
	cout << "arr4的大小为：" << arr4.getSize() << endl;
	cout << "******************************************" << endl;
	MyArray<int>arr5(arr4);
	cout << "arr5的打印输出为： " << endl;
	PrintIntArray(arr5);

	//利用arr5进行尾刪法测试
	arr5.Pop_Back(2);
	cout << "arr5尾刪后的情况：" << endl;
	cout << "arr5的容量为：" << arr5.getCapacity() << endl;
	cout << "arr5的大小为：" << arr5.getSize() << endl;
}
#pragma endregion test02()测试尾插法和尾刪法

#pragma region 4.
//测试自定义数据类型
class Person
{
public:
	string m_name;
	int m_age = 0;
public:
	Person() {}
	Person(string name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
};

#pragma region 1.2
void PrintPersonArray(MyArray<Person>& arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << "姓名：" << arr[i].m_name << "\t" << " 年龄： " << arr[i].m_age << endl;
	}
}
#pragma endregion 打印整型数组的函数PrintPersonArray()

void test03()
{
	MyArray<Person>arr6(10);
	Person p1("唐僧", 30);
	Person p2("孙悟空", 100);
	Person p3("猪八戒", 90);
	Person p4("沙僧", 80);

	//将数据插入到数组中
	arr6.Push_Back(p1);	arr6.Push_Back(p2);
	arr6.Push_Back(p3);	arr6.Push_Back(p4);

	//打印数组,并输出容量和大小
	PrintPersonArray(arr6);
	cout << "arr6的容量为：" << arr6.getCapacity() << endl;
	cout << "arr6的大小为：" << arr6.getSize() << endl;
}
#pragma endregion test03()测试自定义数据类型


int main()
{
	test01();
	test02();
	test03();
	return 0;
}
Shiloh.Tse is coding
关注
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
C++模板的入门学习，看这篇就够了
m0_74234485的博客
04-11 809
目录 1. 函数模板 2.函数模板的原理 3.函数模板的实例化 4.模板参数的匹配原则 5.类模板 1. 类模板的定义格式 2. 类模板的实例化 6.非类型模板参数 7. 模板的特化 7.1 为什么引入模板特化 7.2 函数模板的特化步骤： 7.3 类模板特化 7.3.1 全特化 7.3.2 偏特化
C++学习笔记——标准模板库
华数云图小分队的博客
01-13 1327
C++标准模板库（STL）是C++的一个重要组成部分，它提供了一套丰富的通用数据结构和算法。STL以其高度模块化、可复用的特性，在C++编程中发挥着重要作用。本篇博客将带你深入了解STL，并介绍其常见的组件和使用方法。C++标准模板库（STL）是C++语言的一个标准库，它提供了一套通用的数据结构和算法，以支持高效的编程。STL的设计目标是使程序员能够以简洁、高效和可复用的方式开发代码。// 输出vector的大小return 0;
C++模板学习总结
CodingStart
07-18 755
C++模板学习总结
C++类模板详解
weixin_44115575的博客
03-27 3549
类模板是一种用来生成类定义的模板，其中可以包含一个或多个类型参数。这些类型参数可以在定义类的时候替换为任意类型，从而使得我们能够创建适用于多种数据类型的通用类定义。类模板的定义使用 template或来声明一个类型参数。
C++模板学习
mayue_web的博客
12-03 1850
文章目录1. C++模板2. 函数模板( Function templates)2.1 函数模板分类3. 类模板(Class templates)4. 参考资料 1. C++模板 模板定义：模板是实现代码重用机制的一种工具，它可以实现类型参数化，即把类型定义为参数，从而实现了真正的代码可重用性。 模板分类：函数模板和类模板。函数模板针对参数类型不同的函数；类模板仅针对数据成员和成员函数类型不同的类。 使用模板目的：让程序员编写与类型无关的代码。 注意：模板的声明或定义只能在全局，命名空间或类范围内进行。即不
C++模板元编程详细教程（之五）
fl2011sx的博客
01-31 3397
《C++模板元编程详细教程》系列文章的第5篇，主要介绍了模板元编程两大要素的第一要素——静态数值计算
C++模板函数重载规则细说
红军不怕远征难，万水千山只等闲
12-25 2414
文章真的长呀，如果你能坚持看到这里，说明你是一个非常坚持且对编程有强烈兴趣的人，希望这篇文章让你在c++模板的路上有所帮助。那么接下来我们再来回顾一下这篇文章的内容。我们先介绍了模板元编程要解决的场景与问题然后我们从一个具体的模板元编程例子展开，一步步学习了模板元编程的整体内容接下来针对其核心：模板函数重载匹配规则以及模板规则进一步了解最后再给出在使用方面的一些经验供参考模板元编程他要解决的最核心的问题就是：对模板类型的判断与选择。
【C++】模板进阶
最新发布
C/C++领域,数据结构,linux,MySQl学习者
09-18 1012
整理了关于C++模板进阶相关知识点,包括非类型模板参数,类模板的特化,模板的分离编译等相关内容.
【C++】—— 模板介绍
m0_56069910的博客
06-08 2934
模板的详细介绍
深入学习与实践C++模板编程 值得学习
04-11
C++模板是C++语言中的一个强大特性，它允许程序员创建泛型代码，即能够处理多种数据类型的代码。...深入学习和实践C++模板编程，无论是对初学者还是经验丰富的开发者，都能够进一步提升编程效率和代码质量。
C++编程实例100篇 C++软件源码.zip
04-25
"C++编程实例100篇 C++软件源码.zip"是一个压缩包，其中包含了100个C++编程实例的源代码，这些实例覆盖了C++的基础和进阶概念，对于学习和巩固C++编程技巧非常有帮助。 首先，我们可以从这些实例中学到C++的基础...
C++编程实例100篇
08-28
《C++编程实例100篇》是一本深入浅出的C++编程教程，它以实践为主导，通过丰富的实例帮助学习者掌握C++语言的基础和核心概念。这本书的每个实例都精心设计，旨在帮助初学者和有经验的开发者巩固和提升C++编程技能。 ...
C++学习指南（语法篇）代码+pdf(pdf可直接打印)
03-03
这是 C/C++学习指南(语法篇) 对应的视频教材! 面向零基础的初学者。同时，书中还讲解了初级程序员所必须掌握的知识和技术，如“单步调试”，“编码规范”， ANSI函数库，文件操作，标准模板库STL的使用。 学习方法：...
【学习篇】【C++】【STL容器及案例】
Shiloh的博客
01-13 1335
案例1.评委打分2.员工分组 1.评委打分 五名选手ABCDE，10个评委打分，去掉最高分和最低分，取平均分 步骤： 创建五名选手，放进vector 遍历vector容器取出每一名选手，执行循环，把十个评分存到deque容器中 sort对deque容器进行分数排序，去掉最高分和最低分 deque容器遍历一遍，累加总分 获取平均分 #include<iostream> #include<string> #include<deque> #include<vector
【学习篇】【操作系统理论】
Shiloh的博客
03-01 661
操作系统进程进程的三种基本状态进程控制进程通信并发性互斥、同步互斥的软件实现方法：互斥的硬件实现方法信号量机制管程线程死锁死锁的必要条件死锁的处理策略内存内存管理内存空间的分配和回收连续分配管理非连续分配管理页面分配策略对内存空间进行扩充地址转换功能内存保护功能调度挂起态与七状态模型进程调度狭义的进程调度和进程切换的区别调度算法的评价指标调度算法用户接口操作系统的特征中断文件管理文件目录文件的物理结构（文件的分配方式）文件存储空间管理设备管理 相关学习帖子如下： https://blog.csdn.net/
【学习篇】【STL侯捷课程】（未完待续）
Shiloh的博客
02-16 417
STL源码剖析笔记traits关键字autoHashTable的separate chaining（分离链接法）分配器deque如何模拟连续空间红黑树容器map的独特的operator[]lower_bound容器hashtable算法algorithm仿函数的条件functors的可适配（adaptable）条件一些adaptersort traits traits是人为制造的特性萃取机制，是加的中间层。 class(template)iterators都有能力定义自己的associated types
【学习篇】【C++】【文件操作】
Shiloh的博客
01-07 408
文件操作一、文本文件1.1 文件的打开方式1.2 写文件1.3 读文件二、二进制文件2.1 写文件2.2 读文件 程序运行时产生的数据都属于临时数据，程序运行完后就会被释放，因此通过文件可以将数据持久化。文件操作需要包含头文件fstream。 文件类型分为两种： 文本文件—文件以文本的ASCII码形式存储在计算机中 二进制文件—文件以文本的二进制形式存储在计算机中，一般不能直接读懂 操作文件的三个大类： ofstream 写操作 ifstream 读操作 fstream 读写操作 一、文本文件
【学习篇】【C++语法基础】【结构体】
Shiloh的博客
12-11 402
学习篇—c++语法基础—结构体结构体结构体的基本概念结构体的定义和使用结构体指针结构体嵌套结构体结构体做函数参数如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 结构体 ？？？ 结构体的基本概念 属于用户自定义的数据类型，允许用户存储不同的数据类型 结构体的定义和使用 语法：struct 结构体名｛结构体
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值