堆分配存储串

最新推荐文章于 2023-04-10 17:38:08 发布
原创 最新推荐文章于 2023-04-10 17:38:08 发布 · 790 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文通过一个具体的C++字符串类实现案例，探讨了在类设计过程中如何正确使用引用传递、const关键字来确保参数不被修改，以及如何避免内存泄漏等问题。

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

string类型是天天用的玩意，但是自己实现时，用顺序存储还是链式存储更合适呢？

《数据结构》中介绍了三种方式：

1，定长顺序存储

    长度有限，貌似没大用处

3，块链存储

数组和链表的一种混用形式，原本直觉上认为这种方式较合理，但仔细思考，发现其便利性也仅体现在连接了。综合来说不如第2种。

2，堆分配存储

    这是今天要实现的方式。

    方法的选择上，理论上好歹也应该重载下加号运算符什么的，但运算符重载作为C++的专题留到以后再说。现在仅关心数据结构，实现部分教材中列出的方法。

串的长度是直接记录下来，结尾没有补0作结束符。

效率上当然没法和STL提供的相比，仅是意思下练练手罢。


一开始还有种想法，string这玩意太平常，了解下干脆别浪费时间自己实现了，结果粗大事了。事实证明不动手还是不行啊。


以下是一份错误的代码：

#include <iostream>
using std::cout;
using std::endl;

class MyString
{
public:
    char *ch;
    int length;

    MyString();
    ~MyString();

    //给串赋字符串常量值
    void StrAssign(char *chars);

    //按序比较，>T返回值>0，= =，< <
    int StrCompare(MyString T);

    //S = S + S2;
    void Concat(MyString S2);

    //返回从pos起len长度的子串
    MyString SubString(int pos, int len);

    void Show();
};

//初始化为空串
MyString::MyString()
{
    ch = NULL;
    length = 0;
}

MyString::~MyString()
{
    delete ch;
    ch = NULL;
}

void MyString::StrAssign(char *chars)
{
    //不管三七二十一，先释放掉原有数据
    if (ch)
    {
        delete ch;
        ch = NULL;
    }
    
    //计算chars长度
    int i=0;
    while(chars[i] != NULL)
    {
        i++;
    }

    if (0 == i)     //注意若所赋串为空，length需归0
    {
        ch = NULL;
        length = 0;
    }
    else
    {
        ch = new char[i]();
        for(int j=0; j<i; ++j)
        {
            ch[j] = chars[j];
        }
        length = i;
    }
}

int MyString::StrCompare(MyString T)
{
    for(int i=0; (i<length) && (i<T.length); ++i)
    {
        if (ch[i] > (T.ch)[i])
        {
            return 1;
        }
        else if (ch[i] < (T.ch)[i])
        {
            return -1;
        } 
    }

    return length - T.length;
}

void MyString::Concat(MyString S2)
{
    //为空直接赋值
    if (ch == NULL)
    {
        ch = S2.ch;
        length = S2.length;
    }
    else
    {
        //备份原串
        char *tmp = new char[length]();
        for(int i=0; i<length; ++i)
        {
            tmp[i] = ch[i];
        }

        length = length + S2.length;

        delete ch;
        ch = new char[length]();

        int i = 0;
        //复制原串
        for(; i<(length - S2.length); ++i)
        {
            ch[i] = tmp[i];
        }
        delete tmp;
        tmp = NULL;

        //复制S2
        for(; i<length; ++i)
        {
            ch[i] = (S2.ch)[i - length + S2.length];
        }
    }
}

MyString MyString::SubString(int pos, int len)
{
    MyString result;
    if ((pos<=0)||(pos>length)||(len<0)||(len>length-pos+1))
    {
        cout<<"invalid param or empty String"<<endl;
        result.ch = NULL;
        result.length = 0;
        return result;
    }

    if (0 == len)
    {
        result.ch = NULL;
        result.length = 0;
    }
    else
    {
        result.ch = new char[len]();
        for(int i=0; i<len; ++i)
        {
            result.ch[i] = ch[i+pos-1]; //注意此处要-1
        }

        result.length = len;
    }

    return result;
}

