c模板函数使用方法

A. C语言函数模板问题

首先，C没有函数模版。C++才有。

其次，template <class T>是函数声明的一部分，所以下面函数实现应该是：
template <class T>
void swap(T &a,T &b){
int temp;
temp=a;
a=b;
b=temp;
}

最后，#include <iostream>，在标准的C++函数中，std的域中已经有一个swap函数。
而且前面也using namespace了。函数声明重复。
两个办法：
1 swap(i,j);改为 ::swap(i,j); //全局化。
2 swap改个名字。

B. c++ 模板函数 函数参数运用引用

如果你使用模板函数的话，就只能每个函数一个模板参数，例如;
template<typename T> void a(T t){...}

template<typename T> void b(T t){...}

template<typename T> void c(T t){...}

a,b,c三个函数的模板参数T互不相关，如果你想几个函数使用共同的模板参数的话，你应当使用模板类，例如：
template<typename T> class MyClass
{
void a(T t){...}

void b(T t){...}
void c(T t){...}
};
这样a,b,c三个函数的参数类型T就是统一类型了。在这里T对应a,b,c三个函数来说仅仅是参数类型，而不是模板参数了。
以上回答你满意么？

C. c语言中函数的调用方法

呃···
看书会比较明白吧···
1、函数声明： 返回类型 函数名（形参1，形参2,形参3）；（以此类推，有几个参数写几个）
2、函数调用：函数名 （实参1，实参2，实参3）； （以此类推，有几个参数写几个）

3、函数算法：返回类型 函数名（形参1，形参2,形参3）（以此类推，有几个参数写几个）

{

}

D. C语言sort函数如何使用

C语言中没有预置的sort函数。如果在C语言中，遇到有调用sort函数，就是自定义的一个函数，功能一般用于排序。

一、可以编写自己的sort函数。

如下函数为将整型数组从小到大排序。

voidsort(int*a,intl)//a为数组地址，l为数组长度。

