Split array of chars into two arrays of chars

I would like to split one array of char containing two "strings "separated by '|' into two arays of char.

Here is my sample code.

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

I have two questions:

1. How to further improve this code in C (for example rewrite it in 1 for cycle).

2. How to rewrite开发者_StackOverflow中文版 this code in C++?

If you wan to write it in C++, use the 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);

For A, using internal libraries:

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);
}

I don't know about A), but for B), Here's a method from a utility library I use in various projects, showing how to split any number of words into a vector. It's coded to split on space and tab, but you could pass that in as an additional parameter if you wanted. It returns the number of words split:

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

Probably one of these solutions will work: Split a string in C++?

Take a look at the example given here: strtok, wcstok, _mbstok

I've found a destructive split is the best balance of performance and flexibility.

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]);
        }
    }
}

Then a non-destructive version for 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] ));
    }

I arrived at this when things like boost::Tokenizer have fallen flat on their face dealing with gb+ size files.

I apologize advance for my answer :) No one should try this at home.

To answer the first part of your question.

A] How to further improve this code in C (for example rewrite it in 1 for cycle).

The complexity of this algorithm will depend on where the position of '|' is in the string but this example only works for 2 strings separated by a '|'. You can easily modify it later for more than that.

#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;
}

This works because c-style arrays use the null character to terminate the string. Since initializing a character string with "" will add a null char to the end, all you would have to do is replace the occurrences of '|' with the null character and assign the other char pointers to the next byte past the '|'.

You have to make sure to initialize your original character string with [] because that tells the compiler to allocate storage for your character array where char * might initialize the string in a static area of memory that can't be changed.