void MyString::Show()
{
    if (NULL == ch)
    {
        cout<<"the string is empty"<<endl;
    }
    else
    {
         for(int i=0; i<length; ++i)
        {
            cout<<ch[i];
        }
        cout<<endl;
    }
}

int main()
{
    MyString s1;             s1.Show();
    s1.StrAssign("hello");   s1.Show();
    MyString s2;
    s2.StrAssign("abc");     s2.Show();
    
    if (s1.StrCompare(s2)>0)
    {
        cout<<"s1>s2"<<endl;
    }
    else if(s1.StrCompare(s2)<0)
    {
        cout<<"s1<s2"<<endl;
    }

    s1.Concat(s2);          s1.Show();

    s2.SubString(4,2);
    s2.SubString(2,2).Show();
}


倘若执行，会弹出一个我们熟悉的错误提示框——Debug Assertion Failed!

然后运行结果如下：

the string is empty

hello

abc

s1>s2


我现在刻意的练习C朝C++风格的转换，抛弃struct用class，暴露出了一些漏洞。很好。

为什么出错呢？原因是这样的：

由于我潜意识里希望作为参数传递进各方法的MyString对象不要被修改，而又避免使用对我来说较生疏的const等关键字，所以我采用了直接传递对象的方法，甚至连指针都懒得用。结果就反而弄出问题了！

注意，假如此时将StrCompare()的测试语句注释掉，会发现后面的Concat()是正常的。那明明Compare只是读取了字符作了一些比较，根本没作修改动作，为何还会影响到后面的语句呢？

秘密在于，我将s2作为参数传递进Compare()时，s2是被复制了一份的，当然ch及length都被默认的复制构造函数一一复制进去。当然这些都在预料之中没什么问题。

但是要注意！复制的这份形参，退出函数时，是要被处理的！比如这里的MyString，退出Compare()时是要被析构的！而我之前为了避免内存泄露，专门为MyString的析构函数编写了释放指针的语句。所以导致，形参被析构时，把原本被复制的s2也连累了，s2的指针被delete，资源就不见了。


所以假如把析构函数的语句注释掉，什么都不做，输出的结果就会变正常，不过这种解决方法不好，留下内存泄露的问题。


所以该用const的地方还是得用，而即便仅仅采用引用传递的方式也许反而不会产生问题。


然后我将代码的所有值传递修改为引用传递，运行后，前面部分均正常，SubString()仍报错。

原因也很简单，我很2B的在SubString()中定义了局部变量result，然后返回这个result，但是result是要被析构的啊，于是返回值就没法用了。


修改代码如下后，一切正常了。

/*
2014.4.18
堆分配存储串
*/

#include <iostream>
using std::cout;
using std::endl;

class MyString
{
public:
    char *ch;
    int length;

    MyString();
    ~MyString();

    //给串赋字符串常量值
    void StrAssign(char *chars);

    //按序比较，>T返回值>0，= =，< <
    int StrCompare(MyString *T);

    //S = S + S2;
    void Concat(MyString *S2);

    //返回从pos起len长度的子串
    void SubString(MyString *result, int pos, int len);

    void Show();
};

//初始化为空串
MyString::MyString()
{
    ch = NULL;
    length = 0;
}

MyString::~MyString()
{
    delete ch;
    ch = NULL;
}

void MyString::StrAssign(char *chars)
{
    //不管三七二十一，先释放掉原有数据
    if (ch)
    {
        delete ch;
        ch = NULL;
    }
    
    //计算chars长度
    int i=0;
    while(chars[i] != NULL)
    {
        i++;
    }

    if (0 == i)     //注意若所赋串为空，length需归0
    {
        ch = NULL;
        length = 0;
    }
    else
    {
        ch = new char[i]();
        for(int j=0; j<i; ++j)
        {
            ch[j] = chars[j];
        }
        length = i;
    }
}

