面向对象 – 积少成多

封装

成员变量私有化，提供公共的getter和setter给外界去访问成员变量

class和struct

c++中class和struct就是类，唯一的区别的是 class 定义的类对象，默认情况下成员变量和方法是私有的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <iostream>
using namespace std;

struct Person {
    private:
        int m_age;
    public:
        void setAge(int age) {
            if (age <= 0) return;
            m_age = 1
        } else {
            m_age = age
        }

        int getAge() {
            return m_age;
        }
};

int main() {
    Person person;
    // person.m_age = -4 访问不到
    person.setAge(-4);
    getchar(); // 等待直到输入一个字符
    return 0;
}

内存空间的布局

每个应用都有自己独立的内存空间，其内存空间一般都有以下几大区域

代码段（代码区）
用于存放代码
数据段（全局区）
用于存放全局变量
栈空间
用于存放局部变量等，每调用一个函数就会给它分配一段连续的栈空间，等函数调用完成之后释放栈空间
自动分配和回收
堆空间
需要主动去申请和释放
在程序运行过程中，为了能自由控制内存的生命周期、大小，会经常使用堆空间的内存

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <iostream>
using namespace std;

void test() {
    int *p = (int*)malloc(4); // 从堆空间中获取4个字节的内存空间，返回连续空间的首内存地址
    *p = 10;
    free(p); // 堆空间必须手动释放

    char *t = new char[4]
    delete[] t;
}
int main() {
    test();
    getchar();
    return 0;
}

堆空间的初始化

malloc和new的区别

malloc不会初始化对象，而new会

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include<iostream>
using namespace std;

void test() {
    int *p0 = new int(); // 会初始化
    int *p1 = new int[3]; // 不会初始化
    int *p2 = new int[3](); // 会初始化
    int *p3 = new int[3]{5}; // 将数组首位初始化为5，其他仍为0
    cout << *p0 << endl; // 输出
}
int main() {
    int *p = (int*)malloc(sizeof(int)*10) // 申请40个字节的堆空间
    *p = 1; // 将第一个字节地址赋值为1
    // 从p地址开始的连续4个字节中的每一个字节都设置为1
    // memset(p, 1, 4)
    // 00000001 00000001 00000001 00000001


    // 将四个字节设置为1
    // 00000000 00000000 00000000 00000000
    test()
    getchar;
    return 0;
}

对象内存

对象的内存可以放到全局区，堆空间或者栈空间