8.14~8.15---模板

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

文章目录

一、模板

1.模板的概念

在这里插入图片描述

在这里插入图片描述

2.函数模板

1）函数模板语法

在这里插入图片描述

#include <iostream>
using namespace std;

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

void test01()
{
	int a = 10;
	int b = 20;
	//利用函数模板交换
	//两种方式使用函数模板

	//1.自动指定类型
	//mySwap(a, b);

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

	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
}

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

在这里插入图片描述

2）函数模板的注意事项

在这里插入图片描述

#include <iostream>
using namespace std;
template<class T>//typename可以替换成class
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

//1.自动类型推导，必须推导出一致的数据类型T才可以使用
void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	mySwap(a, b);//正确！
	//TmySwap(a, b);//错误！推导不出一致的T类型
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
}

//2.模板必须要确定出T的数据类型，才可以使用
template<class T>
void  func()
{
	cout << "finc调用" << endl;
}

void test02()
{
	//func();
	func<int>();
}
int main()
{
	//test01();
	test02();
	return 0;
}

在这里插入图片描述

3）函数模板案例

在这里插入图片描述

#include <iostream>
using namespace std;

//实现通用 对数组进行排序的函数
//规则 从大到小
//算法 选择
//测试 char 数组、int 数组

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

//排序算法
template<class 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++)
		{
			//认定的最大值 比 遍历出的数值 要小，说明j下标的元素才是真正的最大值
			if (arr[max] < arr[j])
			{
				max = j;//更新最大值下标
			}
		}
		if (max != i)
		{
			//交换max和i元素
			mySwap(arr[max], arr[i]);
		}
	 }
}

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

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

void test02()
{
	//测试int数组
	int intArr[] = { 7,5,1,3,9,2,4,6,8 };

	int num = sizeof(intArr) / sizeof(int);

	mySort(intArr, num);

	printArray(intArr, num);
}

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

4）普通函数与函数模板的区别

在这里插入图片描述

#include <iostream>
using namespace std;

//1.普通函数调用可以发生隐式类型转换
//2.函数模板 用自动类型推导，不可以发生隐式类型转换
//3.函数模板 用显示指定类型，可以发生隐式类型转换

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

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

void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';// a - 97   c - 99
	cout << myAdd01(a, c) << endl;

	//自动类型推导
	//cout << myAdd02(a, c) << endl;

	//显示指定类型
	cout << myAdd02<int>(a, c) << endl;
}

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

在这里插入图片描述

5）普通函数与函数模板的调用规则

在这里插入图片描述

#include <iostream>
using namespace std;

//1.如果函数模板和普通模板都可以调用，优先调用普通函数
//2.可以通过空模板参数列表 强制调用 函数模板
//3.函数模板可以发生函数重载
//4.如果函数模板可以产生更好的匹配，优先调用函数模板

void myPrint(int a, int b)
{
	cout << "调用的普通函数" << endl;
}

template<class T>
void myPrint(T a, T b)
{
	cout << "调用的模板" << endl;
}

template<class T>
void myPrint(T a, T b, T c)
{
	cout << "调用的重载模板" << endl;
}

void test01()
{
	int a = 10;
	int b = 20;

	//myPrint(a, b);

	//通过空模板参数列表，强制调用函数模板
	//myPrint<>(a, b);

	//myPrint(a, b, 100);

	char c1 = 'a';
	char c2 = 'b';
	myPrint(c1, c2);
}

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

在这里插入图片描述

6）模板的局限性

在这里插入图片描述
在这里插入图片描述

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

class Person
{
public:

	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	//姓名
	string m_Name;
	//年龄
	int m_Age;
};

