当前位置:文档之家› C++知识要点

C++知识要点

C++引言

C++程序的基本框架

(1)结构化程序设计框架:基本组成单元是函数

(2)面向对象程序设计框架:基本组成单元是类

C++基础知识

1、变量命名规则及其变量初始化

例如:double rate=0.07;或double rate(0.07);

2、基本输入输出

通过标准库中的输入/输出流对象cin和cout来完成

3、数据类型和表达式

(1)逻辑型bool,取值范围为true和false(C中没有该数据类型)字符型char

整型int

浮点型float和double

(2)算术运算符和算术表达式注意:++、--、%运算符

(3)关系运算符和关系表达式注意:==和=之间的区别

(4)逻辑运算符(!、&&、||)和逻辑表达式

4、选择语句与循环语句

(1)选择语句:if语句和switch语句

(2)循环语句:for语句、while语句和do-while语句

注:while语句和do-while语句循环体一定要改变循环控制变量

例1、bool类型

#include

using namespace std;

void main()

{

bool a;

cin>>a;

cout<

}

例2、:表达式计算

(1)(float)(a+b)/2-(int)x%(int)y 设a=2,b=3,x=3.5,y=2.5

答:

按优先级先计算强制类型转换:(float)(a+b)/2=5.0 /2=2.5

(int)x%(int)y=(int)3.5%(int)2.5=3%2=1

最后计算(float)(a+b)/2-(int)x%(int)y=2.5-1=1.5

(2)'a'+x%3+5/2-'\24' 设x=8

'a'+x%3+5/2-'\24'=97+8%3+5/2-24=97+2+2-20=81

‘\24’为八进制,‘\24’=024(八进制)=2*8+4(十进制)=20(十进制)

'a'的ASCII码为97

例3、

#include

void main(void)

{ int i,j,m,n;

i=8;j=10;

m=++i;n=j++; //i=9 m=9 ,n=10 j=11

cout<

cout<

}

例4、逗号表达式。设a、b、c的值分别为5、8、9;指出分别运算下列表达式后x、y的值。(1)y=(a+b,b+c,c+a) (2)x=a,y=x+b

解:

(1)y=(a+b,b+c,c+a) =(5+8,8+9,9+5)=(13,17,14)=14 y=14

(2)x=a, y=x+b = (x=5,y=x+b)=(5,y=5+8)=(5,y=13)=13 x=5, y=13

例5、短路求值

#include

void main(void)

{ int w=3,x=10,z=7;

char ch='D';

bool s;

s=w++||++z;

cout<

}

例6、从键盘输入一个三位数abc,从左到右用a、b、c表示各位的数字,现要求依次输出从右到左的各位数字,即输出另一个三位数cba,例如:输入123,输出321,试设计程序。

例7、写出下列程序的运行结果

#include

void main(void)

{ int n=4;

while (--n)

cout<

cout<

}

函数

1、函数基本知识

(1)数据类型转换如:(double)或static_cast

(2)函数定义注:函数只能返回一个值,不能返回多个值

(3)函数调用调用方法为语句调用、表达式调用和参数调用

(4)注意变量作用域与生存周期

Type_returned Function_Name(Parameter_List);

Type_returned Function_Name(Parameter_List)

{

//code to make the function work

}

Argument

2、函数参数

参数的传递方式:

(1)传值

传值是将实参值的副本传递(拷贝)给被调用函数的形参

(2)传指针和传引用

传指针属于显示传递地址,因为传递的是地址,而变量的地址是唯一的,所以操作会影响到实参

引用的本质也是指针,是C++增加的一个更安全的操作。与传值相比,它们的优点是效率高,传指针和传引用不用进行复制操作,不用把实参的值复制一份给形参

注意:引用的概念

3、函数重载

重载规则:

(1)函数重载必须参数类型不一样或参数个数不一样

(2)能依靠返回值不一样来区别重载函数

