C++入门学习：类与对象：基础篇

类与对象

理解：
（作用上）
类就是实体在计算机世界的存在，
数据表示实体的属性，
实体的行为则表示为数据的处理函数，
只要是同类型的实体，都可以用一个类来处理；

（使用上）
一个类相当于一个用户自定义的数据类型，
有自己的类型变量，即对象；
例如：int a;
类相当于int 对象相当于a；

通过实例来理解（基本）

//以时钟设置时间为例

#include <iostream>
using namespace std;
class Myclock
{
    int hp, mp, sp;
public:
    Myclock(int h = 0, int m = 0, int s = 0);//使用默认值，具有兼容性
    Myclock(Myclock& c);//复制构造函数
    ~Myclock();//析构函数的声明
    void setTime(int h, int m, int s)
    {
        hp = h; mp = m; sp = s;
    }
    void showTime();
};

Myclock::Myclock(int h, int m, int s) :hp(h), mp(m), sp(s) {}

Myclock::Myclock(Myclock& c)
{
    hp = c.hp; mp = c.mp; sp = c.sp;
}

Myclock::~Myclock()
{
    cout << "和你分别在时刻";
    showTime();
}

void Myclock::showTime()
{
    cout << hp << ":" << mp << ":" << sp << endl;
}

int main()
{
    Myclock clock1(12, 30, 0);//定义对象clock1，并用括号内的数据初始化
    cout << "clock1:      ";
    clock1.showTime();
    //Myclock clock2(clock1);//定义对象clock2，并用对象clock1初始化
    Myclock clock2;
    clock2 = clock1;
    cout << "clock2:      ";
    clock2.showTime();
    Myclock clock3;
    clock3.setTime(6, 12, 30);
    cout << "clock3:      ";
    clock3.showTime();
    return 0;
}

类

定义类

class 类名
{
private:成员表1;
public:成员表2;
protected:成员表3;
};

类的成员包括数据成员和函数成员
数据成员定义在类体中，形式为：
数据类型 成员名；即上例中的int hp, mp, sp;

函数成员有两种定义方法
①直接在类体中完成函数体的实现，即上例中的

void setTime(int h, int m, int s)
    {
        hp = h; mp = m; sp = s;
    }

②先在类体中进行函数原型声明，再在类外进行函数体的实现。
类外部定义成员函数时必须在成员函数名前给出所属类名，并使用作用域标识符“::”联接。即：

返回值类型 类名::成员函数名 （形参表）
{函数体}

即上例中的：
void Myclock::showTime()
{
    cout << hp << ":" << mp << ":" << sp << endl;
}

理解：
类将数据与数据的处理函数封装在一起，
因此在定义函数成员时，如果将类看作一个封闭的域，
类的数据成员就相当于域中的全局变量，
可以被类的成员函数直接使用、共享，
故上例中函数成员setTime()和showTime()直接使用数据成员hp、mp和sp，showTime()不需要形参；

访问限定符

说明：

1. 数据成员通常被制定为private，函数成员指定为public
2. 如果在类体起点没有给出成员的访问限定符，默认为private
3. 如果某个成员函数并不准备被外界调用，而是只被本类中的成员函数所调用，则应将其指定为private

对象的定义与使用

类数据类型的变量被称为“对象”，
定义格式为：类名 对象名；
即上例中的Myclock clock1(12, 30, 0); //此处涉及到利用构造函数初始化
类名就是数据类型，对象名就是变量标识符；
使用格式为：对象名.成员名；
即上例中的clock1.showTime();

使用对象实质上是通过调用对象的成员函数来完成程序功能，
这种调用属于类外访问，受到访问限定符的约束，
只能使用public属性的成员。即上例中，
需得调用函数修改时间clock3.setTime(6, 12, 30);，
而不能以clock3.hp=6;clock3.mp=12;clock3.sp=30;“对象名.成员名”的方式直接外部访问；

构造函数

构造函数定义

作用：对对象进行初始化；
说明：

类定义是未提供构造函数，
则系统会调用默认构造函数以完成对象的创建流程要求，
即如Myclock();//默认构造函数
但一旦类定义了构造函数，
C++编译器就不会自动生成默认的构造函数以供调用，
即如上例

//若类中只定义了此构造函数
  Myclock(int h,int m,int s)//无返回类型说明
  {hp=h;mp=m;sp=s;}
//则main()函数中定义对象时不带形参会报错，因为此时无默认构造函数
  Myclock clock3;

故为了匹配不同对象的创建需求，
除了提供多个构造函数之外，
可以在构造函数中使用默认形参，
即如上例：Myclock(int h = 0, int m = 0, int s = 0);//使用默认值，具有兼容性

语法特点：

//两种构造函数定义方式作用相同
Myclock::Myclock(int h, int m, int s) :hp(h), mp(m), sp(s) {}
Myclock::Myclock(int h, int m, int s) 
{ hp=h;mp=m;sp=s; }

备注：会有单独的一篇详细叙述构造函数，敬请期待。

复制构造函数

理解：属于构造函数，形参为本类对象的引用，理解为用对象对对象进行初始化，即如上例Myclock clock2(clock1);//定义对象clock2，并用对象clock1对clock2初始化

格式：

类名（类名 &对象名）;//复制构造函数原型声明
类名::类名（类名 &对象名）{函数体;}//复制构造函数的实现

说明：

注意：

关于定义&初始化的理解

Myclock clock1;
clock1(12,30,0);

Myclock clock2;
clock2(clock1);

上述两种写法都是错误的，
在这里并不等同于int a; a=0;
在执行语句Myclock clock1/2时已经初始化了，
此后只能通过setTime()函数去修改时间值；

关于对象性质的理解

对象和普通变量一样， 同类对象之间可以相互赋值，
即如上例中

    //Myclock clock2(clock1);//定义对象clock2，并用对象clock1初始化
    Myclock clock2;
    clock2 = clock1;

赋值语句clock2 = clock1;将对象clock1的数据成员一一复制给clock2中的同名数据成员，
因此对象clock2的时间由0:0:0（默认值）改变为12:30:0，
这一复制过程是C++赋值运算符“=”的运算结果，
和Myclock类的复制构造函数无关。

应用：

//用类的一个对象去初始化该类的另一个对象，
//系统自动调用复制构造函数实现复制赋值
int main()
{
    Myclock Beijing(11, 45, 0);
    Myclock Wuhan(Beijing);//复制构造函数被调用
    return 0;
}

//函数的形参为对象，为了调用函数，系统会创建临时形参对象，
//并将实参对象的值复制给形参对象，系统自动调用复制构造函数完成该过程
void showclock(Myclock c1)
{
    c1.showTime();
}
int main()
{
    Myclock Beijing(11, 45, 0);
    showclock(Beijing);
    return 0;
}

//函数返回值为对象，系统自动调用复制构造函数，
//但是流程为 A→全局变量（临时对象）→B ，
//在“A→全局变量（临时对象）”这一过程中调用了复制构造函数，
//而在“全局变量（临时对象）→B”这一过程中未调用
Myclock setTime()
{
    Myclock A(13, 0, 0);
    return A;
}
int main()
{
    Myclock clock1;
    clock1 = setTime();
    return 0;
}

析构函数

说明：

运行结果分析：

对象的析构顺序和构建顺序相反，
由于程序先创建对象clock1，再创建对象clock2和clock3，
所以先析构对象clock3，再析构clock2，最后析构clock1