首页 > 资讯 > C++ > 正文

C++使用例子，根据半径计算圆的周长和面积

17-10-13 来源：[db:作者]

收藏我要投稿

//根据半径计算圆的周长和面积

#include

const float PI=3.1416; //声明常量(只读变量)PI为3.1416

float fCir_L(float); //声明自定义函数fCir_L()的原型

float fCir_S(float); //声明自定义函数fCir_S()的原型

//以下是main()函数

main()

{

float r,l,s; //声明3个变量

cout<<"r="; //显示字符串

cin>>r; //键盘输入

l=fCir_L(r); //计算圆的周长，赋值给变量l

s=fCir_S(r); //计算圆的面积，赋值给变量s

cout<<"l="< cout<<"\ns="< }

//定义计算圆的周长的函数fCir_L()

float fCir_L(float x)

{

float z=-1.0; //声明局部变量

if (x>=0.0) //如果参数大于0，则计算圆的周长

z=2*PI*x;

return(z); //返回函数值

}

//定义计算圆的面积的函数fCir_S()

float fCir_S(float x)

{

float z=-1.0; //声明局部变量

if (x>=0.0) //如果参数大于0，则计算圆的面积

z=PI*x*x;

return(z); //返回函数值

}

/* Program: P1-2.CPP

Written by: Hap

Date written: 02:11:10

#include

void main(void)

{

double s1,s2,s3;

s1=1.5; /* 对变量s1赋值*/

cout<<"s1="< /* 对变量s2赋值*/ s2=2.5;

cout<<"s2="< s3= /* 对变量s3赋值*/ 3.5;

cout<<"s3="<

cout<<"s1+s2+s3="< //计算并显示 cout<<"s1+s2+s3="< }

#include

main()

{

double r=1.0;

cout<<"r="< double l;

l=2*3.1416*r; //计算圆的周长，赋值给变量l

cout<<"l="< double s=3.1416*r*r; //计算圆的面积，赋值给变量s

cout<<"s="<

cout<<"r="; //显示提示输入的信息

cin>>r; //键盘输入

l=2*3.1416*r; //计算圆的周长，赋值给变量l

cout<<"l="< s=3.1416*r*r;

cout<<"s="< }

#include //包含iostream.h头文件

void main()

{

//输出字符常量、变量和字符串

char c1='A';

cout<<'W';

cout< cout<<"This is a test."< cout<<"------------------"<

//输出整型常量、变量和表达式

int n=100;

cout<<10;

cout< cout<<2*n< cout<<"------------------"<

//输出浮点型常量、变量和表达式

double pi=3.1415926,r=10.0,s=pi*r*r;

cout< cout< cout< cout<<2*r*pi< cout<<"------------------"<

//一个cout可以输出多项数据

cout<<'W'<<" "< cout<<"This is a test."< cout<<"pi="<0 && a<=5="<

//算术运算、关系运算和逻辑运算

cout<<"a+5>2*b+2||a2*b+2||a }

#include

main()

{

//按位与运算

cout<<"24&12="<<(24&12)< //按位异或运算

cout<<"24^12="<<(24^12)< //按位或运算

cout<<"24|12="<<(24|12)< //按位取反运算

cout<<"~24="<<(~24)<

//左移位运算

cout<<"5<<3="<<(5<<3)< cout<<"-5<<3="<<(-5<<3)<

//右移位运算

cout<<"5>>3="<<(5>>3)< cout<<"-5>>3="<<(-5>>3)< }

#include

main()

{

int a=1,b=1,c=3;

//显示a,b,c的值

cout<<"a="< } //对数组按从大到小顺序排序 void sort(int *p,int size) { int t; for (int i=0;i

for (int j=i+1;j if (*(p+i)<=*(p+j)) { t=*(p+i); *(p+i)=*(p+j); *(p+j)=t; } } #include

//定义结构 struct student { char name[10]; float grade; }; //更改student数据的grade成员,参数形式为引用 void change(student &x,float grade) { x.grade=grade; } //更改student数据的grade成员,参数形式为指针 void change1(student *p,float grade) { p->grade=grade; } //更改student类型的数据,普通参数形式 void change2(student x,float grade) { x.grade=grade; } //显示student类型的数据,参数形式为引用 void show(student &x) { cout<

change(a,360); show(a); //用change1修改分数,并显示 cout<<"change1(student *p,float grade):"<

change1(&a,375); show(a); //用change2修改分数,并显示 cout<<"change2(student x,float grade):"<

change2(a,380.5); show(a); } #include

//定义函数计算数组的和和平均值 void calculate(int a[],int size,int& sum,float& average) { sum=0; for (int i=0;i

sum+=a[i]; } average=sum/size; } //定义显示数组的函数 void put_arr(int a[],int size) { for(int i=0;i

cout< } main() { //声明数组并初始化 int asize,bsize; int a[]={2,4,6,1,3,5}; int b[]={1,3,5,7,9,11,13,15}; //显示数组的值 asize=sizeof(a)/sizeof(int); cout<<"put_arr(a,asize):"<

put_arr(a,asize); bsize=sizeof(b)/sizeof(int); cout<<"put_arr(b,bsize):"<

put_arr(b,bsize); //计算数组的和和平均值 float a_ave,b_ave; int a_sum,b_sum; cout<<"calculate(a,asize,a_sum,a_ave):"<

calculate(a,asize,a_sum,a_ave); cout<<"a_sum="<

cout<<" a_ave="< cout<<"calculate(b,bsize,b_sum,b_ave):"<

calculate(b,bsize,b_sum,b_ave); cout<<"b_sum="<

cout<<" b_ave="< } #include

//参数为函数指针的函数 int get_result(int a, int b, int (*sub)(int,int)) { int r; r=sub(a,b); return r; } //计算最大值 int max(int a, int b) { cout<<"In max"<

return((a > b) ? a: b); } //计算最小值 int min(int a, int b) { cout<<"In min"<

return((a < b) ? a: b); } //求和 int sum(int a, int b) { cout<<"In sum"<

return(a+b); } //测试指向函数的指针 void main(void) { int a,b,result; //测试3次 for (int i=1;i<=3;i++) { cout<<"Input a and b :"; cin>>a>>b; cout<

#include

#define size 3 //定义book结构类型 struct book { char title[20]; char author[15]; int pages; float price; }; //book结构的输入函数 input_book(book& bk,char *name) { cout<

cout<<"title:"; cin>>bk.title; cout<<"author:"; cin>>bk.author; cout<<"pages:"; cin>>bk.pages; cout<<"price:"; cin>>bk.price; } //book结构的输出函数 output_book(book& bk,char *name) { cout<

} void main(void) { //声明变量和结构数组 int i; char str[20]; book bk[size]; //输入结构数组 for(i=0;i

sprintf(str,"bk[%d]",i+1); input_book(bk[i],str); } //显示结构数组 for(i=0;i

sprintf(str,"bk[%d]",i+1); output_book(bk[i],str); } } #include

//声明全局变量并初始化 extern int a[]={1,2,3}; extern float p=3.14; //在show()函数中使用外部变量 show() { int i; cout<<"In show():"<

cout<<"p="< cout<<"a[]: "; for (i=0;i<=2;i++) cout<

//cout<<"y="< } //声明外部变量并初始化 int y=5678; //在main()函数中使用外部变量 main() { //声明局部变量 int i,p=100; //显示重名变量 cout<<"In main():"<

cout<<"p="< //显示全局变量 cout<<"::p="<<::p<

cout<<"a[]: "; for (i=0;i<=2;i++) cout<

cout<<"y="< show(); //调用函数 } #include

//使用静态变量的计数器函数 count1() { //声明静态变量i，并置初值为0。i在count()中局部可见 static int i=0; return(++i); } //使用局部变量的计数器函数 count2() { int i=0; return(++i); } //在main()函数中调用count()函数 main() { int i; //调用count1()10次 cout<<"count1():"<

for (i=1;i<=12;i++) cout<

//调用count2()10次 cout<<"count2():"<

for (i=1;i<=12;i++) cout<

} // p1-851.cpp 为main()函数文件 #include

main() { int i,s=0; extern int fact(int x); for (i=2;i<=6;i=i+2) s+=fact(i); cout<<"s="<

} // p1-852.cpp为计算阶乘函数文件 //定义fact()函数为外部(extern)函数 extern int fact(int x) { int i,t=1; if(x==0) return(1); for(i=1;i<=x;i++) t*=i; return(t); } #include

#include

main() { //声明变量 FILE *fp1; char str[80]; //从键盘上任意输入一个字符串 cout<<"Inupt a string:"; cin.getline(str,80); //以写入方式打开d.dat文件 if ((fp1=fopen("d.dat","w"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } // 写"流"文件 fputs(str,fp1); fputs("\n",fp1); fclose(fp1); //关闭文件 // 以读方式打开d.dat文件 if ((fp1=fopen("d.dat","r"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } // 循环从"流"文件读取字符,并显示 char ch; while ((ch=fgetc(fp1))!=EOF) cout<

cout< fclose(fp1); //关闭文件 } #include

#include

void main(void) { //变量声明 char ch; FILE *fp1; //以写入方式打开d.dat文件 if ((fp1=fopen("d.dat","w"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } //循环从键盘上读取字符,写入"流"文件 cout<<"char:"<

cin>>ch; while (ch!='*') { fputc(ch,fp1); //将字符写到fp1指向的"流"文件中 cin>>ch; } fclose(fp1); //关闭文件 // 以读方式打开d.dat文件 if ((fp1=fopen("d.dat","r"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } // 循环从"流"文件读取字符,并显示 while ((ch=fgetc(fp1))!=EOF) cout<

fclose(fp1); //关闭文件 } #include

#include

main() { //声明变量 int i=0; char p[100]; // 声明输入缓冲区 FILE *fp1; // 声明文件指针变量 //以写入方式打开d.dat文件 if ((fp1=fopen("d.dat","w"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } // 写文件操作 for (i=1;;i++) { //无条件循环 cout<

cout<<"Exiting program."< exit(1); //结束程序执行 } // 循环从文件读取字符,并显示 while (fgets(p,100,fp1)!=NULL) cout<

fclose(fp1); //关闭文件 } #include

#include

#define MAX 10 main() { //声明变量 int i,n; FILE *fp1; // 声明文件指针变量 //以写入方式打开d.dat文件 if ((fp1=fopen("d.dat","w"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } // 写文件操作 for (i=1;i<=MAX;i++) { n=rand(); //产生1个整数随机数 putw(n,fp1); cout<

fclose(fp1); //关闭文件 // 以读方式打开d.dat文件 if ((fp1=fopen("d.dat","r"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } // 循环从"流"文件读取字符,并显示 while ((n=getw(fp1))!=EOF) cout<

#include

#define MAX 3 main() { //定义结构类型 struct student { int num; char name[10]; float grade; }; //声明数组和变量 student st[3]; int i; FILE *fp1; // 声明文件指针变量 //以写入方式打开d.dat文件 if ((fp1=fopen("d.dat","w"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } //从键盘上读数据,写入文件 cout<<" num name grade"<

for (i=0;i cout<

cout<<"Exiting program."< exit(1); //结束程序执行 } // 循环从"流"文件读取字符,并显示 student t; while ((fscanf(fp1, "%d %s %f",&t.num,t.name,&t.grade))!=EOF) { cout<

} fclose(fp1); //关闭文件 } #include

#include

int main(void) { FILE *fpd,*fpw; // 声明FILE结构指针变量 unsigned char dw; int i=0; //以二进制读方式打开Calc.exe文件 if((fpd=fopen("C:\WINDOWS\Calc.exe", "rb"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } // 以二进制写方式打开test.exe文件 if((fpw=fopen("test.exe", "wb+"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } // 二进制文件读写操作，每次指定读写1个字节 while(!feof(fpd)) { //使用feof()判断文件尾 fread(&dw, 1, 1, fpd); fwrite(&dw, 1, 1, fpw); } // 关闭文件 fclose(fpd); fclose(fpw); //执行Calc.exe和Calc.exe文件 cout<<"1 Run C:\WINDOWS\Calc.exe"<

system("C:\WINDOWS\Calc.exe"); cout<<"-------------------"<

cout<<"2 Run test.exe!"< system("test.exe"); } #include

#include

void main(void) { //声明变量 int i; char ch; FILE *fp1; //以写入方式打开d.dat文件 if ((fp1=fopen("d.dat","w"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } //循环从键盘上读取字符,写入文件 cout<<"char:"; cin>>ch; while (ch!='*') { fputc(ch,fp1); //将字符写到fp1指向的"流"文件中 cin>>ch; } cout<<"--------------------"<

fclose(fp1); //关闭文件 //以读方式打开d.dat文件 if ((fp1=fopen("d.dat","r"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } //循环从文件读取字符,并显示 while ((ch=fgetc(fp1))!=EOF) cout<

cout< //以下按倒序方式读取文件中的字符，并显示 for (i=-1;;i--) { fseek(fp1,i,2); //设置文件指针，偏移量为i,相对文件尾 if ((ch=fgetc(fp1))!=EOF) cout<

else break; } cout<

//以下读取"流"文件中偶数位置上的字符，并打印 long position; for (i=0;;i=i+2) { fseek(fp1,i,0); //设置文件指针，偏移量为i,相对文件头 position=ftell(fp1); if ((ch=fgetc(fp1))==EOF) //遇到文件尾，则退出，否则打印读取的字符 break; else { cout<

fclose(fp1); //关闭文件 } #include

#include

#define MAX 5 //显示数组的数据 void show_array(double x[],int size) { for(int i=0;i

cout< } //main函数测试数组数据的文件读写 int main(void) { //声明变量 FILE *fp; // 声明FILE结构指针变量 int i; double a[MAX]={1.0,1.2,1.4,1.6,1.8}; //显示数组a的数据 cout<<"a:"; show_array(a,MAX); //打开d.dat文件 if ((fp=fopen("d.dat","wb+"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } //以单个元素对数组进行文件读操作 for(i=0;i

fwrite(&a[i], sizeof(double), 1, fp); } rewind(fp); //恢复读写指针的位置 //以单个元素对数组进行文件读操作 double b[MAX]; for(i=0;i

if (!feof(fp)) //使用feof()判断文件尾 fread(&b[i], sizeof(double), 1, fp); else break; } cout<<"b:"; show_array(b,MAX);//显示数组b的数据 fclose(fp); // 关闭文件 //打开d1.dat文件 if ((fp=fopen("d1.dat","wb+"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } //将数组当成数据块写入文件 fwrite(&a, sizeof(double), MAX, fp); rewind(fp); //恢复读写指针的位置 //将数组当成数据块从文件中读取 double c[MAX]; if (!feof(fp)) //使用feof()判断文件尾 fread(&c, sizeof(double),MAX,fp); cout<<"c:"; show_array(c,MAX); //显示数组c的数据 fclose(fp); // 关闭文件 } #include

#include

#define MAX 5 //定义结构类型 struct student { int num; char name[20]; float grade; }; //显示student结构数据 void show_str(student a,char *name) { cout<

cout< } //main函数测试结构数据的文件读写 int main(void) { //声明变量 FILE *fp; //声明FILE结构指针变量 student st={1001,"ZhangBin",85.5}; //显示st结构数据 show_str(st,"st"); //打开d.dat文件 if ((fp=fopen("d.dat","wb+"))==NULL) { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } //用fprintf()函数写结构数据到文件 fprintf(fp,"%d %s %f",st.num,st.name,st.grade); rewind(fp); //恢复读写指针的位置 //用fscanf()函数读文件中的数据赋值给结构并显示 student temp; fscanf(fp, "%d %s %f",&temp.num,temp.name,&temp.grade); show_str(temp,"temp"); cout<<"-----------------------"<

fclose(fp); // 关闭文件 //将结构数据当成数据块进行读写 if ((fp=fopen("d1.dat","wb+"))==NULL) //打开d1.dat文件 { cout<<"\nCould not open the file."<

cout<<"Exiting program."< exit(1); //结束程序执行 } //声明结构数组并初始化 int i; student starr[3]={{101,"WangPing",92},{102,"Li",85},{103,"LiuMin",97}}; //显示结构数组 for(i=0;i<3;i++) show_str(starr[i],"starr"); //将结构数组当成数据块写入文件 fwrite(starr, sizeof(student), 3, fp); rewind(fp); //恢复读写指针的位置 //按数据块从文件中读取数据赋值给结构数组 student temp_arr[3]; if (!feof(fp)) //使用feof()判断文件尾 fread(temp_arr, sizeof(student),3,fp); for(i=0;i<3;i++) show_str(temp_arr[i],"temp_arr"); fclose(fp); // 关闭文件 } #include

#include

int main(void) { //声明变量 char ch; char str[20]; int n; float x; //用stdin从键盘上输入数据 fprintf(stdout,"ch str\n"); fscanf(stdin,"%c %s",&ch,str); fprintf(stdout,"n x \n"); fscanf(stdin,"%d %f",&n,&x); cout<<"----------------"<

//输出显示 fprintf(stdout,"ch=%c str=%s",ch,str); fprintf(stdout,"\nn=%d x=%f",n,x); cout<

} #include

void main( void ) { int c; /* Create an error by writing to standard input. */ putc( 'A', stdin ); if( ferror( stdin ) ) { perror( "Write error" ); clearerr( stdin ); } /* See if read causes an error. */ printf( "Will input cause an error? " ); c = getc( stdin ); if( ferror( stdin ) ) { perror( "Read error" ); clearerr( stdin ); } } #include

#include

//此预处理指令不可少 const double HD=3.1415926/180; main() { cout<<"x\tsin(x)"<

for (int i=0;i<=180;i=i+30) cout<

} #include