int MyString::StrCompare(MyString *T)
{
    for(int i=0; (i<length) && (i<T->length); ++i)
    {
        if (ch[i] > (T->ch)[i])
        {
            return 1;
        }
        else if (ch[i] < (T->ch)[i])
        {
            return -1;
        } 
    }

    return length - T->length;
}

void MyString::Concat(MyString *S2)
{
    //为空直接赋值
    if (ch == NULL)
    {
        ch = S2->ch;
        length = S2->length;
    }
    else
    {
        //备份原串
        char *tmp = new char[length]();
        for(int i=0; i<length; ++i)
        {
            tmp[i] = ch[i];
        }

        length = length + S2->length;

        delete ch;
        ch = new char[length]();

        int i = 0;
        //复制原串
        for(; i<(length - S2->length); ++i)
        {
            ch[i] = tmp[i];
        }
        delete tmp;
        tmp = NULL;

        //复制S2
        for(; i<length; ++i)
        {
            ch[i] = (S2->ch)[i - length + S2->length];
        }
    }
}

void MyString::SubString(MyString *result, int pos, int len)
{
    if ((pos<=0)||(pos>length)||(len<0)||(len>length-pos+1))
    {
        cout<<"invalid param or empty String"<<endl;
        result->ch = NULL;
        result->length = 0;
    }

    if (0 == len)
    {
        result->ch = NULL;
        result->length = 0;
    }
    else
    {
        result->ch = new char[len]();
        for(int i=0; i<len; ++i)
        {
            result->ch[i] = ch[i+pos-1]; //注意此处要-1
        }

        result->length = len;
    }
}

void MyString::Show()
{
    if (NULL == ch)
    {
        cout<<"the string is empty"<<endl;
    }
    else
    {
         for(int i=0; i<length; ++i)
        {
            cout<<ch[i];
        }
        cout<<endl;
    }
}

int main()
{
    MyString s1;             s1.Show();
    s1.StrAssign("hello");   s1.Show();
    MyString s2;
    s2.StrAssign("abc");     s2.Show();
    
    if (s1.StrCompare(&s2)>0)
    {
        cout<<"s1>s2"<<endl;
    }
    else if(s1.StrCompare(&s2)<0)
    {
        cout<<"s1<s2"<<endl;
    }

    s1.Concat(&s2);          s1.Show();

    MyString result;
    s2.SubString(&result, 4, 2);
    s2.SubString(&result, 2, 2);
    result.Show();
}

/*
运行结果：
the string is empty
hello
abc
s1>s2
helloabc
invalid param or empty String
bc

注意点：
1，字符串比较过程的逻辑关系一定要想清楚
*/

当然，要避免参数值被改动，仅靠个人思维推断是不规范的，最好还是加上const修饰符。

另外把属性改回了private，传指针改成了传引用，最终的代码如下：

/*
2014.4.18
堆分配存储串
*/

#include <iostream>
using std::cout;
using std::endl;

class MyString
{
private:
    char *ch;
    int length;

public:
    MyString();
    ~MyString();

    //给串赋字符串常量值
    void StrAssign(const char *chars);

    //按序比较，>T返回值>0，= =，< <
    int StrCompare(const MyString &T);

    //S = S + S2;
    void Concat(const MyString &S2);

    //返回从pos起len长度的子串
    void SubString(MyString *result, int pos, int len) const;

    void Show();
};

//初始化为空串
MyString::MyString()
{
    ch = NULL;
    length = 0;
}

MyString::~MyString()
{
    delete ch;
    ch = NULL;
}

void MyString::StrAssign(const char *chars)
{
    //不管三七二十一，先释放掉原有数据
    if (ch)
    {
        delete ch;
        ch = NULL;
    }
    
    //计算chars长度
    int i=0;
    while(chars[i] != NULL)
    {
        i++;
    }

    if (0 == i)     //注意若所赋串为空，length需归0
    {
        ch = NULL;
        length = 0;
    }
    else
    {
        ch = new char[i]();
        for(int j=0; j<i; ++j)
        {
            ch[j] = chars[j];
        }
        length = i;
    }
}

