own implementation of std::string::find (brute-force search) - c++

Question

I am trying to find the occurrence of string T in string P and return the position of T in P.
This is what I have tried, but it is incorrect:
int bruteForce(string T, string P) {
int n, m;
for (int i = 0; i <= n-m; i++) {
int j = 0;
while (j < m && T[i+j] == P[j]) {
if (j == m) {
return i;
}
return 0;
}
}
}
What am I doing wrong? What am I missing?

Answer 1

In this part:
int n,m;
for (int i=0;i<= n-m;i++) {
you are using uninitialized local variable which results in undefined behavior. Also try to name your variables with something more meaningful than alphabet letters, I think what you actually meant was:
int bruteForce(std::string needle, std::string haystack) {
int needleLen = needle.length(),
haystackLen = haystack.length();
for (int i = 0; i <= needleLen - haystackLen; i++) {
int j = 0;
while (j < haystackLen && needle[i+j] == haystack[j]) {
if(j == haystackLen) {
return i;
}
return 0;
}
}
// return 0; <--
}
also note that in your function doesn't return any value in case when none of needle[i+j] equals haystack[j] (for every i). What about the situation when needle is "ab" and haystack is "aab" ~> while comparing needle[1] with haystack[1], your function would return 0 (it should be placed after for loop)
Another reasonable change would be changing passing by value to passing by reference to avoid copies being created. And since your function doesn't change these strings, its prototype should be:
int bruteForce(const std::string& needle, const std::string& haystack)
And in case you didn't want to intentionally create own implementation of std::string::find but yet for some reason you still need it to return 0 on failure (did you think about usage of your function when needle is equal to haystack?) it could look like this:
std::size_t bruteForce(const std::string& needle, const std::string& haystack) {
std::size_t pos = haystack.find(needle);
if (pos != std::string::npos)
return pos;
return 0;
}
...but if this is the case, you wouldn't call it bruteForce, would you? :)

Answer 2

I tried not to alter your code too much. My changes were:
Changed function parameters to const reference to avoid wasteful copies.
The variables n and m weren't initialized.
The inner while loop had problems. It didn't increment j and the test for success makes more sense outside the loop.
The return value for failure can't be 0 as that may be a valid position.
Modified code (briefly tested and seems to work):
int bruteforce(const std::string &T, const std::string &P)
{
int n = T.length();
int m = P.length();
for (int i = 0; i <= n-m; ++i) {
int j = 0;
while (j < m && T[i+j] == P[j]) {
++j;
}
if (j == m) { // match found
return i;
}
}
return -1;
}