C++第三部分提高编程1（模板）

最新推荐文章于 2024-11-02 14:05:25 发布
最新推荐文章于 2024-11-02 14:05:25 发布
阅读量72 收藏
点赞数 1
分类专栏： 第三部分-提高编程 C++基础语法学习，入门新手黑马 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liaoyuan1130/article/details/132123117
版权

函数模板

1.1 函数模板基本语法

/* template<typename T>*/
void swapint(int &a,int &b)
{
	int temp = a;
	a = b;
	b = temp;
}
void swapdouble(double &a, double &b)
{
	double temp = a;
	a = b;
	b = temp;
}
//函数模板
template<typename T>
void myswap(T &e,T &f)
{
	T temp = e;
	e = f;
	f = temp;

}
void test01()
{
	int a = 10;
	int b = 20;
	//swapint(a, b);
	//cout << "a=" << a << endl;
	//cout << "b=" << b << endl;
	//double c = 1.1;
	//double d = 2.2;
	//swapdouble(c, d);
	//cout << "c=" << c << endl;
	//cout << "d=" << d << endl;
	//myswap(a, b);//1.自动类型推导
	myswap<int>(a, b);//2.显示指定类型
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
}

int main()
{


	test01();

	system("pause");
	return 0;
}

1.2 函数模型注意事项

template<class T>
void myswap(T &e, T &f)
{
		T temp = e;
		e = f;
		f = temp;
}
//1.自动类型推导，需要一致的数据类型T

//2.模板必须要确定出T的数据类型，才可以使用
void test01()
{
	int a = 10;
	int b = 20;
	myswap<int>(a, b);
		cout << "a=" << a << endl;
		cout << "b=" << b << endl;
}

int main()
{


	test01();

	system("pause");
	return 0;
}

1.3 函数模板案例

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

//交换的函数模板
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++)
		{
			//认定的最下值比遍历出的数值要小，说明j下标的元素才是最大值
			if (arr[max] < arr[j])
			{
				max = j;
			}                                                                                                                        
		}
		if (max != i)
		{
			//交换max和i元素
			myswap(arr[max], arr[i]);
		}

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


void test01()
{
	//测试char数组
	char chararr[] = "badcfe";
	int len = sizeof(chararr) / sizeof(char);
	mysort(chararr, len);
	printarray(chararr, len);


}

int main()
{


	test01();

	system("pause");
	return 0;
}

1.4 普通函数与函数模板的区别

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

int myadd01(int a,int b)
{
	return a + b;
}

template<typename T>
T myadd02(T a, T b)
{
	return a + b;
}
void test01()
{
	int a = 10;
	int b = 20;
	cout << myadd01(a, b) << endl;
	char c = 'c'; //Ascll
	cout << myadd01(a, c) << endl;//可以自动转换

	//cout << myadd02(a, c) << endl;//不可以自动转换
	cout << myadd02<int>(a, c) << endl;//可以自动转换
}


int main()
{


	test01();

	system("pause");
	return 0;
}

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

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;
	int c = 30;
	//myprint(a, b);//优先调用普通函数
	//所以通过空模板参数列表来强制调函数模板
	myprint<>(a, b);
	myprint(a, b, 100);//函数模板也可以发生函数重载

	//如果函数模板可以产生更好的匹配，优先调用函数模板
	char c1 = 'a';
	char c2 = 'b';
	myprint<>(c1, c2);
}
int main()
{


	test01();

	system("pause");
	return 0;
}

1.6 函数的局限性


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

}
//下面不行，会报错,要加上template<>bool mycompare(person &p1, person&p2)的代码才行，或者对运算符重载
void test02()
{
	person p1("Tom", 10);
	person p2("Tom", 20);
	bool ret2 = mycompare(p1, p2);
	if (ret2)
	{
		cout << "p1==p2" << endl;
	}
	else
	{
		cout << "p1!=p2" << endl;
	}
}



int main()
{


	//test01();
	test02();
	system("pause");
	return 0;
}

1.7 类模板

template<class nametype,class agetype >
class person
{
public:
	person(nametype name, agetype age)
	{
		this->m_name = name;
		this->m_age = age;
	}


	void showperson()
	{
		cout << this->m_name << endl;
		cout << this->m_age << endl;
	}
	nametype m_name;
	agetype m_age;

};

void test01()
{
	
	
	person<string, int>p1("张三", 14);
	p1.showperson();

}


