c模版編程

① 編程序創建一個類模板 用c++

// arrayex.h
#pragma once
#include <iostream>

using namespace std;

template <class T>
class CArrayEx
{
public:
// 構造函數，用固定值初始化
CArrayEx(T Initial,int nSize)
{
m_nSize=(nSize>1)?nSize:1;
m_pArray=new T[m_nSize];
for(int i=0;i<m_nSize;i++)
m_pArray[i]=Initial;
}

// 構造函數，用數組初始化
CArrayEx(T arr[], int nSize)
{
m_nSize=(nSize>1)?nSize:1;
m_pArray=new T[m_nSize];
for(int i=0;i<m_nSize;i++)
m_pArray[i]=arr[i];
}

// 計算數組的平均
T CalculateMean()
{
T sum = 0;
for(int i=0;i<m_nSize;i++)
sum +=m_pArray[i];

return (T)(sum/(double)m_nSize);
}

// 顯示數組
void Show(const int nNumElems)
{
for(int i=0;i<nNumElems;i++)
cout<<m_pArray[i]<<' ';

cout<<endl;
}
// 析構函數
virtual~CArrayEx(){delete[ ] m_pArray;}

// 重載[]操作符，實現取值或者更改原值
T &operator [](int nIndex){return m_pArray[nIndex];}
protected:
T* m_pArray;
int m_nSize;
};
// Test.cpp

#include "stdafx.h"
#include "ArrayEx.h"

int _tmain(int argc, _TCHAR* argv[])
{
int arr[5]={1,2,3,4,5};
// CArrayEx<int> ar(0,5);
// 用數組進行構造
CArrayEx<int> ar(arr, 5);

ar.Show(5);
cout<<ar.CalculateMean()<<endl;
return 0;
}

② c++模板概念是什麼詳細點

有以下這樣3個求加法的函數：
int Add(int x,int y)
{
return x+y;
}

double Add(double x,double y)
{
return x+y;
}

long Add(long x,long y)
{
return x+y;
}
它們擁有同一個函數名，相同的函數體，卻因為參數類型和返回值類型不一樣，所以是3個完全不同的函數。即使它們是二元加法的重載函數，但是不得不為每一函數編寫一組函數體完全相同的代碼。如果從這些函數中提煉出一個通用函數，而它又適用於多種不同類型的數據，這樣會使代碼的重用率大大提高。那麼 C++的模板就可解決這樣的問題。模板可以實現類型的參數化(把類型定義為參數)，從而實現了真正的代碼可重用性。C++中的模板可分為函數模板和類模板，而把函數模板的具體化稱為模板函數，把類模板的具體化成為模板類。

③ 在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語言編程是什麼

C語言編程，顧名思義，就是用C語言來進行計算機編程工作。C語言是國際上廣泛流行的,很有發展前途的計算機高級語言.它適合作為系統描述語言,即可用來編寫系統軟體,也可用來編寫應用軟體.