template<class T>
bool myCompare(T& a, T& b)
{
	if (a == b)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//利用具体化Person的版本实现代码，具体化优先调用
template<> bool myCompare(Person& p1, Person& p2)
{
	if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void test01()
{
	int a = 10;
	int b = 20;

	bool ret = myCompare(a, b);

	if (ret)
	{
		cout << "a==b" << endl;
	}
	else
	{
		cout << "a!=b" << endl;
	}
}

void test02()
{
	Person p1("Tom", 10);
	Person p2("Tom", 10);

	bool ret = myCompare(p1, p2);
	if (ret)
	{
		cout << "p1==p2" << endl;
	}
	else
	{
		cout << "p1!=p2" << endl;
	}
}

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

在这里插入图片描述

3.类模板

1）类模板语法

在这里插入图片描述

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

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

	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);
	p1.showPerson();

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

在这里插入图片描述

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

在这里插入图片描述

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

//类模板
template<class NameType,class AgeType=int>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

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

	NameType m_Name;
	AgeType m_Age;
};

//1.类模板没有自动类型推导使用方式
void test01()
{
	//Person p("孙悟空"，1000);

	Person<string, int>p("孙悟空", 1000);//正确，只能用显示指定类型

	p.showPerson();

}

//2.类模板在模板参数列表中可以有默认参数
void test02()
{
	Person<string>p("猪八戒", 999);

	p.showPerson();
}

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

在这里插入图片描述

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

在这里插入图片描述

#include <iostream>
using namespace std;

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();
	//m.func2();
}
int main()
{
	test01();
	return 0;
}

在这里插入图片描述

4）类模板对象做函数参数

在这里插入图片描述

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

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

//1.指定传入类型
void printPerson1(Person<string, int>& p)
{
	p.showPerson();
}

void test01()
{
	Person<string, int>p("孙悟空", 100);
	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("唐僧", 30);
	printPerson3(p);
}
int main()
{
	test01();
	test02();
	test03();
	return 0;
}

在这里插入图片描述

5）类模板与继承

在这里插入图片描述

#include <iostream>
using namespace std;

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()
{
	test01();
	test02();
	return 0;
}

在这里插入图片描述

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

在这里插入图片描述

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

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", 20);
	P.showPerson();
}
int main()
{
	test01();
	return 0;
}

在这里插入图片描述

7）类模板分文件编写

在这里插入图片描述

Person.hpp
#pragma once
#include <iostream>
using namespace std;

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;
}
Person.cpp
#include <iostream>
using namespace std;
#include <string>

//第一种解决方式，直接包含源文件
//#include "Person.cpp"

//第二种解决方式，将.h和.cpp中的内容写到一起，将后缀名改为.hpp文件
#include "Person.hpp"

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

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

在这里插入图片描述

8）类模板与友元

在这里插入图片描述

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

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

//类外实现
template<class T1, class T2>
void printPerson2(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)
	{
		cout << "姓名：" << p.m_Name << " 年龄：" <<p.m_Age << endl;
	}

	//全局函数 类外实现
	//加空模板参数列表
	//如果全局函数是类外函数，需要让编译器提前知道这个函数的存在
	friend void printPerson2<>(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", 20);
	printPerson(p);
}

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

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

在这里插入图片描述

9）类模板案例

在这里插入图片描述

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

template<class T>
class MyArray
{
public:

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

