十一(2) 类的实例化

1.构造函数

函数名必须与类名相同，且没有返回值类型

构造函数调用时机

在定义对象同时自动被调用，且仅被调用一次

Human h;    // 创建类的这个时候就会调用构造方法

• 对象定义语句

/*构造函数
*/
Human(int age, const char* name);Human::Human(int age,const char* name)
{cout << "Human 构造函数被调用..." << endl;this->age = age;strcpy_s(this->name, name);
}void getInfo(){cout << "age = " << this->age << " name = " << this->name << endl;};int main()
{Human h(20,"wyd");// h.setInfo(20, "wyd");h.getInfo();   // age = 20 name = wyd
}

• new 操作符

构造函数重载

• 构造函数可以重载

  • 构造函数也可以通过参数表的差别化形成重载

  • 重载的构造函数，通过构造函数的实参类型进行匹配

  • 不同的构造函数，表示对象的不同创建方式

class HO
{
public:HO();~HO();HO(int age){this->age = age;this->name = "";cout << "HO(int age)" << endl;}HO(int age, const char* name){this->age = age;this->name = name;cout << "HO(int age,const char* name)" << endl;}void getInfo(){cout << "age = " << age << " name = " << name << endl;}private:int age;string name;
};HO::HO()
{cout << "HO() ~ " << endl;this->age = 0;this->name = "";
}HO::~HO()
{
}int main()
{HO hq1;   // 调用无参的构造方法hq1.getInfo();HO hq2(20);  // 调用一个参数的构造方法hq2.getInfo();HO hq3(25,"cls");  // 调用两个参数的构造方法hq3.getInfo();
}输出内容:HO() ~
age = 0 name =HO(int age)
age = 20 name =HO(int age,const char* name)
age = 25 name = cls

• • 使用缺省参数可以减少构造函数重载的数量

• 构造函数分类

  • 多参数构造函数：按多参方式构造

  • 无参(缺省)构造函数：按无参方式

  • 类型转换构造函数：利用不同类型的对象构造

  • 拷贝构造函数：利用相同类型的对象构造

构造函数的作用

• 定义对象的各个成员变量并赋初始值。设置对象的初始状态

• 在对象定义之初想实现的任何操作

对象的创建过程

• 为整个对象创建内存空间

• 以构造实参调用构造函数

  • 定义成员变量

  • 执行构造代码

2. 类的声明和实现

类的声明和实现可以分开实现

class 类名{

返回类型 函数名 (形参表); // 声明

}

返回类型 函数名::函数名 (形参表) //实现

{

函数体;

}

将类的声明，实现与实现分别放在不同的文件中

//Human.h文件  -- 声明

class Human{
    
    
public:
    
    Human();
    void getInfo();
    
private:
    int age;
}

----------------------------------------

// Human.cpp --  实现
    
#include "Human.h"
    
Human:Human()
{
    
}

void Human::getInfo()
{
    
}

--------------------------------------
    
// Main.cpp
    
#include "Human.h"
    
 int main()
{
    
    Human h;
    
    h.getInfo();
    
}
    

3. 定义对象的几种方法

对象的定义与销毁

1.在栈中定义单个对象

• 类名 对象；

Human h1;

• 类名 对象(实参表);

Human h2(20,"wyd");

2.在栈中定义对象数组

• 类名 对象数组[元素个数];

Human h3[3];   // 定义3个Human对象for(int i = 0; i < 3; i++)
{h3[i].getInfo();
}

• 类名 对象数组[元素个数] = {类名(实参表)...};

Human h4[3] = {Human(20,"wyd"),Human(20,"wyd"),Human(20,"wyd")
};

• 类名 对象数组[] = {类名(实参表)...};

Human h5[] = {Human(20,"wyd"),Human(20,"wyd"),Human(20,"wyd")
};

3.在堆中定义/销毁单个对象(new出来的对象声明周期不短暂)

• 类名* 对象指针 = new 类名;

• 类名* 对象指针 = new 类名();

• 类名* 对象指针 = new 类名(实参表);

• delete 对象指针;

4.在堆中定义/销毁对象数组

• 类名* 对象数组指针 = new 类名[元素个数];

• 类名* 对象数组指针 = new 类名[元素个数]{ 类名(实参列表)...};

• delete[] 对象指针数组;