c語言template

『壹』 在c語言中如何實現函數模板

如果要寫個函數支持多種數據類型，首先想到的就是C++的模板了，但是有時候只能用C語言，比如在linux內核開發中，為了減少代碼量，或者是某面試官的要求…
考慮了一陣子後，就想到了qsort上.qsort的函數原型：
void qsort( void *base, size_t num, size_t width, int (__cdecl *compare )(const void *elem1, const void *elem2 ) );
快排時，只要自己實現相應數據類型的比較函數cmpare就可以了.如果比較int型時,一個典型的compare函數如下：

那麼,就是說可以利用void *. void *意指未指定類型，也可以理解為任意類型。其他類型的指針可以直接賦值給void *變數，但是void *變數需要強制類型轉換為其它指針類型。這個相信大家都知道。那麼下面以一個簡單的題目為例，來探討如何在C語言中實現模板函數。
方法1： 利用void *.
在看下面的源程序之前，需要了解幾點。首先，在32位平台上，任何類型的指針所佔的位元組都是4個位元組，因為32位機器虛擬內存一般為4G，即2的32次方，只要32位即4個位元組就可以足夠定址，sizeof(void *)=4； 其次，雖然各種不同類型的指針所佔的空間都為4個位元組，但是不同類型的指針所指的空間的位元組數卻不同(這一點尤為重要，下面的程序我在開始沒有調通就因為這點意識不強)。所以，如果你將一個指針強制轉換為另一個類型的指針，指針本身所佔的位元組是不變的，但是，如果對這個指針進行運算，比如 *p,p++,p-=1等一般都是不同的。 再次，函數指針應該了解下，這里不多說。 最後，因為Sandy跟我說，C++開始的時候模板的實現其實就是利用宏替換，在編譯的時候確定類型。所以，為了方便，類型也用了預編譯指令#define。

<span>#include"stdio.h"</span>

<span>#include"stdlib.h"</span>

<span>//typedefintT;//或者下面的也可以.</span>

<span>#defineTint</span>

//這個FindMin是Sandy寫的.felix021也寫了個,差不多的就不貼出來的.

voidFindMin(constvoid*arr,intarr_size,intarrmembersize,int*index,

int(*cmp)(constvoid*,constvoid*b)){

inti;

*index=0;

char*p=(char*)arr;

char*tmp=p;

for(i=1;i<arr_size;i++){

if(cmp(tmp,p)>0){

tmp=p;

}

p+=arrmembersize;

}

(*index)=((int)(tmp-arr))/arrmembersize;

}

*/</span>

可以把指針看作是char*,如果轉換為int*,那下面的位移就不正確了.</span>

index<span>=</span>i<span>;</span>

<span>}</span>

<span>}</span>

<span>return</span>index<span>;</span>

<span>}</span>

<span>int</span>result<span>;</span><span>//result保存的是最小值索引.</span>

result<span>=</span>FindMin<span>(</span>arr,<span>12</span>,

『貳』 java可以實現c語言的模板功能嗎

1、java是純面向對象的語言（main都是寫到類里的），所以沒有原生的模板功能。

2、使用「模板模式」可以實現類似的效果，這也是java里最常用的模式之一。

以下是一篇教程：

模板方法模式的結構

模板方法模式是所有模式中最為常見的幾個模式之一，是基於繼承的代碼復用的基本技術。

模板方法模式需要開發抽象類和具體子類的設計師之間的協作。一個設計師負責給出一個演算法的輪廓和骨架，另一些設計師則負責給出這個演算法的各個邏輯步驟。代表這些具體邏輯步驟的方法稱做基本方法(primitive method)；而將這些基本方法匯總起來的方法叫做模板方法(template method)，這個設計模式的名字就是從此而來。

模板方法所代表的行為稱為頂級行為，其邏輯稱為頂級邏輯。模板方法模式的靜態結構圖如下所示：

這里涉及到兩個角色：

抽象模板(Abstract Template)角色有如下責任：

■定義了一個或多個抽象操作，以便讓子類實現。這些抽象操作叫做基本操作，它們是一個頂級邏輯的組成步驟。

■定義並實現了一個模板方法。這個模板方法一般是一個具體方法，它給出了一個頂級邏輯的骨架，而邏輯的組成步驟在相應的抽象操作中，推遲到子類實現。頂級邏輯也有可能調用一些具體方法。

具體模板(Concrete Template)角色又如下責任：

■實現父類所定義的一個或多個抽象方法，它們是一個頂級邏輯的組成步驟。

■每一個抽象模板角色都可以有任意多個具體模板角色與之對應，而每一個具體模板角色都可以給出這些抽象方法（也就是頂級邏輯的組成步驟）的不同實現，從而使得頂級邏輯的實現各不相同。

源代碼

抽象模板角色類，abstractMethod()、hookMethod()等基本方法是頂級邏輯的組成步驟，這個頂級邏輯由templateMethod()方法代表。

{
/**
*模板方法
*/
publicvoidtemplateMethod(){
//調用基本方法
abstractMethod();
hookMethod();
concreteMethod();
}
/**
*基本方法的聲明（由子類實現）
*/
();
/**
*基本方法(空方法)
*/
protectedvoidhookMethod(){}
/**
*基本方法（已經實現）
*/
(){
//業務相關的代碼
}
}

具體模板角色類，實現了父類所聲明的基本方法，abstractMethod()方法所代表的就是強制子類實現的剩餘邏輯，而hookMethod()方法是可選擇實現的邏輯，不是必須實現的。

{
//基本方法的實現
@Override
publicvoidabstractMethod(){
//業務相關的代碼
}
//重寫父類的方法
@Override
publicvoidhookMethod(){
//業務相關的代碼
}
}

模板模式的關鍵是：子類可以置換掉父類的可變部分，但是子類卻不可以改變模板方法所代表的頂級邏輯。

每當定義一個新的子類時，不要按照控制流程的思路去想，而應當按照「責任」的思路去想。換言之，應當考慮哪些操作是必須置換掉的，哪些操作是可以置換掉的，以及哪些操作是不可以置換掉的。使用模板模式可以使這些責任變得清晰。

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

『肆』 C語言elemtype

我理解你說的意思是不是想讓elemtype可以替換任意一種類型？
如果是的話，這種東西叫做模板，它是C++的內容，不在C語言的范疇內。

具體用法是：
template <typename elemtype>
typedef struct{
elemtype *elem；
int length；
int listsize；
}sqlist;

之後聲明變數時要賦予elemtype一個已知的類型，比如int。
struct sqlist<int> a;
對於a這裡面的elemtype就變成了int。
不過這是C++的內容，C裡面不能用。

如果不用模板，而必須在C語言里用的話，有兩種方法。
1. 之前聲明它
typedef int elemtype;
2. 之前預編譯它
#define elemtype int

『伍』 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改個名字。