Searching for Substrings in C-Strings

Searching for a substring within a C-style string can be done efficiently using the strstr() function from the <cstring> library. This function returns a pointer to the first occurrence of the substring within the main string, or a null pointer if the substring is not found.

Here's a basic example of how to use strstr():

1#include <iostream>
2#include <cstring>
3
4int main() {
5  const char* haystack{
6    "Hello, World! How are you?"};
7  const char* needle{"World"};
8
9  const char* result{
10    std::strstr(haystack, needle)
11  };  
12
13  if (result) {
14    std::cout << "Substring found at position: "
15      << (result - haystack) << '\n';
16    std::cout << "Remaining string: "
17      << result << '\n';
18  } else {
19    std::cout << "Substring not found.\n";
20  }
21}

1Substring found at position: 7
2Remaining string: World! How are you?

In this example, strstr() efficiently finds "World" within our main string. The function returns a pointer to the start of the found substring, which we can use to calculate its position or print the remaining string.

However, strstr() has limitations:

1. It's case-sensitive.
2. It only finds the first occurrence.
3. It doesn't allow for more complex search patterns.

For more advanced use cases, we might need to implement our own search function. Here's an example of a case-insensitive search that finds all occurrences:

1#include <iostream>
2#include <cctype>
3#include <vector>
4
5std::vector<const char*> findAll(
6  const char* haystack,
7  const char* needle
8) {
9  std::vector<const char*> results;
10  const char* ptr{haystack};
11  while (*ptr) {
12    const char* start{ptr};
13    const char* n{needle};
14    while (*ptr && *n &&
15      (std::tolower(*ptr) == std::tolower(*n))) {
16      ptr++;
17      n++;
18    }
19    if (!*n) {  // Found a match
20      results.push_back(start);
21      // Move past this match
22      ptr = start + 1;
23    } else {
24      // No match, move to next character
25      ptr = start + 1;
26    }
27  }
28  return results;
29}
30
31int main() {
32  const char* text{
33    "The quick brown fox jumps over the lazy dog. "
34    "The FOX is quick."};
35  const char* search{"the"};
36
37  auto results{findAll(text, search)};
38
39  std::cout << "Found " << results.size()
40            << " occurrences:\n";
41  for (const auto& result : results) {
42    std::cout << "Position: " << (result - text)
43              << ", Context: " << result << '\n';
44  }
45}

1Found 3 occurrences:
2Position: 0, Context: The quick brown fox jumps over the lazy dog. The FOX is quick.
3Position: 31, Context: the lazy dog. The FOX is quick.
4Position: 41, Context: The FOX is quick.

This custom findAll() function demonstrates:

1. Case-insensitive matching using std::tolower().
2. Finding all occurrences, not just the first.
3. Returning the positions and contexts of all matches.

While this approach works, it's worth noting that for more complex string operations or when performance is critical, you might want to consider using more advanced string matching algorithms like Knuth-Morris-Pratt or Boyer-Moore. These algorithms can provide better efficiency, especially for longer strings or repeated searches.

Remember that when working with C-style strings, you always need to be cautious about buffer overflows and ensure proper null-termination. In practice, using std::string and its member functions like find() and find_first_of() can often be safer and more convenient for string searching operations in C++.