⑤ c語言編程時的模板裡面{跟//是什麼意思

{和}是匹配的
表示一個單獨的
程序段
。
當if
while
for等
這類
控制語句
，要包含多餘一句的語句時
需要用{}括起來。
//表示注釋
。
//之後到行末
只給編寫程序的人看，
編譯器
不會處理。

⑥ c語言程序模板

#include<stdio.h>
int main()
{
double c,f;
scanf("%lf",&f);
c=5.0/9*(f-32);
printf("攝氏溫度:");
printf("%.2lf\n",c);
return 0;
}

⑦ c語言編程在線急（用標簽里的代碼模板）

#include"stdio.h"
voidoutput(inta[],intn);
main()
{
intn,i,j,x,pos;
intc=0;//c表示有效的數據個數
inta[20];
scanf("%d",&n);
for(i=0;i<n;i++)//插入n個數據
{
scanf("%d",&x);
//查找插入的位置pos，並且向後移動數據
for(pos=c;pos>0;pos--)
if(x<a[pos-1])
a[pos]=a[pos-1];
else
break;

a[pos]=x;//在pos位置插入數據
c++;//個數加1
}
output(a,n);
return0;
}

voidoutput(inta[],intn)
{
inti;
for(i=0;i<n;i++)
printf("%d",a[i]);
printf("
");
}

⑧ 用C語言進行編程

這個不難，就是幾個部分。1.輸入28個成績；2.找出最高成績的那個學號，找出最低成績的那個學號；3.輸出學號和成績。

1. 先定義數組，用for循環輸入按順序逐個輸入成績。

2. 定義一個浮點型變數存儲最大值(可以叫做Max)，定義一個浮點型變數存儲最大值(可以叫做Min)，先把數組的第一個分量存入Max中，然後用for循環讓數組中的分量逐個與Max中的數比較，如果比Max大就用這個數替換掉Max中的數，如果比Max小，就不替換，再與下一個比較，一直循環到最後，Max中的數就是最大值。

   找出最小值也是這個過程。

3. 輸出用printf輸出即可。
   

⑨ c語言編程

//計劃做的腳本引擎的一部分
//參考的 C++編程藝術
//總地來說會有一些難度
//我的是C++應該會給你一些啟發
//TypeDef.h
#include "windows.h"
#ifndef B_TYPE_DEF_H
#define B_TYPE_DEF_H
const int MAX_T_LEN = 128;//可以分析的最大符號長度(同時決定了一個字元變數的最大長度為128位元組)
const int MAX_ID_LEN = 31;//允許的最大的標識長度(一個標識符是指一個變數名或函數名)
const int MAX_BUF_LEN = 1024;//解釋緩沖區1024位元組
const int NUM_PARAMS = 32;//最大參數數目
const int MAX_DIM_NUM = 65536//數組最大維數
//需要分析的所有東西
enum Token_Item { UNDEF=1, //未定義
E_TEMP,//當模板使用
E_CHAR,//char關鍵字
E_INT,//int關鍵字
E_FLOAT,//float關鍵字
E_SWITCH,//switch關鍵字
E_CASE,//case關鍵字
E_IF,//if關鍵字
E_ELSE,//else關鍵字
E_FOR,//for關鍵字
E_DO,//do關鍵字
E_WHILE,//while關鍵字
E_BREAK,//break關鍵字
E_RETURN,//return關鍵字
E_COUT,//cout關鍵字
E_CIN,//cin關鍵字
LBLOCK, //{
RBLOCK,//}
DOU,//,
EOS,//;
MAO,//:
SFEN,//'已舍棄,不含'分析
LT,//<
LE,//<=
GT,//>
GE,//>=
EQ,//==
NE,//!=
FF,//.
LK,//(
NOT,//!
INC,//++
DEC,//--
ADD,//+
SUB,//-
RK,//)
LZK,//[
RZK,//]
LS,//<<
RS,//>>
ASS,//=
AND,//&&
OR,//||
MUL,//*
DIV,///
MOD,//%
POW,//^
NUMBER, //數字
IDENTIFIER,//標識
STRING,//字元串
END//文件結束
};//需要分析的全部符號

enum Token_Type{
UNK,//未知類型
KEY,//關鍵字
FJF,//分界符
CMP,//比較運算符
OPE,//運算符
NUM,//數字
IDE,//標識符
STR,//字元串
NON,//結束符號
UDF//未定義
};

typedef struct Token_Table{//符號表
char name[MAX_T_LEN];
Token_Item token;
Token_Type type;
} TOKEN_TABLE,*PTOKEN_TABLE;

enum error_msg //錯誤類型
{ SYNTAX=1000, NO_EXP, NOT_VAR, DUP_VAR, DUP_FUNC,
SEMI_EXPECTED, UNBAL_BRACES, FUNC_UNDEF,
TYPE_EXPECTED, RET_NOCALL, PAREN_EXPECTED,
WHILE_EXPECTED, QUOTE_EXPECTED, DIV_BY_ZERO,
BRACE_EXPECTED, COLON_EXPECTED,FAIL_OPEN,ERROR_SIZE,
NO_MAIN,ERROR_ASSIGN,ERROR_RZK,ERROR_DIM};

class InterpExc { //錯誤類
error_msg err;
public:
InterpExc(error_msg e) { err = e; }
error_msg get_err() { return err; }
};

enum Vars{類型
V_Int,
V_Float,
V_String,
V_pInt,
V_pFloat,
V_pString,
V_Udef
};
#endif
#ifndef V_NULL
#define V_NULL (-1)
#endif

//Cfenxi.h

#include "TypeDef.h"
#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>
#include <string>

using namespace std;
//Fenxi類說明
//curr_pt始終指向將要分析的地址
//prev_pt為前一個分析的地址
//可以使用函數GotoPt來改變當前分析地址
//分析結果放在變數stoken,item,type
//在Cfenxi.cpp中定義了一個文件級變數TOKEN_TABLE tokentable[];
//在使用的時候必須聲明這個變數

#ifndef B_CFENXI_H
#define B_CFENXI_H

class Fenxi{

public:
char stoken[MAX_T_LEN+1];//分析出來的符號名
char buff[MAX_BUF_LEN+1];//緩沖區
Token_Item item;//分析出來的具體符號
Token_Type type;//符號大類

long curr_pt;//當前分析點
long prev_pt;//前一個分析點
char pFileName[256];//腳本文件名
PTOKEN_TABLE pTokenTable;//符號表
public:
Fenxi(){};
~Fenxi(){};
void Create(char*,PTOKEN_TABLE,int);//創建分析對象
void GetToken();//分析一步
void GotoPt(long);//跳分析點
void PutBack();//回退一個分析點
private:
int nTableItem;//分析表中的分析數目
long iFileLength;//腳本文件長度
int iBlock;//當前所在區塊
int iYouBiao;//當前游標
char cbuff;//當前所指向的字元
char cbuff1;//超前搜索的字元

void MoveNext();//向下移動
void MovePrev();//向前移動
void LoadBlock();//裝入一個塊
long GetPt(int i,int n){return (long)(i*MAX_BUF_LEN+n);};//計算位置
bool KeyLookUp(char*,Token_Item &);//查找是不是關鍵詞
bool isdelim(char);
};
//解釋類
class var_value{
public:
char string_value[MAX_T_LEN+1];
int int_value;
float float_value;
Vars v_type;
public:
var_value()
{
int_value=0;
float_value=0;
string_value[0]=0;
v_type=Udef;
}
var_value(const var_value&);
set_type(Vars type){v_type=type;}
~var_value(){}
friend bool operator == (const var_value& _X, const var_value& _Y);
friend bool operator < (const var_value& _X, const var_value& _Y);
};

class temp_var_value{
public:
char string_value[MAX_T_LEN+1];
int int_value;
float float_value;
int p_int;
int p_float;
int p_string;
vector<int> dim;
Vars v_type;
public:
temp_var_value()
{
int_value=0;
float_value=0;
string_value[0]=0;
p_int=p_float=p_string=V_NULL;
v_type=Udef;
};
temp_var_value(const temp_var_value&);
temp_set_type(Vars type){v_type=type;}
~temp_var_value(){}
friend bool operator == (const temp_var_value& _X, const temp_var_value& _Y);
friend bool operator < (const temp_var_value& _X, const temp_var_value& _Y);
};

struct var_type { //變數類型
char var_name[MAX_ID_LEN+1]; // 變數名
Vars v_type;//數據類型
vector<var_value> value; //變數值
vector<int> v_dim;//變數維數
int v_max;//變數的最大數目
};

struct func_type {
char func_name[MAX_ID_LEN+1]; //函數名
Vars ret_type; //返回值類型
long loc; // 函數入口點,函數的入口點是指分析點指向函數括弧後第一個字元
};

class Script{
public:
Fenxi theFx;//詞法分析對象,負責對腳本文件的操作
char FileName[256];//腳本文件名
var_value ret_value;//返回值
bool breakfound;//中斷
public:
Script(){};
~Script(){};
void Create(char*,PTOKEN_TABLE,int);//創建腳本對象
void ExecuteScript();//開始解釋腳本
private:
void PreScan();//預掃描
void decl_global();//聲明全局變數
long find_func(char*);//返回函數的入口點
void ItemToVar(Token_Item,Vars&);//根據一個項,得到相當的變數類型
void CallFun();//執行一個函數
void get_args();//得到函數的形式參數名
void Interp();//具體解釋
private:
void eval_exp (var_value &value);
void eval_exp0(var_value &value);
void eval_exp1(var_value &value);
void eval_exp2(var_value &value);
void eval_exp3(var_value &value);
void eval_exp4(var_value &value);
void eval_exp5(var_value &value);
void eval_exp6(var_value &value);
void eval_exp7(var_value &value);
void eval_exp8(var_value &value);
bool is_var(char *s);
// 變數名,變數的維數,變數的值,變數的類型
void assign_var(char *var_name,int idx, var_value value);
void find_var_value(char *var_name,int idx,var_value& value);
int find_idx(vector<int>,vector<int>);// 計算[][]
void find_vector(vector<int> &);//讀取[]
int cal_idx(vector<int>);
Vars is_var_type;//使用is_var的時候如果返回值是真那麼這個變數存儲了變數類型
public:
//每執行一個函數的時候就把進入前的局部變數數目
//放到函數結點棧,函數執行完的時候就根據棧里的
//數據改變局部函數表裡的變數,從而實現變數的靈活使用
//同理塊結點棧的原理也一樣

//變數表
vector<var_type> global_vars; //全局變數表
vector<var_type> local_var_stack; //局部變數表(函數參數作為局部變數處理)

vector<func_type> func_table; //函數表
stack<int> func_call_stack;//函數結點棧
stack<int> nest_scope_stack;//塊結點棧
};

#endif

//Fenxi.cpp
#include "CFenxi.h"
#include <cstring>
#include <cctype>
#include <fstream>
#include <cstdio>
#include <cmath>
using namespace std;
///////////////////////////////////////////////////////////////////////
/////////////////////////詞法分析類的函數定義//////////////////////////
///////////////////////////////////////////////////////////////////////
extern TOKEN_TABLE tokentable[]={
"char",E_CHAR,KEY,
"int",E_INT,KEY,
"float",E_FLOAT,KEY,
"switch",E_SWITCH,KEY,
"case",E_CASE,KEY,
"if",E_IF,KEY,
"else",E_ELSE,KEY,
"for",E_FOR,KEY,
"do",E_DO,KEY,
"while",E_WHILE,KEY,
"break",E_BREAK,KEY,
"return",E_RETURN,KEY,
"cout",E_COUT,KEY,
"cin",E_CIN,KEY,
"{",LBLOCK,FJF,
"}",RBLOCK,FJF,
",",DOU,FJF,
";",EOS,FJF,
"<",LT,CMP,
"<=",LE,CMP,
">",GT,CMP,
">=",GE,CMP,
"==",EQ,CMP,
"!=",NE,CMP,
".",FF,OPE,
"(",LK,OPE,
")",RK,OPE,
"[",LZK,OPE,
"]",RZK,OPE,
"++",INC,OPE,
"--",DEC,OPE,
"<<",LS,OPE,
">>",RS,OPE,
"=",ASS,OPE,
"!",NOT,OPE,
"&&",AND,OPE,
"||",OR,OPE,
"+",ADD,OPE,
"-",SUB,OPE,
"*",MUL,OPE,
"/",DIV,OPE,
"%",MOD,OPE,
"^",POW,OPE,
};

var_value::var_value(const var_value& p)
{
int_value=p.int_value;
float_value=p.float_value;
strcpy(string_value,p.string_value);
v_type=p.v_type;
}

bool operator == (const var_value& _X, const var_value& _Y)
{
if (_X.v_type != _Y.v_type)
{
return false;
}
else
{
switch (_X.v_type)
{
case V_Float:
return (abs(_X.float_value - _Y.float_value) < 0.0001);
break;
case V_Int:
return (_X.int_value == _Y.int_value);
break;
case V_Int:
return !(strcmp(_X.string_value, _Y.string_value));
break;
default:
return false;
}
}
}

bool operator < (const var_value& _X, const var_value& _Y)
{
if (_X.v_type != _Y.v_type)
{
return false;
}
else
{
switch (_X.v_type)
{
case V_Float:
return (_X.float_value < _Y.float_value);
break;
case V_Int:
return (_X.int_value < _Y.int_value);
break;
case V_Int:
return !(strcmp(_X.string_value, _Y.string_value));
break;
default:
return false;
}
}

temp_var_value::temp_var_value(const temp_var_value& p)
{
int_value=p.int_value;
float_value=p.float_value;
strcpy(string_value,p.string_value);
p_int=p.p_int;
p_float=p.p_float;
p_string=p.p_string;
v_type=p.v_type;
}
void Fenxi::Create(char* p,PTOKEN_TABLE ptt,int n)
{
strcpy(pFileName,p);
ifstream fin(pFileName,ios::in|ios::binary);
fin.seekg(0,ios::end);
iFileLength=fin.tellg();
fin.close();
if(iFileLength==0)
throw InterpExc(ERROR_SIZE);

iBlock=0;
LoadBlock();
MoveNext();//指向第一個字元
iYouBiao=0;//置游標於文件頭
curr_pt=0;
prev_pt=0;
cbuff=buff[0];//當前應該分析字元
cbuff1=buff[1];//超前搜索字元

pTokenTable=ptt;
nTableItem=n;//分析表設置

}

void Fenxi::MoveNext()
{
if(iYouBiao==MAX_BUF_LEN-1)//如果當前游標在緩沖區尾
{
iBlock++;
LoadBlock();
cbuff=buff[0];
cbuff1=buff[1];//超前搜索
}
else
{
iYouBiao++;
cbuff=buff[iYouBiao];
if(iYouBiao==MAX_BUF_LEN-1)//超前搜索
{
char temp[2];
temp[1]=0;
ifstream fin(pFileName,ios::in|ios::binary);
fin.seekg(MAX_BUF_LEN*(iBlock+1));
fin.read(temp,1);
int i=fin.gcount();
temp[i]=0;
fin.close();
cbuff1=temp[0];
}
else
cbuff1=buff[iYouBiao+1];
}

curr_pt=GetPt(iBlock,iYouBiao);
}

void Fenxi::MovePrev()
{
if(iYouBiao==0)//如果當前游標在緩沖區頭
{
cbuff1=cbuff;//超前搜索
iBlock--;
LoadBlock();
iYouBiao=MAX_BUF_LEN-1;
cbuff=buff[iYouBiao];
}
else
{
cbuff1=cbuff;//超前搜索
iYouBiao--;
cbuff=buff[iYouBiao];
}

curr_pt=GetPt(iBlock,iYouBiao);
}

void Fenxi::PutBack()
{
GotoPt(prev_pt);
}

void Fenxi::LoadBlock()//裝入一個塊
{
ifstream fin(pFileName,ios::in|ios::binary);
fin.seekg(MAX_BUF_LEN*iBlock);
fin.read(buff,MAX_BUF_LEN);
int i=fin.gcount();
buff[i]=0;
iYouBiao=0;
fin.close();
}

void Fenxi::GotoPt(long pt)
{

if(pt/MAX_BUF_LEN==curr_pt/MAX_BUF_LEN)//如果是在同一個塊內的話
{
curr_pt=pt;
iYouBiao=curr_pt-iBlock*MAX_BUF_LEN;
cbuff=buff[iYouBiao];
}
else//否則要重新裝入內存
{
curr_pt=pt;
iBlock=curr_pt/MAX_BUF_LEN;
LoadBlock();
iYouBiao=curr_pt-iBlock*MAX_BUF_LEN;
cbuff=buff[iYouBiao];
}

if(iYouBiao==MAX_BUF_LEN-1)//超前搜索
{
char temp[2];
temp[1]=0;
ifstream fin(pFileName,ios::in|ios::binary);
fin.seekg(MAX_BUF_LEN*(iBlock+1));
fin.read(temp,1);
int i=fin.gcount();
temp[i]=0;
fin.close();
cbuff1=temp[0];
}
else
cbuff1=buff[iYouBiao+1];
}

void Fenxi::GetToken()
{

prev_pt=curr_pt;//保存前一個的位置
char *temp; //利用一個指針向字元里寫內容
item=UNDEF;type=UDF;

temp = stoken;
*temp = '\0';

// 如果當前字元是空格且未到文件末
while(isspace(cbuff) && cbuff) MoveNext();

// 跳過行
while(cbuff == '\r') {
MoveNext();
MoveNext();
while(isspace(cbuff) && cbuff) MoveNext();
}

// 是否結尾
if(cbuff == '\0') {
*stoken = '\0';
item = END;
type=NON;
return ;
}

// 檢查{}標識符
if(strchr("{}", cbuff)) {

stoken[0]=cbuff;
stoken[1]='\0';
type=FJF;
if(cbuff=='{')
item=LBLOCK;
else
item=RBLOCK;
MoveNext();//指向下一個字元
return ;
}
// 檢查注釋信息
if(cbuff == '/')
if(cbuff1 == '*') { // /*注釋符
MoveNext();
MoveNext();
do { // 找到結尾
while(cbuff != '*') MoveNext();
MoveNext();
} while (cbuff != '/');
MoveNext();
GetToken();
return;
} else if(cbuff1 == '/') { // is a // CMPment
MoveNext();
MoveNext();
// Find end of CMPment.
while(cbuff != '\r' && cbuff != '\0') MoveNext();
if(cbuff == '\r') {MoveNext();MoveNext();}
GetToken();
return;
}

// 檢查雙操作符
if(strchr("!<>=+-&|", cbuff)) {
switch(cbuff) {
case '|':
if(cbuff1 == '|') {
MoveNext();MoveNext();
*temp = '|';
temp++;
*temp = '|';
temp++;
*temp = '\0';
item=OR;
type=OPE;

}
break;
case '&':
if(cbuff1 == '&') {
MoveNext();MoveNext();
*temp = '&';
temp++;
*temp = '&';
temp++;
*temp = '\0';
item=AND;
type=OPE;

}
break;

case '=':
if(cbuff1 == '=') {
MoveNext();MoveNext();
*temp = '=';
temp++;
*temp = '=';
temp++;
*temp = '\0';
item=EQ;
type=CMP;

}
break;
case '!':
if(cbuff1 == '=') {
MoveNext();MoveNext();
*temp = '!';
temp++;
*temp = '=';
temp++;
*temp = '\0';
item=NE;
type=CMP;
}
break;
case '<':
if(cbuff1 == '=') {
MoveNext();MoveNext();
*temp = '<';
temp++;
*temp = '=';
item=LE;
type=CMP;
}
else if(cbuff1 == '<') {
MoveNext();MoveNext();
*temp = '<';
temp++;
*temp = '<';
item=LS;
type=OPE;
}
else {
MoveNext();
*temp = '<';
item=LT;
type=CMP;
}
temp++;
*temp = '\0';
break;
case '>':
if(cbuff1 == '=') {
MoveNext();MoveNext();
*temp = '>';
temp++;
*temp = '=';
item=GE;
type=CMP;
} else if(cbuff1 == '>') {
MoveNext();MoveNext();
*temp = '>';
temp++;
*temp = '>';
item=RS;
type=OPE;
}
else {
MoveNext();
*temp = '>';
item=GT;
type=CMP;
}
temp++;
*temp = '\0';
break;
case '+':
if(cbuff1 == '+') {
MoveNext();MoveNext();
*temp = '+';
temp++;
*temp = '+';
temp++;
*temp = '\0';
item=INC;
type=OPE;
}
break;
case '-':
if(cbuff1 == '-') {
MoveNext();MoveNext();
*temp = '-';
temp++;
*temp = '-';
temp++;
*temp = '\0';
item=DEC;
type=OPE;
}
break;
}

if(*stoken) return;
}

// 其它運算符號
if(strchr("+-*^/=().[]|!%", cbuff)) {
type=OPE;
switch(cbuff){
case '+':
item=ADD;break;
case '-':
item=SUB;break;
case '*':
item=MUL;break;
case '/':
item=DIV;break;
case '=':
item=ASS;break;
case '(':
item=LK;break;
case ')':
item=RK;break;
case '[':
item=LZK;break;
case ']':
item=RZK;break;
case '.':
item=FF;break;
case '|':
item=UNDEF;type=UDF;break;
case '!':
item=NOT;break;
case '%':
item=MOD;break;
}
*temp = cbuff;
MoveNext();
temp++;
*temp = '\0';
return ;
}

// 分界符號
if(strchr(";,#:", cbuff)) {
type=FJF;
switch(cbuff){
case ';':
item=EOS;break;
case ',':
item=DOU;break;
case ':':
item=MAO;break;
}
*temp = cbuff;
MoveNext();
temp++;
*temp = '\0';
return ;
}

// 讀取一個字元串
if(cbuff == '"') {
MoveNext();
while(cbuff != '"' && cbuff != '\r' && cbuff) {
// Check for \n escape sequence.
if(cbuff == '\\') {
if(cbuff1 == 'n') {
MoveNext();
*temp++ = '\n';
}
}
else if((temp - stoken) < MAX_T_LEN)
*temp++ = cbuff;

MoveNext();
}
if(cbuff == '\r' || cbuff == 0)
throw InterpExc(SYNTAX);
MoveNext(); *temp = '\0';
item=STRING;
type=STR;
return ;
}

// 讀取一個數字
if(isdigit(cbuff)) {
while((cbuff>='0'&&cbuff<='9')||(cbuff=='.')) {
if((temp - stoken) < MAX_T_LEN)
*temp++ = cbuff;
MoveNext();
}
*temp = '\0';
item=NUMBER;
type=NUM;
return ;
}

// Read identifier or keyword.
if(isalpha(cbuff)) {
while(!isdelim(cbuff)) {
if((temp - stoken) < MAX_T_LEN)
*temp++ = cbuff;
MoveNext();
}
item=E_TEMP;
}

*temp = '\0';

// Determine if token is a keyword or identifier.
if(item == E_TEMP) { // convert to internal form
if(KeyLookUp(stoken,item)) type=KEY; // is a keyword
else {type = IDE;item=IDENTIFIER;}
}
if(type==UDF)
throw InterpExc(SYNTAX);

}

bool Fenxi::KeyLookUp(char *s,Token_Item &it){
int i;
// char *p;

// 轉為小寫字母
// p = s;
// while(*p) { *p = tolower(*p); p++; }

for(i=0; i<nTableItem; i++) {
if((tokentable[i].type==KEY)&&!strcmp(tokentable[i].name, s))
{
it=tokentable[i].token;
return true;
}
}

return false;
}

// 符號檢查
bool Fenxi::isdelim(char c)
{
if(strchr(" !:;,+-<>/*^=().|&[]\"%", c) || c == 9 ||
c == '\r' || c == 0) return true;
return false;
}

⑩ 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出幾個完全類似的函數副本，維護起來特別煩人。非常需要如此的編程模式，故此，分享出來，大家共同探討。