	//拷贝构造
	MyArray(const MyArray& arr)
	{
		//cout << "MyArray拷贝构造调用" << endl;
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		//this->pAddress = arr.pAddress;

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

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

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

	//尾插法
	void Push_Back(const T& val)
	{
		//判断容量是否等于大小
		if (this->m_Capacity == this->m_Size)
		{
			return;
		}
		this->pAddress[this->m_Size] = val;//在数组末尾插入数据
		this->m_Size++;//更新数组大小
	}

	//尾删法
	void Pop_Bake()
	{
		//让用户访问不到最后一个元素，即为尾删，逻辑删除
		if (this->m_Size == 0)
		{
			return;
		}
		this->m_Size--;
	}

	//通过下标方式访问数组中的元素 arr[0] = 100
	T& operator[](int index)
	{
		return this->pAddress[index];
	}

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

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

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

private:
	T* pAddress;//指针指向堆区开辟的真实数组

	int m_Capacity;//数组容量

	int m_Size;//数组大小

};
MyArray.cpp
#include <iostream>
using namespace std;
#include <string>
#include "MyArray.hpp"

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

void test01()
{
	MyArray<int>arr1(5);

	for (int i = 0; i < 5; i++)
	{
		//利用尾插法向数组中插入数据
		arr1.Push_Back(i);
	}
	cout << "arr1的打印输出为：" << endl;

	printIntArray(arr1);

	cout << "arr1的容量为：" << arr1.getCapacity() << endl;
	cout << "arr1的大小为：" << arr1.getSize() << endl;

	MyArray<int>arr2(arr1);

	cout << "arr2的打印输出为：" << endl;

	printIntArray(arr2);

	//尾删
	arr2.Pop_Bake();
	cout << "arr2尾删后：" << endl;
	cout << "arr2的容量为：" << arr2.getCapacity() << endl;
	cout << "arr2的大小为：" << arr2.getSize() << endl;

	//MyArray<int>arr3(100);
	//arr3 = arr1;
}



//测试自定义数据类型
class Person
{
public:

