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.输出学号和成绩。
先定义数组，用for循环输入按顺序逐个输入成绩。
定义一个浮点型变量存储最大值(可以叫做Max)，定义一个浮点型变量存储最大值(可以叫做Min)，先把数组的第一个分量存入Max中，然后用for循环让数组中的分量逐个与Max中的数比较，如果比Max大就用这个数替换掉Max中的数，如果比Max小，就不替换，再与下一个比较，一直循环到最后，Max中的数就是最大值。
找出最小值也是这个过程。
输出用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出几个完全类似的函数副本，维护起来特别烦人。非常需要如此的编程模式，故此，分享出来，大家共同探讨。