C++学习(二) 类和对象、类的组合

1、类

1.1、类的声明

包括数据和函数，分别称为数据成员和成员函数。
按照访问权限分可以分为公有、保护、私有3种。

公有：public，完全公开。
保护：protected，半隐蔽。
私有：private，完全隐蔽。

关键字class后面跟类的名字，花括号内是类体，最后以”;”结束。

class score{
 public:                       //公有
   void setscore(int a,int b); //公有成员函数 
   void showscore();           //公有成员函数
 private:                      //私有 
   int mid_exam;               //私有成员函数 
   int fin_exam;               //私有成员函数 
};

public 类的公有部分 ：是类与外界的接口，来自类外部的访问需要通过这种接口来进行。例如，在类score中声明了setscore()和showscore()函数,在类的外部想要对score内的数据进行操作，只能通过这两个函数来实现。

private 类的私有部分 ：只能由本类的成员函数访问，类外部的任何访问都是非法的。例如，在类score中声明了只能由内部成员函数访问的数据成员, mid_exam和fin_exam 。

protected 类的保护部分 ：可以由本类的成员函数访问，也可以由本类的派生类的成员函数访问，而类外的任何访问都是违法的。

1.2、说明

(1)、类声明中的三个部分至少要有一个。一般情况下，一个类的数据成员应该声明为私有成员，成员函数声明为公有成员。使数据得到有效保护。

(2)、类声明中的private、protected、public三个关键词可以按任意顺序出现任意次。

(3)、不能在类的声明中给数据成员赋初值。C++规定，只有在类的对象定义之后才能给数据成员赋初值。

1.3、成员函数的定义

在类外定义成员函数时，必须在成员函数名之前加上类名，在类名和函数名之间应加上作用域运算符“::”，用于声明这个成员函数是属于哪个类的。

void score::setscore(int a,int b)
{......}      //函数内容
void score::showscore()
{......}     //函数内容

2、对象

2.1、定义

定义对象，在声明类之后，在使用时再定义对象。

class score{
......
}；
...
int main（）
{
   score s1,s2;//定义对象s1,s2
   ...
}

2.2、访问

对象中成员函数的访问
只要是公有的，不论是数据成员，还是成员函数，在类的外部可以通过类的对象进行访问。
形式一般是：

   对象名.数据成员名

或者

   对象名.成员函数名[(参数表)]

“.”为对象选择符，简称点运算符。

若定义是指向此对象的指针变量，则访问此对象的成员时，不能用“.”操作符，而应该使用“->”操作符。

int main()
{
   score s1,*ptr;
   ptr=&s1;
   ptr->setscore(10,11);
   ptr->showscore();
   return 0;
}

2.3、赋值

对象赋值语句一般形式为：
对象名1=对象名2；

s3=s1；

示例代码如下：

#include <iostream>
using namespace std;
class score{
 public:                       //公有
   void setscore(int a,int b); //公有成员函数 
   void showscore();           //公有成员函数
 private:                      //私有 
   int mid_exam;               //私有成员函数 
   int fin_exam;               //私有成员函数 
};
void score::setscore(int a,int b)
{
 mid_exam=a;
 fin_exam=b;
 } 
 void score::showscore()
 {
  cout<<mid_exam<<"  "<<fin_exam<<endl;
 }
 int main()
 {
  score s1,s2,s3,s4,*ptr;
  s1.setscore(10,11);         //调用setscore函数 
  s2.setscore(20,21);
  s3=s1;                      //把s1赋值给s3 
  s1.showscore();             //调用showscore函数 
  s2.showscore();
  s3.showscore();
  ptr=&s4;                    //指针变量 
  ptr->setscore(30,31);
  ptr->showscore();
  return 0;
 }

运行结果：

10  11
20  21
10  11
30  31

3、类的组合

3.1、含义

在一个类中内嵌另一个类的对象作为数据成员。该内嵌对象成为对象成员，又称子对象。

例如：

class Y{
...
}；
class X{
Y y;      //类 Y的对象 y为类 X的对象成员
...
};

3.2、定义

(1)、当创建类的对象时，如果这个类具有内嵌的对象成员，那么内嵌对象成员也将被自动创建。

(2)、因此，在创建对象时既要对本类的基本数据成员初始化，又要对内嵌的对象成员进行初始化。

(3)、含有对象成员的类的构造函数和不含对象成员的构造函数 有所不同。

class X{
 类名 1 对象成员名 1；
 ...
 类名 i 对象成员名 i；
 ...
 类名 n 对象成员名 n；
 }；
 //类 X的构造函数的定义形势如下：
X::X(形参表0):对象成员名 1(形参表1),...,对象成员名 i(形参表i),...,对象成员名 n(形参表n)
{
     类 X 的结构函数体
}

在调用构造函数X::X()时，各对象成员在类声明中的顺序依次调用它们的构造函数，对这些对象初始化，最后，再执行X::X()的构造函数体初始化类中的其他成员。

析构函数的调用顺序与构造函数的调用顺序相反。

3.3、说明

(1)、声明一个含有对象成员的类，首先要创建各成员对象。

(2)、类的对象在调用构造函数进行初始化的同时，也要对对象成员进行初始化，因为它也是属于此类成员。

示例代码如下：

#include<iostream>
using namespace std;
class X{
	public:
		X(int m,int n)
		{
			a=m;b=n;         //类 X的构造函数 
		}
		void show()          //声明并定义类 X中的show函数 
		{
			cout<<"a="<<a<<endl;
			cout<<"b="<<b<<endl;
		 } 
	private:
		int a;int b;
}; 
class Y{
	public:
		Y(int m,int n,int o):x(m,n)  //类 Y的构造函数,含有初始化列表 
		{                            //用于对对象 x进行初始化 
			c=o;
		 } 
		 void show()                 //声明并定义类 Y中的 show函数 
		 {
		 	x.show();                //调用类 X中的 show函数 
		 	cout<<"c="<<c<<endl;
		  } 
	private:
	X x;                             //类 X中的对象 x 
	int c;  
};  
int main()
{
	Y a(12,34,56);
	a.show();
	return 0;
 } 

运行结果：

a=12
b=34
c=56