//以下是几个简单宏替换预处理指令 #define YES 1 #define PI 3.1415926 #define RAD PI/180 #define MESG "This is a string." //以下是主程序 main() { //以下各语句使用了宏替换 cout<<"YES="<

if (YES) cout<<"PI="<

cout<<"RAD="< cout< } #include

//以下为带参数宏替换的预处理指令 #define PRINT(k) cout<<(k)<

#define MAX(a,b) ((a)>(b) ? (a):(b)) main() { int i=3,j=2; //MAX(a,b)宏替换的使用 cout<<"MAX(10,12)="<

cout<<"MAX(i,j)="< cout<<"MAX(2*i,j+3)="< //PRINT(k)宏替换的使用 PRINT(5); PRINT(MAX(7,i*j)); } #include

#define PI 3.1416 main() { int i=100; #if 1 cout<<"i="<

#endif #ifdef PI cout<<"1 PI="<

#endif #ifndef PI cout<<"2 PI="<

#endif } #include

const int MAX=5; //假定栈中最多保存5个数据 //定义名为stack的类，其具有栈功能 class stack { //数据成员 float num[MAX]; //存放栈数据的数组 int top; //指示栈顶位置的变量 public: //成员函数 void init(void) { top=0; } //初始化函数 void push(float x) //入栈函数 { if (top==MAX){ cout<<"Stack is full !"<

return; }; num[top]=x; top++; } float pop(void) //出栈函数 { top--; if (top<0){ cout<<"Stack is underflow !"<

return 0; }; return num[top]; } } //以下是main()函数，其用stack类创建栈对象，并使用了这些对象 main(void) { //声明变量和对象 int i; float x; stack a,b; //声明(创建)栈对象 //以下对栈对象初始化 a.init(); b.init(); //以下利用循环和push()成员函数将2,4,6,8,10依次入a栈对象 for (i=1; i<=MAX; i++) a.push(2*i); //以下利用循环和pop()成员函数依次弹出a栈中的数据并显示 for (i=1; i<=MAX; i++) cout<

//以下利用循环和push()成员函数将键盘输入的数据依次入b栈 cout<<"Please input five numbers."<

for (i=1; i<=MAX; i++) { cin>>x; b.push(x); } //以下利用循环和pop()成员函数依次弹出b栈中的数据并显示 for (i=1; i<=MAX; i++) cout<

const int MAX=5; //假定栈中最多保存5个数据 //定义名为stack的具有栈功能的类 class stack { //数据成员 float num[MAX]; //存放栈数据的数组 int top; //指示栈顶位置的变量 public: //成员函数 stack(void) //初始化函数 { top=0; cout<<"Stack initialized."<

} void push(float x) //入栈函数 { if (top==MAX){ cout<<"Stack is full !"<

return; }; num[top]=x; top++; } float pop(void) //出栈函数 { top--; if (top<0){ cout<<"Stack is underflow !"<

return 0; }; return num[top]; } } //以下是main()函数，其用stack类创建栈对象，并使用了这些对象 main(void) { //声明变量和对象 int i; float x; stack a,b; //声明(创建)栈对象并初始化 //以下利用循环和push()成员函数将2,4,6,8,10依次入a栈 for (i=1; i<=MAX; i++) a.push(2.0*i); //以下利用循环和pop()成员函数依次弹出a栈中的数据并显示 for (i=1; i<=MAX; i++) cout<

//以下利用循环和push()成员函数将键盘输入的数据依次入b栈 cout<<"Please input five numbers."<

for (i=1; i<=MAX; i++) { cin>>x; b.push(x); } //以下利用循环和pop()成员函数依次弹出b栈中的数据并显示 for (i=1; i<=MAX; i++) cout<

} #include

const int MAX=5; //假定栈中最多保存5个数据 //定义名为stack的具有栈功能的类 class stack { //数据成员 float num[MAX]; //存放栈数据的数组 int top; //指示栈顶位置的变量 public: //成员函数 stack(char c) //初始化函数 { top=0; cout<<"Stack "<

return; }; num[top]=x; top++; } float pop(void) //出栈函数 { top--; if (top<0){ cout<<"Stack is underflow !"<

return 0; }; return num[top]; } } //以下是main()函数，其用stack类创建栈对象，并使用了这些对象 main(void) { //声明变量和对象 int i; float x; stack a('a'),b('b'); //声明(创建)栈对象并初始化 //以下利用循环和push()成员函数将2,4,6,8,10依次入a栈 for (i=1; i<=MAX; i++) a.push(2.0*i); //以下利用循环和pop()成员函数依次弹出a栈中的数据并显示 for (i=1; i<=MAX; i++) cout<

} #include

main() { //定义一个名为student的类 class student { int num; char *name; float grade; public: //定义构造函数 student(int n,char *p,float g): num(n),name(p),grade(g){} display(void) { cout<

#include

//定义timer类 class timer{ long minutes; public: //无参数构造函数 timer(void) { minutes =0; }; //字符指针参数的构造函数 timer(char *m) { minutes = atoi(m); }; //整数类型的构造函数 timer(int h, int m) { minutes = 60*h+m ; }; //双精度浮点型构造函数 timer(double h) { minutes = (int) 60*h ; }; long getminutes(void) { return minutes ; }; }; //main()函数的定义 main(void) { //使用double类型的构造函数创建对象 timer start(8.30),finish(17.30); cout<<"finish(17.30)-start(8.30)="; cout<

//使用char指针类型的构造函数创建对象 timer start0("500"),finish0("800"); //创建对象 cout<<"finish0(\"800\")-start0(\"500\")="; cout<

//使用无参数构造函数和整型构造函数创建对象 timer start1; timer finish1(3,30); cout<<"finish1(3,30)-start1="; cout<

return 0; } #include

//定义rect类 class rect { int length; int width; int area; public: rect(int l=1,int w=1) { length=l; width=w; area=length*width; } void show_rect(char *name) { cout<

cout<<"length="< cout<<"width="< cout<<"area="< } }; //测试使用rect类 void main(void) { //用rect类创建对象 rect a; rect b(2); rect c(2,3); //调用对象的函数显示对象中的数据 a.show_rect("a"); b.show_rect("b(2)"); c.show_rect("c(2,3)"); } #include

const int MAX=5; //假定栈中最多保存5个数据 //定义名为stack的具有栈功能的类 class stack { //数据成员 double num[MAX]; //存放栈数据的数组 int top; //指示栈顶位置的变量 public: //成员函数 stack(char *name) //构造函数 { top=0; cout<<"Stack "<

return; }; num[top]=x; top++; } double pop(void) //出栈函数 { top--; if (top<0){ cout<<"Stack is underflow !"<

return 0; }; return num[top]; } } //以下是main()函数，其用stack类创建栈对象，并使用了这些对象 main(void) { double x; //声明(创建)栈对象并初始化 stack a("a"),b("b"); //以下利用循环和push()成员函数将2,4,6,8,10依次入a栈 for (x=1; x<=MAX; x++) a.push(2.0*x); //以下利用循环和pop()成员函数依次弹出a栈中的数据并显示 cout<<"a: "; for (int i=1; i<=MAX; i++) cout<

//从键盘上为b栈输入数据,并显示 for(i=1;i<=MAX;i++) { cout<

} #include

#define MAX 5 //定义stack类接口 class stack{ int num[MAX]; int top; public: stack(char *name); //构造函数原型 ~stack(void); //析构函数原型 void push(int n); int pop(void); }; //main()函数测试stack类 main(void) { int i,n; //声明对象 stack a("a"),b("b"); //以下利用循环和push()成员函数将2,4,6,8,10依次入a栈 for (i=1; i<=MAX; i++) a.push(2*i); //以下利用循环和pop()成员函数依次弹出a栈中的数据，并显示 cout<<"a: "; for (i=1; i<=MAX; i++) cout<

//从键盘上为b栈输入数据,并显示 for(i=1;i<=MAX;i++) { cout<

return 0; } //------------------------- // stack成员函数的定义 //------------------------- //定义构造函数 stack::stack(char *name) { top=0; cout << "Stack "<

return; }; num[top]=n; top++; } //出栈成员函数 int stack::pop(void) { top--; if (top<0){ cout<<"Stack is underflow !"<

return 0; }; return num[top]; } #include

//定义一个全部为public:模式的类 class ex { public: int value; void set(int n) { value=n; } int get(void) { return value; } }; //测试使用ex类 main() { ex a; //创建对象 //以下通过成员函数访问对象数据 a.set(100); cout<<"a.get()="; cout<

//以下直接访问对象的数据成员 a.value=200; cout<<"a.value="; cout<

} #include

// ex_class类接口定义 class ex_class { private: int iv; double dv; public: ex_class(void); ex_class(int n,double x); void set_ex_class(int n,double x); void show_ex_class(char*); }; //定义ex_class类的构造函数 ex_class::ex_class(void):iv(1), dv(1.0) { } ex_class::ex_class(int n,double x):iv(n), dv(x) { } //定义ex_class类的成员函数 void ex_class::set_ex_class(int n,double x) { iv=n; dv=x; } void ex_class::show_ex_class(char *name) { cout<

cout <<"dv=" < } //使用ex_class类 void main(void) { ex_class obj1; obj1.show_ex_class("obj1"); obj1.set_ex_class(5,5.5); obj1.show_ex_class("obj1"); ex_class obj2(100,3.14); obj2.show_ex_class("obj2"); obj2.set_ex_class(2000,1.732); obj2.show_ex_class("obj2"); } #include

//定义一个含有static数据成员的类 class ex { static int num; //static数据成员 public: ex() {num++;} ~ex() {num--;} disp_count() { cout<<"The current instances count:"; cout<

} }; int ex::num=0; //设置static数据成员的初值 //main()函数测试ex类 main() { ex a; a.disp_count(); ex *p; p=new ex; p->disp_count(); ex x[10]; x[0].disp_count(); delete p; a.disp_count(); } #include

