Problem Overview

The core challenge involves locating the initial index of a specific pattern (substring) within a larger source string. If the pattern exists, return its starting position; otherwise, indicate failure (typically returning -1). An empty patttern usually defaults to an index of zero.

Algorithmic Approach

A robust strategy for basic scenarios utilizes a linear scan with two tracking pointers. One pointer advances through the primary dataset (haystack), while the other compares characters against the target sequence (needle). When a character mismatch occurs after partial matches, the primary pointer shifts forward to test the next potential starting position, while the secondary pointer resets to the beginning of the sequence.

Implementation Details

The following solution employs a brute-force comparison method optimized for clarity. We define distinct variables to represent lengths and current positions to anhance readability.

class StringSearchSolver {
public:
    int locateSubstring(const std::string& data, const std::string& pattern) {
        size_t sourceLength = data.length();
        size_t targetLength = pattern.length();

        // Edge case: Empty pattern returns 0
        if (targetLength == 0) return 0;

        size_t srcIdx = 0;
        size_t patIdx = 0;

        while (srcIdx < sourceLength && patIdx < targetLength) {
            if (data[srcIdx] == pattern[patIdx]) {
                srcIdx++;
                patIdx++;
            } else {
                // Backtrack: Move source pointer to next char
                // Reset pattern pointer to start
                srcIdx = srcIdx - patIdx + 1;
                patIdx = 0;
            }
        }

        return (patIdx == targetLength) ? (static_cast<int>(srcIdx - patIdx)) : -1;
    }
};

Memory and Size Operations in C++

Accurately managing string dimensions requires understanding three distinct operators/functions: length(), size(), and sizeof().

• length() and size(): These are member functions belonging to string classes (such as std::string). They compute the number of characters currently stored. Note that size() is also available for STL containers like vectors.
• sizeof Operator: This is a compile-time operator that determines the byte footprint of a data type or object, not the logical content length.

Primitive Type Sizes

In a standard 64-bit architecture, basic types occupy fixed memory blocks:

• Character: 1 byte
• Integer: 4 bytes
• Double Precision Float: 8 bytes
• Pointers (32-bit vs 64-bit): Typically 4 bytes on older systems, 8 bytes on modern 64-bit environments

Array vs Pointer Behavior

Determining the size of static arrays differs from dynamically allocated pointers. Arrays retain knowledge of their bounds at compile time, whereas pointers only store an address.

char bufferA[] = "Example";      // Actual content includes null terminator '\0'
char* ptrToBuffer = bufferA;     // Contains address only
const size_t lenA = sizeof(bufferA); // Returns total bytes (e.g., 8)
const size_t lenP = sizeof(ptrToBuffer); // Returns address size (e.g., 8)

When calculating the count of elements in a statically defined array, divide the total allocated space by the size of a single element:

int numericArray[] = {10, 20, 30};
size_t elementCount = sizeof(numericArray) / sizeof(numericArray[0]); 
// Result corresponds to the total number of items initialized

It is important to note that declaring an array with a fixed capacity (e.g., int arr\[10\]) reserves space for all 10 slots regardless of how many are explicitly initialized, affecting sizeof calculations.