类和对象的基础4——静态成员和常成员

一、静态成员

1、概念：一个类可以创建多个对象，这些对象之间是相对独立的，如果想实现对象之间的数据共享，就得使用静态成员，静态成员属于所有对象，并不属于某个对象，静态成员                     分为静态数据成员和静态函数成员。

2、声明格式：

        （1）若声明静态数据：static   数据类型   数据名；         eg：static  int  speed；

（2）若声明静态函数：static  函数返回值类型  函数名（参数列表）；       eg：static  double  average()；

3、初始化：静态成员的初始化是在类外进行的。

4、例子：利用静态函数和静态变量计算各个对象的平均值。

<pre name="code" class="cpp">/*************************************
时间：2016年9月30日15:29:09
功能：用静态函数和静态成员实现求平均值
**************************************/
#include <iostream>
using namespace std;

//类的声明
class Student
{
public:
	int math,chinese;
	int number;
	char name[10];
	Student(char *pn,int num,int c,int m);
	double person_average();          //个人平均成绩
	static double global_chinese_average();   //整体各科平均成绩，由于是求各个对象之间的平均成绩，用静态函数实现
	static double global_math_average();   //整体各科平均成绩，由于是求各个对象之间的平均成绩，用静态函数实现
	void Addtosum();
private:
	static int chinese_sum,math_sum,count;          //静态变量，静态函数只能使用静态变量
	static double math_average,chinese_average;     //静态变量，静态函数只能使用静态变量
};

int Student::count = 0;                   //静态变量的初始化只能在类外进行
int Student::chinese_sum = 0;
int Student::math_sum = 0;
double Student::math_average = 0;
double Student::chinese_average = 0;

//类的实现
Student::Student(char *pn,int num,int c,int m)
{
	strcpy(name,pn);
	number = num;
	chinese = c;
	math = m;
}

double Student::person_average()
{
	int average_score = 0;
	average_score = (math + chinese)*1.0/2;
	cout<<"你的平均成绩是："<<average_score<<endl;
	return average_score;
}

void Student::Addtosum()
{
	chinese_sum += chinese;
	math_sum += math;
	count = count + 1;
}

double Student::global_chinese_average()
{
	chinese_average = chinese_sum*1.0/count;
	return chinese_average;
}

double Student::global_math_average()
{
	math_average = math_sum*1.0/count;
	return math_average;
}


void main()
{
	Student stu[3] = {Student("king",001,80,80),Student("hu",002,90,90),Student("ling",003,100,100)};
	int check_num;
	double GPA;    //个体平均成绩
	
	//当输入0时表示退出
	while(cout<<"请输入你的学号：" && cin>>check_num && check_num != 0)
	{
		switch(check_num)
		{
			case 001: GPA = stu[0].person_average();break;
			case 002: GPA = stu[1].person_average();break;
			case 003: GPA = stu[2].person_average();break;
			default:break;
		}
		for(int i=0;i<3;i++)
		{
			stu[i].Addtosum();
		}

		cout<<"全班语文平均成绩："<<Student::global_chinese_average()<<"  "<<"全班数学平均成绩："<<Student::global_math_average()<<endl<<endl;
	}
}

注：这个程序还是存在不足，在求所有对象的语文平均成绩和数学平均成绩时，自己用了两个函数来分别返回了其平均值，代码比较繁琐，应该可以用指针来解决这一问题，直接修改指定内存区域存放的平均值更好。

二、常成员

1、概念：常成员分为常数据成员和常函数成员，是指初始化后不能被改变的成员变量。

2、声明格式：

常数据成员：const<类型> <常数据类型名>；                                 eg：constint speed；  //定义常数据成员

常函数成员：<返回值类型><成员函数名>（参数列表） const；               eg：void   print()    const；

3、初始化：

（1）常数据成员初始化

   通过采用构造函数的成员初始化列表来实现，构造函数初始化的列表如下：

<类名>：：<构造函数名> （参数列表）

：<成员初始化列表>

{

//函数体

}

                   eg： Car：：Car（int s）  //构造函数

    ：speed(s)          //初始化成员列表

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">			</span><span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">    {</span>

//函数体

    }

      （2）常成员函数的初始化

在声明和函数实现部分的最后都得加上const，但需要注意的是常对象只能调用常成员函数，这里说的常对象是指对象的数据成员的值在对象被调用时不可改变的，也                   就是说常对象的数据成员值具有“只读属性”。

4、例子：常成员函数以及常成员数据的使用。

/********************************************
时间：2016年10月1日12:40:22
功能：定义常对象和非常对象，用函数重载验证了
	  常对象只能调用常成员函数，并学会使用常
	  数据成员以及其初始化
*********************************************/
#include <iostream>
using namespace std;

class calendar
{
public:
	calendar(int y,int m,int d);
	void print();         //非常成员函数
	void print() const;   //定义常成员函数
	const char writer;    //定义常成员变量
	
private:
	int year;
	int month;
	int day;	
};

calendar::calendar(int y,int m,int d)   //构造函数
:writer('k')          //常成员初始化列表
{
	year = y;
	month = m;
	day = d;
}

void calendar::print()    //成员函数实现
{
	cout<<"in non-const print function:"<<endl;
	cout<<year<<"--"<<month<<"--"<<day<<endl;
}

void calendar::print() const   //常成员函数实现
{
	cout<<"in const print function:"<<endl;
	cout<<year<<"--"<<month<<"--"<<day<<endl;

}


void main()
{
	calendar c1(2016,10,1);     //普通对象
	const calendar c2(2016,10,1);  //常对象
	c1.print();          //实现函数重载，选择非常成员函数
	c2.print();          //常成员函数
	cout<<c1.writer<<endl;

}