//定义一个含有static数据成员的类 class ex { static int num; //static数据成员 public: ex() {num++;} ~ex() {num--;} static disp_count(void) //static成员函数 { cout<<"The current instances count:"; cout<

} }; int ex::num=0; //设置static数据成员的初值 //main()函数测试ex类 main() { ex a; a.disp_count(); ex *p; p=new ex; p->disp_count(); ex x[10]; ex::disp_count(); //直接用类作用域符引用静态成员函数 delete p; ex::disp_count(); //直接用类作用域符引用静态成员函数 } #include

class ex_class { int value; public: ex_class(int n) { value=n; cout << "Stack initialized." << endl; } ~ex_class() { cout << "The Object destroyed." <

} void set_value(int n); void show_val(char *name); } ; //在类外定义内联成员函数 inline void ex_class::set_value(int n) { value=n; } //在类外定义非内联成员函数 void ex_class::show_val(char *name) { cout<

} //在main()函数中测试ex_class类 main(void) { //创建对象x和y ex_class x(100),y(200); //显示对象的数据 x.show_val("x"); y.show_val("y"); //设置新值给对象 x.set_value(1); y.set_value(2); //显示对象的数据 x.show_val("x"); y.show_val("y"); return 0; } #include

//定义空类empty class empty { }; //在main()函数中用空类创建对象 main() { empty a,*p; //编译通过 cout<<"Test a empty class."<

} #include

//用struct关键字定义ex_class类 struct ex_class { ex_class(int n=1): value(n) {} void set_value(int n) { value=n; } show_obj(char *name) { cout<

#include

//定义双亲(parent)类 class parent { char f_name[20]; char m_name[20]; char tel[10]; public: // parent类的构造函数，其带有缺省值 parent(char *p1="",char *p2="",char *p3="") { strcpy(f_name,p1); strcpy(m_name,p2); strcpy(tel,p3); } //显示parent对象的数据 show_parent(void) { cout<<"The parent:"<

cout<<" father's name:"< cout<<" mother's name:"< cout<<" tel:"< } }; //定义student类 class student { int num; char name[20]; float grade; parent pt; public: // student类的构造函数 student(int n,char *str,float g,class parent t) { num=n; strcpy(name,str); grade=g; pt=t; } //显示student对象的数据 show_student(void) { cout<<"num:"<

cout<<"name:"< cout<<"grade:"< pt.show_parent(); } }; //main()函数测试student类的对象 main(void) { //创建双亲对象 parent p1("ZhangHua","LiLan","83665215"); //创建学生对象 student st(10001,"ZhangHui",91.5,p1); //显示学生信息 cout<<"p1:"<

p1.show_parent(); //显示学生信息 cout<<"st:"<

st.show_student(); } #include

#include

//定义timer类 class timer{ long minutes; public: //定义重载成员函数 settimer(char *m) { minutes = atoi(m); }; //定义重载成员函数 settimer(int h, int m) { minutes = 60*h+m ; }; //定义重载成员函数 settimer(double h) { minutes = (int) 60*h ; }; long getminutes(void) { return minutes; }; }; //main()函数的定义 main(void){ timer start,finish; //创建对象 //使用重载成员函数 start.settimer(8,30); finish.settimer(9,40); cout<<"finish.settimer(9,40)-start.settimer(8,30):"; cout<

//使用重载成员函数 start.settimer(2.0); finish.settimer("180"); cout<<"finish.settimer(\"180\")-start.settimer(2.0):"; cout<

return 0; } #include

//定义复数类 class complex{ float real; //实部 float image; //虚部 public: //重载的运算符"+"的原型 complex operator+ (complex right); //重载赋值运算符"="的定义 complex operator= (complex right); void set_complex(float re, float im); void put_complex(char *name); }; //重载加法运算符"+"的定义 complex complex::operator+ (complex right) { complex temp; temp.real = this->real + right.real; temp.image = this->image + right.image; return temp; } //重载加赋值运算符"="的定义 complex complex::operator= (complex right) { this->real = right.real; this->image = right.image; return *this; } //定义set_complex()成员函数 void complex::set_complex(float re, float im) { real = re; image = im; } //定义put_complex()成员函数 void complex::put_complex(char *name) { cout<

//定义YourClass类， class YourClass { //指定YourOtherClass是它的友元类 friend class YourOtherClass; private: int num; public: YourClass(int n){num=n;} display(char *YCname){ cout<

} }; //定义YourOtherClass，它是YourClass类的友元类 class YourOtherClass { public: //使用YourClass类的私有成员 void disp1(YourClass yc,char *YCname){ cout<

} //使用YourClass类的公共成员 void disp2(YourClass yc,char* YCname){ yc.display(YCname); } }; //在main()函数中创建和使用YourClass和YourOtherClass类对象 main(void) { //声明YourClass类对象 YourClass a(10),b(100); //显示a和b对象的值 cout<<"YourClass:"<

a.display("a"); b.display("b"); //声明YourOtherClass类对象 YourOtherClass temp; //通过temp显示a和b对象的值 cout<<"YourOtherClass:"<

temp.disp1(a,"a"); temp.disp2(b,"b"); } #include

//Y类的不完全定义 class Y; //X类的定义 class X { public: void disp(Y py,char *name); //成员函数原型 }; //定义Y类 class Y { //声明本类的友元函数 //X类的disp()为本例的友元函数 friend void X::disp(Y py,char *name); //普通函数putY() 为本例的友元函数 friend void putY(Y& yc,char *name); private: //私有成员 int num; dispY(char *name){ cout<

} public: //公共成员函数 Y(int n){ num=n; } }; //X类成员函数的实现部分 void X::disp(Y py,char *name){ cout<<"In X::disp():"<

py.dispY(name); //访问Y类的私有函数 } //普通函数putY()的定义 void putY(Y& yc,char *name){ cout<<"In getY:"<

yc.dispY(name); cout<

cout< } //在main()函数测试X和Y类的功能 main() { //创建Y和X类的对象 Y y1(100),y2(200); X x; //不可用Y类对象的私有成员函数显示 //y1.dispY("y1"); //y2.dispY("y2"); //调用X类对象的友元函数显示 x.disp(y1,"y1"); x.disp(y2,"y2"); //用getY函数显示Y类的对象显示 putY(y1,"y1"); putY(y2,"y2"); } #include

//定义日期类 class Date { //定义友元重载输入运算符函数 friend istream& operator >> (istream& input,Date& dt ); //定义友元重载输出运算符函数 friend ostream& operator<< (ostream& output,Date& dt ); int mo, da, yr; public: Date(void){ //无参数构造函数 yr = 0; mo = 0; da = 0; } Date( int y, int m, int d ) //带参数构造函数 { yr = y; mo = m; da = d; } }; //定义">>"运算符重载函数 istream& operator >> ( istream& input, Date& dt ) { cout<<"Year:"; input>>dt.yr; cout<<"Month:"; input>>dt.mo; cout<<"Day:"; input>>dt.da; return input; } //定义"<<"运算符重载函数 ostream& operator<< ( ostream& output, Date& dt ) { output<< dt.yr << '/' << dt.mo << '/' << dt.da<

return output; } //在main()函数中测试Date类的插入(<<)和提取(>>)运算符 void main() { //声明对象 Date dt1(2002,5,1),dt2; //显示dt1对象 cout<

//对dt2对象进行输入和输出 cin>>dt2; cout<

} #include

//定义ex类 class ex_class { int a; double b; public: ex_class(int n=1,double x=1.0):a(n),b(x) {} void show_value(char *name) { cout<

cout<<"b="< } }; //定义main()函数 main() { //创建ex_class的对象并显示 ex_class obj1,obj2(100,3.5); obj1.show_value("obj1"); obj2.show_value("obj2"); //创建ex_class的指针变量 ex_class *p; //p指向obj1并显示 p=&obj1; p->show_value("p->obj1"); //p指向obj2并显示 p=&obj2; (*p).show_value("(*p)obj2"); //p指向动态创建的对象并显示 p=new ex_class; p->show_value("p->new"); delete p; //删除对象 } #include

//基类Box class Box { int width,height; public: void SetWidth(int w) { width=w; } void SetHeight(int h) { height=h; } int GetWidth() {return width;} int GetHeight() {return height;} }; //派生类ColoredBox class ColoredBox:public Box { int color; public: void SetColor(int c){ color=c; } int GetColor() {return color;} }; // 在main()中测试基类和派生类 main(void) { //声明并使用ColoredBox类的对象 ColoredBox cbox; cbox.SetColor(3); //使用自己的成员函数 cbox.SetWidth(150); //使用基类的成员函数 cbox.SetHeight(100); //使用基类的成员函数 cout<<"cbox:"<

cout<<"Color:"< cout<<"Width:"< cout<<"Height:"< //cout< } #include

//基类First class First { int val1; public: SetVal1(int v) { val1=v; } void show_First(void) { cout<<"val1="<

} }; //派生类Second class Second:private First { //默认为private模式 int val2; public: void SetVal2(int v1,int v2) { SetVal1(v1); //可见，合法 val2=v2; } void show_Second(void) { // cout<<"val1="<

show_First(); cout<<"val2="<

} }; main() { Second s1; //s1.SetVal1(1); //不可见，非法 s1.SetVal2(2,3); //合法 //s1.show_First(); //不可见，非法 s1.show_Second(); } #include

//基类First class First { int val1; public: SetVal1(int v) { val1=v; } void show_First(void) { cout<<"val1="<

} }; //派生类Second class Second:public First { //默认为private模式 int val2; public: void SetVal2(int v1,int v2) { SetVal1(v1); //可见，合法 val2=v2; } void show_Second(void) { // cout<<"val1="<

show_First(); cout<<"val2="<

} }; main() { Second s1; //调用Second类定义的成员函数 s1.SetVal2(2,3); cout<<"s1.show_Second():"<

s1.show_Second(); //调用First类定义的成员函数 s1.SetVal1(10); cout<<"s1.show_First():"<

s1.show_First(); } #include

//定义最低层基类，它作为其他类的基类 class First { int val1; public: First(void) { cout<<"The First initialized"<

} }; //定义派生类，它作为其他类的基类 class Second :public First { int val2; public: Second(void) { cout<<"The Second initialized"<

} }; //定义最上层派生类 class Three :public Second { int val3; public: Three() { cout<<"The Three initialized"<

} }; //定义各基类的对象，测试构造函数的执行情况 //定义各基类的对象，测试构造函数的执行情况 main() { cout<<"First f1;"<

First f1; cout<<"Second s1;"<

Second s1; cout<<"Three t1;"<

Three t1; } #include

//定义基类First class First { int num; float grade; public: //构造函数带参数 First(int n,float v ) : num(n),grade(v) { cout<<"The First initialized"<

} DispFirst(void) { cout<<"num="<

cout<<"grade="< } }; //定义派生类Second class Second :public First { double val; public: //无参数构造函数，要为基类的构造函数设置参数 Second(void):First(10000,0) { val=1.0; cout<<"The Second initialized"<

} //带参数构造函数，为基类的构造函数设置参数 Second(int n,float x,double dx):First(n,x) { val=dx; cout<<"The Second initialized"<

} Disp(char *name){ cout<

DispFirst(); } }; //main()函数中创建和使用派生类对象 main() { //调用派生类的无参数构造函数 cout<<"Second s1;"<

Second s1; cout<<"s1.Disp(\"s1\");"<

s1.Disp("s1"); //调用派生类的有参数构造函数 cout<<"Second s2(10002,95.7,3.1415926); "<

Second s2(10002,95.7,3.1415926); cout<<"s2.Disp(\"s2\");"<

s2.Disp("s2"); } #include

//定义最低层基类First，它作为其他类的基类 class First { int val1; public: First() { cout<<"The First initialized"<

} ~First() { cout<<"The First destroyed"<

} }; //定义派生类Second，它作为其他类的基类 class Second :public First { //默认为private模式 int val2; public: Second() { cout<<"The Second initialized"<

} ~Second() { cout<<"The Second destroyed"<

} }; //定义最上层派生类Three class Three :public Second { int val3; public: Three() { cout<<"The Three initialized"<

} ~Three() { cout<<"The Three destroyed"<

} }; //main()函数中测试构造函数和析构函数的执行情况 main() { Three t1; cout<<"---- Use the t1----"<

} #include

//基类 class First { int val1; protected: void SetVal1(int v) { val1=v; } public: show_First(void) { cout<<"val1="<

} }; //派生类 class Second:public First { int val2; protected: void SetVal2(int v) { SetVal1(v); //使用First 基类的保护成员 val2=v; } public: show_Second(void) { show_First(); cout<<"val2="<

} }; //派生类 class Third:public Second { int val3; public: void SetVal3(int n) { SetVal1(n); //使用First 基类的保护成员 SetVal2(n); //使用Second基类的保护成员 val3=n; } show_Third(void) { show_Second(); cout<<"val3="<

} }; //main()函数的定义 main(void) { First f1; //f1.SetVal1(1); 不可访问 Second s1; //s1.SetVal1(1); 不可访问 //s1.SetVal2(2); 不可访问 Third t1; //t1.SetVal1(1); 不可访问 //t1.SetVal2(2); 不可访问 t1.SetVal3(10); //显示t1对象的数据 cout<<"t1.show_Third();"<

t1.show_Third(); cout<<"t1.show_Second();"<

t1.show_Second(); cout<<"t1.show_First();"<

t1.show_First(); } #include

