类与对象（面向对象）
- C++类定义
类定义是以关键字class 开头，后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号。例：
class Box
{
public:
double length; // 盒子的长
double breadth; // 盒子的宽
double height; // 盒子的高
};
关键字 public 确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。也可以指定类的成员为private或protected.
定义 C++对象
声明类的对象，就像声明基本类型的变量一样。例如声明类 Box 的两个对象：
Box Box1; // 声明 Box1，类型为 Box
Box Box2; // 声明 Box2，类型为 Box
对象 Box1 和 Box2 都有它们各自的数据成员。
- 访问数据成员
类的对象的公共数据成员可以使用直接成员访问运算符. 来访问。例如：
#include <iostream>
using namespace std;
class Box
{
public:
double length; // 盒子长度
double breadth; // 盒子宽度
double height; // 盒子高度
};
int main( )
{
Box Box1; // 声明 Box1，类型为 Box
Box Box2; // 声明 Box2，类型为 Box
double volume; // 用于存储体积
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;
Box2.height = 10.0;
Box2.length =12.0;
Box2.breadth = 13.0;
volume = Box1.height * Box1.length * Box1.breadth; // box 1 的体积
cout << "Box1 的体积：" << volume <<endl; // box 2 的体积
volume = Box2.height * Box2.length * Box2.breadth;
cout << "Box2 的体积：" << volume <<endl;
return 0;
}
上面的代码运行时，它会产生下列结果：
Box1 的体积：210
Box2 的体积：1560
- 类与对象
1) 构造函数和析构函数：类的构造函数是一种特殊的函数，在创建一个新的对象时调用。类的析构函数也是一种特殊的函数，在删除所创建的对象时调用。析构函数不能重载
2) C++中的this指针：每个对象都有一个特殊的指针 this，它指向对象本身。
3) C++类的静态成员：类的数据成员和函数成员都可以被声明为静态的。
4) 类成员函数：类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。
例如定义的类 Box，使用成员函数来访问类的成员，而不是直接访问这些类的成员：
成员函数可以定义在类定义内部，或使用 :: 定义。例如：
class Box
{
public:
double length; // 长度
double breadth; // 宽度
double height; // 高度
double getVolume()
{
return length * breadth * height;
}
};
或者：
double Box::getVolume()
{
return length * breadth * height;
}
#include <iostream>
using namespace std;
class Box
{
public:
double length; // 盒子的长度
double breadth; // 盒子的宽度
double height; // 盒子的高度
// 成员函数声明
double getVolume();
void setLength(double l );
void setBreadth( double b);
void setHeight(double h);
};
// 成员函数定义
double Box::getVolume(){return length *breadth* height;}
void Box::setLength(double l){length=l;}
void Box::setBreadth(double b){breadth=b;}
void Box::setHeight(double h){height=h;}
int main( )
{
Box Box1; // 声明 Box1，类型为 Box
Box Box2; // 声明 Box2，类型为 Box
double volume;
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
volume = Box1.getVolume();
cout << "Box1 的体积：" << volume <<endl;
volume= Box2.getVolume();
cout << "Box2 的体积：" << volume <<endl;
return 0;
}
当上面的代码运行时，它会产生下列结果：
Box1 的体积： 210
Box2 的体积： 1560
- 带参数的构造函数
默认的构造函数没有任何参数，如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，如：
#include <iostream>
using namespace std;
class Line
{
public:
void setLength( double len );
double getLength( void );
Line(double len);
private:
double length;
};
// 成员函数定义，包括构造函数
Line::Line( double len)
{
cout << "length = " << len << endl;
length = len;
}
void Line::setLength( double len ){length =len;}
double Line::getLength(){return length;}
int main( )
{
Line line(10.0);
cout << "Length of line : "<< line.getLength() <<endl;
line.setLength(6.0);
cout << "Length of line : " << line.getLength()<<endl;
return 0;
}
当上面的代码运行时，它会产生下列结果：
length = 10
Length of line : 10
Length of line : 6
- 复制构造函数
复制构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。如果在类中没有定义肤质构造函数，编译器会自行定义一个。复制构造函数要求有一个类类型的引用参数。
类名：：类名（const 类名&引用名，…）;
例如：
class A
{ public:
A(int);
A(const A&,int=1);
//…
};
//…
A a（1）；
A b(a,0);
A c=b;
C++ this 指针
在 C++ 中，每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数
#include <iostream>
using namespace std；
class Box
{
public:
// 构造函数定义
Box(double l=2.0, double b=2.0, double h=2.0)
{
length = l;
breadth = b;
height = h;
}
double Volume()
{
return length * breadth * height;
}
int compare(Box box)
{
return this->Volume() > box.Volume();
}
private:
double length；
double breadth;
double height;
};
int main()
{
BoxBox1(3.3, 1.2, 1.5);
Box Box2(8.5, 6.0, 2.0);
if(Box1.compare(Box2))
{
cout << "Box2 is smaller than Box1" <<endl;
}
else
{
cout << "Box2 is equal to or larger than Box1"<<endl;
}
return 0;
}
Box2 is equal to or larger than Box1
C++类的静态成员
使用 static 关键字来把类成员定义为静态的。当声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。
Static静态数据成员：封装性、继承性、多态性。
需要注意的几点：
I. C++的基本框架：
定义类
主函数（包括对象的定义：对象. 成员名
对象只能通过成员使用，不能整体操作）
II. 对象不能定义全局
III. 类成员的访是类
返回值类型 类名：：成员函数
成员函数重点对数据成员做操作
IV. 成员函数有两个作用：
1) 操作数据成员，包括访问和修改在数据成员
2) 协同不同的对象操作（传递信息）
V. 对象成员的访问包括：
1) 圆点访问形式：对象名.共有成员
2) 指针
心得体会：
类与对象是一个新的概念（面向对象），包含了许多新的概念，不同于前段时间的学习的内容（面向过程）。而学习类与对象后我们就有了C++ 程序的基本框架：定义类+ 主函数。而且在写那些代码繁长冗杂的系统时，利用类与对象的内容会时代码显得合理有序一些，需要注意的是由于代码较长而且复杂，需要我们在写程序时每定义完一个类就要调试，调试通过后再写下一个类，最终写出一个较好的程序。