例1、参数传递过程。写出下列程序的运行结果

#include

void modify(int x,int y)

{ cout<<"x="<

x=x+3; y=y+4;

cout<<"x="<

}

void main(void)

{ int a,b;

a=1;b=2;

cout<<"a="<

modify(a,b);

cout<<"a="<

}

例2、递归调用过程

#include

int fac(int n)

{ int z;

if (n>0)

z=n*fac(n-2);

else

z=1;

return z;

}

void main(void)

{ int x=7,y;

y=fac(x);

cout<

}

例3、静态变量

#include

void main(void)

{ int i;

void add1(void),add2(void);

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

{ add1();

add2();

cout<

}

}

void add1(void)

{ int x=0;

x++;

cout<

}

void add2(void)

{ static int x=0;

x++;

cout<

}

例4、编写一个函数判断一个整数是否为素数。在主函数中输入一个整数,输出该整数是否为素数的信息。

#include

#include

#include

int prime(int a)

{ int k,i;

k=sqrt(a);

for (i=2;i<=k;i++) //判断a是否是素数

if (a%i==0)

break;

if (i>k) //若i>k,则i为素数return 1;

else

return 0;

}

void main(void)

{ int a,b;

cout<<"请输入一个整数:";

cin>>a;

b=prime(a);

if (b==1)

cout<

else

cout<

}

例5、编写两个函数,分别求两个整数m、n的最大公约数和最小公倍数。在主函数中输入两个整数,分别调用这两个函数求得结果并输出。求两个整数m、n的最大公约数和最小公倍数的算法提示如下:

(1)将m、n中的最大数赋给变量a,最小数赋给变量b。

(2)用大数a除以小数b,若余数c为0,则余数c为最大公约数,否则进行(3)。(3)将小数b赋给a,余数c赋给b,再进行(2),直到余数等于0为止。

(4)最小公倍数=(m*n)/最大公约数。

例如:求20与14的最大公约数方法:20%14=6,14%6=2,6%2=0,则2为20与14的最大公约数。最小公倍数=20*14/2=140。

# include

int gcd(int m,int n)

{ int r;

while (m%n!=0)

{ r=m%n;

m=n;

n=r;

}

return n;

}

int lcm(int m,int n)

{ int lcm;

lcm=m*n;

lcm=lcm/gcd(m,n);

return lcm;

}

void main(void)

{ int m,n;

cout<<"please input m,n:";

cin>>m>>n;

cout<<"Lease common multiple="<

cout<<"Gretest common divisor="<

}

例6:

#include

using namespace std;

int &fun(int &temp)

{temp+=10;

return temp;

}

int main()

{int a=0;

int &b=fun(a);

cout<<"b="<

int n;

void fun(char s[],int k);

n=strlen(a);

fun(a,n);

cout<

}

void fun(char s[],int k)