int main()
{


	test01();
	
	system("pause");
	return 0;
}

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

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


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 << this->m_name << endl;
		cout << this->m_age << endl;
	}
	nametype m_name;
	agetype m_age;

};


//类模板没有自动类型推导
void test01()
{
	//person p("张三", 14);//错误,类模板没有自动类型推导
	person<string, int>p1("张三", 14);
	p1.showperson();

}
//类模板在模板参数列表中可以有默认参数
void test02()
{
	//若上面的类模板改为template<class nametype, class agetype=int>
	person<string>p2("李四", 24);//这里少掉int也不会报错
	p2.showperson();

}

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

	system("pause");
	return 0;
}

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

//1.类模板中成员函数在调用时才去创建
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();
	

	system("pause");
	return 0;
}

1.10 类模板对象做函数参数

//1.指定传入类型，直接显示对象的数据类型
//2.参数模板化
//3.整个类模板化
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 << endl;
		cout << 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("张三", 14);
	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("李四", 15);
	printperson2(p);
}
//3.整个类模板化
template<class T>
void printperson3(T &p)
{
	p.showperson();
	cout << "T的参数类型：" << typeid(T).name() << endl;

}
void test03()
{
	person<string, int>p("王五", 16);
	printperson3(p);
}

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

1.11类模板与继承

//1.当父类是类模板时，子类在声明时，要指定父类T的类型

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

//class son :public base//错误，必须要知道父类T的类型，才能继承
class son:public base<int>
{

};
//、如果想灵活的指定父类中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 test01()
{
	son2<int, char>s2;//这里使父类的T也变成了char
	
}


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

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


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 << endl;
	//	cout << 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 << endl;
		cout << this->m_age << endl;
}


void test01()
{
	person<string, int>p("张三", 14);
	p.showperson();

}


int main()
{
	test01();

	system("pause");
	return 0;
}

1.13 类模板的分文件编写


//类模板分文件编写问题以及解决
//将下面的东西都复制过去
//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 << endl;
//		cout << this->m_age << endl;
//}

void test01()
{
	person<string, int>p("张三", 14);
	p.showperson();
}


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

1.14类模板与友元

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


//通过全局函数打印person信息

template<class t1, class t2>//类外实现，还得先声明这个person类
class person;
//类外实现
template<class t1, class t2>
void printperson2(person<t1, t2>p)
{
	cout << "这是类外实现：" << endl;
	cout << p.m_name << endl;
	cout << p.m_age << endl;
}