enum Color {Red,Yellow,Green,White}; //圆类Circle的定义 class Circle { float radius; public: Circle(float r) {radius=r;} float Area() { return 3.1416*radius*radius; } }; //桌子类Table的定义 class Table { float height; public: Table(float h) {height=h;} float Height() { return height; } }; //圆桌类RoundTable的定义 class RoundTable:public Table,public Circle { Color color; public: RoundTable(float h,float r,Color c); //构造函数 int GetColor() { return color; } }; //圆桌构造函数的定义 RoundTable::RoundTable(float h,float r,Color c):Table(h),Circle(r) { color=c; } //main()函数的定义 main() { RoundTable cir_table(15.0,2.0,Yellow); cout<<"The table properties are:"<

//调用Height类的成员函数 cout<<"Height="<

//调用circle类的成员函数 cout<<"Area="<

//调用RoundTable类的成员函数 cout<<"Color="<

} #include

//定义一个枚举类型 enum Color {Red,Yellow,Green,White}; //圆类Circle的定义 class Circle { float radius; public: Circle(float r) { radius=r; cout<<"Circle initialized!"<

} ~Circle() { //析构函数 cout<<"Circle destroyed!"<

} float Area() { return 3.1416*radius*radius; } }; //桌子类Table的定义 class Table { float height; public: Table(float h) { height=h; cout<<"Table initialized!"<

} ~Table() { //构造函数 cout<<"Table destroyed!"<

} float Height() { return height; } }; //圆桌类RoundTable的定义 class RoundTable:public Table,public Circle { Color color; public: RoundTable(float h,float r,Color c); //构造函数 int GetColor() { return color; } ~RoundTable() { //构造函数 cout<<"RoundTable destroyed!"<

} }; //圆桌构造函数的定义 RoundTable::RoundTable(float h,float r,Color c):Table(h),Circle(r) { color=c; cout<<"RoundTable initialized!"<

} //测试多继承中构造函数和析构函数的执行方式 main() { RoundTable cir_table(15.0,2.0,Yellow); cout<<"The table properties are:"<

//调用Height类的成员函数 cout<<"Height="<

//调用circle类的成员函数 cout<<"Area="<

//调用RoundTable类的成员函数 cout<<"Color="<

} #include

//定义有两个虚函数的基类 class Base { public: //定义两个虚函数 virtual void aFn1(void){ cout<<"aFnl is in Base class."<

} virtual void aFn2(void) { cout<<"aFn2 is in Base class."<

} //定义非虚函数 void aFn3(void) { cout<<"aFn3 is in Base class."<

} }; //派生类Derived_1中重新定义了基类中的虚函数aFn1 class Derived_1:public Base { public: void aFn1(void) { //覆盖aFn1()函数 cout<<"aFnl is in First derived class."<

} // void aFn3(void) { 语法错误 // cout<<"aFn3 is in First derived class."<

//} }; //派生类Derived_2中重新定义了基类中的虚函数aFn2 class Derived_2:public Base{ public: void aFn2(void){ //覆盖aFn2()函数 cout<<"aFn2 is in Second derived class."<

} // void aFn3(void) { 语法错误 // cout<<"aFn3 is in Second derived class."<

//} }; //main()函数的定义 main(void) { //创建和使用基类Base的对象 Base b; cout<<"Base:"<

b.aFn1(); b.aFn2(); b.aFn3(); cout<<"----------------------"<

//创建和使用派生类Derived_1的对象 Derived_1 d1; cout<<"Derived_1:"<

d1.aFn1(); d1.aFn2(); d1.aFn3(); cout<<"----------------------"<

//创建和使用派生类Derived_2的对象 Derived_2 d2; cout<<"Derived_2:"<

d2.aFn1(); d2.aFn2(); d2.aFn3(); } #include

//定义抽象类 class Base { public: //定义两个纯虚函数 virtual void aFn1(void)=0; virtual void aFn2(void)=0; }; //派生类Derived_1中覆盖了基类中的纯虚函数 class Derived_1:public Base { public: void aFn1(void) { cout<<"aFnl is in First derived class."<

} void aFn2(void) { cout<<"aFn2 is in First derived class."<

} }; //派生类Derived_2中覆盖了基类中的纯虚函数 class Derived_2:public Base{ public: virtual void aFn1(void){ cout<<"aFn1 is in Second derived class."<

} void aFn2(void){ cout<<"aFn2 is in Second derived class."<

} }; //main()函数中测试抽象类及其派生类的对象 main(void) { //用抽象类不能创建对象 // Base b; 语法错误 // b.aFn1(); // b.aFn2(); //创建和使用Derived_1类的对象 Derived_1 d1; cout<<"Derived_1 d1:"<

d1.aFn1(); d1.aFn2(); cout<<"------------------"<

//创建和使用Derived_2类的对象 Derived_2 d2; cout<<"Derived_2 d2:"<

d2.aFn1(); d2.aFn2(); } #include

int extract_int() { char ch; int n=0; while(ch=cin.get()) if (ch>='0' && ch<='9') { cin.putback(ch); cin>>n; break; } return n; } //main()函数 main(void) { //提取字符串中的数字 int a=extract_int(); int b=extract_int(); int c=extract_int(); //显示结果 cout<

} #include

//定义节点(数据对象)的接口 class Node { //声明list类为本类的友元类 friend class list; //私有成员 private: int Data; //节点数据 Node *previous; //前趋指针 Node *next; //后继指针 }; //定义双向链表list的接口声明 class list { //私有成员 private: Node *Head; //链表头指针 Node *Tail; //链表尾指针 //定义接口函数 public: //构造函数 list(); //析构函数 ~list(); //从链表尾后添加数据 void Build_HT(int Data); //从链表前头添加数据 void Build_TH(int Data); //从头到尾显示数据 void list::Display_HT(); //从尾到头显示数据 void list::Display_TH(); //清除链表的全部数据 void Clear(); }; //main()函数测试双向链表 int main(void) { list list1; int i; //从尾添加数据 cout<<"Add to the back of the list1:"<

for (i=1;i<=20;i=i+2) { list1.Build_HT(i); cout<

//从头添加数据 cout<<"Add to the front of the list1:"<

for (i=0;i<=20;i=i+2) { list1.Build_TH(i); cout<

//显示链表 list1.Display_HT(); list1.Display_TH(); return 0; } //list类函数的定义 //构造函数的定义 list::list() { //初值 Head=0; Tail=0; } //析构函数的定义 list::~list() { Clear(); } //从链表尾后添加数据 void list::Build_HT(int Data) { Node *Buffer; Buffer=new Node; Buffer->Data=Data; if(Head==0) { Head=Buffer; Head->next=0; Head->previous=0; Tail=Head; } else { Tail->next=Buffer; Buffer->previous=Tail; Buffer->next=0; Tail=Buffer; } } //从链表前头添加数据 void list::Build_TH(int Data) { Node *NewNode; NewNode=new Node; NewNode->Data=Data; if(Tail==0) { Tail=NewNode; Tail->next=0; Tail->previous=0; Head=Tail; } else { NewNode->previous=0; NewNode->next=Head; Head->previous=NewNode; Head=NewNode; } } //从头到尾显示数据 void list::Display_HT() { Node *TEMP; TEMP=Head; cout<<"Display the list from Head to Tail:"<

while(TEMP!=0) { cout<

Data<<" "; TEMP=TEMP->next; } cout<

} //从尾到头显示数据 void list::Display_TH() { Node *TEMP; TEMP=Tail; cout<<"Display the list from Tail to Head:"<

while(TEMP!=0) { cout<

Data<<" "; TEMP=TEMP->previous; } cout<

} //清除链表的全部数据 void list::Clear() { Node *Temp_head=Head; if (Temp_head==0) return; do { Node *TEMP_NODE=Temp_head; Temp_head=Temp_head->next; delete TEMP_NODE; } while (Temp_head!=0); } #include

#include

using namespace std; //测试字符串(string)对象 void main() { //创建string对象,并显示 string s1; string s2="ABCDEFGHIJK"; string s3=s2; string s4(20,'A'); string s5(s2,3,3); cout<<"s1="<

cout<<"s2="< cout<<"s3="< cout<<"s4="< cout<<"s5="< //为string对象输入数据,并显示 cout<<"s1="; cin>>s1; cout<<"s2="; cin>>s2; cout<<"s3="; cin>>s3; cout<<"s4="; cin>>s4; cout<<"s5="; cin>>s5; cout<<"s1="<

cout<<"s2="< cout<<"s3="< cout<<"s4="< cout<<"s5="< } #include

#include

using namespace std; //测试字符串(string)对象 void main() { //创建string对象 string s1,s2; //string对象的赋值运算 s1="One"; s2="Two"; cout<<"s1="<

cout<<"s2="< //string对象的连接运算 string s3; s3=s1+" and "+s2; cout<<"s3="<

//组合赋值连接运算 s3+=" and Three"; cout<<"s3="<

//比较运算及其结果显示 for (int i=1;i<=3;i++) { cout<<"---------------------"<

cout<<"s1="; cin>>s1; cout<<"s2="; cin>>s2; if (s1

cout<

"< if (s1>=s2) //大于等于 cout<

= "< if (s1!=s2) //不等 cout<

cout<<"s2: "< //使用length成员函数 cout<<"s1.length()="<

cout<<"s2.length()="< //使用append成员函数 s1.append(s2); cout<<"s1: "<

//使用find成员函数和下标运算 int pos=s1.find('b'); cout<<"s1["<

//使用insert成员函数 s1.insert(pos," is a "); cout<

//使用assign成员函数 s1.assign("Good"); cout<

} //根据半径计算圆的周长和面积 #include

const float PI=3.1416; //声明常量(只读变量)PI为3.1416 float fCir_L(float); //声明自定义函数fCir_L()的原型 float fCir_S(float); //声明自定义函数fCir_S()的原型 //以下是main()函数 main() { float r,l,s; //声明3个变量 cout<<"R="; //显示字符串 cin>>r; //键盘输入 l=fCir_L(r); //计算圆的周长，赋值给变量l s=fCir_S(r); //计算圆的面积，赋值给变量s cout<<"l="<

cout<<"\ns="< } //定义计算圆的周长的函数fCir_L() float fCir_L(float x) { float z=-1.0; //声明局部变量 if (x>=0.0) //如果参数大于0，则计算圆的周长 z=2*PI*x; return(z); //返回函数值 } //定义计算圆的面积的函数fCir_S() float fCir_S(float x) { float z=-1.0; //声明局部变量 if (x>=0.0) //如果参数大于0，则计算圆的面积 z=PI*x*x; return(z); //返回函数值 } #include

#include

#define MAX 30 //main()的定义 int main(void) { char str[MAX],*p; //从键盘上输入int数 cout<<"Please input a int:"<

int n; cin>>n; //将整型数n按十进制转换为字符串并输出 p=itoa(n,str,10); cout<<"str="<

cout<<"p="< //将整型数n按十六进制转换为字符串并输出 p=itoa(n,str,16); cout<<"str="<

cout<<"p="< //从键盘上输入double类型的数据 cout<<"Please input a double:"<

double x; cout<<"x="; cin>>x; //将浮点数x转换为字符串后输出 p=gcvt(x,10,str); cout<<"str="<

cout<<"p="< return 0; } #include

#include

#define MAX 30 //main()的定义 int main(void) { char str[MAX]; //字符串转换为int和long类型数据 cout<<"Please input a string:"<

cin>>str; int n=atoi(str); cout<<"n="<

long l=atol(str); cout<<"l="<

//字符串转换为double类型 cout<<"Please input a string:"<

cin>>str; double x=atof(str); cout<<"x="<

return 0; } #include

#include

//定义产生[n1,n2]范围int随机数的函数 int rand(int n1,int n2) { if (n1>n2) return -1; if (n1==n2) return 0; int temp=n1+int((n2-n1)*double(rand())/RAND_MAX); return temp; } //main()函数的定义，加法练习程序 void main( void ) { int i; //使用当前的系统时间初始化随机数种子 srand( (unsigned)time( NULL ) ); //加法练习 int a,b,c; do { a=rand(0,20); b=rand(0,20); L1: cout<

cin>>c; if (c==0) break; if (c!=a+b) { cout<<"Error! Try again!"<

goto L1; } cout<<"OK!"<

} while (1); } #include

#include

#define PI 3.1415926535 //main()函数的定义 void main( void ) { int i; double x=PI/180; cout<<"X\tSIN(X)\t\tCOS(X)"<

cout<<"---------------------------------------"< for (i=0;i<=360;i=i+30) { cout<

cout.precision(2); cout<

cout< } } #include

#include

#define PI 3.1415926535 //main()函数的定义 void main( void ) { int i; double d=180/PI; cout<<"X\tASIN(X)\t\tACOS(X)"<

cout<<"---------------------------------------"< for (double x=0;x<=1.0+0.05;x=x+0.1) { cout<

cout< cout< } } #include

#include

//main()函数的定义 void main( void ) { _complex a={3,4},b={3,-4}; double d=cabs(a); cout<<"cabs("<

cout<<"cabs("< } ##include

#include

//main()函数的定义 void main( void ) { double x; //循环输入数据计算对数 do { cout<<"x="; cin>>x; if (x<=0) break; cout<<"log("<

cout<<"log10("< } while(1); } #include

#include

//main()函数的定义 void main( void ) { double y; for(double x=-5;x<=5;x++){ y=exp(x); cout<<"exp("<

} } #include

#include

//main()函数的定义 void main( void ) { double y; int N; //输入一个大于等于0的数 do { cout<<"N="; cin>>N; if (N>=0) break; } while (1); //计算并显示 for(int i=0;i<=N;i++){ y=pow(2,i); cout<<"pow("<<2<<","<

} } #include

#include

