对象和类

CPP的类

类的概述

1. 类是由不同数据类型组合成的集合体

类的声明与定义

1. 类的声明格式

   class 类名标识符{
       public:
       数据成员声明;
       成员函数声明;
       
       private:
       数据成员声明;
       成员函数声明;
       
       protected:
       数据成员声明;
       成员函数声明;     
   }
   

2. 例子

   #include <iostream> 
   
   class Person{
    
    // 成员数据 
    int index; 
    char name[25];
    short age;
    double salary;
    
    // 成员方法
    short getAge();
    short setAge(short sAge);
    
    int getIndex();
    int setIndex(int sIndex);
    
    char *getName();
    int setName(char Name[25]);
    
    double getSalary();
    int setSalary(double sSalary);
   };
   

类的实现

1. 在文件Person.h中，声明一个类

   #include <stdio.h>
   #include <stdlib.h>
   #include <string.h>
   
   class Person{
    
    public:
    // 成员数据 
    int index; 
    char name[25];
    short age;
    double salary;
    
    // 成员方法
    short getAge(){
        return age;
    }
    
    int setAge(short sAge){
        age = sAge;
        return 0 ;  // 成功执行就返回0 
    }
    
    int getIndex(){
        return index;
    }
    
    int setIndex(int sIndex){
        index = sIndex;
        return 0;   
    }
    
    char *getName(){
        return name;
    }
    
    
    int setName(char sName[25]){
        strcpy(sName,name);
        return 0;
    }
    
    double getSalary(){
        return salary;
    }
    int setSalary(double sSalary){
        salary = sSalary;
        return 0;
    }
   };
   

   • .h文件就是头文件，通常类的声明放在头文件中、
   • 注意：类的成员数据不能在类的声明中初始化

对象的声明

1. 类定义之后，通过类名来声明对象，语法格式：类名 对象名

2. 如果同时声明多个对象，需要使用逗号隔开

3. 对象的引用：成员引用方式

   1. 语法格式：对象名.成员名

4. 对象的引用：对象指针方式

   1. 首先声明一个对象指针

      Person *p;
      

   2. 使用->运算符来表示对象指针所指的成员，所谓的对象指针，就是执行对象的指针

      Person *p;
      p-> index;
      
      // 上面的代码等价于下面的
      (*p).index;
      

5. 实例

   #include <iostream>
   #include "Person.h"
   int main(){
    
    using namespace std;
    int age = 14;
    Person p;
    p.setAge(age);
    
    cout << "我的年龄是：" << p.getAge() << endl;
   
    
    return 0;
   }
   

构造函数

概述

1. 构造函数用来完成初始化的工作

2. 构造函数的名字和类名一样

3. 示例

   #include <stdio.h>
   #include <stdlib.h>
   #include <string.h>
   
   class Person{
    
    public:
    // 成员数据 
    int index; 
    char name[25];
    short age;
    double salary;
    
    
    // 声明构造函数
    Person(){
        index = 0;
        age = 18;
        salary = 0;
    }
    Person(int pindex,short page,double psalary){
        index = pindex;
        age = page;
        salary = psalary;
    }
   };
   

复制构造函数

1. 复制构造函数就是函数的参数是一个已经初始化的类对象

2. 示例

   // 文件Person.h中
   #include <stdio.h>
   #include <stdlib.h>
   #include <string.h>
   
   class Person{
    
    public:
    // 成员数据 
    int index; 
    char name[25];
    short age;
    double salary;
    
    
    // 声明构造函数
    Person(int pindex,short page,double psalary){
        index = pindex;
        age = page;
        salary = psalary;
    }
    
    // 复制构造函数
    Person(Person & copyPerson){
        index = copyPerson.index;
        age = copyPerson.age;
        salary = copyPerson.salary;
    } 
    
    // 成员方法
    short getAge(){
        return age;
    }
    
    
    int getIndex(){
        return index;
    }
    
   
    char *getName(){
        return name;
    }
    
    double getSalary(){
        return salary;
    }
    
   };
   
   // 文件usePerson.cpp中
   #include <iostream>
   #include "Person.h"
   int main(){
    
    using namespace std;
    Person p(100,26,17000);
    Person p2(p);
    cout << "我的索引是：" << p2.getIndex() <<endl;
    cout << "我的年龄是：" << p2.getAge() <<endl;
    cout << "我的薪水是：" << p2.getSalary() << endl;
    
    return 0;
   }
   

析构函数

1. 名字和类名一样，但是前面要加波浪线~

2. 功能和构造函数相反，用来在释放一个对象的时候，做一些清理工作

3. 示例

   // 文件Person.h中
   #include <iostream>
   #include <string.h>
   
   using namespace std;
   class Person{
    public:
        
    char *message;
    Person(){
        mseeage = new char[5000];
    }
    
    void showStartMessage(){
        strcpy(message,"Welcome");
        cout << nessage << endl;
    }
    
    void showFrameMessage(){
        strcpy(message, "**********");
        cout << message << endl;
    }
    
    // 析构函数 
    ~Person(){
        delete[] message;  // 释放内存空间
    }
   };
   
   // 文件usePerson.cpp中
   #include <iostream>
   #include "Person.h"
   using namespace std;
   int main(){
    Person P;
    p.showFrameMessage();
    p.showStartMessage();
    p.showFrameMessage(); 
    
    return 0;
   }
   

4. 注意：

   1. 一个类中只能定义一个析构函数
   2. 析构函数不能重载
   3. 析构函数和构造函数都不能使用return语句，也不能加上关键字void

5. 析构函数和构造函数的调用环境

   1. 自动变量的作用域是某个模块，当这个模块激活的时候，自动调用构造函数，退出时，自动调用析构函数
   2. 全局变量在进入main函数之前调用构造函数，在程序终止的时候调用析构函数
   3. 动态分配的对象，在使用new为对象分配内存的时候调用构造函数，使用delete删除对象的时候会调用析构函数
   4. 临时变量是编译器自动产生的，在临时变量生存期的开始和结尾都会调用构造函数和析构函数