字符串查找优化：这段std::wstring条件判断代码是否有更优雅实现？

Great question! Your instinct is right—running two separate find() calls isn't the most efficient approach, since it requires traversing the string twice. Let's break down better alternatives that are both more performant and cleaner, based on the logic you're implementing (checking if the string contains abc but not the exact substring [abc]).

1. Single-Pass Manual Check (Most Efficient) #

This approach traverses the string once, tracking both conditions in a single loop. It avoids the overhead of multiple string scans and temporary substrings by using direct character comparisons:

bool containsAbcNotBracketed(const std::wstring& str) {
    bool found_abc = false;
    bool found_bracketed_abc = false;
    const size_t str_len = str.size();

    size_t i = 0;
    while (i <= str_len - 1) {
        // Check for the exact "[abc]" substring first
        if (i <= str_len - 4 && str.compare(i, 4, L"[abc]") == 0) {
            found_bracketed_abc = true;
            i += 4; // Skip past this match to avoid rechecking
        }
        // Check for non-bracketed "abc"
        else if (i <= str_len - 3 && str.compare(i, 3, L"abc") == 0) {
            found_abc = true;
            i += 3; // Skip past this match
        }
        else {
            ++i;
        }
    }

    return found_abc && !found_bracketed_abc;
}

Why this is better: #

• O(n) time complexity (same as a single find(), vs O(2n) for your original code)
• Uses std::wstring::compare() instead of substr() to avoid creating temporary string objects
• Skips past matched substrings to reduce redundant checks
• Clear, linear logic that makes your intent obvious at a glance

2. Regular Expressions (Cleanest, Most Elegant) #

If performance isn't your top priority and you want code that's highly readable, C++11+ regex support is a great option. We can use a negative lookahead to rule out the [abc] substring while ensuring abc exists:

#include <regex>

bool containsAbcNotBracketed(const std::wstring& str) {
    // Regex breakdown:
    // ^(?!.*\[abc\])  -> Negative lookahead: ensure the string has no "[abc]" substring
    // .*abc.*         -> Ensure the string contains "abc" somewhere
    static const std::wregex pattern(L"^(?!.*\\[abc\\]).*abc.*$");
    return std::regex_search(str, pattern);
}

Why this is better: #

• Extremely readable: The regex pattern directly states your intent in a declarative way
• Minimal code—no manual loop logic to maintain
• Works perfectly for most non-performance-critical use cases

Caveat: #

Regex has a small upfront cost (pattern compilation, which we mitigate by making the regex static), so it's less ideal for tight loops or performance-sensitive code paths.

Quick Note on Your Original Logic #

Just to confirm: your code checks for the presence of abc and the absence of the exact 4-character substring [abc]. If your actual goal is to ensure abc is not wrapped in square brackets (e.g., rejecting [abc] but allowing abc] or [abc), your original logic works—but if you need to reject any abc that's inside a pair of [] (even if it's part of a longer bracket like [abc123]), you'd need a more complex parser to track bracket pairs. But based on your code, we stuck to the exact logic you're implementing.

内容的提问来源于stack exchange，提问作者Igor