//main()函数的定义 void main( void ) { double y; for(int i=0;i<=10;i++){ y=sqrt(i); cout<<"sqrt("<

} } #include

#include

//时间延迟函数 void Dtime(int dt) { time_t current_time; time_t start_time; // 得到开始时间 time(&start_time); do { time(¤t_time); } while ((current_time - start_time) < dt); } //main()函数的定义 void main(void) { cout<<"The First information!"<

cout<<"About to delay 5 seconds"< Dtime(5); cout<<"The Second information!"<

} #include

#include

//main()函数的定义 void main(void) { //声明time_t类型的变量，其以秒为单位存放系统时间 time_t current_time; //得到当前的系统时间(秒) time(¤t_time); //转换系统时间为tm结构的时间信息 tm *ptime=gmtime(¤t_time); //显示time_t结构的时间 cout<<"current_time:"<

//显示tm结构的时间信息 cout<<"seconds after the minute:"<<(ptime->tm_sec)<

cout<<"minutes after the hour:"<<(ptime->tm_min)< cout<<"hours since midnight:"<<(ptime->tm_hour)< cout<<"day of the month:"<<(ptime->tm_mday)< cout<<"months since January:"<<(ptime->tm_mon)< cout<<"years since 1900:"<<(ptime->tm_year)< cout<<"days since Sunday:"<<(ptime->tm_wday)< cout<<"days since January 1:"<<(ptime->tm_yday)< cout<<"daylight savings time flag:"<<(ptime->tm_isdst)< } #include

#include

//main()函数的定义 void main(void) { //声明变量 time_t current_time; //得到当前系统时间 time(¤t_time); //转换系统时间为tm结构 tm *ptime=gmtime(¤t_time); //转换time_t类型的时间字符串并显示 char *timep=ctime(¤t_time); cout<<"ctime(¤t_time):"<

cout< //转换tm类型的数据转换为时间字符串并显示 char *tmp=asctime(ptime); cout<<"asctime(ptime):"<

cout< } #include

#include

//定义时间延迟函数 void Dtime(double dt) { time_t current_time; time_t start_time; //得到开始时间 time(&start_time); //延迟处理 do { time(¤t_time); } while (difftime(current_time,start_time)

} //main()函数的定义 void main(void) { //声明变量 int i; time_t current_time; char *timep; //循环10次，每隔2秒显示一次时间 for(i=0;i<10;i++) { time(¤t_time); timep=ctime(¤t_time); cputs(timep); Dtime(2); } } #include

#include

int main(void) { //定义结构类型 struct student { int num; char name[20]; float grade; }; //声明结构指针变量 struct student *sp; //计算申请的内存量 int size=sizeof(struct student); //申请需要的存储空间并强制类型转换 sp=(struct student*)malloc(size); //为结构对象输入数据 cout<<"nmu:"; cin>>(sp->num); cout<<"name:"; cin>>(sp->name); cout<<"grade:"; cin>>(sp->grade); //输出结构对象的数据 cout<<"num:"<<(sp->num)<

cout<<"name:"<<(sp->name)< cout<<"grade:"<<(sp->grade); //释放内存 free(sp); } #include

#include

//定义时间延迟函数 void Dtime(double dt) { time_t current_time; time_t start_time; // 得到开始时间 time(&start_time); //延迟处理 do { time(¤t_time); } while (difftime(current_time,start_time)

} //控制台函数显示 void cputs_show(int n) { time_t current_time; char *timep; cputs("Show time with cputs\n"); for(int i=0;i<5;i++) { time(¤t_time); timep=ctime(¤t_time); cputs(timep); Dtime(n); } } //cout对象显示 void cout_show(int n) { time_t current_time; char *timep; cout<<"Show time with cout"<

for(int i=0;i<5;i++) { time(¤t_time); timep=ctime(¤t_time); cout<

Dtime(n); } } //main()函数的定义 void main(void) { cputs_show(1); cout_show(1); } #include

main() { //输出字符串 printf("He said \"Hello!\""); //输出各进制整数 int i=64; printf("\ni=%d",i); //以十进制格式输出 printf("\ni=%o",i); //以八进制格式输出 printf("\ni=%x",i); //以十六进制格式输出 printf("\ni=%d,%o,%x",i,i,i); //各种格式混合输出 //输出浮点数 float x=3141.5926; printf("\nx=%f",x); //指定输出浮点数的格式为十进制形式 printf("\nx=%e",x); //指定输出浮点数的格式为指数形式 //控制输出项宽度 int j=123; printf("\nj=%-10d",j); //任选项"-"指定左对齐，W 指定宽度为10 printf("\nj=%10d\n",j); //W 指定宽度为10 //控制输出精度 float y=3.1415926; printf("y=%10.2f\n",y); //W 指定宽度为10，P指定小数点后保留2位 printf("y=%10.5f\n",y); //W 指定宽度为10，P指定小数点后保留5位 } #include

main() { //输入字符串 char str[80]; printf("str:"); //显示提示 scanf("%s",str); printf("The string:%s",str); //输入各进制整数 int a,b,c,sum; printf("\na\tb\tc\n"); //显示提示 scanf("%d %o %x",&a,&b,&c); //以十进制、八进制、十六进制形式输入数据 sum=a+b+c; printf("a=%d b=%d c=%d sum=%d",a,b,c,sum); //输入浮点数并计算显示 float x,y; //声明变量 printf("\nx\ty\n"); //显示提示 scanf("%f %f",&x,&y); //对非空白字符"x= y="读入，不保存 printf("sum=%f product=%f\n",x+y, x*y); //显示表达式的值 } #include

#include

#define MAX_PATH 250 main() { //声明变量 char *p,str[MAX_PATH]; //设置新目录 if (mkdir("d:\\ABC")){ cout<<"mkdir Error!"<

} //更该工作目录 if (chdir("d:\\ABC")){ cout<<"chdir Error!"<

} //读取当前目录 if ((p=getcwd(str,MAX_PATH))==NULL) { cout<<"getcwd Error!"<

} else { cout<<"p:"<

cout<<"str:"< } //更该工作目录 if (chdir("d:\\")){ cout<<"chdir Error!"<

} //删除指定目录 if (rmdir("d:\\ABC")==-1) cout<<"rmdir Error!"<

} #include

#include

void main( void ) { struct stat buf; int result; //获得c:\Windows\Calc.exe文件的状态信息 result =stat( "c:\\windows\\Calc.exe", &buf ); //显示Calc.exe文件的状态信息 if( result != 0 ) perror( "Problem getting information" ); else { cout<<"Size of the file in bytes:"<

cout<<"Drive number of the disk containing the file :"; cout<

cout<<"Time of creation of the file:"< cout<<"Time of last access of the file:"< cout<<"Time of last modification of the file:"< } } #include

#include

void main( void ) { //设置字符串 char string[] = "Fill the string with something"; cout<<"string:"<

char *p=strset(string,'*'); cout<<"p :"<

cout<<"string:"< //按指定字符和指定数目设置字符数组 char string1[] = "Fill the string with something"; cout<<"string1:"<

p=strnset(string1,'*',5); cout<<"p :"<

cout<<"string1:"< } #include

#include

void main( void ) { //拷贝字符串常量到字符数组 char string[80] = "Fill the string with something"; cout<<"string:"<

cout<<"strcpy:"< char *p=strcpy(string,"abc"); cout<<"p :"<

cout<<"string:"< char str[80]; cout<<"str:"; cin>>str; p=strcpy(string,str); cout<<"p :"<

cout<<"string:"< //拷贝前5个字符到string中 cout<<"str:"; cin>>str; cout<<"strncpy:"<

p=strncpy(string,str,strlen(str)); cout<<"p :"<

cout<<"string:"< } #include

#include

void main( void ) { //声明字符数组和字符型指针变量 char string[80],*p; //拷贝字符串 strcpy( string, "I'll see you"); cout<<"string:"<

//追加字符串 p=strcat( string, " in the morning."); cout<<"String: "<

cout<<"p : "< } #include

#include

//字符串输入函数 void str_input(char *p1,char *p2) { cout<<"string1:"; cin>>p1; cout<<"string2:"; cin>>p2; } //显示strcmp()函数的比较结果 void strcmp_put(char *p1,char *p2) { cout<<"strcmp():"<

int result=strcmp(p1,p2); if (result>0) cout<

int result=stricmp(p1,p2); if (result>0) cout<

int result=strncmp(p1,p2,count); if (result>0) cout<

} } #include

#include

//main()函数 void main( void ) { //声明字符数组 char string[80],*p; int i; //转换字符串中的小写字母为大写 cout<<"Convert a string to uppercase:"<

cout<<"string:"; cin>>string; p=strupr(string); cout<<"p:"<

cout<<"string:"< cout<<"----------------------"< //转换字符串中的大写字母为小写 cout<<"Convert a string to lowercase:"<

cout<<"string:"; cin>>string; p=strlwr(string); cout<<"p:"<

cout<<"string:"< } #include

#include

//main()函数 void main( void ) { //声明字符数组 char string[]="This is a test."; int n; //获得字符串的长度 cout<<"string:"<

n=strlen(string); cout<<"The length of "<<"\""<

cout<<"s1: "; cout<

void swap(T &x, T &y) { T temp; temp=x; x=y; y=temp; } #include

//声明函数模板的原型语句 template

void swap(T *x, T *y); //定义一个结构类型 struct student { int n; char name[20]; float grade; }; //在main()函数中测试swap()函数模板 void main(void) { //交换两个int型变量中的数据 int m=3,n=5; cout<<"m="<

cout<<"s1: "; cout<

void swap(T *x, T *y) { T temp; temp=*x; *x=*y; *y=temp; } #include

//定义输入函数模板 template

void input(char *str,T &x) { cout<

cin>>x; } //定义输出函数模板 template

void output(char *str,T x) { cout<

} //在main()函数中测试输入输出函数模板 void main(void) { //输入输出int型数据 int a,b; input("a",a); output("a",a); b=3*a; output("3*a",b); output("a+b",a+b); cout<<"-------------------"<

//输入输出double型数据 double x,y; input("x",x); output("x",x); y=2*x; output("y",y); cout<<"-------------------"<

//输入输出char型数据 char c1; input("c1",c1); output("c1+2",char(c1+2)); cout<<"-------------------"<

//输入输出字符串数据 char string[80]; input("string",string); output("string",string); } #include

#include

//显示数组的函数模板 template

void arr_put(T arr[],int size) { for (int i=0 ;i<=size;i++) cout<

} //选择排序数组的函数模板 template

void sort(T arr[],int size) { T temp; int i,j; for (i=0;i

for (j=i+1;j<=size;j++) if (arr[i]<=arr[j]) { temp=arr[i]; arr[i]=arr[j]; arr[j]=temp; } } //在main()函数中测试数组排序的函数模板 void main(void) { //用排序函数模板处理int型数组 cout<<"int:"<

int a[]={1,5,2,7,9,0,10,-1}; arr_put(a,7); sort(a,7); arr_put(a,7); //用排序函数模板处理double型数组 cout<<"double:"<

double x[]={1.2,2.1,1.414,1.732}; arr_put(x,3); sort(x,3); arr_put(x,3); //用排序函数模板处理char类型数组 cout<<"char:"<

char str[80]; cout<<"str:"; cin>>str; int size=strlen(str); arr_put(str,size); sort(str,size); arr_put(str,size); } #include

#include

//显示数组的函数模板 template

void arr_put(T arr[],int size) { for (int i=0 ;i

cout< } //选择法对数组排序的函数模板 template

void sort(T arr[],int size) { T temp; int i,j; for (i=0;i

for (j=i+1;j if (arr[i]>arr[j]) { temp=arr[i]; arr[i]=arr[j]; arr[j]=temp; } } //二分查找法的函数模板 template

int binary_search(T array[], T value, int size) { int found = 0; int high = size, low = 0, mid; mid = (high + low) / 2; cout<<"Looking for "<

while ((! found) && (high >= low)) { if (value == array[mid]) found = 1; else if (value < array[mid]) high = mid - 1; else low = mid + 1; mid = (high + low) / 2; } return((found) ? mid: -1); } //main()函数中使用处理数组的函数模板 void main(void) { //处理int型数组 int array[10]={1,3,5,7,9,2,4,6,8,10}; //显示数组初值 arr_put(array,10); //对数组排序并显示 sort(array,10); arr_put(array,10); //查找数组 cout<<"Result of search: "<

cout<<"Result of search: "< cout<<"Result of search: "< cout<<"Result of search: "< cout<<"------------------------------"< //处理字符串型数组 char ch1,str[]="happy"; int size=strlen(str); //显示数组初值 arr_put(str,size); //对数组排序并显示 sort(str,size); arr_put(str,size); //查找数组 cout<<"Input a char:"; cin>>ch1; cout<<"Result of search: "<

} #include

//定义名为ex_class的类模板 template

class ex_class { T value; public: ex_class(T v) { value=v; } void set_value(T v) { value=v; } T get_value(void) {return value;} }; //main()函数中测试ex_class类模板 void main(void) { //测试int类型数据 ex_class

a(5),b(10); cout<<"a.value:"<

cout<<"b.value:"< //测试char类型数据 ex_class

ch('A'); cout<<"ch.value:"<

ch.set_value('a'); cout<<"ch.value:"<

//测试double类型数据 ex_class

x(5.5); cout<<"x.value:"<

x.set_value(7.5); cout<<"x.value:"<

} #include

//定义栈的尺寸 const int SIZE = 100; //定义处理栈的类模板接口 template

class stack { T stck[SIZE]; int tos; public: stack(void) { tos = 0; cout << "Stack Initialized." << endl; } ~stack(void) { cout << "Stack Destroyed." << endl; } void push(T); T pop(void); }; //定义栈的成员函数 template

void stack::push(T i) { if(tos==SIZE) { cout << "Stack is full." << endl; return; } stck[tos++] = i; } template

T stack::pop(void) { if(tos==0) { cout << "Stack underflow." << endl; return 0; } return stck[--tos]; } //main()函数中测试stack类模板 void main(void) { //处理int类型数据的栈 cout<<"stack

a :"< stack a; a.push(1); a.push(2); cout << a.pop() << " "; cout << a.pop() << endl; //处理double类型数据的栈 cout<<"stack

b :"< stack b; b.push(99.3); b.push(-12.23); cout << b.pop() << " "; cout << b.pop() <

//处理char类型数据的栈 cout<<"stack

c :"< stack c; for(int i=0; i<10; i++) c.push((char) 'A' + i); for(i=0; i<10; i++) cout <

cout << endl; } #include

