什么是类与对象？
一切事物都可以是对象，其可以是有形的，也可以是抽象的。
相似的对象可以构成一种类型。
面向对象的程序设计是将抽象后的数据和函数封装在一起，构成C++的类。
例：时钟类
#include<iostream>
using namespace std;
class Clock //创建一个时钟类
{
public: //外部接口，公共成员函数
void setTime(int newH, int newM, int newS);
void showTime();
private: //私有函数
int hour,minute,second; //定义时不支持初始化
};
void Clock::setTime(int newH, int newM, int newS)
{
hour=newH;
minute=newM;
second=newS;
}
inline void Clock::showTime() //函数短的建议用内联函数
{
cout<<hour<<":"<<minute<<":"<<second<<endl;
}
int main()
{
Clock myclock; //定义了Clock类的对象myclock
myclock.setTime(8,9,10);
myclock.showTime();
return 0;
}
运行结果：8，9，10
class类似于C中的结构体static；
相同点是都是将一些数据封装成一个新的数据类型。
不同点是类内的数据成员拥有不同的访问权限，结构体是公开的。
如何对类内数据初始化？
当我们创建一个类的变量时，如果未设置初始化值，该变量里的数据是随机数。
因此我们在公共成员函数有专门用来设置初始化值的函数，构造函数。
class Clock
{
public:
Clock(int newH, int newM, int newS); // 构造函数
Clock() //构造函数
{
hour=0;
minute=0;
second=0;
}
void setTime(int newH, int newM, int newS);
void showTime();
private:
int hour,minute,second;
};
Clock::Clock(int newH, int newM, int newS)
{
hour=newH;
minute=newM;
second=newS;
}这里构造函数有二种重载形式，有参数的，和无参数的。
Clock m1；
Clock m2(2,3,4);
我们定义一个新变量时，便可以有二种选择
无参数时，变量里的数据都为0；
有参数时，数据为参数的值；
类的变量可以互相赋值么？
可以的。这点和结构体变量一样，相同的结构体类型的变量可以互相赋值，相同类的对象之间可以相互赋值。
当对象在内存中释放时，我们可以进行扫尾工作
#include<iostream>
using namespace std;
class Clock
{
public:
Clock(int newH, int newM, int newS); //构造函数
~Clock() //析造函数，当对象在内存中释放时运行该函数
{
cout<<"hello world"<<endl;
}
private:
int hour,minute,second;
};
Clock::Clock(int newH, int newM, int newS)
{
hour=newH;
minute=newM;
second=newS;
}
int main()
{
Clock myclock(9,9,0);
return 0;
}
运行结果
hello world
当不同类相互引用怎么办？
与处理不同函数之间相互引用类似，在定义前声明
class B; //前向引用声明
class A
{
public:
void f(B b);
}
class B
{
public:
void q(A a);
}
这里我们要注意一点，当只声明为定义时，不能定义该类型的对象，也不能在内联函数里使用该类型对象
class B;
class A
{
public:
B b; //错误
}
class B
{
public:
void q(A a);
}