	Person() {};
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

void printPersonArray(MyArray<Person>& arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << "姓名：" << arr[i].m_Name << " 年龄：" << arr[i].m_Age << endl;
	}
}
void test02()
{
	MyArray<Person>arr(10);

	Person p1("孙悟空", 999);
	Person p2("韩信", 30);
	Person p3("妲己", 20);
	Person p4("赵云", 20);
	Person p5("安其拉", 27);

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

	//打印数组
	printPersonArray(arr);

	//输出容量
	cout << "arr容量为：" << arr.getCapacity() << endl;
	//输出大小
	cout << "arr大小为：" << arr.getSize() << endl;
}

int main()
{
	test01();
	test02();

	return 0;
}

在这里插入图片描述

木筏筏筏
关注
专栏目录
重构-改善既有代码的设计
06-10
8.15　Replace Type Code with State/Strategy（以State/Strategy取代类型码） 227 8.16　Replace Subclass with Fields（以字段取代子类） 232 第9章　简化条件表达式 237 9.1　Decompose Conditional（分解条件...
重构-改善既有代码的设计 中文版
07-20
8.15 Replace Type Code with State/Strategy （以State/Strategy取代型别码） 8.16 Replace Subclass with Fields（以值域取代子类） 第9章 简化条件表达式 9.1 Decompose Conditional（分解条件式） 9.2 Co ...
leetcode-算法刷题笔记
温柔一刀
09-12 107
官方网址http://leetcode-solution.cn/book 文前 [1]https://chrome.google.com/webstore/detail/leetcodecheatsheet/fniccleejlofifaakbgppmbbcdfjonl 正文 [1] https://github.com/azl397985856/leetcode/blob/master/daily/2019-07-31.md [2] https://leetcode-cn.com/problems/ad
javaSE笔记
weixin_44478522的博客
07-22 344
视频链接：https://www.bilibili.com/video/BV1Yb411z7PG?spm_id_from=333.337.search-card.all.click
C++PrimerPlus 第八章 函数探幽-8.5 函数模板
Hank_W
12-19 836
现在的C++编译器实现了C++新增的一项特性——函数模板。函数模板是通用的函数描述，也就是说，它们使用泛型来定义函数，其中的泛型可用具体的类型（如int或double）替换。通过将类型作为参数传递给模板，可使编译器生成该类型的函数。由于模板允许以泛型（而不是具体类型）的方式编写程序，因此有时也被称为通用编程。由于类型是用参数表示的，因此模板特性有时也被称为参数化类型（parameterized types）。下面介绍为何需要这种特性以及其工作原理。
2019-08
diexian5592的博客
09-07 207
8.1 hex内置函数直接将十进制数转换成十六进制 把十六进制等其他转回十进制可以使用eval 、 eval ('0x3d') 就可以将16进制转换成十进制 数据库的集群配置得在同一个网段？zabbix的主备使用的是代理模式，正常情况下代理端指向主的数据库，异常情况可以改变为备数据库，代理端可以理解为一个zabbix服务端 集合真是个好东西，快速进行两个列表的比较， pymysql模块...
暑假刷题记录--zhengjun
A_zjzj的博客
08-22 963
暑假刷题记录--zhengjun7月份7.17.157.167.177.187.207.227.237.247.257.277.287.297.307.318.18.38.48.58.68.88.138.148.158.168.188.198.208.21by-zhengjun 7月份 7.1 P3388 【模板】割点（割顶）tarjan割点模板 原题 7.15 P3371 【模板】单源最短路径（弱化版） 单源最短路SPFA/Dij模板 原题 P1948 [USACO08JAN]Telephone Line
《重构》笔记 - 持续更
weixin_30493321的博客
01-05 83
第1章 重构，第一个案例 1.1 起点 当你发现自己需要为程序添加一个特性，而代码结构使你无法很方便第达成目的，那就先重构那个程序，使特性的添加比较容易进行，然后再添加特性 1.2 重构的第一步 为即将修改的代码建立一组可靠的测试环境。 1.3 分解并重组 将长长的函数切开，并将较小块的代码移至更合适的类。 1.4 运用多态取代条件逻辑 最好不要在另一个对象的属性基础上运用swit...
gitlab-ci配置详解(二)
大灰狼的小绵羊哥哥的博客
04-23 5168
jobs(任务) .gitlab-ci.yml允许用户创建无数多个任务.但是每个任务必须有一个独一无二的名字，但不能是以下保留字.一个任务是由一列参数定义的，来决定任务的工作内容和行为. job_name: # 要跑的脚本或命令列表 script: - rake spec - coverage # pipelines阶段 stage: test # 只针对哪个分支 only: - master # 除了哪个分支以外 except: - d
Java面试题（一）- 基础
qq_39291028的博客
08-12 650
目录 1. String 2. final, finally, finalize 3. Overload和Override 4. abstract 和interface 5. &和&& 6. 基本数据类型 7. 异常 8. 线程 9. 访问权限 10. equals 11. 集合 12. IO 13. JVM 14. 设计模式 15. 反射 ...
Google C++ 风格指南 - 中文版
yuliying的专栏
03-15 834
from    http://code.google.com/p/google-styleguide/   版本: 3.133 原作者: Benjy Weinberger Craig Silverstein Gregory Eitzmann Mark Mentovai Tashana Landray 翻译: YuleFox yospaly 项
C++与QML的数据交互
qq_50679120的博客
09-11 471
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】CLion配置cout打印语句快捷键
qq_38196449的博客
09-10 241
当我们sout时，自动出现打印语句。点击Apply 和 OK 保存。
C语言从头学59——学习头文件math.h（二）
最新发布
m0_72128260的博客
09-11 438
继续学习头文件的数学函数。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 876
set、map仿STL模拟实现
C++位图的实现与详解
2301_80468112的博客
09-09 668
在讲解位图之前我们先来看一道很经典的面试题。给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。我们有以下两种种解决方法：1. 遍历，时间复杂度O(N)。（太慢）2. 排序(O(NlogN))，利用二分查找: logN。深入分析:解题思路2是否可行，我们先算算40亿个数据大概需要多少内存。
电计量付费系统标准传输规格-RTL8152B(N)布局解析
8.1至8.14节明确了Meter Application Process（电表应用程序过程）的要求，比如如何处理不同类型的令牌，如接受/拒绝令牌、设置最大功率限制、清除信用等，这些都是电能表核心功能的一部分。 9.1和9.2节涉及Key ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值