首页 > 基础教育 > 小学 >

C++.C 2010经典代码大全

4518次浏览 |131点赞 | 432评论 | 2021-02-16 02:56 更新

来源：互联网

最佳文档

本文由作者推荐

一个比划一个猜-

2021年2月16日发(作者：语录网)

2010

最新整理的

代码大全，工作学习参考必备，不下后悔终

Ppt 1-15

生

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

#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; //

声明

个变量

cout<<

显示字符串

cin>>r;

键盘输入

l=fCir_L(r); //

计算圆的周长，赋值给变

量

s=fCir_S(r); //

计算圆的面积，赋值给变

量

cout<<

显示计算结果

cout<<

}

定义计算圆的周长的函数

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) //

如果参数大于

，则计算圆

的面积

z=PI*x*x;

return(z); //

返回函数值

}

/* Program:

Written by: Hap

Date written: 02:11:10

#include

void main(void)

{

double s1,s2,s3;

s1=1.5; /*

对变量

赋值

cout<<

对变量

赋值

*/ s2=2.5;

cout<<

s3= /*

对变量

赋值

*/ 3.5;

cout<<

计

算并显示

计

算

并

显

示

cout<<

}

#include

main()

{

double r=1.0;

cout<<

double l;

l=2*3.1416*r; //

计算圆的周长，赋值给

变量

cout<<

显示圆的周长

double

s=3.1416*r*r; //

计算圆的面积，赋值给

变量

cout<<

显示圆的面积

cout<<

显示提示输入的信息

cin>>r; //

键盘输入

l=2*3.1416*r; //

计算圆的周长，赋值给

变量

cout<<

显示圆的周长

s=3.1416*r*r;

cout<<

显示圆的面积

}

#include //

包含

iostream .h

头文件

void main()

{

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

char c1='A';

cout<<'W';

cout<

cout<<

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

int n=100;

cout<<10;

cout<

cout<<2*n<

输出整型表达式

cout<<

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

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

cout<

cout<<2*r*pi<

输出浮点型表达式

cout<<

一个

cout

可以输出多项数据

cout<<'W'<<

cout<<

}

#include //

包含

iostream.h

头文件

main()

{

输入输出字符

char c;

cin>>c;

页脚内容

cout<<

输入输出整型数据

int n;

cin>>n;

cout<<

输入输出浮点型数据

double x;

cin>>x;

cout<<

输入提示

cout<<

cin>>n;

cout<<

多项输入

cout<<

cin>>c>>n>>x;

cout<<

}

#include //

包含

iostream.h

头文件

main()

{

声明整型变量

int a,b;

从键盘上为整型变量赋值

cout<<

cin>>a;

cout<<

cin>>b;

整型数的算术运算

cout<

测试溢出

short n=32767,m; //n

取

short

类型的最大值

cout<<

m=n+1; //

引起溢出

cout<<

}

#include //

包含

iostream.h

头文件

main()

{

//

声明变量，并初始化

int a=010,b=10,c=0X10;

//

以十进制形式显示数据

cout<<

cout<<

cout<<

cout<<

//

以八进制形式显示数据

Ppt 1-15

cout<<

cout<

指定八进制输出

cout<<

cout<<

cout<<

//

以十六进制形式显示数据

cout<<

cout<

指定十六进制输出

cout<<

cout<<

cout<<

//

八、十和十六进制数混合运算并输出

cout<<

cout<

恢复十进制输出

cout<

//

测试八、十和十六进制输入

cout<<

cout<<

cout<<

cout<<

指定十进

制输出

cout<<

cout<<

cout<<

}

#include //

包含

iostream.h

头文件

#include

//

iomanip.h

头

文

件

包

含

setprecision()

的定义


main()

{

//float

型变量的声明、输入、计算和输出

float fx,fy;

cout<<

cin>>fx;

cout<<

cin>>fy;

cout<

cout<

cout<

cout<

//cout<

//double

型变量的声明、输入、计算和输出

float dx,dy;

cout<<

cin>>dx;

cout<<

cin>>dy;

cout<

cout<

cout<

cout<

//cout<

//

测试

float

和

double

类型数据的有效位

fx=10.0;fy=6.0;

float fz=fx/fy;

页脚内容

2

Ppt 1-15

dx=10.0;dy=6.0;

double dz=dx/dy;

cout<<

cout<

cout<<

cout<

bool flag1=false,flag2=true;

//

输出布尔常量和变量

cout<<

cout<<

cout<<

cout<<

dl;;

//float

型溢出

float x=3.5e14;

cout<<

cout<<

cout<<

}

#include //

包含

iostream.h

头文件

main()

{

//

字符类型变量的声明

char c1='A';

char c2;

//

字符数据的运算及输出

c2=c1+32;

cout<<

cout<<

//

输出字符及

ASCII

码

cout<

cout<

cout<<'$$'<<

//

输入字符

cout<<

cin>>c1>>c2;

cout<<

}

#include //

包含

iostream.h

头文件

main()

{

char c1='a',TAB='t';

//

阵铃一声

cout<

//

使用水平制表符

cout<<1<

//

使用双引号

cout<<

//

使用回车换行

cout<<

}

#include //

包含

iostream.h

头文件

main()

{

//
声明

bool

变量，并初始化

//

布尔变量的赋值和输出

int x=1;

flag1=x>0; //

存放关系运算结果

cout<<

flag2=flag1; //bool

类型变量相互赋值

cout<<

//

布尔变量超界处理

flag1=100;

cout<<

flag2=-100;

cout<<

}

#include

const

double

PI=3.1416; //

声明常量

(const

变量
)PI

为

3.1416

main()

{

//
声明

3

个变量

double r,l,s;

//

输入圆的半径

cout<<

cin>>r;

//

计算圆的周长

l=2*PI*r;

cout<<

//

计算圆的面积

s=PI*r*r;

cout<<

}

#include

main()

{

//

定义枚举类型，并指定其枚举元素的值

enum color {

RED=3,

YELLOW=6,

BLUE=9

};

//

声明枚举变量

a

和

b,

并为枚举变量

a

赋初值

enum color a=RED;

color b; //

合法，与

C

语言不同

//

输出枚举常量

cout<<

cout<<

cout<<

页脚内容

3

Ppt 1-15

//

枚举变量的赋值和输出

b=a;

a=BLUE;

cout<<

cout<<

//a=100;

错误

!

//a=6

也错误

!

//

枚举变量的关系运算

b=BLUE;

//

枚

举

变

量

的赋值运算

cout<<

}

#include

const

double

PI=3.1416; //

声明常量

(const

变量
)PI

为

3.1416

main()

{

//
声明

3

个变量

double r=3,l,s;

//

计算圆的周长

l=2*PI*r;

cout<<

//

计算圆的面积

s=PI*r*r;

cout<<

//

验证赋值误差

int il,is;

il=l;

is=s;

cout<<

cout<<

}

#include

main()

{

//

变量声明

char c;

double x,y;

//

测试自增

cout<<

c='B';

cout<<

输出

c=C

c='B';

cout<<

输出

c=B

x=1.5;

y=5+ ++x; //

加号后的空格不能少

cout<<

输出

y=7.5

x=1.5;

y=5+x++;

cout<<

输出

y=6.5

cout<<

//

测试自减

cout<<

c='B';

cout<<

输出

c=A

c='B';

cout<<

输出

c=B

x=1.5;

y=5+--x;

cout<<

输出

y=5.5

x=1.5;

y=5+x--;

cout<<

输出

y=6.5

}

#include

main()

{

int a=3, b=2;

//

输出关系表达式

cout<

cout<<(ab)<<(a>=b)<<(a==b)<<(a!=b)<

bool flag=2*a

cout<<

}

#include

main()

{

float a=3.5,b=2.1,c=0;

cout<<

//

与运算

cout<<

输出

1

cout<<

输出

0

//

或运算

cout<<

输出

1

cout<<

输出

1

//

非运算

cout<<

输出

0

1

//

关系运算和逻辑运算

bool flag=a>=0 && a<=5; //

变量

a

在

[0,5]

区间内

cout<<

输出

1

//

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

cout<<

输出

1
 

}

#include

main()

{

//

按位与运算

cout<<

//

按位异或运算

cout<<

//

按位或运算

cout<<

页脚内容

4

Ppt 1-15

//

按位取反运算

cout<<

//

左移位运算

cout<<

cout<<

//

右移位运算

cout<<

cout<<

}

#include

main()

