C++中的顺序表动态分配与指针操作-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45111375/article/details/127700623

本文探讨了C++中的顺序表动态分配和静态分配，详细比较了new/delete与malloc/free的使用，指出了引用和指针传参的差异，以及->与.操作符的区别。同时，介绍了顺序表动态分配的实现，并讨论了在实践中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

顺序表的静态和动态分配

在学习这两种顺序表的实现中发现：使用C++中的new和delete，和C中的malloc和free；使用&与*pointer传参的区别；->与.的区别；拿别人的实现方法对比一下记录一下。

1.new和delete，malloc和free

1、new/delete是C++的操作符，而malloc/free是C中的函数。

2、new做两件事，一是分配内存，二是调用类的构造函数；同样，delete会调用类的析构函数和释放内存。而malloc和free只是分配和释放内存。

3、new建立的是一个对象，而malloc分配的是一块内存；new建立的对象可以用成员函数访问，不要直接访问它的地址空间；malloc分配的是一块内存区域，用指针访问，可以在里面移动指针；new出来的指针是带有类型信息的，而malloc返回的是void指针。

4、new/delete是保留字，不需要头文件支持；malloc/free需要头文件库函数支持。
实现如下所示：
(1)new/delete增加表长

// 动态增加顺序表长度
void IncreaseSize(SqList& L, int len) {
    int* p = L.data;
    L.data = new int[L.MaxSize + len];
    for (int i = 0; i < L.length; i++) {
        L.data[i] = p[i]; // 将原数据赋值到新内存中
    }
    L.MaxSize = L.MaxSize + len;
    delete p;
}

（2）malloc与free

//malloc与free实现动态分配
void IncreaseSize(SqList& L, int len) {
    int* p = L.data;
    L.data = (int*)malloc((L.MaxSize+len)*sizeof(int));
    for (int i = 0; i < L.length; i++) {
        L.data[i] = p[i]; // 将原数据赋值到新内存中
    }
    L.MaxSize = L.MaxSize + len;
    free(p);
}

2.引用和指针传参的区别还要牵扯到const头疼

指针从本质上讲是一个变量，变量的值是另一个变量的地址，指针在逻辑上是独立的，它可以被改变的，包括指针变量的值（所指向的地址）和指针变量的值对应的内存中的数据（所指向地址中所存放的数据）。

指针就和普通变量一样有自己的地址，不同的是指针存放的值是一个地址，所以不论什么指针在32位机器上指针占用32位，在64位机器上占用64位

引用从本质上讲是一个别名，是另一个变量的同义词，它在逻辑上不是独立的，它的存在具有依附性，所以引用必须在一开始就被初始化（先有这个变量，这个实物，这个实物才能有别名），而且其引用的对象在其整个生命周期中不能被改变，即自始至终只能依附于同一个变量（初始化的时候代表的是谁的别名，就一直是谁的别名，不能变）。
例如有两个int类型变量a和b，如果c是a的引用，那么c就不能再修改成为b的引用
传参时如果一个public函数传入指针参数，则需要在函数内做空指针判断，如果没做则留下隐患。而如果用引用作为参数，函数可以在享受高效传参的同时，免去为空的判断。（至少把空指针的判断责任推卸给调用者）
指针和引用都实现了对其他对象的间接访问。
区别在于：指针本身是个对象，但是引用不是（引用本质上是一个已经存在的对象的另外一个名字引用必须初始化，指针无须在定义时赋值两者被设计出来有各自的功能，引用更安全，因为不会出现空指针问题，但是指针的灵活性也是引用所不具备的，要根据情况进行合理选择。
这部分实在太麻烦就到这有兴趣再看，指针让人昏头，引用不会出太大麻烦，具体使用过程中遇到问题再解决，可能关注点有点偏有人说是没用的知识。

3.->与.的区别

指针可以使用->或.，对象就使用.运算符。
用“.”的话，只需要声明一个结构体。格式是，结构体类型名+结构体名。然后用结构体名加“.”加域名就可以引用域了。因为自动分配了结构体的内存。如同 int a;一样。用->的话，要声明一个结构体的指针，还要手动开辟一个该结构体的内存，然后把返回的指针给声明的结构体指针。才能用->正确引用。否则内存中只分配了指针的内存，没有分配结构体的内存，想要的结构体实际上是不存在。这时候用->引用自然出错了，因为没有结构体，自然没有结构体的域了。
".“我直接读做"的”。->我读作"指向的结构体的”。

1.实现动态分配

/*
顺序表————动态分配
*/

#define InitSize 5 // 顺序表初始长度

#include <iostream>
#include <stdio.h>

using namespace std;

struct SqList {
   
    int* data;   // 数组
    int MaxSize; // 顺序表的最大长度
    int length;  // 顺序表的当前长度
};

// 初始化顺序表
void InitList(SqList& L) {
   
    L.data = new int[InitSize];
    L.MaxSize = InitSize;
    L.length = 0;
}

// 为顺序表中的数据赋值
void AssginList(SqList& L) {
   
    for (int i = 0; i < InitSize; i++) {
   
        L.data[i] = i;
        L.length++;
    }
}

// 求表长
int Length(SqList& L) {
    return L.length; }
//malloc与free实现动态分配
void IncreaseSize(SqList& L, int len) {
   
    int* p = L.data;
    L.data = (int*)malloc((L.MaxSize+len)*sizeof(int));
    for (int i = 0; i < L.length; i++) {
   
        L.data[i] = p[i]; // 将原数据赋值到新内存中
    }
    L.MaxSize = L.MaxSize + len;
    free(p);
}

// 动态增加顺序表长度
void IncreaseSize(SqList& L, int len) {
   
    int* p = L.data;
    L.data = new int[L.MaxSize + len];
    for (int i = 0; i < L.length; i++) {
   
        L.data[i] = p[i]; // 将原数据赋值到新内存中
    }
    L.MaxSize = L.MaxSize + len;
    delete p;
}

// 按位查找：查找第i个位置的元素
int GetElem(SqList& L, int i) {
   
    return L.data[i - 1];
}

// 按值查找：查找值为i的元素位置
int LocateElem(SqList& L, int i) {
   
    for (int j = 0; j < L.length; j++) {
   
        if (L.data[j] == i) {
   
            return j + 1;
        }
    }
    return 0; // 没有查找到则返回0
}

// 插入：在第i个位置插入e
void ListInsert(SqList& L, int i, int e) {
   
    if (L.length = L.MaxSize) {
    // 内存已满需要扩充
        IncreaseSize(L, 1);
    }
    for (int j = L.length; j >= i; j--) {
   
        L.data[j] = L.data[j - 1]; // 插入位置之后的数据后移
    }
    L.data[i - 1] = e;
    L.length++;
}

// 删除：删除第i个位置的元素
bool ListDelete(SqList& L, int i, int& e) {
   
    if (i