C++使用类和对象
1、 内置函数
程序调用函数时需要一定的时间和空间开销，其执行过程一般如下：
而C++提供了一种高效率的方法，即在编译的时候将所调用函数的代码直接嵌入到主函数中，而不是将流程转出去，这样可以避免函数调用时频繁的转入与转出操作，从而节省过程中“保存现场”和“恢复现场”所需的时间。如下代码：
#include<iostream>
using namespace std;
inline int max(int,int,int);
int main()
{
int i=1,j=2,k=3;
int m=max(i,j,k);
cout<<"max="<<m<<endl;
return 0;
}
inline int max(int a,int b,int c){
if(b>a)
a=b;
if(c>a)
a=c;
return a;
}
内置函数虽然节省了程序的运行时间，但会增加目表函数的长度，这也是不利的，需要综合分析后使用。
2、 成员函数
如下简单案例
#include<iostream>
#include<string>
using namespace std;
class Student{
public:
void display();
void set();
private:
int num;
char sex;
string name;
};
void Student::display()
{
cout<<"num:"<<num<<endl;
cout<<"sex:"<<sex<<endl;
cout<<"name:"<<name<<endl;
}
void Student::set()
{
cin>>num;
cin>>sex;
cin>>name;
}
int main(){
Student stu;
stu.set();
stu.display();
return 0;
}
成员函数在类外定义的时候，必须在函数名前加上类名，予以限定，“::”表示作用域限定符，用它声明函数属于哪个类。
注意：如果函数在类外定义时，系统不会将其认为是加了inline的内置函数，这些成员函数的调用和普通的函数调用相同，这样有利于类的接口和类的实现相分离，利于信息的隐藏。
3、 带参数的构造方法
以一个简单的案例说明：
#include<iostream>
#include<string>
using namespace std;
class Box
{
private:
int height;
int width;
int length;
public:
Box(int,int,int);
int volume();
};
Box::Box(int h,int w,int l){
height=h;
width=w;
length=l;
}
int Box::volume()
{
return height*length*width;
}
int main(){
Box box1(12,25,10);
cout<<"the volume of box1 is "<<box1.volume()<<endl;
return 0;
}
也可以通过参数初始化表对数据成员初始化，将类中的构造方法进行改写，如下：
class Box
{
private:
int height;
int width;
int length;
public:
Box(int h,int w,int l):height(h),width(w),length(l){};
int volume();
};
注意如果类中的数据成员是数组，则应在构造函数体中用语句对其赋值，而不能在参数初始化表中对其初始化。如下案例：
class Student
{private:
int no;
char name[20];
public:
Student(int n,char nam[]):no(n){
strcpy(name,nam);};
void display();
};
void Student::display(){
cout<<no<<" "<<name<<endl;
}
int main()
{
Student stu(1,"郭庆兴");
stu.display();
return 0;
}
或者这样
class Student
{private:
int no;
string name;
public:
Student(int n,string nam):no(n),name(nam){};
void display();
};
4、 构造函数的重载
如下面一个简单的代码案例：
#include<iostream>
#include<string>
using namespace std;
class Box
{
private:
int height;
int width;
int length;
public:
Box();
Box(int h,int w,int l):height(h),width(w),length(l){};
int volume();
};
Box::Box(){
height=10;
width=10;
length=10;
}
int Box::volume()
{
return height*length*width;
}
int main(){
Box box1;
cout<<"the volume of box1 is "<<box1.volume()<<endl;
Box box2(12,25,10);
cout<<"the volume of box1 is "<<box2.volume()<<endl;
return 0;
}
注意：当建立对象使用无参构造函数函数时，要注意语句的书写：
Box box1;
而不能写成：
Box box1(); //错误
以上错误的语句并不是定义Box对象，而是定义一个返回为Box的普通函数。
5、 使用默认参数构造函数
如下案例：
#include<iostream>
#include<string>
using namespace std;
class Box
{
private:
int height;
int width;
int length;
public:
Box(int h=10,int w=10,int len=10):height(h),width(w),length(len){};
int volume();
void display();
};
int Box::volume()
{
return height*length*width;
}
int main(){
Box box1;
cout<<"the volume of box1 is "<<box1.volume()<<endl;
Box box2(12,25);
cout<<"the volume of box2 is "<<box2.volume()<<endl;
Box box3(12,25,30);
cout<<"the volume of box3 is "<<box3.volume()<<endl;
return 0;
}
因此在编写设有默认参数的构造方法的时候，不可以有两个构造方法，如下：
Box(int h=10,int w=10,int len=10);
Box();
这样如果一旦执行“Box box;”，系统就不能分别是以哪个构造方法为基准建立构造函数。
6、 析构函数
析构函数是一个特殊的成员函数，它的名字是类名前面加上“~”符号。在C++中“~”是取反运算符。可以联想到它是与构造函数起相反的作用。析构函数的作用是在撤销对象占用的内存之前，完成一些清理工作。
析构函数不返回任何值，没有函数类型，也没有函数参数。由于没有函数参数，因此它并不能重载，即一个类只能有一个析构函数。
如下案例：
#include<iostream>
#include<string>
using namespace std;
class Student
{private:
int no;
string name;
char sex;
public:
Student(int n,string nam,char s){
no=n;
name=nam;
sex=s;
cout<<"Constructor"<<no<<" called!"<<endl;
}
~Student(){
cout<<"Destructor"<<no<<" called!"<<endl;
}
void display(){
cout<<"no : "<<no<<endl;
cout<<"name : "<<name<<endl;
cout<<"sex : "<<sex<<endl;
}
};
int main()
{
Student stu1(1,"郭庆兴",'m');
stu1.display();
Student stu2(2,"test",'f');
stu2.display();
return 0;
}
结果如图所示：
可知，对于构造函数，程序先执行stu1的构造函数，再去执行stu2的构造函数；而对于析构函数来说，程序先执行stu2的析构函数，再去执行stu1的析构函数，这就十分类似于栈的特性了。对于“同一级别”的构造函数个析构函数是这样的，那么不同“级别”，则不是这样的，这里以局部变量和全局变量来举例。如下代码：
int main()
{
Student stu1(1,"郭庆兴",'m');
stu1.display();
static Student stu2(2,"test",'f');
stu2.display();
return 0;
}
在stu2对象前面加上一个static即可，此时stu2是静态变量，它一直到程序全部运行结束后才会释放。结果如下图：
7、 对象数组
数组不仅可以存放简单变量，还可以存放由类组成的对象。如下案例：
#include<iostream>
#include<string>
using namespace std;
class Box
{
private:
int height;
int width;
int length;
public:
Box(int h=10,int w=10,int len=10):height(h),width(w),length(len){};
int volume();
void display();
};
int Box::volume()
{
return height*length*width;
}
int main(){
Box a[4]={
Box(),
Box(20),
Box(10,30),
Box(10,10,40)
};
cout<<"the volume of box1 is "<<a[0].volume()<<endl;
cout<<"the volume of box2 is "<<a[1].volume()<<endl;
cout<<"the volume of box3 is "<<a[2].volume()<<endl;
cout<<"the volume of box4 is "<<a[3].volume()<<endl;
return 0;
}
结果如图所示：