#ifndef _MYTEMPLATE_H_
#define _MYTEMPLATE_H_
template<typename _T>
class mytemplate{
T val;
public:
void display();
}
#include "mytemplate.cpp"
#endif
// 文g mytemplate.cpp
#ifdef _MYTEMPLATE_H_
template<typename T>
void mytemplate<T>::display(){
cout<<val<<endl;
}
#endif
q样做的好处是我只需改变一个地方就可以使模板有不同的实玎ͼ避免?br />把不同的实现攑֜同一个文仉旉以避免的预编译标?那些预编译标?br />常常很难用，因ؓC它们都很ȝ),而且文g短小Q阅ȝ护v来更
方便(一个例子是你需要比较模板的不同实现的综合性能?把它的几个实?br />都写C个文仉常常会把人搞p涂).
不管怎样?E序必须在声明模板实例以前就"看见"了模板的实现部分
]]>
#include<map>
#include<string>
#include<iterator>
using namespace std;
typedef map<string,string>maps;
typedef pair<string,string>pr;
int main()
{
maps temp;
temp.insert(pr("aa","aaaaa"));
temp.insert(pr("bb","bbbbbb"));
temp.insert(pr("cc","cccc"));
maps tent;
maps::iterator it;
for(it=temp.begin();it!=temp.end();++it)tent.insert(*it);
for(it=tent.begin();it!=tent.end();++it)
{
cout<<(*it).first<<" "<<(*it).second<<endl;
}
return 0;
}
]]>
cryptQ将密码或数据编码）
相关函数
表头文g
#include<unistd.h>
定义函数
函数说明
q回?
附加说明
范例
main()
{
char passwd[13];
char *key;
char slat[2];
key= getpass(“Input First Password:?;
slat[0]=key[0];
slat[1]=key[1];
strcpy(passwd,crypt(key slat));
key=getpass(“Input Second Password:?;
slat[0]=passwd[0];
slat[1]=passwd[1];
printf(“After crypt(),1st passwd :%s\n?passwd);
printf(“After crypt(),2nd passwd:%s \n?crypt(key slat));
}
执行
Input Second Password /*输入testQ密码相同编码后也会相同*/
After crypt () 1st Passwd : teH0wLIpW0gyQ
After crypt () 2nd Passwd : teH0wLIpW0gyQ
bsearchQ二元搜索）
相关函数
表头文g
定义函数
函数说明
附加说明
范例
#include<stdlib.h>
#define NMEMB 5
#define SIZE 10
int compar(const void *a,const void *b)
{
return (strcmp((char *)a,(char *)b));
}
main()
{
char data[50][size]={“linux?”freebsd?”solaris?”sunos?”windows”};
char key[80],*base ,*offset;
int i, nmemb=NMEMB,size=SIZE;
while(1){
printf(?gt;?;
fgets(key,sizeof(key),stdin);
key[strlen(key)-1]=’\0?
if(!strcmp(key,”exit?)break;
if(!strcmp(key,”list?){
for(i=0;i<nmemb;i++)
printf(?s\n?data[i]);
continue;
}
base = data[0];
qsort(base,nmemb,size,compar);
offset = (char *) bsearch(key,base,nmemb,size,compar);
if( offset = =NULL){
printf(?s not found!\n?key);
strcpy(data[nmemb++],key);
printf(“Add %s to data array\n?key);
}else{
printf(“found: %s \n?offset);
}
}
}
执行
hello not found! /*找不到hello 字符?/
add hello to data array /*hello字符串加?/
>.list /*列出所有数?/
freebsd
linux
solaris
sunos
windows
hello
>hello
found: hello
lfindQ线性搜索）
相关函数
表头文g
定义函数
size,int(* compar) (const void * ,const void *));
函数说明
q回?
范例
lsearchQ线性搜索）
相关函数
表头文g
定义函数
函数说明
q回?
范例
#include<stdlib.h>
#define NMEMB 50
#define SIZE 10
int compar (comst void *a,const void *b)
{
return (strcmp((char *) a, (char *) b));
}
main()
{
char data[NMEMB][SIZE]={“Linux?”freebsd?”solzris?”sunos?”windows”};
char key[80],*base,*offset;
int i, nmemb=NMEMB,size=SIZE;
for(i=1;i<5;i++){
fgets(key,sizeof9key),stdin);
key[strlen(key)-1]=’\0?
base = data[0];
offset = (char *)lfind(key,base,&nmemb,size,compar);
if(offset ==NULL){
printf(?s not found!\n?key);
offset=(char *) lsearch(key,base,&nmemb,size,compar);
printf(“Add %s to data array\n?offset);
}else{
printf(“found : %s \n?offset);
}
}
}
执行
found:linux
os/2
os/2 not found!
add os/2 to data array
os/2
found:os/2
qsortQ利用快速排序法排列数组Q?
相关函数
表头文g
定义函数
函数说明
q回?
附加说明
范例
#include <stdlib.h>
int compar (const void *a ,const void *b)
{
int *aa=(int * ) a,*bb = (int * )b;
if( * aa >* bb)return 1;
if( * aa == * bb) return 0;
if( * aa < *bb) return -1;
}
main( )
{
int base[nmemb]={ 3,102,5,-2,98,52,18};
int i;
for ( i=0; i<nmemb;i++)
printf(?d ?base[i]);
printf(“\n?;
qsort(base,nmemb,sizeof(int),compar);
for(i=0;i<nmemb;i++)
printf(?d”base[i]);
printf(“\n?;
}
执行
-2 3 5 18 52 98 102
randQ生随机数Q?
相关函数
表头文g
定义函数
函数说明
q回?
范例
#include<stdlib.h>
main()
{
int i,j;
for(i=0;i<10;i++)
{
j=1+(int)(10.0*rand()/(RAND_MAX+1.0));
printf(?d ?j);
}
}
执行
9 4 8 8 10 2 4 8 3 6
srandQ设|随机数U子Q?
相关函数
表头文g
定义函数
函数说明
q回?
范例
#include<time.h>
#include<stdlib.h>
main()
{
int i,j;
srand((int)time(0));
for(i=0;i<10;i++)
{
j=1+(int)(10.0*rand()/(RAND_MAX+1.0));
printf(?%d ?j);
}
}
执行
2 9 7 4 10 3 2 10 8 7
]]>
<本文中排序都是采用的从小到大排序>
一、对intcd数组排序
int num[100];
Sample:
int cmp ( const void *a , const void *b )
{
return *(int *)a - *(int *)b;
}
qsort(num,100,sizeof(num[0]),cmp);
二、对charcd数组排序Q同intcdQ?
char word[100];
Sample:
int cmp( const void *a , const void *b )
{
return *(char *)a - *(int *)b;
}
qsort(word,100,sizeof(word[0]),cmp);
三、对doublecd数组排序Q特别要注意Q?
double in[100];
int cmp( const void *a , const void *b )
{
return *(double *)a > *(double *)b ? 1 : -1;
}
qsort(in,100,sizeof(in[0]),cmp)Q?
四、对l构体一U排?
struct In
{
double data;
int other;
}s[100]
//按照data的g到大将l构体排?关于l构体内的排序关键数据data的类型可以很多种Q参考上面的例子?
int cmp( const void *a ,const void *b)
{
return (*(In *)a)->data > (*(In *)b)->data ? 1 : -1;
}
qsort(s,100,sizeof(s[0]),cmp);
五、对l构体二U排?
struct In
{
int x;
int y;
}s[100];
//按照x从小到大排序Q当x相等时按照y从大到小排序
int cmp( const void *a , const void *b )
{
struct In *c = (In *)a;
struct In *d = (In *)b;
if(c->x != d->x) return c->x - d->x;
else return d->y - c->y;
}
qsort(s,100,sizeof(s[0]),cmp);
六、对字符串进行排?
struct In
{
int data;
char str[100];
}s[100];
//按照l构体中字符串str的字兔R序排?
int cmp ( const void *a , const void *b )
{
return strcmp( (*(In *)a)->str , (*(In *)b)->str );
}
qsort(s,100,sizeof(s[0]),cmp);
七、计几何中求凸包的cmp
int cmp(const void *a,const void *b) //重点cmp函数Q把除了1点外的所有点Q旋转角度排?
{
struct point *c=(point *)a;
struct point *d=(point *)b;
if( calc(*c,*d,p[1]) < 0) return 1;
else if( !calc(*c,*d,p[1]) && dis(c->x,c->y,p[1].x,p[1].y) < dis(d->x,d->y,p[1].x,p[1].y)) //如果在一条直U上Q则把远的放在前?
return 1;
else return -1;
}
PS:
其中的qsort函数包含?lt;stdlib.h>的头文g里，strcmp包含?lt;string.h>的头文g?img src ="http://www.shnenglu.com/qywyh/aggbug/3405.html" width = "1" height = "1" />
]]>
------转蝲沐枫's blog
在C/C++中，数据指针是最直接Q也最常用的，因此Q理解v来也比较Ҏ。而函数指针，作ؓq行时动态调用（比如回调函数 CallBack FunctionQ是一U常见的Q而且是很好用的手D，不能不好好认识一番?/P>
接下来，我们pZ下函数指针?BR>
2 常规函数指针(隑ֺ: 3)
void(*fp)();
fp 是一个典型的函数指针Q用于指向无参数Q无q回值的函数?BR> void(*fp2)(int);
fp2 也是一个函数指针，用于指向有一个整型参敎ͼ无返回值的函数?BR> 当然Q有l验人士一般都会徏议用typedef来定义函数指针的cdQ如Q?BR> typedef void(* FP)();
FP fp3; // 和上面的fp一L定义?BR> 函数指针之所以让初学者畏惧，最主要的原因是它的括号太多了；某些用途的函数指针Q往往会让人陷在括号堆中出不来Q这里就不D例了Q因Z是本文讨论的范围Qtypedef Ҏ可以有效的减括L数量Q以及理清层ơ，所以受到推荐。本文暂时只考虑单的函数指针Q因此暂不用到typedef?BR>
假如有如下两个函敎ͼ
void f1()
{
std::cout << "call f " << std::endl;
}
void f2(int a)
{
std::cout << "call f2( " << a << " )" << std::endl;
}
现在需要通过函数指针来调用，我们需要给指针指定函数Q?BR> fp = &f1; // 也可以用Qfp = f1;
fp2= &f2; // 也可以用Qfp2= f2;
void (*fp3)() = &f1; // 也可以用Qvoid (*fp3)() = f1;
调用时如下：
fp(); // ?(*fp)();
fp2(1); // ?(*fp2)(1);
fp3(); // ?(*fp3)();
对于此两U调用方法，效果完全一P我推荐用前一U。后一U不仅仅是多打了键盘Q而且也损׃一些灵zL。这里暂且不说它?BR>
C++cd安全。也是_不同cd的变量是不能直接赋值的Q否则轻则警告，重则报错。这是一个很有用的特性，常常能帮我们扑ֈ问题。因此，有识之士认ؓQC++中的M一外警告都不能忽视。甚x人提出，~译的时候不能出CQ何警告信息，也就是说Q警告应该当作错误一样处理?BR>
比如Q我们把f1赋值给fp2Q那么C++~译?vc7.1)׃报错Q?BR> fp2 = &f1; // error C2440: ??: 无法从“void (__cdecl *)(void)”{换ؓ“void (__cdecl *)(int)?BR> fp1 = &f1; // OK
q样Q编译器可以帮我们找出编码上的错误，节省了我们的排错旉。C++~译器正致力于这一炏V?BR>
考虑一下C++标准模板库的sort函数Q?BR> // 快速排序函?BR> template
void sort(
RandomAccessIterator _First, // 需排序数据的第一个元素位|?BR> RandomAccessIterator _Last, // 需排序数据的最后一个元素位|（不参与排序）
BinaryPredicate _Comp // 排序使用的比较算?可以是函数指针、函数对象等)
);
比如Q我们有一个整型数l：
int n[5] = {3,2,1,8,9};
要对它进行升序排序，我们需定义一个比较函敎ͼ
bool less(int a, int b)
{
return a < b; // 感谢|友指出W误之处。原?return a-b 是错误的?BR> }
然后用：
sort(n, n+5, less);
要是惛_它进行降序排序，我们只要换一个比较函数就可以了：
bool great(int a, int b)
{
return b < a; // 感谢|友指出W误之处。原?return b-a 是错误的?BR>
}
sort(n, n+5, great);
q样Q不需要改变sort函数的定义，可以按LҎq行排序Q是不是很灵z？
q种用法以C++的标准模板库(STL)中非常流行。另外，操作pȝ中也l常使用回调(CallBack)函数Q实际上Q所谓回调函敎ͼ本质是函数指针?/P>
Q附注）
本文中ؓ了说明函数指针，使用了less和greatq两个函数。在C/C++的标准模板库中已l有相应的函数可以直接用，不需要自已定义?BR>
]]>
------转蝲沐枫's blog
指针Q在C/C++语言中一直是很受宠的Q几乎找不到一个不使用指针的C/C++应用。用于存储数据和E序的地址Q这是指针的基本功能。用于指向整型数Q用整数指针(int*)Q指向QҎ用QҎ指针(float*)Q指向结构，用对应的l构指针(struct xxx *)Q指向Q意地址Q用无类型指?void*)?BR> 有时候，我们需要一些通用的指针。在C语言当中Q?void*) 可以代表一切；但是在C++中，我们q有一些比较特D的指针Q无法用(void*)来表C。事实上Q在C++中，xC个通用的指针，特别是通用的函数指针可是一个“不可能d”?BR>
C++是一U强cd的语aQC++的编译器的功能是强大的，它的其中一个设计目标，是尽力ؓE序扑ևE序中可能存在的问题Q因此，C++对类型的匚w是非怸格的。在C语言中，你可以用void*来指向一切；但在C++中，void*q不能指向一切，q能，也没有意义，因ؓ它不能帮你发现问题，比如Q用函数指针赋值给一个数据指针?BR>
下面我们来探讨一下，C++中如何存储各U类型的指针?BR>
1. 数据指针
数据指针分ؓ两种Q常规数据指针和成员数据指针
1.1 常规数据指针 (隑ֺ: 1)
q个不用说明了，和C语言一P很简单，直接定义、赋值就够了。常见的有：int*, double* {等?BR> 如：
int value = 123;
int * pn = &value;
1.2 成员数据指针 (隑ֺ: 4)
有如下的l构Q?BR> struct MyStruct
{
int key;
int value;
};
现在有一个结构对?
MyStruct me;
我们需?value 成员的地址Q我们可以：
int * pValue = &me.value;
:) 没什么难的对吧？
我们假设一下，现在有一个结构的指针Q?BR>
MyStruct* pMe = new MyStruct;
现在Q我们要取得 pMe?value 的指针，要怎么做呢Q?BR> int * ppValue = &pMe->value;
:) q仍然很Ҏ?BR>
当然了，上面讨论的仍然是属于W一U范{?---常规数据指针?BR>
好了Q我们现在需要一U指针，它指向MyStruct中的M数据成员Q那么它应该是这L子：
int MyStruct::* pMV = &MyStruct::value;
?BR> int MyStruct::* pMK = &MyStruct::key;
q种指针的用途是用于取得l构成员在结构内的地址。我们可以通过该指针来讉K成员数据Q?BR> int value = pMe->*pMV; // 取得pMe的value成员数据?BR> int value = me.*pMK; // 取得me的key成员数据?BR>
也许有h会问了，q种指针有什么用Q?BR> 实Q成员指针本来就不是一U很常用的指针。不q，在某些时候还是很有用处的。我们先来看看下面的一个函敎ͼ
int sum(MyStruct* objs, int MyStruct::* pm, int count)
{
int result = 0;
for(int i = 0; i < count; ++i)
result += objs[i].*pm;
return result;
}
q个函数的功能是什么，你能看明白吗Q它的功能就是，l定count个MyStructl构的指针，计算出给定成员数据的d。有Ҏ口对吧？看看下面的程序，你也许就明白了：
MyStruct me[10] =
{
{1,2},{3,4},{5,6},{7,8},{9,10},{11,12},{13,14},{15,16},{17,18},{19,20}
};
int sum_value = sum(me, &MyStruct::value, 10);
//计算10个MyStructl构的value成员的dQ?sum_value ??110 (2+4+6+8+...+20)
int sum_key = sum(me, &MyStruct::key, 10);
//计算10个MyStructl构的key成员的dQ?nbsp; sum_key ??100 (1+3+5+7+...+19)
也许Q你觉得用常规指针也可以做到Q而且更易懂。OkQ没问题Q?BR> int sum_value(MyStruct* objs, int count)
{
int result = 0;
for(int i = 0; i < count; ++i)
result += objs[i].value;
return result;
}
你是惌么做吗？但这么做Q你只能计算valueQ如果要key的话Q你要多写一个函数。有多少个成员需要计的话，你就要写多少个函敎ͼ多麻烦啊?BR>
]]>