函数模版中的引用

最新推荐文章于 2024-03-15 19:38:16 发布
最新推荐文章于 2024-03-15 19:38:16 发布
阅读量835 收藏
点赞数
分类专栏： C++笔记 C++疑问 文章标签： types 2010 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wdy_yx/article/details/7668682
版权

一：函数模版和特化模版的引用

1.首先考虑特化函数模版的参数


#include "stdafx.h"
#include<iostream>
#include<ostream>
#include<istream>
template<class T>
int compare( T ls, T rs)
{
	if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;
}


template<>
int compare(const int& ls,const int& rs)
{
	std::cout<<"first \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}

int _tmain(int argc, _TCHAR* argv[])
{
	int first1(1),first2(2);
	int &second1(first1);
	int &second2(first2);
	const int &third1(first1);
	const int &third2(first2);
	int r(0);

	r = compare(first1,first2);
	std::cout<<r<<'\n';

	r = compare(second1,second2);
	std::cout<<r<<'\n';

	r = compare(third1,third2);
	std::cout<<r<<'\n';

	r = compare(3,2);
	std::cout<<r<<'\n';
	
	std::cin>>r;
	return 0;
}

对compare模版定义了 const &int的特化，请预测结果是：

？

实际上结果是

-1

-1

-1

1

也就是四个调用都实例了函数模版，并没有调用特化模版，甚至常量引用third1,third2作为参数仍然么有调用对应的特化模版。


如果我们去掉特化模版形参的const和&如下：

#include "stdafx.h"
#include<iostream>
#include<ostream>
#include<istream>
template<class T>
int compare(  T ls, T rs)
{
	if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;
}


template<>
int compare( int ls, int rs)
{
	std::cout<<"first \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}


int _tmain(int argc, _TCHAR* argv[])
{
	int first1(1),first2(2);
	int &second1(first1);
	int &second2(first2);
	const int &third1(first1);
	const int &third2(first2);
	int r(0);

	r = compare(first1,first2);
	std::cout<<r<<'\n';

	r = compare(second1,second2);
	std::cout<<r<<'\n';

	r = compare(third1,third2);
	std::cout<<r<<'\n';

	r = compare(3,2);
	std::cout<<r<<'\n';
	
	std::cin>>r;
	return 0;
}
结果为

first

-1

first

-1

first

-1

first

1

全部调用特化函数模版。


当特化模版形参为引用时，如下

#include "stdafx.h"
#include<iostream>
#include<ostream>
#include<istream>
template<class T>
int compare(  T ls, T rs)
{
	if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;
}


template<>
int compare( int &ls, int &rs)
{
	std::cout<<"first \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}

int _tmain(int argc, _TCHAR* argv[])
{
	int first1(1),first2(2);
	int &second1(first1);
	int &second2(first2);
	const int &third1(first1);
	const int &third2(first2);
	int r(0);

	r = compare(first1,first2);
	std::cout<<r<<'\n';

	r = compare(second1,second2);
	std::cout<<r<<'\n';

	r = compare(third1,third2);
	std::cout<<r<<'\n';

	r = compare(3,2);
	std::cout<<r<<'\n';
	
	std::cin>>r;
	return 0;
}
结果是

-1

-1

-1

1

这次所有都调用的是实例化的函数模版而不是特化函数模版。

2.函数模版的参数变化

接下来对函数模版compare添加引用

#include "stdafx.h"
#include<iostream>
#include<ostream>
#include<istream>
template<class T>
int compare( T &ls, T &rs)
{
	if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;
}


template<>
int compare(const int& ls,const int& rs)
{
	std::cout<<"first \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}


int _tmain(int argc, _TCHAR* argv[])
{
	int first1(1),first2(2);
	int &second1(first1);
	int &second2(first2);
	const int &third1(first1);
	const int &third2(first2);
	int r(0);

	r = compare(first1,first2);
	std::cout<<r<<'\n';

	r = compare(second1,second2);
	std::cout<<r<<'\n';

	r = compare(third1,third2);
	std::cout<<r<<'\n';

	r = compare(3,2);
	std::cout<<r<<'\n';
	
	std::cin>>r;
	return 0;
}

调用 

r = compare(3,2);

时提示

1>e:\sourcecodes\comparetest\comparetest\comparetest.cpp(67) : error C2664: 'compare' : cannot convert parameter 1 from 'int' to 'int &'
这个错误和 

int &a = 1;

这样的代码语句错误是一样的。


以下转自http://developer.51cto.com/art/201002/183476.htm

关于引用的初始化有两点值得注意：

（1）当初始化值是一个左值（可以取得地址）时，没有任何问题；

（2）当初始化值不是一个左值时，则只能对一个const T&（常量引用）赋值。而且这个赋值是有一个过程的：

首先将值隐式转换到类型T，然后将这个转换结果存放在一个临时对象里，最后用这个临时对象来初始化这个引用变量。

  • const double& cdr = 1; // ok
相当于 

 
 
  1. double temp = double(1);  
  2. const double& cdr = temp;

注释掉语句

	r = compare(3,2);
	std::cout<<r<<'\n';
所得结果为

-1

-1

-1


所以我们再次将函数模版compare的形参加上const 

#include "stdafx.h"
#include<iostream>
#include<ostream>
#include<istream>
template<class T>
int compare( const T &ls, const T &rs)
{
	if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;
}


template<>
int compare(const int& ls,const int& rs)
{
	std::cout<<"first \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}

int _tmain(int argc, _TCHAR* argv[])
{
	int first1(1),first2(2);
	int &second1(first1);
	int &second2(first2);
	const int &third1(first1);
	const int &third2(first2);
	int r(0);

	r = compare(first1,first2);
	std::cout<<r<<'\n';

	r = compare(second1,second2);
	std::cout<<r<<'\n';

	r = compare(third1,third2);
	std::cout<<r<<'\n';

	r = compare(3,2);
	std::cout<<r<<'\n';
	
	std::cin>>r;
	return 0;
}

结果为

first

-1

first

-1

first

-1

first

1

这次均调用了特化的函数模版！！！！

3.加上重载函数

接下来我们在特化模版后再加入同样形参的函数

int compare(const int& ls,const int& rs)
如下 

#include "stdafx.h"
#include<iostream>
#include<ostream>
#include<istream>
template<class T>
int compare( const T &ls, const T &rs)
{
	if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;
}


template<>
int compare(const int& ls,const int& rs)
{
	std::cout<<"first \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}


int compare(const int& ls,const int& rs)
{
	std::cout<<"SECOND \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}

int _tmain(int argc, _TCHAR* argv[])
{
	int first1(1),first2(2);
	int &second1(first1);
	int &second2(first2);
	const int &third1(first1);
	const int &third2(first2);
	int r(0);

	r = compare(first1,first2);
	std::cout<<r<<'\n';

	r = compare(second1,second2);
	std::cout<<r<<'\n';

	r = compare(third1,third2);
	std::cout<<r<<'\n';

	r = compare(3,2);
	std::cout<<r<<'\n';
	
	std::cin>>r;
	return 0;
}
这次结果为

SECOND

-1

SECOND

-1

SECOND

-1

SECOND1

从结果我们可以看出函数重载了函数模版以及特化模版。


4重载和函数模版

#include "stdafx.h"
#include<iostream>
#include<ostream>
#include<istream>
template<class T>
int compare(  T ls, T rs)
{
	if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;
}

int compare(const int& ls,const int& rs)
{
	std::cout<<"SECOND \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}

结果

SECOND

-1

SECOND

-1

SECOND

-1

SECOND

1


重载函数去掉const，只留&

#include "stdafx.h"
#include<iostream>
#include<ostream>
#include<istream>
template<class T>
int compare(  T ls, T rs)
{
	if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;
}


int compare( int& ls, int& rs)
{
	std::cout<<"SECOND \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}

结果为

SECOND

-1

SECOND

-1

-1

1

说明int,int &调用的函数，const &,常量数字调用的函数模版。



#include "stdafx.h"
#include<iostream>
#include<ostream>
#include<istream>
template<class T>
int compare(  T ls, T rs)
{
	if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;
}

int compare( int ls, int rs)
{
	std::cout<<"SECOND \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}

结果

SECOND

-1

SECOND

-1

SECOND

-1

SECOND

1

均调用的函数非模版。


为模版添加引用

#include "stdafx.h"
#include<iostream>
#include<ostream>
#include<istream>
template<class T>
int compare(  T &ls, T &rs)
{
	if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;
}


int compare( int ls, int rs)
{
	std::cout<<"SECOND \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}

结果

SECOND

-1

SECOND

-1

SECOND

-1

SECOND

1

再添加常量

#include "stdafx.h"
#include<iostream>
#include<ostream>
#include<istream>
template<class T>
int compare( const T &ls, const T &rs)
{
	if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;
}


int compare( int ls, int rs)
{
	std::cout<<"SECOND \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}

结果

SECOND

-1

SECOND

-1

SECOND

-1

SECOND

1

#include "stdafx.h"
#include<iostream>
#include<ostream>
#include<istream>
template<class T>
int compare(   T &ls,  T &rs)
{
	if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;
}


int compare( int &ls, int &rs)
{
	std::cout<<"SECOND \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}
结果

SECOND

-1

SECOND

-1

r = compare(3,2);
出错 

1>e:\sourcecodes\comparetest\comparetest\comparetest.cpp(78) : error C2665: 'compare' : none of the 2 overloads could convert all the argument types
1>        e:\sourcecodes\comparetest\comparetest\comparetest.cpp(9): could be 'int compare<int>(T &,T &)'
 1>        e:\sourcecodes\comparetest\comparetest\comparetest.cpp(33): or       'int compare(int &,int &)'





#include "stdafx.h"
#include<iostream>
#include<ostream>
#include<istream>
template<class T>
int compare(   T ls,  T rs)
{
	if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;
}


int compare( int &ls, int &rs)
{
	std::cout<<"SECOND \n";
		if(ls<rs)
		return -1;
	if(rs<ls)
		return 1;
	return 0;

}

SECOND

-1

SECOND

-1

-1




最后留下的疑问是当函数模版的参数不是引用时，如下，

int compare( T ls, T rs)
为什么特化模版 

template<>
int compare(const int& ls,const int& rs)
没有起到作用

而

template<>
int compare( int ls, int rs)


kingeasternsun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
函数模板中的参数引用问题
Darren's Thought
09-08 1671
看下面两个例子： #include #include using namespace std; template void fun(T1 t[5]) { cout<<t[6]<<endl; } int main() { int ia[]={1,2,3,4,5}; fun(ia); return 0; } #include #include using nam
c++函数模板和类模板计实验报告
04-26
这个函数模板接受两个类型相同的引用作为参数，通过临时变量`temp`实现了交换过程。这个模板可以用于任何可以赋值的数据类型，如`int`、`double`或者自定义的类类型。 第二部分，我们编写了一个`sort`函数模板，...
向函数传递参数（传值、传引用、传const引用）
C++ 爱好者 make_it_simple888
09-03 1510
向函数传递参数（传值、传引用、传const引用）
18.C++中模板参数类型推断与引用
机器人视觉感知
10-20 296
第一个编译规则，当将一个左值传递给模板函数的模板类型右值引用的参数时，编译器推断模板类型参数为实参的左值引用类型。所以调用。
【vue.js】文档解读【day 5】| ref模板引用
最新发布
认真在学习的小白博客
03-15 797
在前面学过的v-onv-ifv-show等指令都是对DOM操作的抽象指令，而有时我们需要直接访问底层DOM元素。例如在我们刚挂载完组件实例时，想要将一个input输入框聚焦。参照之前的知识好像无法完成，在该章节我们可以使用vue提供的ref属性。我们称为模板引用。
引用和函数模板的相关注意事项
weixin_45861463的博客
10-22 235
函数模板的注意事项： 函数模板是把相同函数名的函数通过 改变参数的类型，顺序，个数 来使同一个名字的函数实现不同的功能 但是注意：不能通过改变返回值的类型构造函数重载 引用的相关注意事项： 1.引用必须初始化，且初始化之后不可以更改 如： int &b； 这是不对的，因为没有初始化，且b成为a的别名后就不能是c的别名了 2.引用传参时，可以利用引用的方式让形参修饰实参，就是在传参时候把主函数中的值都改变，而不是只改变函数中的局部参数（其效果与地址传递即用指针传递异曲同工，但不同于值传递）.
探讨:C++中函数返回引用的注意事项
09-05
在C++编程语言中，函数返回值有两种主要方式：返回值和返回引用。返回值会创建一个临时副本，而返回引用则不会。本文主要讨论了在C++中使用函数返回引用时需要注意的一些关键点。 首先，函数可以返回引用作为其...
C++ 类模板、函数模板全特化、偏特化的使用
12-20
本文将深入探讨类模板和函数模板的全特化与偏特化。 一、类模板全特化与偏特化 1. 全特化（Full Specialization） 全特化是指为类模板或函数模板指定一个完全特定的类型参数列表，创建一个独立的非模板类或函数。...
C++函数模板
11-23
在C++中，函数模板是一种非常强大的特性，它允许我们编写能够处理多种数据类型的通用函数。通过使用模板，我们可以避免重复编写相同逻辑但适用于不同数据类型的代码。这不仅提高了代码的可重用性，还减少了出错的...
简单类与函数模板实验报告
06-07
`Swap`函数模板接受两个引用参数`T & t1`和`T & t2`，可以交换任何相同类型的数据。这个函数在实验中被用于交换`CStudent`对象。 6. **拷贝构造函数（Copy Constructor）**： - 拷贝构造函数是一个特殊的构造函数...
C++ 引用与引用作为函数的参数
zhangxu
03-05 4万+
对一个数据建立一个“引用”，他的作用是为一个变量起一个别名。这是C++对C语言的一个重要补充。
第十六章
peakyblinder的博客
05-21 164
16.1.1        函数模板可以用与非模板函数一样的方式声明为 inline。说明符放在模板形参表之后、返回类型之前，不能放在关键字 template 之前。 16.1.3        模板形参遵循常规名字屏蔽规则。与全局作用域中声明的对象、函数或类型同名的模板形参会屏蔽全局名字： typedef double T; template &lt;class T&gt; T calc(con...
关于模板和函数传参
Tan_HandSome的博客
07-21 955
#include using namespace std; //定义了一个函数模板，采用引用传参 template void mswap(A &a, A &b) { A c; c = a; a = b; b = c; } /*A是一种类型，当实际调用的时候会根据参数类型而变化，比如a，b是int类型的，那么在实际调用时就会变成int类型的，而a，b是float类型的，那么在
C++引用
weixin_50866517的博客
01-29 387
引用函数函数模板引用函数模板函数模板具体化 引用 1.c和c++使用&符合来表示指示变量的地址，c++给&符合赋予了另一个含义，将其用来声明引用。例如：将rodents作为rats变量的别名： int rats; int & rodents = rats; 其中，&不是地址运算符，而是类型标识的一部分。就像声明中的char*指的是指向char的指针一样，int&指的是指向int的引用。例： #include <iostream> using namesp
函数模板和模板函数(引用)
lishuiwang的专栏
10-08 7667
函数模板和模板函数(引用)1.函数模板的声明和模板函数的生成 1.1函数模板的声明 函数模板可以用来创建一个通用的函数，以支持多种不同的形参，避免重载函数的函数体重复设计。它的最大特点是把函数使用的数据类型作为参数。 函数模板的声明形式为： template(参数表) {
C++函数模板(二)引用
luoganttcc的博客
11-15 585
#include <iostream> using namespace std; template<typename T> void Swap(T &a, T &b){ T temp = a; a = b; b = temp; } int main(){ //交换 int 变量的值 int n1 = 100, n2 = 200; Swap(n1, n2); cout<<n1<<", "&l
模板函数调用
fireeeea的博客
04-24 4672
#include&lt;iostream&gt;using namespace std;template &lt;class t&gt;t MAX(t a,t b){    cout&lt;&lt;"模板一被调用"&lt;&lt;endl; }template&lt;class T1,class T2&gt;T1 MAX(T1 a,T2 b){    cout&lt;&lt;"函数二
C++模板：函数模板和模板函数
热门推荐
HavenZhao的专栏
05-20 14万+
1.函数模板的声明和模板函数的生成 1.1函数模板的声明 函数模板可以用来创建一个通用的函数，以支持多种不同的形参，避免重载函数的函数体重复设计。它的最大特点是把函数使用的数据类型作为参数。 函数模板的声明形式为： template (参数表) {     函数体 } 其中，template是定义模板函数的关键字；template后面的尖括号不能省略；typename（或cl
普通函数与函数模板的调用规则
嵌入式
07-01 1866
规则： 如果函数模板和普通函数都可以实现，优先调用普通函数 可以通过空模板参数列表来强制调用函数模板 函数模板也可以发生重载 如果函数模板可以产生更好的匹配,优先调用函数模板 测试代码： #include <iostream> #include <string> using namespace std; //普通函数与函数模板调用规则 void myPrint(int...
vue3 ref函数模板引用
08-07
在模板中，可以通过 `.value` 来访问 `ref` 创建的引用对象的值： ```html {{ myValue.value }} ``` 这样，`myValue` 就成为了一个响应式的变量，当它的值发生变化时，相关的视图也会自动更新。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值