{

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

//
显示

a,b,c

的值

cout<<

//

计算显示

(1) b+=a+2*c%5;

的结果

b+=a+2*c%5;

//

相
当

于

表

达

式

语

句

b=b+(a+2*c%5);

cout<<

//

计算显示

(2) a<<=c-2*b;

的结果

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

a<<=c-2*b;

//

相

当

于

表

达

式

语

句

a=a<<(c-2*b);

cout<<

//

计算显示

(3) a*=b=c=3;

的结果

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

a*=b=c=3;

//

相当于语句组

c=3;b=c;a=a*b;

cout<<

//

计算显示

(4) a+=b+=c;

的结果

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

a+=b+=c;

//

相当于语句组

b=b+c; a=a+b;

cout<<

//

计算显示

(5) a-=b=++c+2;

的结果

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

a-=b=++c+2;

//

相

当

于

语

句

组

++c;b=b+c+2;a=a-b;

cout<<

}

#include

main()

{

//

用

sizeof

计算各类种常量的字节长度

cout<<

cout<<

cout<<

cout<<

//

用

sizeof

计算各类型变量的字节长度

int i=100;

char c='A';

float x=3.1416;

double p=0.1;

cout<<

cout<<

cout<<

cout<<

//

用

sizeof

计算表达式的字节长度

cout<<

//

用

sizeof

计算各类型的字节长度

cout<<

cout<<

cout<<

cout<<

//

用

sizeof

计算数组的字节长度

char str[]=

int a[10];

double xy[10];

cout<<

cout<<

cout<<

//

用

sizeof

计算自定义类型的长度

struct st {

short num;

float math_grade;

float Chinese_grade;

float sum_grade;

};

st student1;

cout<<

cout<<

}

#include

main()

{

//

声明变量语句中使用顺序运算

int x, y;

//

计算中使用顺序运算

x=50;

y=(x=x-5, x/5);

cout<<

cout<<

}

#include

main()

{

//

测试表达式类型的转换

int n=100,m;

double x=3.791,y;

cout<<

//

赋值类型转换

m=x;

y=n;

cout<<

cout<<

页脚内容

5

Ppt 1-15

//

强制类型转换

cout<<

cout<<

cout<<

cout<<

cout<<

}

#include

main()

{

float a,b,s;

cout<<

cin>>a>>b;

//

利用

cin

从键盘上为变量

a,b

赋值

s=a;

if (a

s=b; //if

语句中只有这一个语句，可省略花

括号

}

s=s*s; //

变量

s

中保存
a,b

中较大的一个

数的平方

cout<<

}

#include

main()

{

int x,y;

cout<<

cin>>x;

if (x<=0) { //

满足条件执行

y=2*x;

cout<<

输出结果

}

else { //

不满足条件执行

y=x*x;

cout<<

输出结果

}

}

#include

main()

{

int a,b,c;

int smallest;

cout<<

cin>>a>>b>>c;

if (a<=b) //

外层条件语句

{

if (a<=c) //

内层条件语句

smallest=a;

else

smallest=c;

}

else

{

if (b<=c) //

内层条件语句

smallest=b;

else

smallest=c;

}

cout<<

}

#include

main()

{

int score;

//

从键盘上输入分数

cout<<

cin>>score;

//

用带

else if

的条件语句判断处理

if (score<0 || score>100)

{

cout<<

}

else if (score>=90)

cout<<

else if (score>=80)

cout<<

else if (score>=70)

cout<<

else if (score>=60)

cout<<

else

cout<<

}

#include

main()

{

int n;

cout<<

cin>>n;

if (n>=0 && n<=100 &&n%2==0)

cout<<

else

cout<<

}

#include

main()

{

int a,b,Max;

//

输入数据

cout<<

cin>>a;

cout<<

cin>>b;

//

找出较大值

Max=a>b?a:b;

cout<<

}

#include

main()

{

int a,b;

页脚内容

6

Ppt 1-15

//

输入数据

cout<<

cin>>a;

cout<<

cin>>b;

//

除法判断

if (b!=0 && a%b==0) {

cout<

cout<<

}

else

cout<

}

#include

main()

{

//x,y

为操作数，

c

为运算符

int x,y,z;

char c1;

cin>>x>>c1>>y; //c1

//

多路选择语句选择不同表达式计算语句

switch(c1) {

case

'+':cout<

break;

case

'-':cout<

break;

case

'*':cout<

break;

case

'/':cout<

break;

case

'%':cout<

break;

default :co ut<<

当不符

合上述情况时执行本子句

}

}

#include

float x=365.5; //

声明全局变量

main() {

int x=1,y=2;

double w=x+y;

{

double x=1.414,y=1.732,z=3.14;

cout<<

cout<<

cout<<

cout<<

cout<<

访问重名的全

局变量

}

cout<<

cout<<

cout<<

//cout<<

无效

cout<<

访问重名的全局变

量

}

#include

main() {

//

显示

1,2,3...10

for(int i=1;i<=10;i++)

cout<

cout<

//

显示

10,9,8...1

for(int j=10;j>=1;j--)

cout<

cout<

//

显示

1,3,5...9

for(int k=1;k<=10;k=k+2)

cout<

cout<

//

显示

ABC...Z

for(char c='A';c<='Z';c++)

cout<

cout<

//

显示

0,0.1,0.2...1.0

for(float x=0;x<=1.0;x=x+0.1)

cout<

cout<

//

显示

0,0.1,0.2...1.0

for(float x1=0;x1<=1.0+0.1/2;x1=x1+0.1)

cout<

cout<

//

计算

s=1+2+3.. .+100

int s=0;

for(int n=1;n<=100;n++)

s=s+n;

cout<<

}

#include

main()

{

//
计算

s=1+2+3...+100

int s=0,n=1;

while(n<=100) {

s=s+n;

n++;

}

cout<<

//

累加键盘输入的数据

页脚内容

7

Ppt 1-15

double x,sum=0.0;

cout<<

cin>>x;

while(x!=0) {

sum+=x;

cout<<

cin>>x;

}

cout<<

}

#include

main()

{

//
计算

s=1+2+3...+100

int s=0,n=0;

do {

n++;

s+=n;

}while(n<100);

cout<<

//

累加键盘输入的数据

double x,sum=0.0;

do {

cout<<

cin>>x;

sum+=x;

} while(x!=0);

cout<<

}

#include

main()

{

//

计算和打印打印乘法九九表

for (int i=1;i<=9;i++) {

cout<

for (int j=1;j<=9;j++)

cout<<'t'<

cout<

}

}

#include

main()

{

int x,sum=0;

//

定义标号

L1

L1: cout<<

cin>>x;

if (x==-1)

goto L2; //

无条件转移语句，转到

L2

语句处

else

sum+=x;

goto L1; //

无条件转移语句，转到

L1

语句处

//

定义标号

L2

L2: cout<<

}

#include

main()

{

//

累加键盘输入的数据

double x,sum=0.0;

while(1) {

cout<<

cin>>x;

if (x<=0) break;

sum+=x;

}

cout<<

}

#include

main()

{

int i;

for (i=1;i<=20;i++)

{

if

(i%3==0) //

能被

3

整除的整数，返回进行

下次循环

continue;

cout<

}

cout<

}

#include

main()