int MyString::StrCompare(const MyString &T)
{
    for(int i=0; (i<length) && (i<T.length); ++i)
    {
        if (ch[i] > (T.ch)[i])
        {
            return 1;
        }
        else if (ch[i] < (T.ch)[i])
        {
            return -1;
        } 
    }

    return length - T.length;
}

void MyString::Concat(const MyString &S2)
{
    //为空直接赋值
    if (ch == NULL)
    {
        ch = S2.ch;
        length = S2.length;
    }
    else
    {
        //备份原串
        char *tmp = new char[length]();
        for(int i=0; i<length; ++i)
        {
            tmp[i] = ch[i];
        }

        length = length + S2.length;

        delete ch;
        ch = new char[length]();

        int i = 0;
        //复制原串
        for(; i<(length - S2.length); ++i)
        {
            ch[i] = tmp[i];
        }
        delete tmp;
        tmp = NULL;

        //复制S2
        for(; i<length; ++i)
        {
            ch[i] = (S2.ch)[i - length + S2.length];
        }
    }
}

void MyString::SubString(MyString *result, int pos, int len) const
{
    if ((pos<=0)||(pos>length)||(len<0)||(len>length-pos+1))
    {
        cout<<"invalid param or empty String"<<endl;
        result->ch = NULL;
        result->length = 0;
    }

    if (0 == len)
    {
        result->ch = NULL;
        result->length = 0;
    }
    else
    {
        result->ch = new char[len]();
        for(int i=0; i<len; ++i)
        {
            result->ch[i] = ch[i+pos-1]; //注意此处要-1
        }

        result->length = len;
    }
}

void MyString::Show()
{
    if (NULL == ch)
    {
        cout<<"the string is empty"<<endl;
    }
    else
    {
         for(int i=0; i<length; ++i)
        {
            cout<<ch[i];
        }
        cout<<endl;
    }
}

