Question

我有一个字符串的字符数组，其中每个字符串都以null结尾。

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

const char* p = "I\0had\0a\0little\0lamb\0";

如何存储其他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]=='\0')
            add[++k]=&p[i+1];
    }

Answer 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;

Answer 2

const char* p = "I\0had\0a\0little\0lamb\0";

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 = "I\0had\0a\0little\0lamb\0";

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个字符串的字符数组中的第一个元素的指针p（每个字符串以'\ 0'结尾），返回动态分配的所有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("I\0had\0a\0little\0lamb\0");

// arr[0] = "I"
// arr[1] = "had"
// arr[2] = "a"
// arr[3] = "little"
// arr[4] = "lamb"
// arr[5] = NULL

delete[] arr;

Live demo

指针指针，动态内存分配

2 个答案: