C++类的定义与实现

关于C++类

C++和其他面向对象语言一样每类都是由 构造函数、析构函数、成员变量、成员函数 组成。

  • 构造函数：对于类对象的初始化（如：成员变量的初始化赋值）
  • 析构函数：与构造函数相反（如：类对象在内存空间中申请的内存可以在析构函数释放给内存管理器，从而避免内存泄露的问题）
  • 成员变量：在类中使用的成员属性，一般情况下成员属性都是私有的。
  • 成员函数：类中的方法，主要实现类中的具体功能。

类的定义

一般情况下，在定义具体类时都会先定义一个头文件来声明类原型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>

class Human
{
public:
    Human() {
        std::cout << "Human->construct" << std::endl;
    };
    ~Human() {
        std::cout << "Human->destruct" << std::endl;
    };

public:
    void setSex(int s);
    int getSex();
    void setAge(int a);
    int getAge();

private:
    int sex;
    int age;

};

类的实现

实现具体类时把头文件引入通过 类名称::成员函数 方式，实现具体方法，如果类方法传入的参数和成员不重名的情况下可以使用 成员变量 = 传入参数，反之相同时可以使用 this.成员变量 = 传入参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include "human.h"

void Human::setSex(int s)
{
    sex = s;
};

int Human::getSex()
{
    return sex;
};

void Human::setAge(int a)
{
    age = a;
};

int Human::getAge()
{
    return age;
};

使用类

使用类是有两种声明方式一种在栈中分配内存，一种在堆中分配内存，二者的区别是栈中分配内存时在对象没有引用的情况下会调用 destruct 析构函数来释放类所占用的内存，在堆中分配内存时需要通过 delete 关键字释放类的内存。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include "human.h"

int main(int argc, char const *argv[])
{
    // 栈分配空间内存
    Human stackHuman;
    stackHuman.setAge(18);
    stackHuman.setSex(0);
    std::cout << "stackHuman.age: " << stackHuman.getAge() << std::endl;
    std::cout << "stackHuman.sex: " << stackHuman.getSex() << std::endl;

    // std::cout << "\n" << std::endl;

    // 堆分配空间内存
    // Human *heapHuman = new Human();
    // heapHuman->setAge(19);
    // heapHuman->setSex(1);
    // std::cout << "heapHuman->age: " << heapHuman->getAge() << std::endl;
    // std::cout << "heapHuman->sex: " << heapHuman->getSex() << std::endl;
    
    return 0;
}