//定义名为ex_class的类模板 template

class ex_class { T1 value1; T2 value2; public: ex_class(T1 v1,T2 v2) { value1=v1; value2=v2; } void set_value(T1 v1,T2 v2) { value1=v1; value2=v2; } void put_value(void) { cout<<"valu1="<

cout<<"valu2="< } }; //main()函数中测试ex_class类模板 void main(void) { //测试int和double类型数据 ex_class

a(5,1.5); cout<<"ex_class

a:"< a.put_value(); a.set_value(100,3.14); a.put_value(); //测试double和int类型数据 ex_class

b(0.5,5); cout<<"ex_class

b:"< b.put_value(); b.set_value(1.732,100); b.put_value(); //测试char和int类型数据 ex_class

c('a',5); cout<<"ex_class

c:"< c.put_value(); c.set_value('B',100); c.put_value(); //测试int和int类型数据 ex_class

d(5,10); cout<<"ex_class

d:"< d.put_value(); d.set_value(100,200); d.put_value(); } #include

#include

using namespace std; //创建一个list容器的实例LISTINT typedef list

LISTINT; //创建一个list容器的实例LISTCHAR typedef list

LISTCHAR; void main(void) { //-------------------------- //用list容器处理整型数据 //-------------------------- //用LISTINT创建一个名为listOne的list对象 LISTINT listOne; //声明i为迭代器 LISTINT::iterator i; //从前面向listOne容器中添加数据 listOne.push_front (2); listOne.push_front (1); //从后面向listOne容器中添加数据 listOne.push_back (3); listOne.push_back (4); //从前向后显示listOne中的数据 cout<<"listOne.begin()--- listOne.end():"<

for (i = listOne.begin(); i != listOne.end(); ++i) cout << *i << " "; cout << endl; //从后向后显示listOne中的数据 LISTINT::reverse_iterator ir; cout<<"listOne.rbegin()---listOne.rend():"<

for (ir =listOne.rbegin(); ir!=listOne.rend();ir++) { cout << *ir << " "; } cout << endl; //使用STL的accumulate(累加)算法 int result = accumulate(listOne.begin(), listOne.end(),0); cout<<"Sum="<

cout<<"------------------"< //-------------------------- //用list容器处理字符型数据 //-------------------------- //用LISTCHAR创建一个名为listOne的list对象 LISTCHAR listTwo; //声明i为迭代器 LISTCHAR::iterator j; //从前面向listTwo容器中添加数据 listTwo.push_front ('A'); listTwo.push_front ('B'); //从后面向listTwo容器中添加数据 listTwo.push_back ('x'); listTwo.push_back ('y'); //从前向后显示listTwo中的数据 cout<<"listTwo.begin()---listTwo.end():"<

for (j = listTwo.begin(); j != listTwo.end(); ++j) cout << char(*j) << " "; cout << endl; //使用STL的max_element算法求listTwo中的最大元素并显示 j=max_element(listTwo.begin(),listTwo.end()); cout << "The maximum element in listTwo is: "<

} #include

#include

using namespace std; typedef vector

INTVECTOR; //测试vector容器的功能 void main(void) { //vec1对象初始为空 INTVECTOR vec1; //vec2对象最初有10个值为6的元素 INTVECTOR vec2(10,6); //vec3对象最初有3个值为6的元素 INTVECTOR vec3(vec2.begin(),vec2.begin()+3); //声明一个名为i的双向迭代器 INTVECTOR::iterator i; //从前向后显示vec1中的数据 cout<<"vec1.begin()--vec1.end():"<

for (i =vec1.begin(); i !=vec1.end(); ++i) cout << *i << " "; cout << endl; //从前向后显示vec2中的数据 cout<<"vec2.begin()--vec2.end():"<

for (i =vec2.begin(); i !=vec2.end(); ++i) cout << *i << " "; cout << endl; //从前向后显示vec3中的数据 cout<<"vec3.begin()--vec3.end():"<

for (i =vec3.begin(); i !=vec3.end(); ++i) cout << *i << " "; cout << endl; //测试添加和插入成员函数 vec1.push_back(2); vec1.push_back(4); vec1.insert(vec1.begin()+1,5); vec1.insert(vec1.begin()+1,vec3.begin(),vec3.end()); cout<<"push() and insert():" <

for (i =vec1.begin(); i !=vec1.end(); ++i) cout << *i << " "; cout << endl; //测试赋值成员函数 vec2.assign(8,1); cout<<"vec2.assign(8,1):" <

for (i =vec2.begin(); i !=vec2.end(); ++i) cout << *i << " "; cout << endl; //测试引用类函数 cout<<"vec1.front()="<

cout<<"vec1.back()="< cout<<"vec1.at(4)="< cout<<"vec1[4]="< //测试移出和删除 vec1.pop_back(); vec1.erase(vec1.begin()+1,vec1.end()-2); cout<<"vec1.pop_back() and vec1.erase():" <

for (i =vec1.begin(); i !=vec1.end(); ++i) cout << *i << " "; cout << endl; //显示序列的状态信息 cout<<"vec1.capacity(): "<

cout<<"vec1.max_size(): "< cout<<"vec1.size(): "< cout<<"vec1.empty(): "< //vector序列容器的运算 cout<<"vec1==vec3: "<<(vec1==vec3)<

cout<<"vec1<=vec3: "<<(vec1<=vec3)< } #include

#include

using namespace std; typedef deque

INTDEQUE; //从前向后显示deque队列的全部元素 void put_deque(INTDEQUE deque, char *name) { INTDEQUE::iterator pdeque; cout << "The contents of " << name << " : "; for(pdeque = deque.begin(); pdeque != deque.end(); pdeque++) cout << *pdeque << " "; cout<

} //测试deqtor容器的功能 void main(void) { //deq1对象初始为空 INTDEQUE deq1; //deq2对象最初有10个值为6的元素 INTDEQUE deq2(10,6); //deq3对象最初有3个值为6的元素 INTDEQUE deq3(deq2.begin(),deq2.begin()+3); //声明一个名为i的双向迭代器变量 INTDEQUE::iterator i; //从前向后显示deq1中的数据 put_deque(deq1,"deq1"); //从前向后显示deq2中的数据 put_deque(deq2,"deq2"); //从前向后显示deq3中的数据 put_deque(deq3,"deq3"); //从deq1序列后面添加两个元素 deq1.push_back(2); deq1.push_back(4); cout<<"deq1.push_back(2) and deq1.push_back(4):"<

put_deque(deq1,"deq1"); //从deq1序列前面添加两个元素 deq1.push_front(5); deq1.push_front(7); cout<<"deq1.push_front(5) and deq1.push_front(7):"<

put_deque(deq1,"deq1"); //在deq1序列中间插入数据 deq1.insert(deq1.begin()+1,3,9); cout<<"deq1.insert(deq1.begin()+1,3,9):"<

put_deque(deq1,"deq1"); //测试引用类函数 cout<<"deq1.front()="<

cout<<"deq1.back()="< cout<<"deq1.at(4)="< cout<<"deq1[4]="< deq1.at(1)=10; deq1[2]=12; cout<<"deq1.at(1)=10 and deq1[2]=12 :"<

put_deque(deq1,"deq1"); //从deq1序列的前后各移去一个元素 deq1.pop_front(); deq1.pop_back(); cout<<"deq1.pop_front() and deq1.pop_back():"<

put_deque(deq1,"deq1"); //清除deq1中的第2个元素 deq1.erase(deq1.begin()+1); cout<<"deq1.erase(deq1.begin()+1):"<

put_deque(deq1,"deq1"); //对deq2赋值并显示 deq2.assign(8,1); cout<<"deq2.assign(8,1):"<

put_deque(deq2,"deq2"); //显示序列的状态信息 cout<<"deq1.max_size(): "<

cout<<"deq1.size(): "< cout<<"deq1.empty(): "< //deqtor序列容器的运算 cout<<"deq1==deq3: "<<(deq1==deq3)<

cout<<"deq1<=deq3: "<<(deq1<=deq3)< } #include

#include

using namespace std; typedef list

INTLIST; //从前向后显示list队列的全部元素 void put_list(INTLIST list, char *name) { INTLIST::iterator plist; cout << "The contents of " << name << " : "; for(plist = list.begin(); plist != list.end(); plist++) cout << *plist << " "; cout<

} //测试list容器的功能 void main(void) { //list1对象初始为空 INTLIST list1; //list2对象最初有10个值为6的元素 INTLIST list2(10,6); //list3对象最初有3个值为6的元素 INTLIST list3(list2.begin(),--list2.end()); //声明一个名为i的双向迭代器 INTLIST::iterator i; //从前向后显示各list对象的元素 put_list(list1,"list1"); put_list(list2,"list2"); put_list(list3,"list3"); //从list1序列后面添加两个元素 list1.push_back(2); list1.push_back(4); cout<<"list1.push_back(2) and list1.push_back(4):"<

put_list(list1,"list1"); //从list1序列前面添加两个元素 list1.push_front(5); list1.push_front(7); cout<<"list1.push_front(5) and list1.push_front(7):"<

put_list(list1,"list1"); //在list1序列中间插入数据 list1.insert(++list1.begin(),3,9); cout<<"list1.insert(list1.begin()+1,3,9):"<

put_list(list1,"list1"); //测试引用类函数 cout<<"list1.front()="<

cout<<"list1.back()="< //从list1序列的前后各移去一个元素 list1.pop_front(); list1.pop_back(); cout<<"list1.pop_front() and list1.pop_back():"<

put_list(list1,"list1"); //清除list1中的第2个元素 list1.erase(++list1.begin()); cout<<"list1.erase(++list1.begin()):"<

put_list(list1,"list1"); //对list2赋值并显示 list2.assign(8,1); cout<<"list2.assign(8,1):"<

put_list(list2,"list2"); //显示序列的状态信息 cout<<"list1.max_size(): "<

cout<<"list1.size(): "< cout<<"list1.empty(): "< //list序列容器的运算 put_list(list1,"list1"); put_list(list3,"list3"); cout<<"list1>list3: "<<(list1>list3)<

cout<<"list1

} //put_THset函数，从尾向头显示set容器的所有元素 void put_THset(SET_INT s1,char *name) { SET_INT::reverse_iterator i; cout<

} //测试set模板 void main(void) { int i; //声明set的对象和迭代器 SET_INT s1; //容器初始尾空 SET_INT::iterator it; //向s1对象中插入值 for (i=1;i<20;i=i+2) { s1.insert(i); } //正向显示s1中的数据 put_HTset(s1,"s1"); //反向显示s1中的数据 put_THset(s1,"s1"); //构造含有元素的序列并显示 SET_INT s2(s1); put_HTset(s2,"s2"); //删除s2的第2个元素并显示 s2.erase(++s2.begin()); put_HTset(s2,"s2"); //向s2插入8和9并显示 s2.insert(8); s2.insert(9); put_HTset(s2,"s2"); //清空s2的序列 s2.clear(); put_HTset(s2,"s2"); //按关键给定的区间显示序列中的元素 cout<<"[s1.lower_bound(5),s1.upper_bound(15)] :"; for (it=s1.lower_bound(4);it!=s1.upper_bound(16);it++) cout<<(*it)<<" "; cout<

//显示s1的状态信息 cout<<"s1.size():"<

cout<<"s1.max_size():"< cout<<"s1.count(15):"< //交换两个set容器的元素并显示 s1.swap(s2); put_HTset(s1,"s1"); put_HTset(s2,"s2"); //关系运算 s1.insert(5); cout<<"s1>s2 = "<<(s1>s2)<

} #include

#include

using namespace std; //创建multiset模板的实例 typedef multiset

MULTISET_INT; //put_HTset函数，从头向尾显示multiset容器的所有元素 void put_HTset(MULTISET_INT set1,char *name) { MULTISET_INT::iterator it; cout<

} //put_THset函数，从尾向头显示multiset容器的所有元素 void put_THset(MULTISET_INT s1,char *name) { MULTISET_INT::reverse_iterator i; cout<

} //测试multiset模板 void main(void) { int i; //声明multiset的对象和迭代器 MULTISET_INT s1; //容器初始尾空 MULTISET_INT::iterator it; //向s1对象中插入值 for (i=1;i<20;i=i+2) { s1.insert(i); } //正向显示s1中的数据 put_HTset(s1,"s1"); //反向显示s1中的数据 put_THset(s1,"s1"); //构造含有元素的序列并显示 MULTISET_INT s2(s1); put_HTset(s2,"s2"); //删除s2的第2个元素并显示 s2.erase(++s2.begin()); put_HTset(s2,"s2"); //向s2插入8和9并显示 s2.insert(8); s2.insert(9); put_HTset(s2,"s2"); //清空s2的序列 s2.clear(); put_HTset(s2,"s2"); //按键给定的区间显示序列中的元素 cout<<"[s1.lower_bound(5),s1.upper_bound(15)] :"; for (it=s1.lower_bound(4);it!=s1.upper_bound(16);it++) cout<<(*it)<<" "; cout<

