类
class Box
{
public:
double length; // 盒子的长度
double breadth; // 盒子的宽度
double height; // 盒子的高度
};
类成员的作用域：
public：公共成员。访问权限：外部、子类、本身
protected：受保护成员。访问权限：子类、本身
private：私有成员。访问权限：本身
构造函数
跟其他语言一样，使用类名作为函数名，无返回值，可以有参数。
#include <iostream>
using namespace std;
class Line
{
public:
void setLength( double len );
double getLength( void );
Line(); // 这是构造函数
private:
double length;
};
// 成员函数定义，包括构造函数
Line::Line(void)
{
cout << "Object is being created" << endl;
}
void Line::setLength( double len )
{
length = len;
}
double Line::getLength( void )
{
return length;
}
// 程序的主函数
int main( )
{
Line line;
// 设置长度
line.setLength(6.0);
cout << "Length of line : " << line.getLength() <<endl;
return 0;
}
如果是带参数的构造函数，可以使用初始化列表：
Line::Line( double len): length(len)
{
cout << "Object is being created, length = " << len << endl;
}
上面的语法等同于如下语法：
Line::Line( double len)
{
cout << "Object is being created, length = " << len << endl;
length = len;
}
如果有多个参数，中间用逗号隔开：
Line::Line( double len): length(len), para02(var02)
{
cout << "Object is being created, length = " << len << endl;
}
另外，初始化列表并不是构造函数专用的，类的普通成员函数也可以使用。
析构函数
这个挺新鲜的，作用跟构造函数正好相反，在对象被销毁的时候执行。
无返回值，无参数，所以无法重载，一个类只能有一个析构函数
函数名也是与类同名，只需要在前面加一个波浪线前桌：~
在析构函数中，主要用来销毁在构造函数或成员方法里 new 出来的对象或指针，最常用的就是：delete obj
#include <stdio.h>
#include <iostream>
#include <vector>
using namespace std;
struct CP
{
int a;
int b;
};
class TEST
{
public:
CP* compound;
int num;
TEST(){
compound = new CP();
cout << "create a new TEST obj" << endl;
};
~TEST(){
cout << "delete TEST obj" << endl;
delete compound;
};
};
类的继承
跟JAVA不同，C++中允许一个类继承多个父类：
#include <iostream>
using namespace std;
// 基类 Shape
class Shape
{
public:
void setWidth(int w)
{
width = w;
}
void setHeight(int h)
{
height = h;
}
protected:
int width;
int height;
};
// 基类 PaintCost
class PaintCost
{
public:
int getCost(int area)
{
return area * 70;
}
};
// 派生类
class Rectangle: public Shape, public PaintCost
{
public:
int getArea()
{
return (width * height);
}
};
int main(void)
{
Rectangle Rect;
int area;
Rect.setWidth(5);
Rect.setHeight(7);
area = Rect.getArea();
// 输出对象的面积
cout << "Total area: " << Rect.getArea() << endl;
// 输出总花费
cout << "Total paint cost: $" << Rect.getCost(area) << endl;
return 0;
}
输出：
Total area: 35
Total paint cost: $2450
虚函数
这个不太好理解，只能按照别人的描述硬性记忆：在类的成员函数前面加 virtual 表示该成员函数为虚函数。
虚函数在C++中的作用不低，很多官方的源码中都存在大量的虚函数
目前位置能理解的作用包括：
1、允许用基类的指针来调用子类的这个函数：
class A
{
public:
virtual void foo()
{
cout<<"A::foo() is called"<<endl;
}
};
class B : public A
{
public:
void foo()
{
cout<<"B::foo() is called"<<endl;
}
};
int main(void)
{
A *a = new B();
a->foo(); // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!
return 0;
}
2、通过“纯虚函数”实现抽象类
虚函数：
virtual ReturnType funtion1(params...);
虚函数在基类中可以有默认实现，派生类也可以覆盖；
但如果在基类中没有默认实现，那么派生类必须具体实现。
纯虚函数：
virtual ReturnType funtion1(params...)=0;
在虚函数声明的后面加“=0”就表示这是一个纯虚函数，含有纯虚函数的类成为抽象类。
纯虚函数用来规范派生类的行为，即接口。派生类中必须对这个纯虚函数进行具体实现。
抽象类不能定义实例，但可以声明指向实现该抽象类的具体类的指针或引用。
对虚函数的理解，有一个很好的比方：
比如你有个游戏，里面有个含有纯虚函数 [攻击] 的抽象类 [怪物]，然后有三个派生子类 [狼]、[蜘蛛]、[蛇] 都继承了 [怪物]，并且都各自实现了自己独特的 [攻击] 函数。
那在出现怪物的时候就可以定义一个 虚基类指针数组，把各种怪物的指针给它，然后迭代循环的时候直接：怪物[i]->攻击() 攻击玩家就行了
Monster *pMonster[3];
pMonster[0] = new Wolf(); //初始化一匹狼
pMonster[1] = new Spider(); //初始化一只蜘蛛
pMonster[2] = new Snake(); //初始化一条蛇
for(int i=0; i<3; i++){
pMonster[i] -> attack(); //攻击
}
双冒号（::）
1、调用 namespace 中的成员时，需要用 ::
2、在类的外部定义成员函数时，需要用::
3、区别两个类中同名的成员变量或者函数时，需要用::
4、在成员函数内部调用同名的全局变量时，需要用::
5、调用类的静态成员函数时，可以用::
宠辱不惊，看庭前花开花落；去留无意，望天上云卷云舒