{ int x,y;

char c;

x=0;

for (y=k-1;x

{ c=s[y]; s[y]=s[x]; s[x]=c;

x++;

}

}

例2、编写一个排序函数用选择法对一批整数按从大到小的次序进行排序。在主函数内输入数据,调用排序函数对数据排序,输出排序结果。

解:

# include

# define N 5

void sort1(int a[])

{ int i,j,k,temp;

for (i=0;i

{ k=i;

for (j=i+1;j

if (a[k]

k=j;

if (i!=k)

{ temp=a[i];a[i]=a[k];a[k]=temp;}

}

}

void main(void)

{ int a[N],i;

cout<<"Please input a["<

for (i=0;i

cin>>a[i];

sort1(a);

for (i=0;i

cout<

cout<

}

例3、编写两个名为max的重载函数,分别实现求两个整数和两个实数中的大数。

解:

# include

float max(float a,float b)

{ return a>b?a:b;

}

int max(int a,int b)

{ return a>b?a:b;

}

void main(void)

{ int a,b;

float x,y ;

cout<<"Please a、b:";

cin>>a>>b;

cout<<"max="<

cout<<"Please x、y:";

cin>>x>>y;

cout<<"max="<

}

例4 叙述二维数组a的行地址、行首地址、元素地址的概念、作用及表示方法,写出元素a[i][j]值的表示方法。

答:

(1)二维数组a的第i行首地址是第i行第0列元素地址&a[i][0]。

有三种表示方式:&a[i][0]、a[i]、*(a+i)、&a[i][0]。

(2)二维数组a的第i行的行地址是用于指向一维数组指针变量的地址。

有二种表示方式:a+i、&a[i]

(3)二维数组a的元素a[i][j]的地址为该元素在内存中的地址,

有四种表示方式:a[i]+j 、*(a+i)+j、&a[i][0]+j、&a[i][j]

(4)元素a[i][j]的值的表示方式:*(a[i]+j) 、*(*(a+i)+j)、*(&a[i][0]+j)、a[i][j]

例5、对字符串指针变量,能否用cin、cout对其输入/输出字符串?能否对字符串指针变量进行赋值运算?字符串指针变量能否作为字符串处理函数的参数?

答:

对字符串指针变量,能用cout对其输出字符串,但不能用cin对其输入字符串;能对字符串指针变量进行赋值运算;

字符串指针变量能作为字符串处理函数的参数。

例6、读下列程序,并写出程序运行结果。

(1)

# include

void main (void)

{ float x=1.5,y=2.5,z;

float *px,*py;

px=&x;

py=&y;

z= * px + *py;

cout<<"x="<<*px<<'\t'<<"y="<<*py<<"z="<

}

(2)

# include

void main( void)

{ int a[5]={10,20,30,40,50};

int *p=&a[0]; //p指向a[0]

p++; //p指向a[1]

cout<< *p<<'\t'; //输出a[1]=20

p+=3; //p指向a[4]

cout<< *p<<'\t'; //输出a[4]=50

cout<< *p――<<'\t'; //先输出a[4]=50,后p指向a[3]

cout<<++ *p<<'\n'; //先对a[3]内容加1,后输出a[3]=41

}

(3)# include

void f(int *a,int b)

{ int t=*a;*a=b;b=t;}

void main(void)

{ int x=10,y=20;

cout<

f(&x,y);

cout<

}

例7、用指针变量编写下列字符串处理函数:

(1)字符串拷贝函数,void str_cpy( char *p1,char *p2){函数体}

(2)字符串比较函数,int str_cmp( char *p1,*char *p2) {函数体}

(3)取字符串长度函数,int str_len( char *p){函数体}

在主函数中输入两个字符串,对这两个字符串进行比较,并输出比较结果。然后将第一个字符串拷贝到第二个字符串,输出拷贝后的字符串及其长度。

解:

# include

int str_cmp(char *p1,char *p2)

{ while(*p1==*p2)

{p1++;

p2++;

}

if (*p1>*p2)

return 1;

else if (*p1==*p2)

return 0;

else

return -1;

}

void str_cpy(char *p1,char *p2)

{ while(*p1!=0)

*p2++=*p1++;

*p1=0;

}

int str_len(char *p)

{ int length=0;

while(*p!=0)

{ p++;

length++;

}

return length;

}

void main(void)

{ char s1[20],s2[40];

cout<<"Input String1:";

cin>>s1;

cout<<"Input String2:";

cin>>s2;

if (str_cmp(s1,s2)==1)

cout<<"String1>String2"<

else if (str_cmp(s1,s2)== -1)

cout<<"String2>String1"<

else

cout<<"String1=String2"<

str_cpy(s1,s2);

cout<<"String2 ="<

cout<<" String2 Length="<

}

例8、设计返回指针值的函数,将输入的一个字符串按逆向输出。

解:

# include

# include

char *reverse(char *p, int n)

{ int i=0,j=n-1;

char temp;

while(i

{ temp=*(p+i);

*(p+i)=*(p+j);

*(p+j)=temp;

i++;

j--;

}

return p;

}

void main(void)

{ char s[30];

int l;

cout<<"Input String:";

cin>>s;

l=strlen(s);

cout<

}

例、有哪三种方法来定义const 型指针?这三种const指针限制哪些变量的值不能改变?答:

const 型指针

有三种方法来定义const 型指针:

const <类型> *<指针变量名>;

定义指针变量所指数据值不能改变,但指针变量值可以改变。

<类型> * const <指针变量名>;

定义指针变量值不能改变,但指针变量所指数据值可以改变。

const <类型> * const <指针变量名>;

指针变量值与指针变量所指数据值都不能改变。

输入输出流

1、C++流的概念

(1)C++流的体系结构

与C++流相关的头文件:

①iostream——要使用cin、cout的预定义流对象进行针对标准设备的I/O操作,

必须包含此文件

②fstream——要使用文件流对象进行针对磁盘文件的I/O操作,必须包含此文件

③iomanip——要使用setw、fixed等操作符,必须包含此文件

(2)预定义流对象

cin、cout等

(3)提取运算符和插入运算符>>与<<

(4)输入输出的格式控制

①格式控制标志与格式控制

②输入输出宽度的控制

③浮点数输出格式的控制

④输出精度的控制

⑤对齐方式的控制

⑥小数点处理方式的控制

⑦填充字符设置

(5)cin.get()、cin.put()和cin.getline()的应用

注意:一般情况下,cin自动跳过输入的空格,如果你要把键盘上输入的每个字符包括空格和回车键都作为一个输入字符给字符型变量时,必须使用函数cin.get()。

2、文件流

ifstream是文件输入流,ofstream是文件输出流,fstream是文件输入输出流类

(1)文件流的建立——文件流的成员函数open()

①在建立文件流对象的同时打开文件

②先建立文件流对象,再在适当的时候打开文件

注意:文件的打开模式

(2)文件流的关闭——文件流的成员函数close()

(3)文件流状态的判别

①fail()——刚进行的操作失败时返回true,否则返回false

②eof()——若达到文件尾返回true,否则返回false

例1、叙述文本文件的使用过程。

答:

文本文件的具体使用步骤如下:

(1) 用文件流类定义文件流对象,

(2) 打开文件

①用成员函数open()打开文件

②用构造函数打开文件

(3) 读/写文件

①用提取运算符“>>”与插入运算符“<<”对文件进行读与写操作;

②用成员函数get()、getline()与put() 对文件读写。

(4)关闭文件

用成员函数close关闭文件。

例2、使用成员函数打开文本文件,并将源文件中内容添加到目的文件的尾部。

解:

# include

# include

# include

void main(void)

{ char fname1[256],fname2[256];

char buff[300];

cout<<"输入源文件名:";

cin>>fname1;

cout<<"输入目的文件名:";

cin>>fname2;

fstream infile,outfile;

infile.open(fname1,ios::in | ios::nocreate);

outfile.open(fname2,ios::app);

if (!infile)

{ cout<<"源文件不存在,不能打开源文件!"<

exit(1);

}

if (!outfile)

{ cout<<"目标文件不存在,不能打开目标文件!"<

exit(2);

}

while (infile.getline(buff,300)) //从源文件中读一行字符到缓冲区;

outfile<

infile.close(); //关闭源文件

outfile.close(); //关闭目的文件

}

例3、从文本文件中读取数据输入一维数组,对一维数组元素进行升序排列。再存入另一个文本文件中。

解:

# include

# include

# include

# define N 5

void main(void)

{ float a[N],temp;

int i,j,k;

char fname1[256],fname2[256];

cout<<"输入源文件名:";

cin>>fname1;

ifstream infile;

infile.open(fname1);

if (!infile)

{ cout<<"不能打开目的文件:"<

exit(1);

}

cout<<"输入目标文件名:";

cin>>fname2;

ofstream outfile;

outfile.open(fname2);

if (!outfile)

{ cout<<"不能打开目的文件:"<

exit(1);

}

for(i=0;i

infile>>a[i];

for(i=0;i

{ k=i;

for(j=i+1;j

if (a[k]>a[j]) k=j;

if (k>i)

{ temp=a[i];a[i]=a[k];a[k]=temp;}

}

for (i=0;i

cout<

cout<

for(i=0;i

outfile<

infile.close();

outfile.close();

}

String与Vector

1、字符数组

(1)字符数组的初始化

注意:用字符串对字符数组进行初始化时,编译程序以’\0’为结束这个数组的标志(2)常用字符串函数(注意:这些函数包含在头文件cstring中)

①strcpy函数

②strcat函数

③strcmp函数

④strlen函数

2、string类型

(1)在使用string数据类型前,需要包含如下格式:

#include

using namespace std;

(2)string类型的输入

cin自动跳过输入的空格,若读入的串还有空格等字符,则使用getline函数(3)string类的常用成员函数

①构造函数

②字符操作

③赋值与连接

④比较

⑤查找

3、vector

容器向量(vector)是一个类模板。标准库vector类型使用需要的头文件:#include 。vector 是一个类模板,不是一种数据类型,vector是一种数据类型。Vector的存储空间是连续的

(1)定义与初始化

vector< typeName > v1; //默认v1为空

vector< typeName > v4(n); //v4含有n个值为0的元素

(2)vector对象的几种操作

①v.push_back(t) 在容器的最后添加一个值为t的数据,容器的size变大。

②v.size() 返回容器中数据的个数

③v[n] 返回v中位置为n的元素

④v.capacity()返回容器在它已经分配的内存中可以容纳多少元素

⑤v.resize(n)强制把容器改为容纳n个元素。

⑥v.reserve(n)强制容器把它的容量改为至少n,提供的n不小于当前大小。

类的定义

1、结构体

(1)结构体类型的声明

(2)结构体变量的定义与初始化

(3)结构体变量的引用(“.”是成员分量运算符)

2、类

(1)类的定义

类的定义可以分为说明部分和实现部分。类定义的一般格式如下:

//类说明部分

class <类名>

{

public:

<成员函数或数据成员的说明> //公有成员,外部接口

protected:

<成员函数或数据成员的说明> //保护成员

private:

<成员函数或数据成员的说明> //私有成员

};

//类的实现部分

<各个成员函数的实现>

(2)类成员的控制访问

类中提供了3种访问控制权:

①公有(public):公有类型定义了类的外部接口,任何一个外部访问都必须通过外部

接口进行

②私有(private):私有类型的成员只允许本类的成员函数访问,来自类外部的任何访

问都是非法的

③保护(protected):保护类型介于公有类型和私有类型之间,在继承和派生时可以体

现出其特点

(3)类的数据成员

注意:类中的数据成员可以是任意类型,也可以是对象。但是要注意,只有另外一个类的对象,才可以作为该类的成员,即作为该类的成员对象存在。自身类的对象是不可以作为自身类的成员存在的,但自身类的指针可以。

(4)类的成员函数

类的成员函数描述类所表达的问题的行为。

成员函数的定义可以直接定义在类的内部,即该函数作为内联函数;

成员函数的定义也可以在类的外部定义,注意它的格式:

<返回类型> <类名>::<成员函数名> (<参数表>)

{

<函数体>

}

注意:若形参为const,则该形参值不能变

(5)构造函数

构造函数的作用是在对象被创建时利用特定的值构造对象,将对象初始化为一种特定的状态,使该对象具有区别于其他对象的特征。它具有如下的特性:

①构造函数的名字必须与类的名相同

②构造函数不指定返回类型

③构造函数可以重载

④在创建对象时,系统自动调用构造函数

(6)析构函数

用来完成对象被删除前的一些清理工作,它具有如下的特性:

①析构函数的名是在类名前面加上~符号

②析构函数不指定返回类型

③析构函数没有参数,一个类中只能定义一个析构函数

④在撤销对象时,系统自动调用析构函数

(7)拷贝构造函数

它用一个已知的对象初始化一个正在创建的同类对象,它的一般格式如下:<类名>::<类名> (const <类名>&<引用对象名>)

{

//拷贝构造函数体

}

拷贝构造函数在以下情况会被调用:

①用类的一个已知的对象去初始化该类的另一个正在创建的对象

②采用传值调用方式时,对象作为函数实参传递给函数形参

③对象作为函数返回值

3、对象的定义、生存周期和this指针

(1)对象的定义

(2)对象的成员

定义了对象后,可以使用“.”和“->”运算符访问对象的成员。其中,“.”运算符适用

于一般对象和引用对象,“->”运算符适用于指针对象

(3)对象的生存周期

全局对象、静态对象和局部对象

(4)this指针

this指针是一个隐含的指针,它隐含于每个类的非静态成员函数中,它明确的表示出了成员函数当前操作的数据所属的对象

4、静态成员和常成员

(1)静态成员

对于类中的非静态成员,每个类对象都拥有一个拷贝(副本),即每个对象的同名数据成员可以分别存储不同的数值。

静态成员的特性是不管类创建了多少个对象,它的静态成员都只有一个拷贝(副本),这个副本被所有属于这个类的对象共有

①静态数据成员

声明时要使用关键字static,静态数据成员初始化在类体外进行,一般格式:<数据类型><类名>::<静态数据成员名>=<初始值>;

②静态成员函数

使用static关键字声明的成员函数就是静态成员函数。静态成员函数属于整个类而不属于类中的某个对象

静态成员函数只能直接访问类中说明的静态成员

5、常成员

(1)常对象

使用const关键字修饰的对象

(2)常成员函数

使用const关键字说明的成员函数,其格式:

<返回类型> <成员函数名> (<参数表>) const

其重载原则是,常对象调用常成员函数,一般对象调用一般成员函数

(3)常数据成员

使用const说明的数据成员

6、抽象数据类型的含义和特点

例1、用学生档案结构体定义一个学生的档案结构变量。用初始化方式输入学生档案内容,并输出学生档案。

解:

# include

struct student

{ int no ;

char name[8];

char sex;

int age;

char addr[20];

int post;

char photo[15];

};

void main(void)

{ student s={101,"Zhou",'M',23,"wuxi",214073,"0510-*******"};

cout<<"学号:"<

cout<<"姓名:"<

cout<<"性别:"<

cout<<"年龄:"<

cout<<"地址:"<

cout<<"邮编:"<

cout<<"电话:"<

}

例2、什么叫类?什么叫对象?

答:

类由描述某类事物的数据(数据成员)及处理数据的函数(成员函数)组成的导出数据类型,用类定义的变量称为对象。

例3、叙述公有、私有、保护成员在类内、外的访问权限。

答:

public(公有成员)公有数据成员允许类内或类外函数访问,成员的公有成员函数允许在类内或类外调用。

访问权限private(私有成员)私有数据成员只允许类内函数访问,

私有成员函数只允许在类内调用。

protected(保护成员) 保护数据成员只允许类或其子类中函数访问,

保护成员函数允许在类内或其子类中调用。

例4、构造函数的作用是什么?构造函数的名称与类型有何特点?何时调用构造函数?

答:

构造函数用于对象数据成员的初始化。

构造函数名必须与类名相同,且无返回类型。

用类定义对象时调用构造函数对数据成员进行初始化。

例5、构造函数可以分为哪三类?其形参有何区别?分别初始化何种对象?

答:

构造函数可以分为:

(1)有参构造函数:形参可以是任意类型的变量,用于初始化有实参的对象;

(2)无参构造函数:没有形参,用于初始化无实参的对象;

(3)拷贝构造函数:形参必须为类的对象的引用, 初始化时用于将一个已存在对象的数据拷贝到新建对象中,即用于初始化实参为已存在对象的对象。

例6、叙述定义对象时,调用构造函数的过程及参数的传送过程?

答:

用类定义一个对象时,系统先为其分配内存空间,然后调用构造函数对数据成员进行初始化。系统调用构造函数前,首先判断定义对象是否有实参。

若无实参,则调用无参构造函数,对新建对象的数据成员进行初始化。

若有实参,且实参不是对象,则调用带参构造函数,先将实参传送给形参,然后通过构造函数体实现对新建对象数据成员的初始化。

若实参为已存在的对象,则调用拷贝构造函数,由于拷贝构造函数的形参为对象的引用,所以实参对象与形参对象占用相同的内存空间,具有相同的数据内容,因此通过拷贝构造函数可实现新建对象数据成员的初始化。

例7、析构函数的作用是什么?析构函数的名称与类型有何特点?何时调用析构函数?

答:

(1)析构函数的作用是回收对象所占用的内存空间。

(2)析构函数的名称必须与类名相同,且析构函数名前必须加”~”。析构函数无参数无返回类型,析构函数不允许重载,即析构函数是唯一的;

(3)当对象结束其生命期,系统调用析构函数,回收对象所占用的内存空间。

例8、用new运算符动态建立对象与用delete运算符撤消动态建立对象时,系统如何调用构造函数与析构函数?

答:

当用new运算符动态建立对象时,系统

(1)为对象分配内存空间

(2)调用构造函数初始化对象的数据成员

先将实参传送给形参,然后由构造函数体完成对数据成员的初始化工作。

(3)将对象起始地址返回给指针变量

用new动态分配的内存空间必须用delete回收,在执行delete 语句时,将调用析构函数回收对象占用的内存空间。

例9、什么是this指针?

答:

用类定义一个对象时,系统会自动建立一个指向该对象的指针变量,该指针变量称this指针,this指针变量指向所定义的对象。

例10、定义一个学生成绩类Score,描述学生成绩的私有数据成员为学号(No)、姓名(Name[8])、数学(Math)、物理(Phi)、数据结构(Data)、总分(Sum)。定义能输入学生成绩的公有成员函数Input(),能计算学生总分的成员函数Sum(),能显示学生成绩的成员函数Show()。在主函数中用Score类定义学生成绩对象数组s[5]。用Input()输入学生成绩,用Sum()计算每个学生的总分,最后用Show()显示每个学生的成绩。

解:

# include

# include

class Score

{ private:

int No;

char Name[8];

float Math,Phi,Data,Sum;

public:

void Input(int no,char name[],float math,float phi,float data)

{ No=no;

strcpy(Name,name);

Math=math;

Phi=phi;

Data=data;

}

void Output(int &no,char name[],float &math,float &phi,float &data,float

&sum)

{ no=No;

strcpy(name,Name);

math=Math;

phi=Phi;

data=Data;

sum=Sum;

}

void Summation(void)

{ Sum=Math+Phi+Data;}

void Show()

{ cout<

cout<

}

};

void main(void)

{ int i,no;

char name[8];

float math,phi,data;

Score s[5];

cout<<"Input 5 student data"<<'\n';

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

{

cin>>no>>name>>math>>phi>>data;

s[i].Input(no,name,math,phi,data);

s[i].Summation();

}

cout<<"学号姓名数学物理数据结构总分\n";

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

s[i].Show();

}

例11、定义一个复数类Complex,复数的实部Real与虚部Image定义为私有数据成员。用复数类定义两个复数对象c1、c2,用构造函数将c1初始化为

c1=10+20i ,将c2初始化为c2=0+0i。

然后将c1的值赋给c2。最后用公有成员函数Dispaly()显示复数c1与c2 的内容。

解:

相关主题
相关文档 最新文档