//显示s1的状态信息 cout<<"s1.size():"<

cout<<"s1.max_size():"< cout<<"s1.count(15):"< //交换两个multiset容器的元素并显示 s1.swap(s2); put_HTset(s1,"s1"); put_HTset(s2,"s2"); //关系运算 s1.insert(2); put_HTset(s1,"s1"); put_HTset(s2,"s2"); cout<<"s1>s2 = "<<(s1>s2)<

} #include

#include

using namespace std; //创建map的实例，整数(int)映射字符串(string) typedef map

INT2STRING; //测试map容器 void main() { //创建map对象theMap INT2STRING theMap; INT2STRING::iterator theIterator,it; //向theMap容器中添入数据，数字和字符串配对 //每个元素是一个映射对 theMap.insert(INT2STRING::value_type(0,"Zero")); theMap.insert(INT2STRING::value_type(2,"Two")); theMap.insert(INT2STRING::value_type(4,"Four")); theMap.insert(INT2STRING::value_type(6,"Six")); theMap.insert(INT2STRING::value_type(8,"Eight")); //显示map容器的所有对象 cout<<"theMap.begin()--theMap.end():"<

for (theIterator=theMap.begin();theIterator!=theMap.end();++theIterator){ cout<<(*theIterator).first; cout<<","<<(*theIterator).second<<" "; } cout<

//测试map容器key的惟一性 theMap.insert(INT2STRING::value_type(0,"Zero")); theMap.insert(INT2STRING::value_type(1,"One")); theMap.insert(INT2STRING::value_type(2,"Two")); theMap.insert(INT2STRING::value_type(3,"Three")); theMap.insert(INT2STRING::value_type(4,"Four")); theMap.insert(INT2STRING::value_type(5,"Five")); theMap.insert(INT2STRING::value_type(6,"Six")); theMap.insert(INT2STRING::value_type(7,"Seven")); theMap.insert(INT2STRING::value_type(8,"Eight")); theMap.insert(INT2STRING::value_type(9,"Nine")); //下列语句将不能插入到map容器中 theMap.insert(INT2STRING::value_type(5,"AAA")); //显示map容器的所有对象 cout<<"theMap.begin()--theMap.end():"<

for (theIterator=theMap.begin();theIterator!=theMap.end();++theIterator){ cout<<(*theIterator).first; cout<<","<<(*theIterator).second<<" "; } cout<

//按键给定的区间显示序列中的元素 cout<<"[theMap.lower_bound(3),theMap.upper_bound(8)] :"<

for (it=theMap.lower_bound(3);it!=theMap.upper_bound(8);it++) { cout<<(*it).first; cout<<","<<(*it).second<<" "; } cout<

//显示theMap的状态信息 cout<<"theMap.size():"<

cout<<"theMap.max_size():"< cout<<"theMap.count(15):"< // 从键盘上输入数字，显示对应的字符串 string theString = ""; int index; for( ; ; ) { cout << "Enter \"q\" to quit, or enter a Number: "; cin >> theString; if(theString == "q") break; for(index = 0; index < theString.length(); index++){ theIterator = theMap.find(theString[index] - '0'); if(theIterator != theMap.end() ) cout << (*theIterator).second << " "; else cout << "[err] "; } cout << endl; } } #include

#include

using namespace std; //创建multimap的实例，整数(int)映射字符串(string) typedef multimap

INT2STRING; //测试multimap容器 void main() { //创建multimap对象theMap INT2STRING theMap; INT2STRING::iterator theIterator,it; //向theMap容器中添入数据，数字和字符串配对 //每个元素是一个映射对 theMap.insert(INT2STRING::value_type(90,"张卫")); theMap.insert(INT2STRING::value_type(85,"李华")); theMap.insert(INT2STRING::value_type(73,"赵明")); theMap.insert(INT2STRING::value_type(96,"郝名")); //显示multimap容器的所有对象 cout<<"theMap.begin()--theMap.end():"<

for (theIterator=theMap.begin();theIterator!=theMap.end();++theIterator){ cout<<(*theIterator).second; cout<<"\t"<<(*theIterator).first<

} //测试multimap容器key的非惟一性 theMap.insert(INT2STRING::value_type(90,"李朋")); theMap.insert(INT2STRING::value_type(85,"钱德")); theMap.insert(INT2STRING::value_type(93,"赵刚")); //按成绩高低输出multimap容器的所有对象 INT2STRING::reverse_iterator i; cout<<"theMap.rbegin()--theMap.rend():"<

for (i=theMap.rbegin();i!=theMap.rend();++i){ cout<<(*i).second; cout<<"\t"<<(*i).first<

} //按关键给定的区间显示序列中的元素 cout<<"[theMap.lower_bound(80),theMap.upper_bound(90)] :"<

for (it=theMap.lower_bound(80);it!=theMap.upper_bound(90);it++) { cout<<(*it).second; cout<<"\t"<<(*it).first<

} //显示theMap的状态信息 cout<<"theMap.size():"<

cout<<"theMap.max_size():"< cout<<"theMap.count(90):"< //清除90分以下的数据,并显示结果 theMap.erase(theMap.lower_bound(60),theMap.upper_bound(89)); cout<<"theMap.rbegin()--theMap.rend():"<

for (i=theMap.rbegin();i!=theMap.rend();++i){ cout<<(*i).second; cout<<"\t"<<(*i).first<

} } #include

#include

using namespace std; #define ARRAY_SIZE 3 //array size //测试valarray容器 void main() { //创建具有3个元素的数组val_array valarray

val_array(ARRAY_SIZE); //设置数组的值为1, 4, 9 for (int i = 0; i < ARRAY_SIZE; i++) val_array[i] = (i+1) * (i+1); //显示val_array数组的大小 cout << "Size of val_array = " << val_array.size() << endl; // 显示val_array数组的值 cout << "The values in val_array before calling sqrt() and pow():" << endl; for (i = 0; i < ARRAY_SIZE; i++) cout << val_array[i] << " "; cout << endl; //声明一个rev_valarray数组，其保存对数组val_array的取反 valarray

rev_valarray(ARRAY_SIZE); for (i = 0; i < ARRAY_SIZE; i++) rev_valarray[i] = val_array[ARRAY_SIZE - i - 1]; //显示rev_valarray数组的大小和元素 cout << "Size of rev_valarray = " << rev_valarray.size() << endl; cout << "The values in rev_valarray:" << endl; for (i = 0; i < ARRAY_SIZE; i++) cout << rev_valarray[i] << " "; cout <

// 声明rvalue_array数组，其存放调用sqrt()和pow()函数的返回值 valarray

rvalue_array; //调用sqrt()函数并显示结果 rvalue_array = sqrt(val_array); cout << "The result of rvalue_array after calling sqrt():" << endl; for (i = 0; i < ARRAY_SIZE; i++) cout << rvalue_array[i] << " "; cout <

//对val_array数组元素计算幂函数并显示 rvalue_array = pow(val_array, rev_valarray); cout << "The result after calling pow(val_array, rev_valarray):" << endl; for (i = 0; i < ARRAY_SIZE; i++) cout << rvalue_array[i] << " "; cout <

//对val_array数组元素计算幂函数，指数均为2.0，并显示 rvalue_array = pow(val_array, 2.0); cout << "The result after calling pow(val_array, 2.0):" << endl; for (i = 0; i < ARRAY_SIZE; i++) cout << rvalue_array[i] << " "; cout <

//对2.0进行幂函数运算，指数均为数组val_array的各元素值 rvalue_array = pow(2.0, val_array); cout << "The result after calling pow(2.0, val_array):" << endl; for (i = 0; i < ARRAY_SIZE; i++) cout << rvalue_array[i] << " "; cout <

//对val_array和rvalue_array求和 cout<<"val_array.sum()="<

cout<<"rvalue_array.sum()="< //求最大值并显示 cout<<"val_array.max()="<

cout<<"rvalue_array.max()="< } #include

#include

using namespace std ; typedef stack

STACK_INT; void main() { STACK_INT stack1; int i; //判断栈是否空 cout << "stack1.empty() returned " << (stack1.empty()? "true": "false") << endl; //0,2,4,6...入栈 for (i=0;i<10;i=i+2) stack1.push(i); //top()函数 if (!stack1.empty()) cout << "stack1.top() returned " <

//计算栈的长度 cout<<"stack1.size(): "<

//改变栈顶的值 20. if (!stack1.empty()) { cout << "stack1.top()=20;" << endl; stack1.top()=20; } //弹出栈中所有的数据并显示 cout<<"stack1: "; while (!stack1.empty()) { cout<

} #include

#include

using namespace std; //创建一个list容器的实例LISTINT，其存放int型数据 typedef list

LISTINT; void main(void) { //用LISTINT创建一个名为listOne的list对象 LISTINT listOne; //指定i为迭代器变量 LISTINT::iterator i; LISTINT::reverse_iterator ir; //从前面向listOne容器中添加数据 listOne.push_front (2); listOne.push_front (1); //从后面向listOne容器中添加数据 listOne.push_back (3); listOne.push_back (4); //从前向后显示listOne中的数据 for (i = listOne.begin(); i != listOne.end(); ++i) cout << *i << " "; cout << endl; //从后向后显示listOne中的数据 for (ir =listOne.rbegin();ir!=listOne.rend(); ++ir) cout << *ir << " "; cout << endl; //从键盘上输入数据 for (i = listOne.begin(); i != listOne.end(); ++i) { cout<<"listOne :"; cin>>(*i); } //从前向后显示listOne中的数据 for (i = listOne.begin(); i != listOne.end(); ++i) cout << *i << " "; cout << endl; //bidirectional迭代器不允许加减运算 // i=listOne.begin()+1; } #include

#include

using namespace std; //利用类模板生成类实例 typedef vector < int > IntArray; typedef list

LISTINT; typedef set

SET_INT; int add(int a, int b) { return a+b; } //在main()函数中测试accumulate算法 void main () { //-------------------------------------------- // accumulate算法对于普通数组的计算 //--------------------------------------------- int x[]={1,3,5,7,9}; cout<<"x[]:"; for (int i=0;i<5;i++) cout<

cout<<"accumulate(x,x+5,0)="; cout<

int val=100; cout<<"val="<

cout<<"accumulate(x,x+5,val)="; cout<

//-------------------------------------------- // accumulate算法对于vector容器的计算 //--------------------------------------------- //声明intvector容器和迭代器ii IntArray intvector; IntArray::iterator ii; //向intvector容器中插入元素 for (i=1; i<=5; i++) { intvector.push_back(i); }; //显示intvector容器中的元素值和累加结果 cout << "intvector: "<

for (ii=intvector.begin();ii !=intvector.end();++ii) cout<<(*ii)<<" "; cout<

cout<<"accumulate(intvector.begin(),intvector.end(),0)="; cout<

//-------------------------------------------- // accumulate算法对于list容器的计算 //--------------------------------------------- //声明list容器对象和迭代器 LISTINT::iterator iL; LISTINT list1; //向list1容器对象中插入元素并显示 list1.push_front(1); list1.push_front(3); list1.push_front(5); list1.push_back(2); list1.push_back(6); //显示list1容器的元素值和累加结果 cout << "list1: "<

for (iL=list1.begin();iL !=list1.end();++iL) cout<<(*iL)<<" "; cout<

cout<<"accumulate(list1.begin(),list1.end(),0)="; cout<

//-------------------------------------------- // accumulate算法对于set容器的计算 //--------------------------------------------- //声明set容器对象和迭代器 SET_INT set1; SET_INT::iterator si; //向set1容器中插入元素 set1.insert(5); set1.insert(20); set1.insert(10); set1.insert(15); set1.insert(25); //显示set1容器的元素值和累加结果 cout <<"set1: "<

for (si=set1.begin();si !=set1.end();++si) cout<<(*si)<<" "; cout<

cout<<"accumulate(set1.begin(),set1.end(),0)="; cout<

cout<<"accumulate(set1.begin(),set1.end(),100)="; cout<

} #include

#include

#define size 10 using namespace std; //产生指定范围的整数随机数 int getrand(int min,int max) { int m; m=(max-min); m=min+double(rand())/RAND_MAX*m ; return m; } //利用类模板生成实例 typedef vector < int > IntArray; typedef list

LISTINT; typedef set

SET_INT; //在main()函数中测试accumulate算法 void main () { //-------------------------------------------- // count算法对于普通数组的计算 //--------------------------------------------- int x[size]; cout<<"x[]:"; for (int i=0;i

x[i]=getrand(1,3); cout<

cout<<"count(x,x+size,2)="; cout<

cout<<"count(x+2,x+8,2)="; cout<

//-------------------------------------------- // count算法对于vector容器的计算 //--------------------------------------------- //声明intvector容器和迭代器ii IntArray intvector; IntArray::iterator ii; //向intvector容器中插入元素 for (i=1; i

intvector.push_back(getrand(2,6)); }; //显示intvector容器中的元素值和统计结果 cout << "intvector: "; for (ii=intvector.begin();ii !=intvector.end();++ii) cout<<(*ii)<<" "; cout<

cout<<"count(intvector.begin(),intvector.end(),4)="; cout<

//-------------------------------------------- // count算法对于list容器的计算 //--------------------------------------------- //声明list容器对象和迭代器 LISTINT::iterator iL; LISTINT list1; //向list1容器对象中插入元素并显示 for (i=1; i

list1.push_front(getrand(3,5)); }; //显示list1容器的元素值和统计结果 cout << "list1: "; for (iL=list1.begin();iL !=list1.end();++iL) cout<<(*iL)<<" "; cout<

