Find number of string separators in a string - c

Question

I am using the following to find the number of separators in a string:
char * string = "xi--len--xia"
char * split_on = "--";
size_t len_joined_string = strlen(string);
size_t len_split_on = strlen(split_on);
size_t num_separators_in_string = 0;
for (int i=0; i < len_joined_string; i++) {
if (joined_string_buffer[i] == split_on[0]) {
int has_match = 1;
for (int j=1; j < len_split_on; j++) {
if (joined_string_buffer[i+j] != split_on[j])
has_match = 0;
}
if (has_match)
num_separators_in_string ++;
}
}
Is there a way to do the above in a built-in C function, or is it required that I write the code above?
From another question, Counting number of occurrences of a char in a string in C, it looks a bit simpler to do this for a char:
for (i=0; s[i]; s[i]=='.' ? i++ : *s++);
But is there something similar like this when splitting on a string (char-array) instead of a single char?

Answer 1

Just getting it done
You could do something like this:
const char * split = "--";
int i;
for(i=0; s[i]; strncmp(&s[i], split, strlen(split)) ? *s++ : i++);
Note that I flipped *s++ and i++ because strncmp returns 0 on equal. Also, you might want to modify it depending on how you want to handle a string like "xi---len----xia".
Making it readable
If you ask me, the above snippet looks a bit clunky and hard to understand. If you asked me what it does, I would need quite some time to figure it out. It has the look of "look what I can do".
Put it in a function
I would put it in a function like this to hide this terrible for loop for someone who is reading your code.
size_t no_splits(const char *s, const char *split)
{
size_t i;
for(i=0; s[i]; strncmp(&s[i], split, strlen(split)) ? *s++ : i++)
; // Put semicolon here to suppress warnings
return i;
}
Make the logic readable
But then again, when you have inserted the code in a well named function, the need to shorten down the code this much is basically gone. So for readability, I would rewrite it as:
size_t no_splits(const char *s, const char *split)
{
size_t i=0;
// Not only more readable, but also better for performance
const size_t len=strlen(split);
while(s[i]) {
if(strncmp(&s[i], split, len))
// The only reason to use * in above code was to suppress a warning
s++;
else
i++;
}
return i;
}
Note that in the last piece of code, I removed two things whose only purpose was to suppress warnings. I'm not saying that it's always wrong to do things only to suppress warnings, but when you do, that's a sign that you should consider redesigning your code instead. Even though it can be used different, the usual way of using a for loop is for(<init>; <condition>; <inc/dec>) and it's often a bad thing diverging from this convention. Not only because of readability, but also because of that it makes it harder for the optimizer. The reason is that the optimizer recognizes common patterns and have rules to optimize them.
Change the logic to something more intuitive
Actually, I also think this alternating between incrementing s and i is very confusing. Here is a version that (to me) makes much more sense. Change the while loop to:
while(*s) {
if(strncmp(s, split, len) == 0)
i++;
s++;
}
And if you REALLY want to compress it, change to:
// *s++ is back, but this time with another purpose than suppressing warnings
while(*s++) // Or for(; *s; s++) which I personally think looks better
if(strncmp(s, split, len) == 0)
i++;
Abusing the syntax
Here is an example of how you really can abuse the syntax of a for loop. It's a matrix multiplication that I wrote with empty for body:
// Do NOT do like this!!!
void matrix_multiply(int *A, int *B, int *C, int N)
{
for( int i=0,j=0,k=0;
k++<N ? 1 : ++j<N ? k=1 : ++i<N ? k=1+(j=0) : 0;
C[i*N + j] = A[i*N + k -1] * B[(k-1)*N + j] + (k==1 ? 0 : C[i*N + j])
);
}
And here is an example of insertion sort:
// Do NOT do like this either!!!
void insertionSort(int *list, int length)
{
for(int i=0, j=0, max=0;
++j<length ? 1 : i<length-1 ? max=j=i+++1+ 0*
(0*((0*(j=list[i-1])) ? 0 : ((0*(list[i-1]=list[max]))
? 0 : list[max]=j))) : 0;
list[j]>list[max] ? max=j : 0
);
}
The above snippets are examples that is basically your for loop taken to the absolute extreme.
Summary
In general, I would say that you should have very strong reasons to write the function no_splits in another way than I did with more readable versions with a while loop. Performance is a valid reason, but first make sure that this code really is the bottleneck. And remember that short code does not imply fast code. If you really want to use the for loop instead, then at least put it in a function like I did, and give it a comment describing what it does. But this snippet is my final recommendation for your purpose:
// Count the number of occurrences of substr in str
size_t no_splits(const char *str, const char *substr)
{
size_t ret = 0;
const size_t len = strlen(substr);
for(; *str; str++)
if(strncmp(str, substr, len) == 0)
ret++;
return ret;
}
If you want to make it a bit quicker, especially for long substr, you can do like this:
size_t no_splits(const char *str, const char *substr)
{
size_t ret = 0;
const size_t len = strlen(substr);
for(size_t n = strlen(str) - len; n >= 0; n--)
if(strncmp(&str[n], substr, len) == 0)
ret++;
return ret;
}