int main()
{
    MyString s1;             s1.Show();
    s1.StrAssign("hello");   s1.Show();
    MyString s2;
    s2.StrAssign("abc");     s2.Show();
    
    if (s1.StrCompare(s2)>0)
    {
        cout<<"s1>s2"<<endl;
    }
    else if(s1.StrCompare(s2)<0)
    {
        cout<<"s1<s2"<<endl;
    }

    s1.Concat(s2);          s1.Show();

    MyString result;  
    s2.SubString(&result, 4, 2);
    s2.SubString(&result, 2, 2);
    result.Show();
}
（二十五）第 4 章 串（串的堆分配存储）
墨夜白
09-16 408
算法 4.1、4.4
串的堆分配存储结构（C语言详解版）
数据结构和算法教程（C语言版）
03-15 3331
串的堆分配存储，其具体实现方式是采用动态数组存储字符串。 通常，编程语言会将程序占有的内存空间分成多个不同的区域，程序包含的数据会被分门别类并存储到对应的区域。拿 C 语言来说，程序会将内存分为 4 个区域，分别为堆区、栈区、数据区和代码区，其中的堆区是本节所关注的。 与其他区域不同，堆区的内存空间需要程序员手动使用 malloc 函数申请，并且在不用后要手动通过 free 函数将其释放。 C 语...
串的基本操作堆存储表示：初始化串、复制串、判断串是否为空、比较两个字符串、计算字符串长度、清空串、连接串、找子串、模式匹配、替换子串、插入和删除子串
06-05
串的基本操作堆存储表示：初始化串、复制串、判断串是否为空、比较两个字符串、计算字符串长度、清空串、连接串、找子串、模式匹配、替换子串、插入和删除子串
4.2.2 堆分配存储结构
SJMP
11-11 1073
/* c4-2.h 串的堆分配存储 */  typedef struct  {    char *ch; /* 若是非空串，则按串长分配存储区，否则ch为NULL */    int length; /* 串长度 */  }HString;
数据结构---串（堆分配存储 C语言）
小陆同学LLR的博客
05-05 1816
串是由零个或者多个字符组成的有限序列，串中字符的个数称为串的长度，含有零个元素的串叫空串。串通常用一个字符数组来表示。串中任意连续的字符组成的子序列称为该串的子串，包含子串的串称为主串，某个字符在串中的序号称为这个字符的位置。通常用子串第一个字符的位置作为子串在主串中的位置。空格也是串字符集合的一个元素，由一个或多个空格组成的串称为空格串（空格串不是空串）串的逻辑结构和线性表类似，串是限定了元素为...
串结构之堆分配存储详解（C语言版）
qq_44075108的博客
04-03 9988
串结构之堆分配存储详解（C语言版）
C语言实现数据结构串（堆分配存储表示法）实例详解
01-20
堆分配存储表示法 存储结构： 构建堆来存储字符串，本质上是顺序表 实现代码： #include #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -2 #define STR_...
串的堆分配
11-23
严蔚敏数据结构教材中关于串的堆分配的Ｃ语言实现
数据结构（13）：串的堆分配存储实现
欢迎来到关关雎鸠儿的博客
08-14 1420
代码实现 #include<stdio.h> #include<stdlib.h> #include<string.h> #define OK 1 #define ERROR 0 typedef struct{ char *ch; //若是非空串，则按串长分配存储区；否则ch为NULL int length; }HString; typedef int S...
第四章（2）.堆分配存储表示
风吹无迹雨落无痕
04-26 797
//与定长顺序存储一样，仍以一组地址连续的存储单元存放串值字符序列，但他们的空间都是动态分配的#include#includetypedef struct{ char *ch; int length;}HString;void InitString(HString *T)    //take care!    T要初始化，T指向的结构体也要初始化{ (*T).ch=NULL; (*T).lengt
用串的堆分配存储方法实现串的各种基本运算
11-02
用串的堆分配存储方法实现串的各种基本运算
串的堆分配存储c语言,串的堆分配存储结构
weixin_35733586的博客
05-17 473
串的堆分配存储，其具体实现方式是采用动态数组存储字符串。通常，编程语言会将程序占有的内存空间分成多个不同的区域，程序包含的数据会被分门别类并存储到对应的区域。拿 C 语言来说，程序会将内存分为 4 个区域，分别为堆区、栈区、数据区和代码区，其中的堆区是本节所关注的。与其他区域不同，堆区的内存空间需要程序员手动使用 malloc 函数申请，并且在不用后要手动通过 free 函数将其释放。C 语言中使...
数据结构笔记（十三）-- 串的堆分配存储表示
m0_43609475的博客
06-13 5405
串的堆分配存储表示 一、堆分配存储概述 堆分配内存仍是一组地址连续的存储单元来存放串值字符序列，但是存储空间实在程序执行过程中动态分配而得。在C语言中，存在一个称为“堆”的自由存储区，并由C语言的动态分配函数malloc()和free()来管理。利用函数malloc()为每个新产生的串分配一块实际串长所需的存储空间，若分配成功，则返回一个指向起始地址的指针，作为串的基址，同时为了方便以后的处理，约定串长也作为存储结构的一部分。 二、串的堆分配存储结构 三、串的操作 //1、初始化(产生空串)字符串S v
串的堆分配存储表示
春播秋忙
05-02 1308
common.h #ifndef _COMMON_H_ #define _COMMON_H_ #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int Stat
【C++实战篇】串的三种存储结构：定长存储、堆分配存储、块链存储
热门推荐
程序员，他们想的是什么?他们想的永远都是技术，他们崇尚的也永远都是技术。
06-09 1万+
本文介绍了字符串的三种存储方式及其连接实现：定长顺序存储通过固定长度数组存储字符串，但存在截断风险；堆分配存储动态分配内存空间，可灵活调整；块链存储采用链表结构，通过增加节点存储字符数提高存储密度。文章分别展示了三种存储方式下字符串连接的具体实现代码，其中定长存储通过数组拷贝实现连接，堆存储动态分配内存空间，块链存储则通过链表节点操作完成连接。这三种方法各有优劣，适用于不同场景，为字符串处理提供了多样化的解决方案。
堆分配存储表示c语言,数据结构 | 串的堆分配储存表示
weixin_39843738的博客
05-19 793
相关定义串的定长顺序储存采取顺序存储结构，存在长度上限，超出部分会截去。为克服此弊病唯有不限定长度上限，即采用动态分配串的储存空间。堆分配储存特点：仍以一组地址连续的储存单元存放地址序列，但存储空间是在程序执行过程中动态分配而得。堆：在C语言中，存在一个称为堆的自由存储区，有动态分配函数malloc()和free()管理。堆分配存储的表示与实现堆分配储存的表示typedef struct{char...
【数据结构 严蔚敏版】 串的堆分配存储 基本操作
Friday
12-22 1万+
串的堆分配存储表示的特点是，仍以一组地址连续的存储单元存放串值字符序列，但它们的存储空间是在程序执行过程中动态分配的。使用动态分配函数malloc()和函数free()来管理存储空间的大小。 串的堆分配存储方法具有顺序存储的特点，又弥补了定长存储的大小限制，多以多被采用。 //文件名：串操作----堆分配存储实现 //描述：这个存储的特点是，仍以一组地址连续的存储单元存放串值字符序列，但是存储空...
【数据结构】串的堆分配存储表示
程序员好冰的博客
04-10 1147
串的堆分配存储表示
堆分配存储串的插入，求子串（根据数据结构的算法设计）写出可以运行的代码
最新发布
10-20
在堆（如C语言中的标准库函数`malloc`）上分配内存存储字符串，并实现插入操作以及查找子串的功能，通常涉及到动态内存管理和字符串处理。下面是一个简单的C语言示例，它使用了字符串连接函数`strcat`和`strcmp`来实现这个功能： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> // 动态分配和初始化字符串 char* create_string(char* str) { int len = strlen(str) + 1; // 加一是因为需要空间来存储结束符'\0' char* result = (char*) malloc(len * sizeof(char)); strcpy(result, str); return result; } // 插入子串 void insert_substring(char** target, const char* substring, int index) { if (*target == NULL) { *target = create_string(substring); // 如果目标字符串不存在，先创建 } else { size_t substr_len = strlen(substring) + 1; char* new_str = (char*) realloc(*target, (strlen(*target) + substr_len) * sizeof(char)); // 扩展空间 if (new_str != NULL) { strcat(new_str, substring); new_str[index - 1] = '\0'; // 更新插入位置后的结束符 free(*target); // 释放原内存 *target = new_str; } else { printf("Memory allocation failed.\n"); } } } // 查找子串 int find_substring(const char* string, const char* sub_string) { size_t string_len = strlen(string); size_t sub_len = strlen(sub_string); for (size_t i = 0; i <= string_len - sub_len; i++) { if (strcmp(&string[i], sub_string) == 0) { return i; // 返回子串起始位置 } } return -1; // 如果未找到，返回-1 } int main() { char* target_str = "Hello, world!"; insert_substring(&target_str, "C", 4); printf("Modified string: %s\n", target_str); int sub_index = find_substring(target_str, "world"); if (sub_index != -1) printf("Substring 'world' found at position %d\n", sub_index); else printf("Substring not found.\n"); free(target_str); // 一定要记得释放不再使用的动态内存 return 0; } ``` 这个程序首先创建了一个字符串并插入指定子串，然后寻找并打印出子串的位置。请注意，这里我们假设输入的子串不会导致内存溢出。在实际应用中，需要考虑内存管理的细节和错误处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值