template<class t1,class t2>
class person
{
	//全局函数类内实现  friend void printperson(person<t1, t2>p)
	friend void printperson(person<t1, t2>p)
	{
		cout << "这是类内实现：" << endl;
		cout << p.m_name << endl;
		cout << 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("张三", 16);
	printperson(p);
	printperson2(p);
}

int main()
{
	
	test01();
	system("pause");
	return 0;
}
lyoneself
关注
专栏目录
C++模板元编程（0）模板编程与泛型编程
二进制君
04-04 3833
什么是元编程 元编程 (metaprogramming) 通过操作 程序实体 (program entity)，在 编译时 (compile time) 计算出 运行时 (runtime) 需要的常数、类型、代码的方法。 一般的编程是通过直接编写 程序 (program)，通过编译器 编译 (compile)，产生目标代码，并用于 运行时 执行。与普通的编程不同，元编程则是借助语言提供的 模板 (template) 机制，通过编译器 推导 (deduce)，在 编译时 生成程序。元编程经过编译器推导得到的程
朱老师C++课程第3部分3.1-C++模板编程入门
06-30
朱老师C++第1部分-从C到C++ 朱老师C++第2部分-C++和面向对象 朱老师C++第3部分-STL等和泛型 朱老师C++第4部分-Boost库和设计模式 朱老师C++第5部分-C++编程优化   课程特色 *完全零基础，降低学习门槛。 *深入浅出...
C++模板元编程详细教程（之五）
fl2011sx的博客
01-31 3333
《C++模板元编程详细教程》系列文章的第5篇，主要介绍了模板元编程两大要素的第一要素——静态数值计算
C++之模板编程
u010378559的博客
05-04 2213
C++模板编程总结
C++模板元编程详细教程（之一）
热门推荐
fl2011sx的博客
12-02 1万+
《C++模板元编程详细教程》系列文章的第一篇，主要介绍了模板的概念以及基本的模板语法和相关示例。
C++ 泛型编程 之模板（template）
qq_24472227的博客
04-29 5282
C++的 函数模板与类模板
【C++】模板与泛型编程
Qiuhan_909的博客
03-29 959
1. 函数模板 2. 类模板 3. 非类型模板参数 4. 模板编译 5. 模板特化 6. 可变参数模板
C++ 模板元编程（1）-概念 concept
no_to_last的博客
01-20 1492
模板元编程（template metaprogramming）是一种利用 C++ 模板机制在编译期生成或修改代码的技术，它可以用来实现一些运行期无法完成的任务，或者提高运行期的效率。模板元编程是一种典型的元编程（metaprogramming）方式，即用代码来操作代码。我们使用了概念 IsOdd 来约束模板参数 T 必须是一个奇数，然后我们对模板函数 add 进行了特化，使得当两个参数都是奇数时，返回结果加一。这样，我们就实现了一种编译期的分支逻辑，根据不同的参数类型选择不同的函数实现。
C++模板元编程详细教程（之三）
fl2011sx的博客
12-15 3066
《C++模板元编程详细教程》系列文章的第3篇，主要介绍的是模板的链接方式和模板的特化
C++ 模板元编程简介
Dablelv 的博客专栏。
09-17 2648
1.概述 模板元编程（Template Metaprogramming，TMP）是编写生成或操纵程序的程序，也是一种复杂且功能强大的编程范式（Programming Paradigm）。C++模板给C++提供了元编程的能力，但大部分用户对 C++ 模板的使用并不是很频繁，大致限于泛型编程，在一些系统级的代码，尤其是对通用性、性能要求极高的基础库（如 STL、Boost）几乎不可避免在大量地使用 C...
C++高阶必会操作--模板元编程
轻松学C语言
07-19 1485
点击蓝字关注我们泛型编程大家应该都很熟悉了，主要就是利用模板实现“安全的宏”，而模板元编程区别于我们所知道的泛型编程，它是一种较为复杂的模板，属于C++的高阶操作了，它最主要的优点就在于把计算过程提前到编译期，能带来可观的性能提升。接下来，一起来学习吧。1、概述模板元编程（Template Meta programming，TMP）是编写生成或操纵程序的程序，也是一种复杂...
C++核心编程第一部分讲义.doc
10-30
C++语言融合了三种不同的编程方式：过程性语言、面向对象语言和泛型编程。C++语言的学习可以相互促进C语言的学习，反之亦然。 1. C++概述 * C++语言的名称来自于C语言中的递增运算符++ * C++语言是对C语言的扩展，...
第一阶段C++提高编程.pdf第二阶段C++提高编程.pdf第三阶段C++ 核心编程.pdf
10-08
第三阶段：“第三阶段程序员C++核心编程.pdf”更进一步，可能涵盖了C++的高级主题，如异常处理、命名空间、内联函数、预处理器宏、以及更深入的内存管理，包括动态内存分配和智能指针。此外，可能还会涉及多线程编程...
朱老师C++课程第3部分3.4.模板特化与类型萃取
07-01
朱老师C++第1部分-从C到C++ 朱老师C++第2部分-C++和面向对象 朱老师C++第3部分-STL等和泛型 朱老师C++第4部分-Boost库和设计模式 朱老师C++第5部分-C++编程优化和常见面试题   课程特色 *完全零基础，降低学习门槛...
黑马程序员匠心之作 C++教程_第5阶段-C++提高编程资料讲义.rar
03-19
《黑马程序员匠心之作 C++教程_第5阶段-C++提高编程资料讲义》是一份针对C++编程初学者精心制作的教程资料，旨在帮助学习者深入理解和提升C++编程技能。这份讲义涵盖了许多关键的C++知识点，下面将对其进行详细解读...
HJ51输出单向链表中倒数第k个结点
晴山の博客
10-29 304
HJ51输出单向链表中倒数第k个结点。
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 245
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
c++中局部变量和全局变量同名，使用::访问全局变量
最新发布
weixin_43845922的博客
11-02 209
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
第八天: C语言深度探索：指针与函数的奥秘
qq_57484399的博客
10-31 585
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
C++编程思想第二版第1卷：标准C++入门指南
"C++编程思想(第2版)_第1卷_标准C++引导 中文版的" 《C++编程思想》是Bjarne Stroustrup所著的经典之作，第二版分为多卷，其中第一卷主要关注标准C++的引导学习。这本书深入浅出地介绍了C++编程语言的核心概念和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值