C++使用例子，根据半径计算圆的周长和面积
//根据半径计算圆的周长和面积
#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
#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
#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
#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
#include
#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
#include
#include
#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
#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
#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
#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
#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
#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
#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
#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
#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
#include
//main()函数的定义 void main( void ) { _complex a={3,4},b={3,-4}; double d=cabs(a); cout<<"cabs("<
cout<<"cabs("< } ##include
#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
#include
//main()函数的定义 void main( void ) { double y; for(double x=-5;x<=5;x++){ y=exp(x); cout<<"exp("<
} } #include
#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
#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
#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
#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
#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!\"");
下一篇： mysql如何进行字符串处理？