1、抽象：
是对具体对象（问题）进行概括，抽出这一类对象的公共性质并加以描述的过程。
1.1 先注意问题的本质描述，其次是实现过程和细节；
1.2 数据抽象：描述某类对象的属性或状态（对象相互区别的物理量）；
1.3 代码抽象：描述某类对象共有的行为特征和具体功能；
1.4 抽象的实现：类的声明。
例如：
钟表抽象：
数据抽象 int hour; int minute; int second;
代码抽象 settime(); showtime();
抽象实现
class clock{//钟表类
public://在外界可以访问的，相当于钟表外面可以操作的部分，即接口
void settime(int newh, int newm, int news);
void showtime();//成员函数
private://在类外不能直接操作的，封装的部分，相当于钟表的内部
int hour, int minute, int second;//成员数据};
2、封装：
将抽象出来的数据成员、代码成员相结合，将它们视为一个整体。
2.1 目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只需要通过外部接口，以特定的访问权限来使用类的成员。
2.2 实现封装：类声明中的{}。
3、继承与派生：
允许程序员在保持原有类的特性的基础上进行更具体的说明，通过声明派生类来实现。
4、类的多态性：
同一名称不同功能，达到行为标识的统一，减少程序中标识符的个数，通过重载函数和虚函数来实现。
5、类的声明：
class 类名称{
public: 公有成员（外部接口），任何外部函数都可以访问公有类型的数据和函数；
private:私有成员，只允许本类中的函数访问；
protected:保护性成员，与私有成员类似，差别在于继承与派生时对派生类的影响不同。}
#include<iostream>
using namespace std;
class Clock //时钟类的声明
{
public: //外部接口
//公有成员函数，在类中声明原型，可以在类外给出实现，并在函数名前使用类名加以限制，也可在类内给出，形成内联成员函数,
//允许声明重载函数和带默认形参值的函数
void SetTime(int NewH=0, int NewM=0, int NewS=0);
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; //定义类对象即类类型的变量：myClock，
cout<<"First time set and output:"<<endl;
myClock.SetTime(); //设置时间为默认值，在类外访问public成员使用 对象员.成员名
myClock.ShowTime(); //显示时间
cout<<"Second time set and output:"<<endl;
myClock.SetTime(8,30,30); //设置时间为8：30：30
myClock.ShowTime(); //显示时间
}
6、构造函数：
构造函数的作用是在对象被创建时使用特定的值构造对象，或者说将对象初始化为一个特定的状态。在对象创建时由系统自动调用。如果在程序中没有声明构造函数，则系统自动产生一个默认形式的构造函数，构造函数可以使内联函数、重载函数和带默认形参值的函数，构造函数名与类名一致，没有返回值且不用void。
思考：
当我们声明整型数据时，int i=0;我们给i赋初值0。同样我们声明类的对象的时候也应该可以赋给初值，构造函数就是类对象赋初值的规则。
class Clock
{
public:
Clock(int NewH,int NewM,int NewS);//构造函数
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;
}
建立对象时构造函数的作用：
int main()
{
Clock c(0,0,0); //隐含调用构造函数，将初始值作为实参。
c.ShowTime();
}
7、拷贝构造函数和析构函数：
析构函数
析构函数是一种特殊的成员函数，除具有一般成员函数的特性外，还具有如下特性：
1）、析构函数的函数名必须与其类名相同，不能指定返回类型，也不能使用void。为了能与构造函数相区别，要在函数名前加~(波浪符)；
2）、析构函数没有参数，一个类中只能拥有一个析构函数，所以析构函数不能重载。定义格式为： ~类名(){ 函数体 } ；
3）、如果程序员没有定义类的析构函数，系统会自动为类创建一个默认析构函数，形式为： ~类名(){ }；
4）、通常为public类型，系统在撤消对象时，自动调用析构函数。也允许显式调用；
5）、用delete运算符删除对象时也会自动调用析构函数 。
概念：用一个已有的对象来初始化一个被创建的同类对象，是一种特殊的成员函数。
声明的一般格式： 类名(类名 & 对象名）；
利用拷贝构造函数可以实现同类对象的数据传递, 即对象的“克隆”。(注意：与对象赋值的不同) (相对于拷贝构造函数，前面介绍的构造函数被称为普通构造函数)
拷贝构造函数的性质 ：
1）、函数名必须与类名相同，并且不指定返回类型；
2）、只有一个参数，是同类的对象的引用；
3）、每一个类中都必须有一个拷贝构造函数。如果类中没有声明拷贝构造函数，编译器就会自动生成一个具有上述形式的公有的拷贝构造函数。
拷贝构造函数被调用的场景:
1）、声明时赋值 Student s1 = s;
2）、作为参数传入，实参给形参赋值 func(s);
3）、作为函数返回值返回，给变量初始化赋值 Student s1 = func(s);
浅拷贝与深拷贝
如果在类的定义里没有提供拷贝构造函数，C++会提供一个默认的拷贝构造函数； 默认拷贝构造函数的拷贝方式是各成员逐一复制，这称为是浅拷贝； 在某些情况下，浅拷贝会产生问题，例如：当一个类在它的构造函数动态分配了内存资源，浅拷贝只会复制该资源的地址，而不会为新建的对象重新分配一个资源，因此，会出现多个对象指向同一个堆空间的地址的现象。
应用举例
一圆形游泳池如图所示，现在需在其周围建一圆型过道，并在其四周围上栅栏。栅栏价格为35元/米，过道造价为20元/平方米。过道宽度为3米，游泳池半径由键盘输入。要求编程计算并输出过道和栅栏的造价。
#include <iostream>
using namespace std;
const float PI = (float)3.14159; //给出p的值
const float FencePrice = 35.; //栅栏的单价
const float ConcretePrice = 20.; //过道水泥单价
class Circle //声明类Circle 及其数据和方法
{
public: //外部接口
Circle(float r); //构造函数
float Circumference(); //计算圆周长
float Area(); //计算圆面积
private: //私有数据成员
float radius;
};
// 类的实现
Circle::Circle(float r) { radius=r; } // 构造函数初始化数据成员radius
float Circle::Circumference() // 计算圆的周长
{
return 2 * PI * radius;
}
float Circle::Area() // 计算圆的面积
{
return PI * radius * radius;
}
//主函数实现
void main ()
{
float radius;
float FenceCost, ConcreteCost;
cout << "Enter the radius of the pool: "; // 提示用户输入半径
cin >> radius;
Circle Pool(radius); // 声明Circle 对象
Circle PoolRim(radius + 3);
// 计算栅栏造价并输出
FenceCost = PoolRim.Circumference() * FencePrice;
cout << "Fencing Cost is ￥" << FenceCost << endl;
// 计算过道造价并输出
ConcreteCost = (PoolRim.Area() - Pool.Area())*ConcretePrice;
cout << "Concrete Cost is ￥" << ConcreteCost << endl;
}
运行结果
Enter the radius of the pool: 10
Fencing Cost is ￥2858.85
Concrete Cost is ￥4335.39
8、组合类中的成员数据时另一个类的对象，可以在已有抽象的基础上实现更复杂的抽象。
类的数据成员可以是数据，当然可以是类的对象，这就是类的组合。
class Point
{ private:
float x,y; //点的坐标
public:
Point(float h,float v); //构造函数
float GetX(void); //取X坐标
float GetY(void); //取Y坐标
void Draw(void); //在(x,y)处画点
};
//...函数的实现略
class Line
{
private:
Point p1,p2; //线段的两个端点，用点类的对象作为线类的数据成员。
public:
Line(Point a,Point b); //构造函数，其初始值是点类的对象。
Void Draw(void); //画出线段
};
//...函数的实现略
类组合构造函数不仅需要对本类的基本类型成员数据赋初值，也要对对象成员初始化，声明形式：
类名：：类名（对象成员所需形参，本类成员形参）：对象1（参数），对象2（参数），……{本类初始化}
class Part //部件类
{
public:
Part();
Part(int i);
~Part();
void Print();
private:
int val;
};
class Whole
{
public:
Whole();
Whole(int i,int j,int k);
~Whole();
void Print();
private:
Part one;
Part two;
int date;
};
Whole::Whole()
{
date=0;
}
Whole::Whole(int i,int j,int k):
two(i),one(j),date(k)
{}
类要先声明后使用，但是如果要在声明之前引用一个类（当两个类之间相互引用的时候），就需要事先说明。比如说：
class B; //前向引用声明class A
{ public:
void f(B b);
};
class B
{ public:
void g(A a);
};
class Fred;//前向引用声明 ，仅仅声明B是一个类，并没有声明其任何对象，所以也不能再完整声明B之前使用其对象
class Barney {
public:
void method()
{
x->yabbaDabbaDo(); //错误：Fred类的对象在定义之前被使用
}
private:
Fred* x;//正确，经过前向引用声明，可以声明Fred类的对象指针
};
class Fred {
public:
void yabbaDabbaDo();
private:
Barney* y;
};