{

//

声明数组和变量

int a[5],i,sum;

double avg;

//

从键盘上循环为数组赋值

for (i=0;i<5;i++) {

cout<<

cin>>a[i];

}

//

直接显示数组元素

co ut<

//

利用
 for

循环显示数组各元素的值

for (i=0;i<5;i++)

cout<

cout<

//

计算数组元素之和

,

并显示计算结果

sum=a[0]+a[1]+a[2]+a[3]+a[4];

cout<<

//

利用循环计算数组的累加和

for (sum=0,i=0;i<5;i++)

sum+=a[i];

//

显示累加和及平均值

cout<<

页脚内容

8

Ppt 1-15

avg=sum/5.0;

int

low,high,mid;

cout<<

for (i=1;i<=3;i++) {

}

cout<<

#include

cin>>value;

main()

{

//

二分法查找数组

a

int i,max,index,a[5];

found=0;

low=0;

//

从键盘上为数组赋值

high=size-1;

for (i=0;i<=4;i++)

while(low<=high)

{

{

cout<<

mid=(high+low)/2;

cin>>a[i];

if (a[mid]==value)

}

{

found=1;

//

利用循环遍历数组，找出最大值的元素及其下标

break;

max=a[0];

}

for (i=0;i<=4;i++)

if (a[mid]

{

low=mid+1;

if (max

else

{

high=mid-1;

max=a[i];

}

index=i;

if (found)

}

cout<<

valu

}

at:a[

cout<<

else

}

cout<<

#include

found!

#define size 5

}

main()

}

{

#include

//

声明变量

main()

int i,j;

{

float t,a[size];

//

声明变量

int i,j;

//

从键盘上为数组赋值

float t,a[5];

for (i=0;i

{

//

从键盘上为数组赋值

cout<<

for (i=0;i<=4;i++)

cin>>a[i];

{

}

cout<<

cin>>a[i];

//

对数组按从小到大顺序排序

}

for (i=0;i

for (j=i+1;j

//

对数组按从大到小顺序排序

if (a[i]>a[j])

for (i=0;i<=3;i++)

{

for (j=i+1;j<=4;j++)

t=a[i];

if (a[i]<=a[j])

a[i]=a[j];

{

a[j]=t;

t=a[i];

}

a[i]=a[j];

a[j]=t;

//

显示排序结果

}

for (i=0;i

cout<

//

显示排序结果

cout<

for (i=0;i<=4;i++)

cout<

//

输入要查找的数据

}

int value;

#include

int found; //

找到为

1

，否则为

0

main()

页脚内容

9

found

is

not

{

//

声明二维数组及变量

int a[2][3],i,j;

//

从键盘上为数组

a

赋值


for (i=0;i<2;i++)

for (j=0;j<3;j++)

{

cout<<

cin>>a[i][j];

}

//

显示数组

a

for (i=0;i<2;i++) {

for (j=0;j<3;j++)

{

cout<

}

cout<

}

//

找出该数组的最大元素及其下标

int h,l,Max=a[0][0];

for (i=0;i<2;i++) {

for (j=0;j<3;j++)

{

if (Max

Max=a[i][j];

h=i;

l=j;

}

}

}

cout<<

}

#include

main()

{

//

声明字符数组和变量

char str[6];

int i;

//

从键盘上输入字符串

cout<<

cin>>str;

cout<

//

按数组和下标变量两种方式显示字符数组

cout<

for (i=0;i<6;i++)

cout<

cout<

//

字符串反向输出

for (i=5;i>=0;i--)

cout<

cout<

//

将字符数组变成大写字母后输出

Ppt 1-15

for (i=0;i<=5;i++)

str[i]-=32;

//

小写字母转换成大写字母

cout<

//

显示字符串

}

#include

main()

{

//

声明变量和指针变量

int a,b,c,*ip;

//

指针变量

ip

指向变量

a

a=100;

ip=&a; //

使指针变量

ip

指向变量

a

cout<<

cout<<

cout<<

//

指针变量

ip

指向变量

b

ip=&b; //

使指针变量

ip

指向变量

b

b=200;

cout<<

cout<<

cout<<

//

指针变量

ip

指向变量

c

ip=&c; //

使指针变量

ip

指向变量

b

*ip=a+b;

cout<<

cout<<

cout<<

}

#include

main()

{

//

声明数组、变量和指针变量

int a[2][3],i,j;

int* ip;

//

从键盘上为数组

a

赋值

for (i=0;i<2;i++) //

为数组

a

赋值

for (j=0;j<3;j++)

{

cout<<

cin>>a[i][j];

}

//

利用下标变量显示数组

a

for (i=0;i<2;i++) {

for (j=0;j<3;j++)

{

cout<

}

cout<

}

//

利用指针变量显示数组

a

ip=&a[0][0];

for (i=0;i<2;i++) {

for (j=0;j<3;j++)

{

页脚内容

10

cout<<

cout<

cout<<*ip<

ip++;

}

}

}

#include

main()

{

//

声明数组、变量和指针变量

int a[]={1,2,3,4,5,6};

int *ip1,*ip2;

//

测试指针的赋值运算

ip1=a;

ip2=ip1;

cout<<

cout<<

//

测试指针的自增自减运算和组合运算

ip1++;

ip2+=4;

cout<<

cout<<

//

测试指针变量之间的关系运算

int n=ip2>ip1;

cout<<

cout<<

//

指针变量之间的减法

n=ip2-ip1;

cout<<

}

#include

main()

{

//

声明字符型数组和指针变量

char str[10];

char *strip=str;

//

输入输出

cout<<

cin>>str; //

用字符数组输入字符串

cout<<

cout<<

cout<<

用字符指针变量输入字符串

cout<<

cout<<

//

利用指针变量改变其指向字符串的内容

*(strip+2)='l';

cout<<

cout<<

//

动态为字符型指针变量分配内存

strip=new char(100);

cout<<

Ppt 1-15

cin>>strip; //

用字符指针变量输入字符串

cout<<

cout<<

}

#include

main()

{

//

声明用于存放运动员号码的数组

int h[]={1001,1002,1003,1004};

//

声明用于存放运动员成绩的数组

float x[]={12.3,13.1,11.9,12.1};

//

声明用于存放运动姓名的字符型指针数组

char

*p[]={

hu a

jian

wei

ming


//i,j,it

是用做循环控制变量和临时变量

int i,j,it;

//ft

用做暂存变量

float ft;

//pt

为字符型指针变量用做暂存指针变量

char *pt;

//

用选择法对数组

x

进行排序，并相应调整数组

h

和

p

中的数据

for (i=0;i<=3;i++)

for (j=i+1;j<=3;j++)

if (x[i]>=x[j]) {

ft=x[i],x[i]=x[j],x[j]=ft;

it=h[i],h[i]=h[j],h[j]=it;

pt=p[i],p[i]=p[j],p[j]=pt;

}

//

以下打印排序结果

for (i=0;i<=3;i++)

cout<

}

#include

main()

{

//

声明指针数组

char

*colors[]={

//

指向指针的指针变量

char **pt;

//

通过指向指针的变量访问其指向的内容

pt=colors;

for (int i=0;i<=3;i++) {

cout<<

cout<<

cout<<

pt++;

}

}

#include

main()

{

//

定义结构类型

struct books

{

char title[20];

页脚内容

11

cin>>strip; //

Ppt 1-15

char author[15];

int pages;

float price;

}

//

声明结构变量

struct books Zbk={

float chemistry;

double total;

};

//

声明结构数组

st

student st[3];

books Wbk;

//

对结构变量的输出

cout<<

cout<< <

cout<<<

cout<<<

cout<<<

cout<<

//

对结构成员的运算

+=10;

+=0.5;

cout<<

cout<<

cout<<

//

对结构变量的输入输出

cout<<

cin>>;

cout<<

cin>>;

cout<<

cin>>;

cout<<

cin>>;

cout<<

cout<< <

cout<<<

cout<<<

cout<<<

cout<<

//

结构变量之间的相互赋值

books temp;

temp=Wbk;

cout<<

cout<<<

cout<<<

cout<<<

cout<<<

}

#include

main()

{

int i;

//

定义结构类型

struct student {

int num;

char name[10];

float maths;

float physics;

//

从键盘上为结构数组输入值

cout<<

num

name

maths

physics

chemistry

for (i=0;i<3;i++)

{

cout<

cin>>st[i].num;

cin>>st[i].name;

cin>>st[i].maths;

cin>>st[i].physics;

cin>>st[i].chemistry;

}

//

计算每个学生的总成绩

for (i=0;i<3;i++)



st[i].total=st[i].maths+st[i].physics+st [i].chemistry;

//

输出结构数组各元素的值

for (i=0;i<3;i++)

{

cout<<

cout<

cout<

cout<

cout<

cout<

cout<

}

}

#include

main()

{

//

定义结构类型

struct human {

char name[10];

int sex;

int age;

};

//

声明结构变量和结构指针变量

,

并初始化

struct human x={

//

结构指针变量指向对象

p=&x;

//

显示结构变量的值

cout<<

cout<<

cout<<

//

利用结构指针显示结构对象中的数据

cout<<

页脚内容

12

cout<<

cout<<

cout<<

cout<<

cout<<

//

通过结构指针为结构对象输入数据

cout<<

cin>>(*p).name;

cout<<

cin>>(*p).sex;

cout<<

cin>>(*p).age;

//

显示结构变量的值

cout<<

cout<<

cout<<

}

include

main()

{

//

定义结构类型

struct human {

char name[10];

int sex;

int age;

};

//

声明结构变量和结构指针

,

并初始化

struct human x={

//

利用结构指针显示结构中的数据

cout<<

cout<<

cout<<

cout<<

//

利用

new

运算符为

p

分配内存
 

p=new human;

//

从键盘上为

p

指向的结构对象赋值

cout<<

cin>>p->name;

cout<<

cin>>p->sex;

cout<<

cin>>p->age;

cout<<

//

显示

p

所指结构对象的值

cout<<

cout<<

cout<<

cout<<

//

显示结构变量的值

cout<<

cout<<

cout<<

Ppt 1-15

//

释放

p

指向的内存

delete p;

}

#include

main()

{

//

定义结构类型

struct human {

char name[10];

int sex;

int age;

};

//

声明结构数组和结构指针变量

,

并初始化

human

x[]={{

*p=NULL;

//

用下标变量的输出结构数组的元素

for (int i=0;i<3;i++)

{

cout<

cout<

cout<

}

cout<<

//

用结构指针输出结构数组的元素

for (p=x;p<=&x[2];p++)

{

cout<name<<'t';

cout<sex<<'t';

cout<age<

}

}

#include

main()

{

//

定义一个包含指针成员的结构类型

struct test {

char *str;

int *ip;

} x;

//

使用结构变量

x

中的整型指针
ip

=new int; //

分配

1

个单元

*()=100;

cout<<

cout<<

delete

=new int[5]; //

分配

5

个单元

for(int i=0;i<5;i++)

*(+i)=100+i;

cout<<

for(i=0;i<5;i++)

cout<<+i<<'t'<<(*(+i))<

delete

cout<<

页脚内容

13

Ppt 1-15

//

使用结构变量

x

中的字符型指针

str

=new char('A'); //

分配

1
个单元

cout<<

cout<<

delete

=new char[5]; //

分配多个单元

*='G';

*(+1)='o';

*(+2)='o';

*(+3)='d';

*(+4)='0';

cout<<

delete ;

cout<<

//

在声明结构变量时初始化

test y={

cout<<

cout<<

}

#include

main()

{

//
定义

date

结构

struct date

{

int year;

int month;

int day;

};

//

定义
 baby

结构

struct baby {

int num;

float weight;

date birthday; // date

为结构类型

};

//
声明

baby

结构变量并初始化

baby b1={10001,10,{2002,12,25}};

//

下列是

baby

结构变量

b1

的引用。

cout<<

cout<<

cout<<

cout<<

cout<<

cout<<

//

声明

baby

结构变量

temp,

并进行赋值运算

baby temp;

temp=b1;

cout<<

cout<<

cout<<

cout<<

l;

cout<<

}

#include

main()

{

//
定义名为

list

的递归结构

struct list {

char name[10];

int sex;

int age;

list *next; //

成员

next

为指向

其自身结构的指针

};

//

使用递归结构变量

list L1={

cout<<

cout<<

cout<<

cout<<

cout<<

}

#include

main()

{

int i;

//

定义名为

student

的递归结构

struct student {

char name[10];

int math;

int computer;

float sum;

student *next; //next

成员是指向自身

的结构指针

};

//

用

student

声明

3

个结构指针变量

struct student *head,*tail,*temp;

//

申请第

1

块数据，并设置各结构指针的初值

temp=new struct student; //

申请内存

head=temp; //

头指针

tail=head; //

尾指针

//

循环为链表输入数据

cout<<

for (i=1;;i++) {

cout<

cin>>temp->name;

if (temp->name[0]!='*')

{

cin>>temp->math>>temp->computer;

temp->sum=temp->math+temp->computer;

temp->next=NULL;

tail=temp; //

设置链表尾指针

}

else

页脚内容

14

Ppt 1-15

{

//

以下是输入结束处理

delete temp;

tail->next=NULL;

break;

}

//

为下一个学生申请内存

temp->next=new struct student;

temp=temp->next; //
 使处理指针

temp

指向

新内存块

}

//

将链表数据从头到尾打印出来

cout<<

temp=head;

while (temp!=NULL) {

cout<name<<

cout<computer<<

temp=temp->next;

}

}

#include

main()

{

int i;

//

定义名为

student

的递归结构

struct student {

char name[10];

int math;

int computer;

float sum;

student *forw; //forw

成员是前指针

student *next; //next

成员是后指针

};

//

用

student

声明

3

个结构指针变量

struct student *head,*tail,*temp;

//

申请第

1

块数据，并设置各结构指针的初值

temp=new struct student; //

申请内存

head=temp; //

头指针

tail=head; //

尾指针

head->forw=NULL;

//

循环为链表记录输入数据

cout<<

for (i=1;;i++) {

cout<

cin>>temp->name;

if (temp->name[0]!='*')

{

cin>>temp->math>>temp->computer;

temp->sum=temp->math+temp->computer;

temp->next=NULL;

tail=temp; //

设置链表尾指针

}

else

{

//

以下是输入结束处理

delete temp;

tail->next=NULL;

break;

}

//

为下一个学生申请内存

temp->next=new struct student;

temp->next->forw=temp; //

设置前指针

temp=temp->next; //

使处理指针

temp

指向新内存块

}

//

将链表数据从头到尾打印出来

cout<<

temp=head;

while (temp!=NULL) {

cout<name<<

cout<computer<<

temp=temp->next;

}

//

将链表数据从尾到头打印出来

cout<<

temp=tail;

while (temp!=NULL) {

cout<name<<

cout<computer<<

temp=temp->forw;

}

}

#include

main()

{

int i;

//

定义联合类型

union utag {

char c;

int k;

float x;

};

//

声明联合变量

union utag u;

//

使用联合变量中的字符型成员

u.c='*';

cout<<

//

使用联合变量中的整型成员

u.k=1000;

cout<<

//

使用联合变量中的浮点型成员

u.x=3.1416;

cout<<

//

声明联合变量时初始化

utag u1={'A'};

页脚内容

15

Ppt 1-15

//

同时引用联合变量的各成员

cout<<

cout<<

cout<<

}

#include

main()

{

//

定义结构类型，并为声明的结构变量赋初值

struct s_tag {

short i;

float x;

} sx={100,3.1416};

//

定义联合类型，并为声明的联合变量赋初值

union u_tag {

short i;

float x;

} ux={1000};

//

输出结构类型和结构变量的有关信息

cout<<

s_tag)=

s_tag)<

cout<<

cout<<

cout<<

cout<<

//

输出联合类型和联合变量的有关信息

cout<<

u_tag)=

u_tag)<

ux.i=200;

cout<<

输出联合变量

ux

的

i

成员

ux.x=123.456;

cout<<

输出联合变量

ux

的

x

成员

cout<<

}

#include

main()

{

//

自定义类型

typedef int ARRAY_INT[50];

int i;

ARRAY_INT a; //

用自定义类型声明数组变量

a

//

以下为数组

a

赋值，并打印

for (i=0;i<50;i++) {

if (i%10==0) //

每

10

个数换一次行

cout<

a[i]=i;

cout<

}

cout<

}

#include

//

定义结构类型

struct student

{

int num;

char name[20];

float grade;

};

void main(void)

{

//

声明数组

int i,size;

char str[]=

int int_values[] = {51, 23, 2, 44, 45,0,11};

float float_values[] = {15.1, 13.3, 22.2, 10.4,

1.5};

student

st_arr[]={101,

n

//

显示

char

类型数组元素及其大小

size=sizeof(str) / sizeof(char);

cout<<

cout<

for(i=0;i

cout<

}

cout<

//

显示
 int

类型数组元素及其大小

size=sizeof(int_values) / sizeof(int);

cout<<

cout<

for(i=0;i

cout<

}

cout<

//

显示
 float

类型数组元素及其大小

size=sizeof(float_values) / sizeof(float);

cout<<

cout<

for(i=0;i

cout<

}

cout<

//

显示
 student

类型数组元素及其大小

size=sizeof(st_arr) / sizeof(student);

cout<<

cout<

for(i=0;i

cout<

cout<

cout<

}

}

#include

//add()

函数的定义，其有返回值

double add(double x,double y)

{

double z;

z=x+y;

cout<

页脚内容

16

Ppt 1-15

return(z);

}

main()

{

double a=0.5,b=1.0;

//

以不同参数形式调用函数

add()

cout<<

cout<<

cout<<

cout<<

//

以表达式方式调用函数

add()

double c=2*add(a,b);

cout<<

cout<<

//

以语句式方式调用函数

add()

add(2*a,b);

cout<<

//

用其他类型参数调用函数

add()

int n=1,m=2;

cout<<

}

#include

//

定义符号函数

sgn(),

其返回值为

int

类型

int sgn(double x)

{

if (x>0) return(1); //

返回出口

1

if (x<0) return(-1); //

返回出口

2

return(0); //

返回出口

3

}

//main()

函数定义

main()

{

double x;

int i;

for (i=0;i<=2;i++) {

cout<<

cin>>x;

cout<<

}

}

#include

//

函数原型语句可以在这里

//

定义

main()

函数

main()

{

//max()

函数原型声明语句

float max(float,float);

//

变量声明语句

float a,b,Max;

//

输入参数并计算

cout<<

cin>>a;

cout<<

cin>>b;

Max=max(a,b); //

调用

max()

函数

cout<<

}

 //

定义

max()

函数

float max(float x,float y) //max()

返回值类型为

浮点型

{

float z;

z=(x>y)?x:y;

return(z);

}

#include

//

定义

f()

函数

f(int x,int y) //f()

的参数以值方式传递

{

++x;

--y;

cout<<

}

main() {

int a,b;

//

设置实际参数的值

a=b=10;

//

以变量为参数调用

f()

函数

f(a,b);

//

验证实际参数的值

cout<<

//

以表达式参数形式调用

f ()

函数

f(2*a,a+b);

}

#include

//

定义公共结构类型

struct student {

int num;

char name[10];

float maths;

float physics;

float chemistry;

double total;

};

//

定义结构输入函数

input_Rec(struct

student

*p) //

参数为

studen t

类型

的结构指针变量

{

cin>>p->num;

cin>>p->name;

cin>>p->maths;

cin>>p->physics;

cin>>p->chemistry;

}

//

定义结构数据交换函数

swap_Rec(struct student *p1,struct student *p2)

页脚内容

17

Ppt 1-15

{

struct student x;

//

交换两个记录的数据

x=*p1;

*p1=*p2;

*p2=x;

}

//

输出结构的值

put_Rec(struct student *p)

{

cout<num<<'t';

cout<name<<'t';

cout<maths<<'t';

cout<physics<<'t';

cout<chemistry<<'t';

cout<total<

}

//

定义

main()

函数
 

main()

{

int i,j;

//

声明结构指针变量和结构数组

struct student *p1,a[3];

//
输入

3

个学生的数据并计算总成绩

cout<<

for (p1=a;p1<=a+2;p1++) {

input_Rec(p1);

p1->total=p1->maths+p1->physics+p1->chemist ry;

}

//

对
3

个学生的数据排序

for (i=0;i<=2;i++)

for (j=i+1;j<=2;j++)

if (a[i].total

swap_Rec(&a[i],&a[j]); //

交换两

个结构变量中的数据

cout<<

//

输

出一分界线

//

输出排序后的结构数组

cout<<

ndl;

for (p1=a;p1<=a+2;p1++)

put_Rec(p1);

}

#include

//

定义结构

struct student {

char name[10];

float grade;

};

//

交换

s tudent

类型的数据

void swap(student &x,student &y) //swap

的参数

为引用传递方式

{

student temp;

temp=x;

x=y;

y=temp;

}

//

返回

s tudent

类型的引用，求优者

student& max(student &x,student &y) //swap

的

参数为引用传递方式

{

return (>?x:y);

}

//

显示

s tudent

类型的数据

void show(student &x) //show

的参数为引用传递

方式

{

cout<<<<

}

void main()

{

student

a={

//

显示

a

和

b

的数据

cout<<

show(a);

cout<<

show(b);

cout<<

//

交换

a

和

b

的数据

,

并显示

swap(a,b);

cout<<

show(a);

cout<<

show(b);

cout<<

//

计算和显示成绩高者

student t=max(a,b);

cout<<

show(t);

}

#include

//

参数带有默认值的函数

disp(int x=1,int y=1,int z=1)

{

cout<<

参数

1:

cout<<

参数

2:

cout<<

参数

3:

cout<<

}

//m ain()

函数中测试参数带有默认值的函数

disp()

void main()

{

页脚内容

18

Ppt 1-15

disp();

disp(10);

disp(10,20);

disp(10,20,30);

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

disp(a,b,c);

}

#include

//

计算字符串长度的函数

int str_len(const char *string)

{

//char *temp=string;

编译报错！

//*string='x';

编译报错！

int i=0;

while (*(string+i)!=NULL)

i++;

return i;

}

//main()

函数中测试

str_ len()

void main()

{

char a[]=

cout<

char *str=

cout<

cout<<

a test.

}

#include

void disp(void); //

这个函数声明语句不能少

//

定义

main()
函数的参数和返回值类型是

void

类型
 

void main(void)

{

//
调用

void

类型函数

disp();

}

//

以下定义

disp()

函数

void disp(void) {

cout<<

}

#include

//

函数原型语句

int abs(int x);

long abs(long x);

float abs(float x);

//main()

函数的定义

void main(void)

{

//

声明变量

int i1=32767,i2=-32767;

long l1=456789,l2=-456789;

float x1=1.1234,x2=-1.1234;

//

直接在

cout

输出中调用函数

cout<

cout<

cout<

}

//

定义

i nt

型的

abs()

函数

int abs(int x) {

if (x<0)

return(-x);

else

return(x);

}

//

定义

l ong

型的

abs()

函数


long abs(long x) {

if (x<0)

return(-x);

else

return(x);

}

//

定义

f loat

型

abs

函数

float abs(float x) {

if (x<0.0)

return(-x);

else

return(x);

}

#include

//max()

为内联函数

inline int max(int x,int y) //

注意

inline

关键字

{

return x>y?x:y;

}

//

定义

m ain()

函数

main()

{

int a=3,b=5,c;

c=max(a,b);

cout<<

cout<<

}

#include

main()

{

//

函数原型声明

int fact(int x);

int n,sn;

//

依次从键盘上输入

3

个正整型数据计算它们的阶乘

for (int i=1;i<=3;i++)

{

cout<

cin>>n;

sn=fact(n);

cout<

}

}

//

以下是采用递归方法定义的

fact()

函数

int fact(int x)

页脚内容

19

Ppt 1-15

{

if (x==0) return(1);

return(x*fact(x-1)); //

此处又调用了它自身

}

#include

//

带参数的

main()

函数

int main(int argc,char *argv[])

{

int i;

for(i=0;i

cout<

return 0;

}

#include

//

用函数原型声明要使用的函数

void show_array1(int*,int);

void show_array2(int a[],int);

void sort(int*,int);

main()

{

//

声明数组并初始化

int a[]={2,4,6,1,3,5};

int b[3][3]={{2,4,6},{1,3,5},{0,1,2}};

//

显示数组的值

cout<<

show_array1(a,6);

show_array1(&b[0][0],3*3);

//

用

sort1

排序并显示

cout<<

and

show_array1(int*,int):

sort(a,6);

show_array1(a,6);

sort(&b[0][0],3*3);

show_array1(&b[0][0],9);

//

显示数组的值

cout<<

show_array2(a,6);

show_array2(&b[0][0],3*3);

}

//

显示数组

,

用指针当参数

void show_array1(int *p,int size) {

for(int i=0;i

cout<<*(p+i)<<

cout<

}

//

显示数组

,

用数组当参数

void show_array2(int a[],int size) {

for(int i=0;i

cout<

cout<

}

//

对数组按从大到小顺序排序

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;

};

//

更改

s tudent

数据的

grade

成员

,

参数形式为引用

void change(student &x,float grade)

{

=grade;

}

//

更改

s tudent

数据的

grade

成员

,

参数形式为指针

void change1(student *p,float grade)

{

p->grade=grade;

}

//

更改

s tudent

类型的数据

,

普通参数形式

void change2(student x,float grade)

{

=grade;

}

//

显示

s tudent

类型的数据

,

参数形式为引用

void show(student &x)

{

cout<<<<

}

//

在

ma in()

函数中，测试对结构的处理函数

void main()

{

student a={

//

显示

a

的数据

show(a);

//

用

change

修改分数

,

并显示

cout<<

change(a,360);

show(a);

//

用

change1

修改分数

,

并显示

cout<<

change1(&a,375);

show(a);

//

用

change2

修改分数

,

并显示

cout<<

页脚内容

20

Ppt 1-15

change2(a,380.5);

int max(int a, int b)

show(a);

{

}

cout<<

#include

return((a > b) ? a: b);

//

定义函数计算数组的和和平均值

}

void

calculate(int

a[],int

size,int&

sum,float&

average)

//

计算最小值

{

int min(int a, int b)

sum=0;

{

for (int i=0;i

cout<<

sum+=a[i];

return((a < b) ? a: b);

}

}

average=sum/size;

}

//

求和

//

定义显示数组的函数

int sum(int a, int b)

void put_arr(int a[],int size)

{

{

cout<<

for(int i=0;i

return(a+b);

cout<

}

cout<

}

//

测试指向函数的指针

main()

void main(void)

{

{

//

声明数组并初始化

int a,b,result;

int asize,bsize;

int a[]={2,4,6,1,3,5};

//

测试

3

次

int b[]={1,3,5,7,9,11,13,15};

for (int i=1;i<=3;i++) {

cout<<

//

显示数组的值

cin>>a>>b;

asize=sizeof(a)/sizeof(int);

cout<<

cout<

put_arr(a,asize);

&max):

bsize=sizeof(b)/sizeof(int);

result =get_result(a, b, &max);

cout<<

cout<<

of

and

put_arr(b,bsize);

//

计算数组的和和平均值

result = get_result(a, b, &min);

float a_ave,b_ave;

cout<<

of

and

int a_sum,b_sum;

cout<<

calculate(a,asize,a_sum,a_ave);

result = get_result(a, b, &sum);

cout<<

cout<<

of

and

cout<<

}

cout<<

}

calculate(b,bsize,b_sum,b_ave);

#include

cout<<

#include

cout<<

#define size 3

}

//

定义

book

结构类型

#include

struct book

{

//

参数为函数指针的函数

char title[20];

int get_result(int a, int b, int (*sub)(int,int))

char author[15];

{

int pages;

int r;

float price;

r=sub(a,b);

};

return r;

//book

结构的输入函数

}

input_book(book& bk,char *name)

{

//

计算最大值

cout<

页脚内容

21

is

is

is

cout<<

cin>>;

cout<<

cin>>;

cout<<

cin>>;

cout<<

cin>>;

}

//book

结构的输出函数

output_book(book& bk,char *name)

{

cout<

cout<<<<

cout<<<<

cout<<<<

cout<<<

}

void main(void)

{

//

声明变量和结构数组

int i;

char str[20];

book bk[size];

//

输入结构数组

for(i=0;i

sprintf(str,

input_book(bk[i],str);

}

//

显示结构数组

for(i=0;i

sprintf(str,

output_book(bk[i],str);

}

}

#include

//

声明全局变量并初始化

extern int a[]={1,2,3};

extern float p=3.14;

//

在

show()

函数中使用外部变量

show() {

int i;

cout<<

cout<<

cout<<

for (i=0;i<=2;i++)

cout<

cout<

//cout<<

编译出错！

}

//

声明外部变量并初始化

int y=5678;

//

在

main()

函数中使用外部变量

main()

{

Ppt 1-15

//

声明局部变量

int i,p=100;

//

显示重名变量

cout<<

cout<<

//

显示全局变量

cout<<

cout<<

for (i=0;i<=2;i++)

cout<

cout<

cout<<

编译正确！

show(); //

调用函数

}

#include

//

使用静态变量的计数器函数

count1()

{

//
声明静态变量

i

，并置初值为

0

。

i

在

coun t()

中局

部可见

static int i=0;

return(++i);

}

//

使用局部变量的计数器函数

count2()

{

int i=0;

return(++i);

}

//

在

main()

函数中调用

count()

函数

main()

{

int i;

//

调用

count1()10

次

cout<<

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

cout<

cout<

//

调用

count2()10

次

cout<<

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

cout<

cout<

}

//

为

main()

函数文件

#include

main()

{

int i,s=0;

extern int fact(int x);

for (i=2;i<=6;i=i+2)

s+=fact(i);

cout<<

}

//

为计算阶乘函数文件

页脚内容

22

//

定义

fact()

函数为外部

(exter n)

函数

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<<

e(str,80);

/ /

以写入方式打开

文件

if ((fp1=fopen(

{

cout<<

cout<<

exit(1); //

结束程序执行

}

//

写

流

文件

fputs(str,fp1);

fputs(

fclose(fp1);

//

关闭文件

//

以读方式打开

文件

if ((fp1=fopen(

{

cout<<

cout<<

exit(1); //

结束程序执行

}

//

循环从

流

文件读取字符

,

并显示

char ch;

while ((ch=fgetc(fp1))!=EOF)

cout<

cout<

fclose(fp1); //

关闭文件

}

#include

#include

#include

#include

void main(void) {

//

变量声明

char ch;

FILE *fp1;

Ppt 1-15

//

以写入方式打开

文件

if ((fp1=fopen(

cout<<

cout<<

exit(1); //

结束程序执行

}

//
 循环从键盘上读取字符

,

写入



流

文件

cout<<

cin>>ch;

while (ch!='*') {

fputc(ch,fp1); //

将字符写到

fp1

指向的

流

文件中

cin>>ch;

}

fclose(fp1); //

关闭文件

//

以读方式打开

文件

if ((fp1=fopen(

{

cout<<

cout<<

exit(1); //

结束程序执行

}

//

循环从

流

文件读取字符

,

并显示

while ((ch=fgetc(fp1))!=EOF)

cout<

cout<

fclose(fp1); //

关闭文件

}

#include

#include

#include

#include

main() {

//

声明变量

int i=0;

char p[100];

//

声明输入缓冲区

FILE *fp1;

//

声明文件指针变量

//

以写入方式打开

文件

if ((fp1=fopen(

{

cout<<

cout<<

exit(1); //

结束程序执行

}

//

写文件操作

for (i=1;;i++) { //

无条件循环

cout<

cin>>p;

//

从

键

盘

上

输

入
数据

if (stricmp(p,

//

如果输入的字

符串为

end

，则结束循环

fputs(p,fp1); //

写入文件操作

fputs(

}

页脚内容

23

Ppt 1-15

else

break; //

退出循环

}

fclose(fp1);

//

关闭文件

//

以读方式打开

文件

if ((fp1=fopen(

{

cout<<

fclose(fp1); //

关闭文件

}

#include

#include

#include

#include

#include

#define MAX 3

main() {

//

定义结构类型

cout<<

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;

//

声明文件指针变量

//

以写入方式打开

文件

if ((fp1=fopen(

{

cout<<

cout<<

exit(1); //

结束程序执行

}

//

写文件操作

for (i=1;i<=MAX;i++) {

n=rand(); //

产生

1

个整数随机数
 

putw(n,fp1);

cout<

}

cout<

fclose(fp1);

//

关闭文件

//

以读方式打开

文件

if ((fp1=fopen(

{

cout<<

cout<<

exit(1); //

结束程序执行

}

//

循环从


流

文件读取字符

,

并显示

cout<

struct student {

int num;

char name[10];

float grade;

};

//

声明数组和变量

student st[3];

int i;

FILE *fp1;

//

声明文件指针变

量

//

以写入方式打开

文件

if ((fp1=fopen(

{

cout<<

cout<<

exit(1); //

结束程序执行

}

//

从键盘上读数据

,

写入文件

cout<<

for (i=0;i

cout<

cin>>st[i].num;

cin>>st[i].name;

cin>>st[i].grade;

fprintf(fp1,

ade);

}

fclose(fp1);

//

关闭文件

//

以读方式打开

文件

if ((fp1=fopen(

{

cout<<

cout<<

exit(1); //

结束程序执行

}

//
 循环从

流

文件读取字符

,

并显示

student t;

while

((fscanf(fp1,

cout<<<<

cout<<<<

cout<<<

}

页脚内容

24

while ((n=getw(fp1))!=EOF)

Ppt 1-15

fclose(fp1); //

关闭文件

}

#include

#include

#include

#include

int main(void)

{

FILE *fpd,*fpw; // 

声明

FILE

结构指针变量

unsigned char dw;

int i=0;

//

以二进制读方式打开

文件

if((fpd=fopen(

{

cout<<

cout<<

exit(1); //

结束程序执行

}

//

以二进制写方式打开



文件

if((fpw=fopen(

{

cout<<

cout<<

exit(1); //

结束程序执行

}

//

二进制文件读写操作，每次指定读写

1

个字节

while(!feof(fpd)) { //

使用

fe of()

判断文件尾

fread(&dw, 1, 1, fpd);

fwrite(&dw, 1, 1, fpw);

}

//

关闭文件

fclose(fpd);

fclose(fpw);

//

执行

和



文件

cout<<

system(

cout<<

cout<<

system(

}

#include

#include

#include

#include

void main(void) {

//

声明变量

int i;

char ch;

FILE *fp1;

//

以写入方式打开

文件

if ((fp1=fopen(

cout<<

cout<<

exit(1); //

结束程序执行

}

//

循环从键盘上读取字符

,

写入文件

cout<<

cin>>ch;

while (ch!='*') {

fputc(ch,fp1); //

将字符写到

fp1

指向的

流

文件中

cin>>ch;

}

cout<<

fclose(fp1); //

关闭文件

//

以读方式打开

文件

if ((fp1=fopen(

{

cout<<

cout<<

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<

}

}

cout<

fclose(fp1); //

关闭文件

}

#include

#include

#include

#include

#define MAX 5

页脚内容

25

//

显示数组的数据

void show_array(double x[],int size) {

for(int i=0;i

cout<

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<<

show_array(a,MAX);

//

打开

文件

if ((fp=fopen(

{

cout<<

cout<<

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<<

sh ow_array(b,MAX);//

显示数组

b

的数据

fclose(fp); //

关闭文件

//

打开

文件

if ((fp=fopen(

{

cout<<

cout<<

exit(1); //

结束程序执行

}

//

将数组当成数据块写入文件

fwrite(&a, sizeof(double), MAX, fp);

rewind(fp); //

恢复读写指针的位置

Ppt 1-15

//

将数组当成数据块从文件中读取

double c[MAX];

if (!feof(fp)) //

使用

feof()

判断文件尾

fread(&c, sizeof(double),MAX,fp);

cout<<

show_array(c,MAX); //

显示数组

c

的数据

fclose(fp); //

关闭文件

}

#include

#include

#include

#include

#define MAX 5

//

定义结构类型

struct student {

int num;

char name[20];

float grade;

};

//

显示

s tudent

结构数据

void show_str(student a,char *name) {

cout<

cout<<<<

cout<

}

//main

函数测试结构数据的文件读写

int main(void)

{

//

声明变量

FILE *fp;

//

声明

FILE

结构指针变量

student st={1001,

//

显示

st

结构数据

show_str(st,

//

打开

文件

if ((fp=fopen(

{

cout<<

cout<<

exit(1); //

结束程序执行

}

//
 用

fprintf()

函数写结构数据到文件


fprintf(fp,

%s

%f

rewind(fp); //

恢复读写指针的位置

//

用
fscanf()

函数读文件中的数据赋值给结构并显示

student temp;

fscanf(fp,

show_str(temp,

cout<<

页脚内容

26

Ppt 1-15

fclose(fp); //

关闭文件

//

将结构数据当成数据块进行读写

if

((fp=fopen(

//

打

开

文件

{

cout<<

cout<<

exit(1); //

结束程序执行

}

//

声明结构数组并初始化

int i;

student

starr[3]={{101,

in

//

显示结构数组

for(i=0;i<3;i++)

show_str(starr[i],

//

将结构数组当成数据块写入文件

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],

fclose(fp); //

关闭文件

}

#include

#include

#include

int main(void)

{

//

声明变量

char ch;

char str[20];

int n;

float x;

//

用
stdin

从键盘上输入数据

fprintf(stdout,

fscanf(stdin,

fprintf(stdout,

fscanf(stdin,

cout<<

//

输出显示

fprintf(stdout,

fprintf(stdout,

cout<

}

#include

void main( void )

*/

{

int c;

/* Create an error by writing to standard input.

putc( 'A', stdin );

if( ferror( stdin ) )

{

perror(

clearerr( stdin );

}

/* See if read causes an error. */

printf(

c = getc( stdin );

if( ferror( stdin ) )

{

perror(

clearerr( stdin );

}

}

#include

#include //

此预处理指令不可少

const double HD=3.1415926/180;

main() {

cout<<

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

cout<

}

#include

//

以下是几个简单宏替换预处理指令

#define YES 1

#define PI 3.1415926

#define RAD PI/180

#define MESG

//

以下是主程序

main() {

//

以下各语句使用了宏替换

cout<<

if (YES)

cout<<

cout<<

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<<

cout<<

cout<<

//PRINT(k)

宏替换的使用

PRINT(5);

PRINT(MAX(7,i*j));

页脚内容

27

Ppt 1-15

}

#include

#define PI 3.1416

main() {

int i=100;

#if 1

cout<<

#endif

#ifdef PI

cout<<

#endif

#ifndef PI

cout<<

此语句不被编译执

行

#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<<

return;

};

num[top]=x;

top++;

}

float pop(void) //

出栈函数

{

top--;

if (top<0){

cout<<

return 0;

};

return num[top];

}

}

//

以下是

main()

函数，其用

stack

类创建栈对象，并使用

了这些对象

main(void)

{

//

声明变量和对象

int i;

float x;

stack a,b; //

声明

(

创建

)

栈对象


//

以下对栈对象初始化

();

();

//

以下利用循环和

push()

成员函数将

2,4,6,8,1 0

依

次入

a

栈对象

for (i=1; i<=MAX; i++)

(2*i);

//

以下利用循环和

pop()

成员函数依次弹出

a

栈中的

数据并显示
 

for (i=1; i<=MAX; i++)

cout<<()<<

cout<

//

以下利用循环和

push()

成员函数将键盘输入的数据

依次入

b

栈

cout<<

for (i=1; i<=MAX; i++) {

cin>>x;

(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(void) //

初始化函数

{

top=0;

cout<<

}

void push(float x) //

入栈函数

{

if (top==MAX){

cout<<

return;

};

num[top]=x;

top++;

}

float pop(void) //

出栈函数

{

top--;

if (top<0){

cout<<

return 0;

};

return num[top];

}

页脚内容

28

Ppt 1-15

}

//

以下是

main()

函数，其用

stack

类创建栈对象，并使用

了这些对象

main(void)

{

//

声明变量和对象

int i;

float x;

stack a,b; //

声明

(

创建

)

栈对象并初始化

//

以下利用循环和

push()

成员函数将
2,4,6,8,10

依

次入

a

栈

for (i=1; i<=MAX; i++)

(2.0*i);

//

以下利用循环和

pop()

成员函数依次弹出

a

栈中的

数据并显示

for (i=1; i<=MAX; i++)

cout<<()<<

cout<

//

以下利用循环和

push()

成员函数将键盘输入的数据

依次入

b

栈

cout<<

for (i=1; i<=MAX; i++) {

cin>>x;

(x);

}

//
以下利用循环和

pop()

成员函数依次弹出

b

栈中的

数据并显示

for (i=1; i<=MAX; i++)

cout<<()<<

cout<

}

#include

const int MAX=5;

//

假定栈中最多保存

5

个数据

//

定义名为

stack

的具有栈功能的类

class stack {

//

数据成员

float num[MAX]; //

存放栈数据的数组

int top; //

指示栈顶位置的变量

public:

//

成员函数

stack(char c) //

初始化函数

{

top=0;

cout<<

}

void push(float x) //

入栈函数

{

if (top==MAX){

cout<<

return;

};

num[top]=x;

top++;

}

float pop(void) //

出栈函数

{

top--;

if (top<0){

cout<<

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++)

(2.0*i);

//

以下利用循环和

pop( )

成员函数依次弹出

a

栈中的

数据并显示

for (i=1; i<=MAX; i++)

cout<<()<<

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<

}

};

student

a(1001,

 //

创

建

对象，并初始化

//student c;

错误，没提供参数

y(); //

显示对象

a

中的数据

y(); //

显示对象

b

中的数据

}

#include

#include

页脚内容

29

Ppt 1-15

//

定义

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<<

cout<

//

使用
 char

指针类型的构造函数创建对象

timer start0(

创建对

象

cout<<

cout<

//

使用无参数构造函数和整型构造函数创建对象

timer start1;

timer finish1(3,30);

cout<<

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<<

cout<<

cout<<

}

};

//

测试使用

rect

类

void main(void)

{

//
用

rect

类创建对象

rect a;

rect b(2);

rect c(2,3);

//

调用对象的函数显示对象中的数据

_rect(

_rect(

_rect(

}

#include

const int MAX=5;

//

假定栈中最多保存

5

个数据

//

定义名为

stack

的具有栈功能的类

class stack {

//

数据成员

double num[MAX]; //

存放栈数据的数组

int top; //

指示栈顶位置的变量

public:

//

成员函数

stack(char *name) //

构造函数

{

top=0;

cout<<

initialized.

}

~stack(void) //

析构函数

{

cout <<

显示

信息

}

void push(double x) //

入栈函数

{

if (top==MAX){

cout<<

return;

};

num[top]=x;

top++;

}

double pop(void)

//

出栈函数

{

top--;

if (top<0){

cout<<

return 0;

};

return num[top];

页脚内容

30

Ppt 1-15

}

}



//

以下是

main()

函数，其用

stack

类创建栈对象，并使用

了这些对象

main(void)

{

double x;

//

声明

(

创建

)

栈对象并初始化

stack a(

//

以下利用循环和

push()

成员函数将

2,4,6,8,1 0

依

次入

a

栈

for (x=1; x<=MAX; x++)

(2.0*x);

//

以下利用循环和

pop()

成员函数依次弹出

a

栈中的

数据并显示

cout<<

for (int i=1; i<=MAX; i++)

cout<<()<<

cout<

//

从键盘上为

b

栈输入数据

,

并显示

for(i=1;i<=MAX;i++) {

cout<

cin>>x;

(x);

}

cout<<

for(i=1;i<=MAX;i++)

cout<<()<<

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(

//

以下利用循环和

push()

成员函数将

2,4,6,8,10

依

次入

a

栈

for (i=1; i<=MAX; i++)

(2*i);

//

以下利用循环和

pop()

成员函数依次弹出

a

栈中的

数据，并显示

cout<<

for (i=1; i<=MAX; i++)

cout<<()<<

cout<

//

从键盘上为

b

栈输入数据

,

并显示

for(i=1;i<=MAX;i++) {

cout<

cin>>n;

(n);

}

cout<<

for(i=1;i<=MAX;i++)

cout<<()<<

cout<

return 0;

}

//-------------------------

// stack

成员函数的定义

//-------------------------

//

定义构造函数

stack::stack(char *name)

{

top=0;

cout

<<

ini tialized.

<<

endl;

}

//

定义析构函数

stack::~stack(void)

{

cout <<

显示信息

}

//

入栈成员函数

void stack::push(int n)

{

if (top==MAX){

cout<<

return;

};

num[top]=n;

top++;

}

//

出栈成员函数

int stack::pop(void)

{

top--;

if (top<0){

cout<<

return 0;

};

return num[top];

}

#include

//

定义一个全部为

public:
 模式的类

class ex

{

public:

int value;

void set(int n) {

页脚内容

31

Ppt 1-15

value=n;

}

int get(void) {

return value;

}

};

//

测试使用

ex

类

main()

{

ex a; //

创建对象

//

以下通过成员函数访问对象数据

(100);

cout<<

cout<<()<

//

以下直接访问对象的数据成员

=200;

cout<<

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) { }

//

定义

e x_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 <<

cout <<

}

/ /

使用

ex_class

类


void main(void)

{

ex_class obj1;

_ex_class(

_ex_class(5,5.5);

_ex_class(

ex_class obj2(100,3.14);

_ex_class(

_ex_class(2000,1.732);

_ex_class(

}

#include

//

定义一个含有

static

数据成员的类

class ex

{

static int num; //static

数据成员

public:

ex() {num++;}

~ex() {num--;}

disp_count() {

cout<<

cout<

}

};

int ex::num=0; //

设置

static

数据成员的初值

//main()

函数测试

ex

类

main()

{

ex a;

_count();

ex *p;

p=new ex;

p->disp_count();

ex x[10];

x[0].disp_count();

delete p;

_count();

}

#include

//

定义一个含有

static

数据成员的类

class ex

{

static int num; //static

数据成员

public:

ex() {num++;}

~ex() {num--;}

static disp_count(void) //static

成员函数

{

cout<<

cout<

}

};

int ex::num=0; //

设置

static

数据成员的初值

//main()

函数测试

ex

类

main()

{

ex a;

_count();

ex *p;

p=new ex;

p->disp_count();

ex x[10];

页脚内容

32

Ppt 1-15

ex::disp_count(); //

直接用类作用域符引用静态

成员函数

delete p;

ex::disp_count(); //

直接用类作用域符引用静态

cout<<

}

#include

//

用

struct

关键字定义

ex_class

类

struct ex_class {

成员函数

}

#include

class ex_class {

int value;

public:

ex_class(int n) {

value=n;

cout <<

}

~ex_class() {

cout <<

}

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<

cout<

}

//

在

main()

函数中测试

ex_clas s

类

main(void)

{

//
创建对象

x

和

y
 

ex_class x(100),y(200);

//

显示对象的数据

_val(

_val(

//

设置新值给对象

_value(1);

_value(2);

//

显示对象的数据

_val(

_val(

return 0;

}

#include

//

定义空类

empty

class empty

{

};

//

在

main()

函数中用空类创建对象

main()

{

empty a,*p; //

编译通过

ex_class(int n=1): value(n) {}

void set_value(int n) {

value=n;

}

show_obj(char *name) {

cout<

}

private:

int value;

}

//

测试

ex_class

类

main()

{

//
用

ex_class

创建对象

ex_class a,b(3);

_obj(

_obj(

_value(100);

_value(200);

_obj(

_obj(

}

#include

#include

//

定义双亲（

parent

）类

class parent {

char f_name[20];

char m_name[20];

char tel[10];

public:

// parent

类的构造函数，其带有缺省值

parent(char *p1=

strcpy(f_name,p1);

strcpy(m_name,p2);

strcpy(tel,p3);

}

//

显示

parent

对象的数据

show_parent(void) {

cout<<

cout<<

cout<<

cout<<

}

};

//

定义

student

类

class student {

int num;

char name[20];

float grade;

parent pt;

public:

// student

类的构造函数

页脚内容

33

Ppt 1-15

student(int n,char *str,float g,class parent t)

{

num=n;

strcpy(name,str);

grade=g;

pt=t;

}

//

显示

student

对象的数据

show_student(void) {

cout<<

cout<<

cout<<

_parent();

}

};

//main()

函数测试

student

类的对象
 

main(void)

{

//

创建双亲对象

parent p1(

//

创建学生对象

student st(10001,

//

显示学生信息

cout<<

_parent();

//

显示学生信息

cout<<

_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; //

创建对象

//

使用重载成员函数

er(8,30);

er(9,40);

cout<<

:

cout<

//

使用重载成员函数

er(2.0);

er(

cout<<

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;

= this->real +

= this->image +

return temp;

}

//

重载加赋值运算符

的定义

complex complex::operator= (complex right) {

this->real =

this->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<

cout << real << ' ';

if (image >= 0.0 ) cout << '+';

cout << image <<

}

//

在

main()

函数中使用

complex

类的对象

main(void)

{

complex A, B, C; //

创建复数对象

//

设置复数变量的值

_complex(1.2, 0.3);

_complex(-0.5, -0.8);

页脚内容

34

Ppt 1-15

//

显示复数数据

_complex(

_complex(

//

赋值运算，显示结果

C = A;

_complex(

//

加法及赋值运算，显示结果

C = A + B;

_complex(

return 0;

}

// Example of the friend class

#include

//

定义

YourClass

类，

class YourClass

{

//

指定

YourOtherClass

是它的友元类
 

friend class YourOtherClass;

private:

int num;

public:

YourClass(int n){num=n;}

display(char *YCname){

cout<

cout<

}

};

/ /

定义

YourOtherClass

，它是

YourClass

类的友元类

class YourOtherClass

{

public:

//

使用

YourClass

类的私有成员

void disp1(YourClass yc,char *YCname){

cout<

cout<<<

}

//

使用

YourClass

类的公共成员

void disp2(YourClass yc,char* YCname){

y(YCname);

}

};

//

在

main()

函

数
中

创

建

和

使

用

YourClass

和

YourOtherClass

类对象

main(void)

{

//
声明

YourClass

类对象

YourClass a(10),b(100);

//

显示
 a

和

b

对象的值

cout<<

y(

y(

//

声明
 YourOtherClass

类对象

YourOtherClass temp;

//

通过
 temp

显示

a

和

b

对象的值

cout<<

1(a,

2(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<<

(name); //

访问

Y

类的私有函数

}

//

普通函数

putY()

的定义


void putY(Y& yc,char *name){

cout<<

(name);

cout<

cout<<<

}

//

在

ma in()

函数测试

X

和

Y

类的功能

main()

{

//
创建

Y

和

X

类的对象

Y y1(100),y2(200);

X x;

//

不可用

Y

类对象的私有成员函数显示
 

//(

//(

//

调用

X

类对象的友元函数显示

(y1,

(y2,

页脚内容

35

一个比划一个猜-

一个比划一个猜-

一个比划一个猜-

一个比划一个猜-

一个比划一个猜-

一个比划一个猜-

一个比划一个猜-

一个比划一个猜-

小学

中学

高等教育

小段美文

三国演义读书笔记

《木偶奇遇记》读书笔记

《狼王梦》读书笔记

《昆虫记》读书笔记

教师读书笔记

《神秘岛》学生读书笔记

欧也妮葛朗台读书笔记摘抄

活着读书笔记

格兰特船长的儿女读书笔记

鲁滨逊漂流记读书笔记左右

简爱读书笔记

鲁迅《呐喊》读书笔记

《海的女儿》读书笔记

《爱的教育》读书笔记

文档作者

温柔似野鬼°

我已相信有些人我永不必等、

您可能关注的内容

1
小段美文

2
三国演义读书笔记

3
《木偶奇遇记》读书笔记

4
《狼王梦》读书笔记

5
教师读书笔记

6
《昆虫记》读书笔记

7
《神秘岛》学生读书笔记

8
欧也妮葛朗台读书笔记摘抄

9
活着读书笔记

10
格兰特船长的儿女读书笔记

为你推荐

一年级趣味趣味奥数活动总结

小学数学一年级下册：奥数题训练(3)

几千元投资创业小项目利润惊人致富快-投资,创业项目完整篇.doc

最新六年级下册健康教育教案

热门标签

[db:TAG]

标题

小学英语4年级

忆读书答案

整除

百部经典电影

童话

高尚的行为

趣味数学游戏

乘法结合律

七桥问题答案

小学数学公式

tonghua

什么路不能走

观察日记300字

活版练习题

秋色宜人

英语教学计划

必备古诗

牛吃草问题

72小时打一字

问题鸡蛋

名人成长故事

北人食菱

数学小论文

走马见诸葛

黄山奇石课文

将心比心课文

兰兰过桥

一面课文

煮书

中华少年课文

白杨课文

数列

一般将来时态

小学作文指导

小狮子爱尔莎

晏子辞千金

国庆专题

考试题

小学英语论文

北师大版教材

一片绿草地

整数

趣味数学故事

说课稿范文

走马荐诸葛

排列组合问题

教学课件

斜塔上的实验

5年级上册英语

四则混合运算

四则运算教案

三峡之秋

学习习惯

数学趣味故事

鸡兔同笼公式

分数应用题

角的分类

6年级上册英语

计算公式

50以内的口算题

衡州新学记

数独4宫格

乘法公式小学

利率的公式

学弈课文

10以内加法口诀

电子书课本

语文数学辅导

的棋盘

乘法口算100题

容积的公式

草船借箭原文

数学家手抄报

日记30

穷人课文原文

四上

神笔马良作者

五年级方程题

英语下册

元角分练习题

小学单词

五年级英语下

笋芽儿课文

加法公式

和差倍问题

数学成语

狮子和鹿课文

数学ppt

语文书

趣味数学100题

六年级语文上

小学生英文

等差

换元法

取整

裂项公式

小学生三年级

青蛙写诗课文