{

inti,j;

intv;

//排序主体

for(i=0;i<l-1;i++)

for(j=i+1;j<l;j++)

{

if(a[i]>a[j])//如前面的比后面的大，则交换。

{

v=a[i];

a[i]=a[j];

a[j]=v;

}

对于这样的自定义sort函数，可以按照定义的规范来调用。

二、C语言有自有的qsort函数。

功 能： 使用快速排序例程进行排序

头文件：stdlib.h

原型： void qsort(void *base,int nelem,int width,int (*fcmp)(const void *,const void *));

参数：

1 待排序数组首地址

2 数组中待排序元素数量

3 各元素的占用空间大小

4 指向函数的指针，用于确定排序的顺序

这个函数必须要自己写比较函数，即使要排序的元素是int,float一类的C语言基础类型。

以下是qsort的一个例子：

#include<stdio.h>

#include<stdlib.h>

intcomp(constvoid*a,constvoid*b)//用来做比较的函数。

{

return*(int*)a-*(int*)b;

}

intmain()

{

inta[10]={2,4,1,5,5,3,7,4,1,5};//乱序的数组。

inti;

qsort(a,n,sizeof(int),comp);//调用qsort排序

for(i=0;i<10;i++)//输出排序后的数组

{

printf("%d ",array[i]);

}

return0;

(4)c模板函数使用方法扩展阅读：

sort函数的用法(C++排序库函数的调用)

对数组进行排序，在c++中有库函数帮我们实现，这们就不需要我们自己来编程进行排序了。

（一）为什么要用c++标准库里的排序函数

Sort（）函数是c++一种排序方法之一，学会了这种方法也打消我学习c++以来使用的冒泡排序和选择排序所带来的执行效率不高的问题！因为它使用的排序方法是类似于快排的方法，时间复杂度为n*log2(n)，执行效率较高！

（二）c++标准库里的排序函数的使用方法

I）Sort函数包含在头文件为#include<algorithm>的c++标准库中，调用标准库里的排序方法可以不必知道其内部是如何实现的，只要出现我们想要的结果即可！

II）Sort函数有三个参数：

（1）第一个是要排序的数组的起始地址。

（2）第二个是结束的地址（最后一位要排序的地址的下一地址）

（3）第三个参数是排序的方法，可以是从大到小也可是从小到大，还可以不写第三个参数，此时默认的排序方法是从小到大排序。

Sort函数使用模板:

Sort(start,end,排序方法)

下面就具体使用sort（）函数结合对数组里的十个数进行排序做一个说明！

例一：sort函数没有第三个参数，实现的是从小到大

#include<iostream>

#include<algorithm>

using namespace std;

int main()

{

int a[10]={9,6,3,8,5,2,7,4,1,0};

for(int i=0;i<10;i++)

cout<<a[i]<<endl;

sort(a,a+11);

for(int i=0;i<10;i++)

cout<<a[i]<<endl;

return 0;

}

编译器

GCC，GNU组织开发的开源免费的编译器

MinGW，Windows操作系统下的GCC

Clang，开源的BSD协议的基于LLVM的编译器

Visual C++:: cl.exe，Microsoft VC++自带的编译器

集成开发环境

CodeBlocks，开源免费的C/C++ IDE

CodeLite，开源、跨平台的C/C++集成开发环境

Orwell Dev-C++，可移植的C/C++IDE

C-Free

Light Table

Visual Studio系列

Hello World

E. C中的模板怎样使用 最好给个例子~

看看这个吧
http://www.njcc.e.cn/njhysite/njhygao_js/xuebao/xuebao0402/zhjm.doc
其他的见

C语言中实现模板函数的方法

在C语言中实现模板函数的方法：

各种用C语言实现的模板可能在使用形式上有所不同。

现以一个求和函数Sum为例，用C++Template可写如下：

template<classT,classR> RSum(constT*array,intn)

{

Rsum=0;

for(inti=0;i<n;++i)

sum+=i;

returnsum;

}

如果不是内置类型，该模板隐式地需要有RR::operator+=(T)运算符可用。

1. 使用函数指针作为Functor替换者
TypedefstructtagAddClass

{

Void(*add)(char*r1,constchar*r2);

IntelemSize;

Char sum[MAX_ELEM_SIZE];

}AddClass;

voidSum(AddClass*self,constchar*array,intn)

{

for(inti=0;i<n;++i)

self->add(self->sum,array+i*self->elemSize);

}

使用时：

…..

VoidAddInt(char*r1,constchar*r2)

{

*(long*)r1+=*(int*)r2;

}

AddClassaddClass={AddInt,2,0};

Intarray[100];

Read(array);

Sum(&addClass,array,100);

…..

2. 用宏作为Functor的替换者
#define GenSumFun(SumFunName,Add,RetType,ElemType) \

RetTypeSumFunName(constElemType*array,intn) \

{ \

RetTypesum=0; \

for(inti=0;i<n;++i) \

Add(sum,i); \

returnsum; \

}

使用时：

#defineAddInt(x,y) ((x)+=(y))

GenSumFun(SumInt,AddInt,long,int)

…..

Intarray[100];

Read(array);

Longsum=SumInt(array,100);

…..

3. 所有可替换参数均为宏
至少需要一个额外的文件(实现文件)为impsum.c

/*impsum.c*/

RetTypeFunName(constElemType*array,intn)

{

RetTypesum=0;

for(inti=0;i<n;++i)

Add(sum,i);

returnsum;

}

使用时：

#undef RetType

#undef FunName

#undef ElemType

#undef Add

#defineAddInt(x,y) ((x)+=(y))

#defineRetTypelong

#defineFunNameSumInt

#defineElemTypeint

#defineAdd AddInt

#includeimpsum.c

…..

Intarray[100];

Read(array);

Longsum=SumInt(array,100);

…..

4. 总结：
第一种方法，易于跟踪调试，但是效率低下，适用于对可变函数（函数指针）的效率要求不高，但程序出错的可能性较大（复杂），模板函数（Sum）本身很复杂，模板参数也比较复杂（add）的场合。

第二种方法，效率高，但很难跟踪调试，在模板函数和模板参数本身都很复杂的时候更是如此。

第三种方法，是我最近几天才想出的，我认为是最好的，在模板参数（Add）比较复杂时可以用函数（第二种也可以如此），简单时可以用宏，并且，易于调试。在模板函数本身很复杂，而模板参数比较简单时更为优越。但是，可能有点繁琐。

一般情况下，没有必要做如此劳心的工作，一切交给编译器去做就行了。但是本人在开发一个文件系统时，由于是基于一种少见的平台，没有可用的C++编译器，有几个函数，除了其中的类型不同（uint16和uint32），和几个可参数化的宏不同，其它地方完全相同，而函数本身很复杂（两百多行代码）。Copy出几个完全类似的函数副本，维护起来特别烦人。非常需要如此的编程模式，故此，分享出来，大家共同探讨。

F. C++的函数模板是怎么使用的，好像是比函数重载好一些

两种用途不一样.

模板可应用于, 多型别兼容, 使用相同功能, 编译器自动展开.
函数重载, 多用于功能差异, 例如参数数量不一致, 内部执行不同行为.

例如加法函数:
模板用途, 可套用不同型别的变量, 进行一样的加法功能.
(A= B+C, 型别可变int->long->float都可支持, 程序源码沿用不变)
重载, 可用于不同参数数量的加法函数, 内部有不一样的加法程序.
(A=B+C => A=B+C+D, 程序源码因为变量数目的不同而有变化)

G. C++,如何模板函数里面使用 常规参数

#include <iostream>
using namespace std;

template<typename T,int R,int C>
void ada(T (*data)[C])
{
for(int i=0;i<R;i++)
{
data=data+i;
for(int j=1;j <C;j++)
{
(*data)[0]+=(*data)[j];
}
}

}
void main()
{
int a[2][5]={{1,3,5,7,9},{2,4,6,8,10}};
ada<int,2,5> (a); //常规参数
for(int i=0;i<2;i++)
{
for(int j=0;j<5;j++)
cout<<a[i][j]<<" ";
cout<<endl;
}

}

example 2:

#include <iostream>
using namespace std;

template<typename t1,int n>
t1 s(t1 a[]){
t1 sum=0;
for(int i=0;i<n;i++){
sum+=a[i]*a[i];
}

return sum;
}

void main(){
int x[]={1,2,3,4,5};
cout<<s<int,5>(x)<<endl; //常规参数
}

H. c语言，函数，函数模板

for (i=0; i<n; i++)
{
proizv[i]=pro(a[i],n); //用函数调用代替注释掉的循环
// proizv[i]=1;
// for(j=0; j<n; j++)
// {
// if(a[i][j]>0) proizv[i]*=a[i][j];
// else proizv[i]=0;
// }
if(proizv[i]>0) printf("Proizvedenie elementov stroki %d ravno %d\n",i+1,proizv[i]);
}

system("PAUSE");
}
int pro(int *v,int n) //函数定义
{
int s=1;
while(n--)
{
if(*v>0) s*=*v;
else s=0;
v++;
}
return s;
}
------------------
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//int pro(int *v,int n); //<-改成下面的
template<class T> T pro(T *v,int n);
int main()
{
...
...
...
for (i=0; i<n; i++)
{
proizv[i]=pro(a[i],n); //用函数调用代替注释掉的循环
// proizv[i]=1;
// for(j=0; j<n; j++)
// {
// if(a[i][j]>0) proizv[i]*=a[i][j];
// else proizv[i]=0;
// }
if(proizv[i]>0) printf("Proizvedenie elementov stroki %d ravno %d\n",i+1,proizv[i]);
}

system("PAUSE");
}
template<class T> T pro(T *v,int n)
{
T s=1;
while(n--)
{
if(*v>0) s*=*v;
else s=0;
v++;
}
return s;
}

I. C语言如何调用函数

C语言中，函数调用的一般形式为：

函数名(实际参数表)

对无参函数调用时则无实际参数表。实际参数表中的参数可以是常数、变量或其它构造类型数据及表达式。各实参之间用逗号分隔。

#include<stdio.h>
intfun(intx,inty);//函数声明，如果函数写在被调用处之前，可以不用声明
voidmain()
{
inta=1,b=2,c;
c=fun(a,b);//函数的调用，调用自定义函数fun，其中a，b为实际参数，传递给被调用函数的输入值
}
//自定义函数fun
intfun(intx,inty)//函数首部
{//{}中的语言为函数体
returnx>y?x:y;//返回x和y中较大的一个数
}

(9)c模板函数使用方法扩展阅读

C语言中不允许作嵌套的函数定义。因此各函数之间是平行的，不存在上一级函数和下一级函数的问题。但是C语言允许在一个函数的定义中出现对另一个函数的调用。

这样就出现了函数的嵌套调用。即在被调函数中又调用其它函数。这与其它语言的子程序嵌套的情形是类似的。其关系可表示如图。

图表示了两层嵌套的情形。其执行过程是：执行main函数中调用a函数的语句时，即转去执行a函数，在a函数中调用b 函数时，又转去执行b函数，b函数执行完毕返回a函数的断点继续执行，a函数执行完毕返回main函数的断点继续执行。

J. 在c语言中如何实现函数模板

各种用
C
语言实现的模板可能在使用形式上有所不同。现以一个求和函数
Sum
为例，用
C++
Template
可写如下：
template
R
Sum(const
T
*array,
int
n)
{
R
sum
=
0;
for
(int
i
=
0
;
i
<
n
;
++i)
sum
+=
i;
return
sum;
}
如果不是内置类型，该模板隐式地需要
有R
R::operator+=(T)运算符可用。
1.
使用函数指针作为
Functor
替换者
Typedef
struct
tagAddClass
{
Void
(*add)(char*
r1,
const
char*
r2);
Int
elemSize;
Char
sum[MAX_ELEM_SIZE];
}
AddClass;
void
Sum(AddClass*
self,
const
char*
array,
int
n)
{
for
(int
i
=
0
;
i
<
n
;
++i)
self->add(self->sum,
array
+
i*self->elemSize);
}
使用时：
Void
AddInt(char*
r1,
const
char*
r2)
{
*(long*)r1
+=
*(int*)r2;
}
AddClass
addClass
=
{AddInt,
2,
0
};
Int
array[100];
Read(array);
Sum(&addClass,
array,
100);
…..
2.
用宏作为Functor的替换者
#define
GenSumFun(SumFunName,
Add,
RetType,
ElemType)
RetType
SumFunName
(const
ElemType
*array,
int
n)
\
{
RetType
sum
=
0;
for
(int
i
=
0
;
i
<
n
;
++i)
Add(sum,
i);
return
sum;
}
使用时：
#define
AddInt(x,
y)
((x)
+=
(y))
GenSumFun(SumInt,
AddInt,
long,
int)
…..
Int
array[100];
Read(array);
Long
sum
=
SumInt(array,
100);
…..
3.
所有可替换参数均为宏
至少需要一个额外的文件(实现文件)为
impsum.c
/*
impsum.c
*/
RetType
FunName(const
ElemType
*array,
int
n)
{
RetType
sum
=
0;
for
(int
i
=
0
;
i
<
n
;
++i)
Add(sum,
i);
return
sum;
}
使用时：
#undef
RetType
#undef
FunName
#undef
ElemType
#undef
Add
#define
AddInt(x,
y)
((x)
+=
(y))
#define
RetType
long
#define
FunName
SumInt
#define
ElemType
int
#define
Add
AddInt
#include
impsum.c
…..
Int
array[100];
Read(array);
Long
sum
=
SumInt(array,
100);
4.
总结：
第一种方法，易于跟踪调试，但是效率低下，适用于对可变函数（函数指针）的效率要求不高，但程序出错的可能性较大（复杂），模板函数（Sum）本身很复杂，模板参数也比较复杂（add）的场合。
第二种方法，效率高，但很难跟踪调试，在模板函数和模板参数本身都很复杂的时候更是如此。
第三种方法，是我最近几天才想出的，我认为是最好的，在模板参数（Add）比较复杂时可以用函数（第二种也可以如此），简单时可以用宏，并且，易于调试。在模板函数本身很复杂，而模板参数比较简单时更为优越。但是，可能有点繁琐。