指针指针，动态内存分配

pointer to pointers, dynamic memory allocation

本文关键字：指针 分配 内存 动态      更新时间：2023-10-16

我有一个字符串的字符阵列，其中每个字符串均由null终止。

一个指向数组的指针是第一个字符串的起始地址。

const char* p = "Ihadalittlelamb";

如何存储其他4个字符串的起始地址？

这是我应用的逻辑，但它无法正常工作：

const char** stara(const char* p, int n) {
    const char** add=new char*[n];
    int k=0;
    add[k]=p;
    for(i=1;i<p.size()) {
        if(p[i]=='')
            add[++k]=&p[i+1];
    }

您必须为此自己编写代码。您怎么知道字符串的数量？

假设您知道n是4，并且想要4个指针，那么您可以这样做：

const char *p0 = p;
const char *p1 = p0 + strlen(p0) + 1;
const char *p2 = p1 + strlen(p1) + 1;
const char *p3 = p2 + strlen(p2) + 1;

const char* p = "Ihadalittlelamb";
const char* arr[5];
arr[0] = p;                            // "I"
arr[1] = arr[0] + strlen(arr[0]) + 1;  // "had"
arr[2] = arr[1] + strlen(arr[1]) + 1;  // "a"
arr[3] = arr[2] + strlen(arr[2]) + 1;  // "little"
arr[4] = arr[3] + strlen(arr[3]) + 1;  // "lamb"

这对小字符串很好。但是，如果您想在运行时动态执行此操作，尤其是如果您不知道要处理多少个子字符串，请使用更多类似的东西：

#include <vector>
const char* p = "Ihadalittlelamb";
std::vector<char*> vec;
while (*p)
{
    vec.push_back(const_cast<char*>(p));
    p += (strlen(p) + 1);
}
// vec[0] = "I"
// vec[1] = "had"
// vec[2] = "a"
// vec[3] = "little"
// vec[4] = "lamb"

说，根据您的要求，在评论中说明：

在包含n个字符串的字符数组（每个由' 0'终止）中给出一个指针p，返回所有N字符串的启动地址的动态分配的数组

您需要更多这样的东西：

const char** stara(const char* str)
{
    const char* p = str;
    int n = 0;
    while (*p)
    {
        ++n;
        p += (strlen(p) + 1);
    }
    const char* *arr = new const char*[n+1];
    p = str;
    n = 0;
    while (*p)
    {
        arr[n++] = p;
        p += (strlen(p) + 1);
    }
    arr[n] = NULL;
    return arr;
}


const char* *arr = stara("Ihadalittlelamb");
// arr[0] = "I"
// arr[1] = "had"
// arr[2] = "a"
// arr[3] = "little"
// arr[4] = "lamb"
// arr[5] = NULL
delete[] arr;

实时演示

相关文章：