cout<<"count(list1.begin(),list1.end(),3)="; cout<

//-------------------------------------------- // count算法对于set容器的计算 //--------------------------------------------- //声明set容器对象和迭代器 SET_INT set1; SET_INT::iterator si; //向set1容器中插入元素 for (i=1; i

set1.insert(getrand(1,10)); }; //显示set1容器的元素值和统计结果 cout <<"set1: "; for (si=set1.begin();si !=set1.end();++si) cout<<(*si)<<" "; cout<

cout<<"count(set1.begin(),set1.end(),5)="; cout<

} #include

#include

using namespace std; //如果字符串以'S'开头，则返回true int MatchFirstChar( const string& str) { string s("S") ; return s == str.substr(0,1) ; } //测试count_if算法 void main() { const int VECTOR_SIZE = 8 ; //生成成员类型为strings的vector容器类 typedef vector

StringVector ; //定义迭代器类型 typedef StringVector::iterator StringVectorIt ; //声明vector容器的对象 StringVector NamesVect(VECTOR_SIZE) ; //声明迭代器 StringVectorIt start, end, it ; int result = 0 ; // 存放统计数据 //初始化vector容器NamesVect NamesVect[0] = "She" ; NamesVect[1] = "Sells" ; NamesVect[2] = "Sea" ; NamesVect[3] = "Shells" ; NamesVect[4] = "by" ; NamesVect[5] = "the" ; NamesVect[6] = "Sea" ; NamesVect[7] = "Shore" ; //设置容器的起始位置和终止位置 start = NamesVect.begin() ; end = NamesVect.end() ; //显示NamesVect容器的元素 cout << "NamesVect: " ; for(it = start; it != end; it++) cout << *it << " " ; cout <

//统计并显示NamesVect容器的所有元素中以'S'字符开头的字符串 result = count_if(start, end, MatchFirstChar) ; cout << "Number of elements that start with letter \"S\" = " << result << endl ; //显示NamesVect容器[1,6]之间的元素 cout <<"NamesVect[1]--NamesVect[6]: " ; for(it =&NamesVect[1]; it != &NamesVect[7]; it++) cout << *it << " " ; cout <

//统计并显示NamesVect容器的所有元素中以'S'字符开头的字符串 result = count_if(&NamesVect[1], &NamesVect[7], MatchFirstChar) ; cout << "Number of elements that start with letter \"S\" = " << result << endl ; } #include

#include

using namespace std; //利用类模板生成实例 typedef vector < int > IntArray; //显示数组 void put_array(int x[],int size) { for(int i=0;i

cout< } //显示vector容器中的元素 void put_vector(IntArray v) { IntArray::iterator theIterator; for (theIterator=v.begin();theIterator!=v.end();++theIterator){ cout<<(*theIterator)<<" "; } cout<

} //在main()函数中测试fill和fill_n算法 void main () { //-------------------------------------------- // fill和fill_n算法对普通数组的计算 //--------------------------------------------- int x[]={1,3,5,7,9}; cout << "x[]: "; put_array(x,5); //填数处理 fill(x+1,x+3,2); cout << "fill(x+1,x+3,2): "<

put_array(x,5); fill_n(x,3,8); cout << "fill_n(x,3,8): "<

put_array(x,5); //-------------------------------------------- // fill和fill_n算法对于vector容器的计算 //--------------------------------------------- //声明intvector容器和迭代器ii IntArray intvector; //向intvector容器中插入元素 for (int i=1; i<=10; i++) { intvector.push_back(i); }; //显示intvector容器中的元素值和统计结果 cout << "intvector: "<

put_vector(intvector); //填数处理 fill(intvector.begin(),intvector.begin()+3,2); cout << "fill(intvector.begin(),intvector.begin()+3,2): "<

put_vector(intvector); fill_n(&intvector[5],3,8); cout << "fill_n(&intvector[5],3,8): "<

put_vector(intvector); } #include

#include

#define ARRAY_SIZE 10 using namespace std; //利用类模板生成实例 typedef vector < int > IntArray; //显示数组 void put_array(int x[],int size) { for(int i=0;i

} //在main()函数中测试find()算法 void main () { int i,value,*p; //-------------------------------------------- // find()算法对于普通数组的处理 //--------------------------------------------- int x[ARRAY_SIZE]={1,3,5,7,9,2,4,6,8,10}; cout << "x[]: "; put_array(x,ARRAY_SIZE); //find()算法查找,并显示查找结果 for(i=0;i<=2;i++) { cout<<"value="; cin>>value; p=find(x,x+ARRAY_SIZE,value); if (p != x + ARRAY_SIZE) { //查到 cout << "First element that matches " << value; cout<< " is at location " << p - x<< endl; } else { //未查到 cout << "The sequence does not contain any elements"; cout<< " with value " << value << endl ; } } //-------------------------------------------- // find()算法对于vector容器的处理 //--------------------------------------------- //声明intvector容器对象 IntArray intvector; //向intvector容器中插入元素 for (i=1; i<=10; i++) { intvector.push_back(i); }; //显示intvector容器中的元素值 cout << "intvector: "; put_vector(intvector); //find()算法查找,并显示查找结果 IntArray::iterator pos; for (i=0;i<=2;i++) { cout<<"value="; cin>>value; pos=find(intvector.begin(),intvector.end(),value); if (pos != intvector.end()) { //查到 cout << "First element that matches " << value; cout<< " is at location " <

} else { //未查到 cout << "The sequence does not contain any elements"; cout<< " with value " << value << endl ; } } } #include

#include

#define ARRAY_SIZE 10 using namespace std; //利用类模板生成实例 typedef vector < int > IntArray; //显示数组 void put_array(int x[],int size) { for(int i=0;i

cout<

int y[]={5,7,9}; cout << "y[]: "; put_array(y,3); cout<

// find_end()算法查找,并显示查找结果 int *p=find_end(x,x+ARRAY_SIZE,&y[0],&y[2]); if (p != x + ARRAY_SIZE) { //查到 cout << "The first element that matches :" ; put_array(y,3); cout<< " is at location in x" << p - x<< endl; } else { //未查到 cout << "The sequence does not contain any elements"; cout<< " with value " ; put_array(&x[3],3); } //-------------------------------------------- // find_end()算法对vector容器的处理 //--------------------------------------------- //声明intvector容器对象 IntArray intvector; //向intvector容器中插入元素 for (int i=1; i<=10; i++) { intvector.push_back(i); }; //显示intvector容器中的元素值 cout << "intvector: "; put_vector(intvector); cout<

IntArray temp; temp.push_back(5); temp.push_back(6); temp.push_back(7); cout << "temp: "; put_vector(temp); cout<

// find_end()算法查找,并显示查找结果 IntArray::iterator pos; pos=find_end(intvector.begin(),intvector.end(),temp.begin(),temp.end()); if (pos != intvector.end()) { //查到 cout << "The first element that matches "; put_vector(temp); cout<< " is at location in intvector " <

} else { //未查到 cout << "The sequence does not contain any elements"; cout<< " with value "; put_vector(temp); cout<< endl ; } } #include

#include

using namespace std; //返回一个Fibonacci数，其由generate_n()算法调用 int Fibonacci1(void) { static int r; static int f1 = 0; static int f2 = 1; r = f1 + f2 ; f1 = f2 ; f2 = r ; return f1 ; } //返回一个Fibonacci数，其由generate()算法调用 int Fibonacci2(void) { static int r; static int f1 = 0; static int f2 = 1; r = f1 + f2 ; f1 = f2 ; f2 = r ; return f1 ; } //定义整型数的vector容器类 typedef vector

IntVector ; //显示vector容器中的元素 void put_vector(IntVector v,char *name) { IntVector::iterator theIterator; cout<

for (theIterator=v.begin();theIterator!=v.end();++theIterator){ cout<<(*theIterator)<<" "; } cout<

} //测试generate()和generate_n()算法 void main() { const int VECTOR_SIZE = 15 ; //定义迭代器类 typedef IntVector::iterator IntVectorIt ; //声明vector容器对象 IntVector Numbers1(VECTOR_SIZE),Numbers2(VECTOR_SIZE); int i ; //初始化vector容器对象 for(i = 0; i < VECTOR_SIZE; i++) Numbers1[i] = i ; //显示vector容器对象的元素 cout << "Before calling generate_n:" << endl ; put_vector(Numbers1,"Numbers1"); //利用generate_n算法用Fibonacci 数填充vector容器 generate_n(Numbers1.begin(), VECTOR_SIZE, Fibonacci1) ; //显示vector容器对象的元素 cout << "After calling generate_n:" << endl ; put_vector(Numbers1,"Numbers1"); //利用generate算法用Fibonacci 数填充vector容器 generate(Numbers2.begin(),Numbers2.end(), Fibonacci2) ; //显示vector容器对象的元素 cout << "After calling generate:" << endl ; put_vector(Numbers2,"Numbers2"); } #include

#include

using namespace std; //利用类模板生成实例 typedef vector < int > IntArray; //显示数组 void put_array(int x[],int size) { for(int i=0;i

} //在main()函数中测试reverse()和reverse_copy()算法 void main () { //-------------------------------------------- // reverse()和reverse_copy()算法对普通数组处理 //--------------------------------------------- int x[]={1,3,5,7,9}; cout<<"x[]:"; put_array(x,5); //reverse()反转x数组并显示 reverse(x,x+5); cout<<"x[]:"; put_array(x,5); int y[]={2,4,6,8,10}; cout<<"y[]:"; put_array(y,5); //reverse_copy()反转y数组的部分元素并拷贝到x数组第2个元素位置 reverse_copy(y+1,y+3,x+1); cout<<"x[]:"; put_array(x,5); cout<<"y[]:"; put_array(y,5); //-------------------------------------------- // reverse()和reverse_copy()算法对vector容器的处理 //--------------------------------------------- //声明intvector容器和迭代器ii IntArray intvector; //向intvector容器中插入元素 for (int i=1; i<=10; i++) { intvector.push_back(i); }; //显示intvector容器中的元素值 cout << "intvector: "<

put_vector(intvector); //reverse()对于vector容器的处理 reverse(intvector.begin(),intvector.end()); cout << "intvector: "<

put_vector(intvector); // reverse_copy对于vector容器的处理 IntArray temp(5); reverse_copy(intvector.begin()+2,intvector.begin()+7,temp.begin()); cout << "temp: "<

put_vector(temp); } #include

#include

#define ARRAY_SIZE 15 using namespace std; //定义整型数的vector容器类 typedef vector

IntVector ; //显示数组 void put_array(int x[],int size) { for(int i=0;i

cout< } //显示vector容器中的元素 void put_vector(IntVector v,char *name) { IntVector::iterator theIterator; cout<

} //产生指定范围的整数随机数 int getrand(int min,int max) { int m; m=(max-min); m=min+double(rand())/RAND_MAX*m ; return m; } //在main()函数中测试sort()和partial_sort()算法 void main () { int i; //-------------------------------------------- // sort()和partial_sort()算法对普通数组处理 //--------------------------------------------- //sort()算法处理数组，并显示 int x[ARRAY_SIZE]; for (i=0;i

x[i]=getrand(1,20); } cout<<"x[]:"; put_array(x,ARRAY_SIZE); sort(x,x+ARRAY_SIZE); cout<<"sort(x,x+ARRAY_SIZE):"<

put_array(x,ARRAY_SIZE); //partial_sort()算法对于数组进行处理 int y[ARRAY_SIZE]; for (i=0;i

y[i]=getrand(1,30) ; } cout<<"y[]:"; put_array(y,ARRAY_SIZE); partial_sort(y+2,y+7,y+ARRAY_SIZE); cout<<"partial_sort(y+2,y+7,y+ARRAY_SIZE):"<

put_array(y,ARRAY_SIZE); //-------------------------------------------- // sort()和partial_sort()算法对vector容器的处理 //--------------------------------------------- IntVector Numbers1,Numbers2; for(i=0;i<15;i++) { Numbers1.push_back(getrand(1,30)); Numbers2.push_back(getrand(1,30)); } put_vector(Numbers1,"Numbers1"); put_vector(Numbers2,"Numbers2"); //sort()算法处理并显示 sort(Numbers1.begin(),Numbers1.end()); cout<<"After call sort():"<

put_vector(Numbers1,"Numbers1"); //partial_sort()算法处理并显示 partial_sort(Numbers2.begin()+2,Numbers2.begin()+7,Numbers2.end()); cout<<"After call partial_sort():"<

put_vector(Numbers2,"Numbers2"); } #include

#include

#define ARRAY_SIZE 15 using namespace std; //显示数组 void put_array(int x[],int size) { for(int i=0;i

cout< } //产生指定范围的整数随机数 int getrand(int min,int max) { int m; m=(max-min); m=min+double(rand())/RAND_MAX*m ; return m; } //在main()函数中测试max_element()和 min_element()算法 void main () { //声明变量和数组 int i; int x[ARRAY_SIZE]; //用1到100的随机数初始化数组，并显示 srand( (unsigned)time( NULL ) ); for (i=0;i

x[i]=getrand(1,100); } cout<<"x[]:"; put_array(x,ARRAY_SIZE); //对数组x使用max_element()算法，并显示 int *pMax=max_element(x,x+ARRAY_SIZE); cout<<"pMax ="<

cout<<"Location="<<(pMax-x)< cout<<"*pMax ="<<(*pMax)< //对数组x使用min_element()算法，并显示 int *pMin=min_element(x,x+ARRAY_SIZE); cout<<"pMin ="<

cout<<"Location="<<(pMin-x)< cout<<"*pMin ="<<(*pMin)< }

点击复制链接与好友分享!回本站首页