C++ String find() Function

What You’ll Learn

The find() member of std::string locates a substring inside text and returns its starting index. It is the standard C++ way to answer “Is this word in the string?” and “Where does it start?”—essential for parsing URLs, validating input, and searching log lines.

Definition and Usage

In C++, std::string is the modern class for text. Its find() method searches the calling string for another string (or a single character) and reports where the match begins. Indexing is zero-based: the first character is at position 0.

If the substring appears multiple times, find() returns only the first occurrence unless you call it again with an updated start position. When nothing matches, the result is std::string::npos—always compare against that constant instead of guessing a numeric value.

📝 Syntax

The most common overloads declared in <string>:

size_t find(const std::string& str, size_t pos = 0) const;
size_t find(const char* s, size_t pos, size_t count) const;
size_t find(const char* s, size_t pos = 0) const;
size_t find(char ch, size_t pos = 0) const;

Parameters

• str / s / ch — the substring, C-string, or single character to search for.
• pos — optional index where the search begins (default 0, the start of the string).
• count — (C-string overload) maximum number of characters from s to compare.

Return Value

Returns the index of the first character of the first match. Returns std::string::npos if the substring is not found.

Examples Gallery

Compile with any C++11+ compiler (for example g++ find.cpp -std=c++17 -o find). Each example builds practical search skills step by step.

#include <iostream>
#include <string>

int main() {
    std::string text = "Hello, C++!";

    size_t position = text.find("C++");

    if (position != std::string::npos) {
        std::cout << "Substring found at position: "
                  << position << std::endl;
    } else {
        std::cout << "Substring not found." << std::endl;
    }

    return 0;
}

Substring found at position: 7

#include <iostream>
#include <string>

int main() {
    std::string email = "user@example.com";

    size_t at = email.find("@");
    size_t hash = email.find("#");

    std::cout << "At sign index: " << at << std::endl;

    if (hash == std::string::npos) {
        std::cout << "No hash symbol in email." << std::endl;
    }

    return 0;
}

At sign index: 4
No hash symbol in email.

#include <iostream>
#include <string>

int main() {
    std::string word = "banana";

    size_t first = word.find("na");
    size_t second = word.find("na", first + 1);

    std::cout << "First 'na' at: " << first << std::endl;
    std::cout << "Second 'na' at: " << second << std::endl;

    return 0;
}

First 'na' at: 2
Second 'na' at: 4

#include <iostream>
#include <string>

int main() {
    std::string data = "one two one three one";
    std::string target = "one";
    size_t pos = 0;
    int count = 0;

    while ((pos = data.find(target, pos)) != std::string::npos) {
        std::cout << "Found at index " << pos << std::endl;
        count++;
        pos += target.length();
    }

    std::cout << "Total matches: " << count << std::endl;
    return 0;
}

Found at index 0
Found at index 8
Found at index 16
Total matches: 3

#include <iostream>
#include <string>

bool contains(const std::string& haystack, const std::string& needle) {
    return haystack.find(needle) != std::string::npos;
}

int main() {
    std::string url  = "https://codetofun.com/cpp/string/function/find";
    std::string file = "report.pdf";

    std::cout << std::boolalpha;
    std::cout << "URL has /cpp: " << contains(url, "/cpp") << std::endl;
    std::cout << "File is PDF: " << contains(file, ".pdf") << std::endl;
    std::cout << "File is TXT: " << contains(file, ".txt") << std::endl;

    return 0;
}

URL has /cpp: true
File is PDF: true
File is TXT: false

🚀 Common Use Cases

• URL and path parsing — locate "/", "?", or domain segments before splitting.
• File extension checks — confirm ".cpp", ".txt", or ".json" appears in a file name.
• Input validation — verify an email contains "@" or a command includes a required flag.
• Log analysis — search large text buffers for error codes or keywords.
• Token extraction — combine find() with substr() to slice text between delimiters.

📝 Notes

• The search is case-sensitive—"Java" and "java" are different.
• Always compare results with std::string::npos; do not rely on -1 (wrong type and value).
• find() returns the first match only; use a loop or rfind() for other needs.
• Include <string> and use the std::string class—not C-style char* search functions unless you intentionally work with C strings.
• Passing a C-string to find requires a null-terminated const char*; avoid unterminated buffers.

⚡ Optimization

For typical beginner and application strings, find() is fast enough and well optimized in standard libraries. For very large texts searched repeatedly, consider whether you need a specialized algorithm (Boyer–Moore, hash maps, or full-text indexes). Avoid calling find() on the same huge string thousands of times inside tight loops without caching results or restructuring data.

💡 Best Practices