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）比較復雜時可以用函數（第二種也可以如此），簡單時可以用宏，並且，易於調試。在模板函數本身很復雜，而模板參數比較簡單時更為優越。但是，可能有點繁瑣。