C memchr() Function

The memchr() function in C is a standard library function that searches for the first occurrence of a specified character in a block of memory. It is part of the C standard library (string.h). This function is useful for locating a specific byte in a memory block.

Table of Contents

1. Introduction
2. memchr() Function Syntax
3. Understanding memchr() Function
4. Examples
   • Locating a Character in an Array of Integers
   • Locating a Character in a String
5. Real-World Use Case
6. Conclusion

Introduction

The memchr() function searches the first n bytes of the memory block pointed to by ptr for the first occurrence of the specified character c. It returns a pointer to the located character, or NULL if the character is not found within the given range.

memchr() Function Syntax

The syntax for the memchr() function is as follows:

void *memchr(const void *ptr, int c, size_t n);

Parameters:

• ptr: A pointer to the memory block to be searched.
• c: The character to be located. It is passed as an int, but it is internally converted to an unsigned char.
• n: The number of bytes to be analyzed.

Returns:

• The function returns a pointer to the first occurrence of the character c in the memory block. If the character is not found within the first n bytes, the function returns NULL.

Understanding memchr() Function

The memchr() function performs a byte-by-byte search for the specified character in the given memory block. It stops searching as soon as it finds the character or when it reaches the end of the specified range (n bytes). The function treats the memory block as an array of unsigned char.

Examples

Locating a Character in an Array of Integers

To demonstrate how to use memchr() to locate a character in an array of integers, we will write a simple program.

Example

#include <stdio.h>
#include <string.h>

int main() {
    int array[] = {1, 2, 3, 4, 5};
    int target = 3;
    size_t n = sizeof(array);

    // Locate the character using memchr
    int *result = (int *)memchr(array, target, n);

    // Print the result
    if (result != NULL) {
        printf("Found %d at position %ld\n", target, result - array);
    } else {
        printf("Character not found\n");
    }

    return 0;
}

Output:

Found 3 at position 2

Locating a Character in a String

This example shows how to use memchr() to locate a character in a string.

Example

#include <stdio.h>
#include <string.h>

int main() {
    char str[] = "Hello, World!";
    char target = 'W';
    size_t n = strlen(str);

    // Locate the character using memchr
    char *result = (char *)memchr(str, target, n);

    // Print the result
    if (result != NULL) {
        printf("Found '%c' at position %ld\n", target, result - str);
    } else {
        printf("Character not found\n");
    }

    return 0;
}

Output:

Found 'W' at position 7

Real-World Use Case

Searching for a Byte in a Data Stream

In real-world applications, the memchr() function can be used to search for a specific byte in a data stream, such as finding a delimiter in a network packet.

Example: Searching for a Byte in a Data Stream

#include <stdio.h>
#include <string.h>

int main() {
    unsigned char data_stream[] = {0x01, 0x02, 0x03, 0x7E, 0x04, 0x05};
    unsigned char delimiter = 0x7E;
    size_t n = sizeof(data_stream);

    // Locate the delimiter using memchr
    unsigned char *result = (unsigned char *)memchr(data_stream, delimiter, n);

    // Print the result
    if (result != NULL) {
        printf("Found delimiter 0x%X at position %ld\n", delimiter, result - data_stream);
    } else {
        printf("Delimiter not found\n");
    }

    return 0;
}

Output:

Found delimiter 0x7E at position 3

Conclusion

The memchr() function is used for locating a specific byte in a block of memory in C. By understanding and using this function correctly, you can efficiently search for characters in arrays, strings, and other data structures. This is particularly useful in applications that involve searching for specific values or delimiters in data streams or memory blocks.