Question

我想拆分一个包含两个“字符串”的字符数组，用“|”分隔变成了两个char。

这是我的示例代码。

void splitChar(const char *text,  char *text1, char *text2)
{
   for (;*text!='\0' && *text != '|';) *text1++ = *text++;
   *text1 = '\0';
   for (;*++text!='\0';) *text2++ = *text;
   *text2 = '\0';
}

int main(int argc, char* argv[])
{

    char *text = "monday|tuesday", text1[255], text2 [255];
    splitChar (text, text1, text2);
    return 0;
}

我有两个问题：

如何在C中进一步改进此代码（例如，将其重写为1代表循环）。
如何在C ++中重写此代码？

Answer 1

如果要用C ++编写，请使用STL

string s = "monday|tuesday";  
int pos = s.find('|');  
if(pos == string::npos)  
    return 1;  
string part1 = s.substr(0, pos);  
string part2 = s.substr(pos+1, s.size() - pos);

Answer 2

我不知道A），但对于B），这是我在各种项目中使用的实用程序库中的方法，展示了如何将任意数量的单词拆分为vector。它被编码为在空格和制表符上进行分割，但如果您愿意，可以将其作为附加参数传递。它返回分割的单词数：

unsigned util::split_line(const string &line, vector<string> &parts)
{
    const string delimiters = " \t";
    unsigned count = 0;
    parts.clear();

    // skip delimiters at beginning.
    string::size_type lastPos = line.find_first_not_of(delimiters, 0);

    // find first "non-delimiter".
    string::size_type pos = line.find_first_of(delimiters, lastPos);

    while (string::npos != pos || string::npos != lastPos)
    {
        // found a token, add it to the vector.
        parts.push_back(line.substr(lastPos, pos - lastPos));
        count++;

        // skip delimiters.  Note the "not_of"
        lastPos = line.find_first_not_of(delimiters, pos);

        // find next "non-delimiter"
        pos = line.find_first_of(delimiters, lastPos);
    }

    return count;
}

Answer 3

对于A，使用内部库：

void splitChar(const char *text,  char *text1, char *text2)
{
    int len = (strchr(text,'|')-text)*sizeof(char);
    strncpy(text1, text, len);
    strcpy(text2, text+len+1);
}

Answer 4

这些解决方案中的一个可能会起作用：Split a string in C++?

Answer 5

看一下这里给出的例子：strtok, wcstok, _mbstok

Answer 6

我发现破坏性分裂是性能和灵活性的最佳平衡。

void split_destr(std::string &str, char split_by, std::vector<char*> &fields) {
    fields.push_back(&str[0]);
    for (size_t i = 0; i < str.size(); i++) {
        if (str[i] == split_by) {
            str[i] = '\0';
            if (i+1 == str.size())
                str.push_back('\0');
            fields.push_back(&str[i+1]);
        }
    }
}

然后是lazies的非破坏性版本。

template<typename C>
    void split_copy(const std::string &str_, char split_by, C &container) {
        std::string str = str_;
        std::vector<char*> tokens;
        parse::split_destr(str, split_by, tokens);
        for (size_t i = 0 ; i < tokens.size(); i++)
            container.push_back(std::string( tokens[i] ));
    }

当我对boost :: Tokenizer这样的东西处理gb + size文件时，我已经达到了这个目的。

Answer 7

我为我的回答道歉...没有人应该在家里试试。

回答问题的第一部分。

A]如何在C中进一步改进此代码（例如，将其重写为1循环）。

此算法的复杂性将取决于“|”的位置在字符串中，但此示例仅适用于由“|”分隔的2个字符串。您可以稍后轻松修改它。

#include <stdio.h>

void splitChar(char *text,  char **text1, char **text2)
{
    char * temp = *text1 = text;
    while (*temp != '\0' && *temp != '|') temp++;

    if (*temp == '|') 
    {
        *temp ='\0';
        *text2 = temp + 1;
    }
}

int main(int argc, char* argv[])
{

    char text[] = "monday|tuesday", *text1,*text2;
    splitChar (text, &text1, &text2);
    printf("%s\n%s\n%s", text,text1,text2);
    return 0;
}

这是有效的，因为c样式数组使用空字符来终止字符串。由于使用“”初始化字符串会在末尾添加一个空字符，所以您只需要替换'|'的出现位置使用null字符并将其他char指针分配给超过'|'的下一个字节。

您必须确保使用[]初始化原始字符串，因为它告诉编译器为您的字符数组分配存储空间，其中char *可能会在无法更改的静态内存区域中初始化字符串。 / p>

将字符数组拆分为两个字符数组

7 个答案: