Character table-based searcher doesn't work - c

Question

The following code is supposed to return the character that is registered in the table set and has been determined in the source string.
int find (char source[], char set[])
{
int i, l = strlen(set);
int exit = 0;
for(i = 0; source[i] != '\0';)
{
do
{
if(source[i] == set[l])
{
exit = 1;
break;
}
else l--;
} while (!l);
if(exit)
break;
else
{
i++;
l = strlen(set);
}
}
return set[l];
}
What am I doing wrong?

Answer 1

Use early returns when appropriate, use for loops with all three clauses most of the time, avoid calling strlen() more than once, and avoid do … while loops.
int find(char source[], char set[])
{
int len = strlen(set);
for (int i = 0; source[i] != '\0'; i++)
{
for (int l = 0; l < len; l++)
{
if (source[i] == set[l])
return (unsigned char)set[l];
}
}
return -1;
}
The cast returns a positive value even if plain char is a signed type.
I'm not wholly convinced that returning the character is best; the index where the character is found might be better.
If you're stuck with a C89 compiler, then you can use:
int find(char source[], char set[])
{
int len = strlen(set);
int i;
for (i = 0; source[i] != '\0'; i++)
{
int l;
for (l = 0; l < len; l++)
{
if (source[i] == set[l])
return (unsigned char)set[l];
}
}
return -1;
}
I'm letting the compiler optimize source[i] in the inner loop. If you don't trust your compiler, you could use:
int find(char source[], char set[])
{
int len = strlen(set);
int i;
for (i = 0; source[i] != '\0'; i++)
{
char c = source[i];
int l;
for (l = 0; l < len; l++)
{
if (c == set[l])
return (unsigned char)set[l];
}
}
return -1;
}
If you want to use a standard function, you probably want strcspn(), a much-neglected part of Standard C. This will return 0 (or '\0') if there is no other match, unlike the other functions that return -1.
int find(char source[], char set[])
{
size_t i = strcspn(source, set);
return (unsigned char)source[i];
}
If the negative return is important, then you'd use:
int find(char source[], char set[])
{
size_t i = strcspn(source, set);
return (source[i] == '\0') ? -1 : (unsigned char)source[i];
}
Or you could use strpbrk():
int find(char source[], char set[])
{
char *tgt = strpbrk(source, set);
if (tgt == 0)
return -1;
return (unsigned char)*tgt;
}
And there are probably other variants I've not thought of.
If you want to keep the inner do/while loop (thus fixing up the original logic) you can write:
int find(char source[], char set[])
{
int i;
int len = strlen(set) - 1;
for (i = 0; source[i] != '\0'; i++)
{
int l = len;
do
{
if (source[i] == set[l])
return (unsigned char)set[l];
} while (--l >= 0);
}
return -1;
}
This avoids testing set[strlen(set)], which is by definition '\0', with source[i] which is known not to be '\0'. It still uses an early return which radically simplifies the code (no exit variable, which is not a good name to use since there's a standard function exit() too). Note, too, how this keeps the loop control for the variable i all in the for statement — that is one of its principal virtues. You should aim to use it whenever possible. Note that the original code scans from the end of set to the beginning instead of from the beginning to the end. Both methods work essentially equally well, but starting at the beginning and ending at the end is the more conventional way to work. It is also less apt to create bugs. If someone changes the type of l to size_t, then it never goes negative, so the do/while variant fails. The original proposed version will work fine if every int in the body of the function is changed to size_t.

Answer 2

I think, instead of
while (!l);
what you want is
while (l);
while (l > -1); //yeah, because array index starts from 0.
because you are decrementing the value of l and want to continue looping untill l becomes less than 0, right?
Also, return type of function find() is int and you're returning a char. Even it is not an error, you may probably want to change that.