Posted incompare

How Does String Compare Work In C?

No Comments

String comparison in C is fundamental for various applications, from verifying user inputs to detecting similarities in text. At COMPARE.EDU.VN, we aim to demystify the process of comparing strings in C, providing you with a comprehensive understanding and practical examples. This guide explores different methods, including using the strcmp() function, manual comparisons, pointers, and recursion, ensuring you can efficiently compare strings and determine their lexicographical order. Dive in to master string comparison techniques and enhance your C programming skills. Explore different methods for string comparison and improve your C programming skills with insights on equality checks, lexical ordering, and string handling available on compare.edu.vn.

1. What Is String Comparison and Why Is It Important in C?

String comparison in C involves determining if two strings are identical. This operation is crucial for various tasks, including verifying user input, searching within text, and sorting data. Efficient string comparison can significantly impact the performance and reliability of C applications. It enables developers to accurately manipulate and analyze textual data, ensuring program functionality aligns with intended behavior.

1.1 Applications of String Comparison

String comparison forms the backbone of numerous essential applications:

  • Password Verification: Verifying user-entered passwords against stored values is a classic example.

  • Plagiarism Detection: Identifying similarities between documents often relies on string comparison techniques.

  • Lexicographical Sorting: Arranging strings in dictionary order utilizes comparison algorithms.

  • Data Validation: Ensuring that user input matches expected formats and values requires string comparison.

  • Searching and Filtering: Locating specific text within larger datasets often involves comparing strings.

1.2 Lexicographical Order Explained

Lexicographical order, also known as dictionary order, is a method of ordering strings based on the alphabetical sequence of their characters. In C, the strcmp() function and other comparison techniques use ASCII values to determine the order. For example, “apple” comes before “banana” because ‘a’ has a lower ASCII value than ‘b’. Understanding lexicographical order is crucial for sorting and searching operations in C.

2. Method 1: String Comparison Using strcmp()

The strcmp() function, part of the string.h header file, offers a straightforward way to compare two strings in C. It compares the strings character by character until it finds a difference or reaches the null terminator ().

2.1 Understanding the strcmp() Function

strcmp() is a standard library function that takes two strings as arguments and returns an integer value. This value indicates the relationship between the strings. The function works by comparing the ASCII values of characters at each index until a mismatch is found or the end of the strings is reached.

2.1.1 Syntax of strcmp()

int strcmp(const char *str1, const char *str2);

In this syntax:

  • str1 and str2 are the two strings being compared.
  • The function returns an integer value.

2.1.2 Return Values of strcmp()

Return Value Meaning
0 The strings are identical.
< 0 str1 is lexicographically less than str2 (i.e., str1 comes before str2).
> 0 str1 is lexicographically greater than str2 (i.e., str1 comes after str2).

2.1.3 Code Example Using strcmp()

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

int main() {
    char str1[50], str2[50];

    printf("Enter the first string: ");
    scanf("%s", str1);

    printf("Enter the second string: ");
    scanf("%s", str2);

    int result = strcmp(str1, str2);

    if (result == 0) {
        printf("The strings are equal.n");
    } else if (result < 0) {
        printf("The first string is less than the second string.n");
    } else {
        printf("The first string is greater than the second string.n");
    }

    return 0;
}

Explanation:

  1. Include Headers: The code includes stdio.h for input/output operations and string.h for using the strcmp() function.
  2. Declare Strings: Two character arrays (str1 and str2) are declared to store the input strings.
  3. Input Strings: The program prompts the user to enter two strings, which are stored in str1 and str2 using scanf().
  4. Compare Strings: The strcmp() function is called to compare str1 and str2. The result is stored in the result variable.
  5. Check Result: The program checks the value of result:
    • If result is 0, it prints “The strings are equal.”
    • If result is less than 0, it prints “The first string is less than the second string.”
    • If result is greater than 0, it prints “The first string is greater than the second string.”
  6. Return 0: The program returns 0 to indicate successful execution.

2.2 Practical Examples of Using strcmp()

2.2.1 Password Verification

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

int main() {
    char correctPassword[] = "Secret123";
    char userPassword[50];

    printf("Enter your password: ");
    scanf("%s", userPassword);

    if (strcmp(userPassword, correctPassword) == 0) {
        printf("Password is correct!n");
    } else {
        printf("Incorrect password. Please try again.n");
    }

    return 0;
}

2.2.2 Sorting Strings

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

int main() {
    char names[5][50] = {
        "Charlie", "Alice", "Bob", "David", "Eve"
    };
    char temp[50];

    // Sort names array
    for (int i = 0; i < 4; i++) {
        for (int j = i + 1; j < 5; j++) {
            if (strcmp(names[i], names[j]) > 0) {
                strcpy(temp, names[i]);
                strcpy(names[i], names[j]);
                strcpy(names[j], temp);
            }
        }
    }

    printf("Sorted names:n");
    for (int i = 0; i < 5; i++) {
        printf("%sn", names[i]);
    }

    return 0;
}

2.3 Advantages and Disadvantages of strcmp()

Advantages:

  • Simplicity: Easy to use and understand.
  • Efficiency: Optimized for performance in standard C libraries.
  • Standardization: Available in virtually all C environments.

Disadvantages:

  • Case Sensitivity: strcmp() is case-sensitive, which may not be suitable for all applications.
  • No Partial Matching: Cannot be used for partial or fuzzy string matching without additional logic.

3. Method 2: String Comparison Without Using strcmp()

Comparing strings character by character provides more control and customization compared to using strcmp(). This method involves iterating through both strings and comparing characters manually.

3.1 Implementing Manual String Comparison

Manual string comparison involves writing custom code to iterate through the strings and compare each character. This approach allows for more flexibility and the ability to handle specific requirements, such as case-insensitive comparisons or partial matching.

3.1.1 Code Example for Manual String Comparison

#include <stdio.h>
#include <stdbool.h>

bool compareStrings(const char *str1, const char *str2) {
    int i = 0;
    while (str1[i] != '' && str2[i] != '') {
        if (str1[i] != str2[i]) {
            return false; // Strings are different
        }
        i++;
    }
    // Check if both strings ended at the same index
    return str1[i] == '' && str2[i] == '';
}

int main() {
    char str1[50], str2[50];

    printf("Enter the first string: ");
    scanf("%s", str1);

    printf("Enter the second string: ");
    scanf("%s", str2);

    if (compareStrings(str1, str2)) {
        printf("The strings are equal.n");
    } else {
        printf("The strings are not equal.n");
    }

    return 0;
}

Explanation:

  1. Include Headers: The code includes stdio.h for input/output operations and stdbool.h for using the bool data type.
  2. compareStrings Function:
    • Takes two strings, str1 and str2, as input.
    • Initializes an index i to 0.
    • Uses a while loop to iterate through the strings character by character as long as neither string reaches its null terminator ().
    • Inside the loop, it checks if the characters at the current index i are different. If they are, the function immediately returns false, indicating that the strings are not equal.
    • If the characters are the same, the index i is incremented to check the next pair of characters.
    • After the loop, it checks if both strings have reached their null terminators at the same index. If they have, it means the strings are equal, and the function returns true. Otherwise, it returns false.
  3. main Function:
    • Declares two character arrays, str1 and str2, to store the input strings.
    • Prompts the user to enter two strings and stores them in str1 and str2 using scanf.
    • Calls the compareStrings function to compare str1 and str2.
    • Prints whether the strings are equal or not based on the return value of compareStrings.
  4. Return 0: The program returns 0 to indicate successful execution.

3.1.2 Case-Insensitive Comparison

To perform a case-insensitive comparison, you can convert both strings to the same case (upper or lower) before comparing them.

#include <stdio.h>
#include <stdbool.h>
#include <ctype.h>

bool compareStringsCaseInsensitive(const char *str1, const char *str2) {
    int i = 0;
    while (str1[i] != '' && str2[i] != '') {
        if (tolower((unsigned char)str1[i]) != tolower((unsigned char)str2[i])) {
            return false; // Strings are different
        }
        i++;
    }
    return str1[i] == '' && str2[i] == '';
}

int main() {
    char str1[50], str2[50];

    printf("Enter the first string: ");
    scanf("%s", str1);

    printf("Enter the second string: ");
    scanf("%s", str2);

    if (compareStringsCaseInsensitive(str1, str2)) {
        printf("The strings are equal (case-insensitive).n");
    } else {
        printf("The strings are not equal (case-insensitive).n");
    }

    return 0;
}

Explanation:

  1. Include Headers: The code includes stdio.h for input/output operations, stdbool.h for using the bool data type, and ctype.h for character handling functions like tolower.
  2. compareStringsCaseInsensitive Function:
    • Takes two strings, str1 and str2, as input.
    • Initializes an index i to 0.
    • Uses a while loop to iterate through the strings character by character as long as neither string reaches its null terminator ().
    • Inside the loop, it converts both characters at the current index i to lowercase using tolower. The (unsigned char) cast is used to ensure that tolower works correctly with extended character sets.
    • It then checks if the lowercase versions of the characters are different. If they are, the function immediately returns false, indicating that the strings are not equal.
    • If the lowercase versions of the characters are the same, the index i is incremented to check the next pair of characters.
    • After the loop, it checks if both strings have reached their null terminators at the same index. If they have, it means the strings are equal, and the function returns true. Otherwise, it returns false.
  3. main Function:
    • Declares two character arrays, str1 and str2, to store the input strings.
    • Prompts the user to enter two strings and stores them in str1 and str2 using scanf.
    • Calls the compareStringsCaseInsensitive function to compare str1 and str2 in a case-insensitive manner.
    • Prints whether the strings are equal or not based on the return value of compareStringsCaseInsensitive.
  4. Return 0: The program returns 0 to indicate successful execution.

3.2 Advantages and Disadvantages of Manual Comparison

Advantages:

  • Customization: Allows for tailored comparison logic, such as case-insensitive comparisons.
  • Flexibility: Can handle partial matching and other specific requirements.
  • Control: Provides direct control over the comparison process.

Disadvantages:

  • Complexity: Requires more code and can be more error-prone.
  • Performance: May be slower than optimized library functions like strcmp().
  • Maintenance: Requires careful maintenance and testing to ensure correctness.

4. Method 3: String Comparison Using Pointers

Using pointers for string comparison can offer a more efficient way to traverse and compare strings in C. This method involves using pointers to access and compare characters directly.

4.1 How Pointers Work with Strings

In C, a string is an array of characters terminated by a null character (). A pointer can be used to point to the first character of the string, and pointer arithmetic can be used to move through the string.

4.1.1 Code Example for Pointer-Based String Comparison

#include <stdio.h>
#include <stdbool.h>

bool compareStringsWithPointers(const char *str1, const char *str2) {
    while (*str1 != '' && *str2 != '') {
        if (*str1 != *str2) {
            return false; // Strings are different
        }
        str1++;
        str2++;
    }
    return *str1 == '' && *str2 == '';
}

int main() {
    char str1[50], str2[50];

    printf("Enter the first string: ");
    scanf("%s", str1);

    printf("Enter the second string: ");
    scanf("%s", str2);

    if (compareStringsWithPointers(str1, str2)) {
        printf("The strings are equal.n");
    } else {
        printf("The strings are not equal.n");
    }

    return 0;
}

Explanation:

  1. Include Headers: The code includes stdio.h for input/output operations and stdbool.h for using the bool data type.
  2. compareStringsWithPointers Function:
    • Takes two strings, str1 and str2, as input (as const char * to ensure the strings are not modified).
    • Uses a while loop to iterate through the strings character by character as long as neither string reaches its null terminator ().
    • Inside the loop:
      • *str1 and *str2 dereference the pointers to access the characters at the current positions.
      • If the characters are different, the function immediately returns false, indicating that the strings are not equal.
      • If the characters are the same, the pointers str1 and str2 are incremented to point to the next characters in the strings.
    • After the loop, it checks if both strings have reached their null terminators. If they have, it means the strings are equal, and the function returns true. Otherwise, it returns false.
  3. main Function:
    • Declares two character arrays, str1 and str2, to store the input strings.
    • Prompts the user to enter two strings and stores them in str1 and str2 using scanf.
    • Calls the compareStringsWithPointers function to compare str1 and str2.
    • Prints whether the strings are equal or not based on the return value of compareStringsWithPointers.
  4. Return 0: The program returns 0 to indicate successful execution.

4.1.2 Advantages of Using Pointers

  • Efficiency: Pointers can be more efficient for string traversal compared to array indexing.
  • Direct Memory Access: Allows direct manipulation of memory locations.

4.1.3 Potential Pitfalls

  • Complexity: Requires a good understanding of pointer arithmetic.
  • Risk of Errors: Incorrect pointer usage can lead to segmentation faults or other memory-related errors.

4.2 Practical Examples

4.2.1 Finding the Length of a String

#include <stdio.h>

int stringLength(const char *str) {
    int length = 0;
    while (*str != '') {
        length++;
        str++;
    }
    return length;
}

int main() {
    char myString[] = "Hello, World!";
    int len = stringLength(myString);
    printf("Length of the string: %dn", len);
    return 0;
}

4.2.2 Copying a String

#include <stdio.h>

void stringCopy(char *dest, const char *src) {
    while (*src != '') {
        *dest = *src;
        dest++;
        src++;
    }
    *dest = ''; // Null-terminate the destination string
}

int main() {
    char source[] = "Source string";
    char destination[50];
    stringCopy(destination, source);
    printf("Copied string: %sn", destination);
    return 0;
}

4.3 Advantages and Disadvantages

Advantages:

  • Efficiency: Can offer better performance compared to array indexing.
  • Flexibility: Allows for more complex string manipulations.

Disadvantages:

  • Complexity: Requires a solid understanding of pointers.
  • Error-Prone: Can lead to memory-related errors if not handled carefully.

5. Method 4: String Comparison Using Recursion

Recursion can also be employed to compare two strings in C. This method involves breaking down the problem into smaller, self-similar subproblems.

5.1 Understanding Recursion

Recursion is a programming technique where a function calls itself to solve smaller instances of the same problem. In the context of string comparison, the function compares the first characters of the strings and then recursively calls itself with the rest of the strings.

5.1.1 Code Example for Recursive String Comparison

#include <stdio.h>
#include <stdbool.h>

bool compareStringsRecursive(const char *str1, const char *str2) {
    if (*str1 == '' && *str2 == '') {
        return true; // Both strings are empty, so they are equal
    }
    if (*str1 == '' || *str2 == '') {
        return false; // One string is empty, and the other is not
    }
    if (*str1 != *str2) {
        return false; // Characters are different
    }
    return compareStringsRecursive(str1 + 1, str2 + 1); // Recursive call
}

int main() {
    char str1[50], str2[50];

    printf("Enter the first string: ");
    scanf("%s", str1);

    printf("Enter the second string: ");
    scanf("%s", str2);

    if (compareStringsRecursive(str1, str2)) {
        printf("The strings are equal.n");
    } else {
        printf("The strings are not equal.n");
    }

    return 0;
}

Explanation:

  1. Include Headers: The code includes stdio.h for input/output operations and stdbool.h for using the bool data type.
  2. compareStringsRecursive Function:
    • Takes two strings, str1 and str2, as input (as const char * to ensure the strings are not modified).
    • Base Cases:
      • If both strings are empty (*str1 == '' && *str2 == ''), it means we’ve reached the end of both strings and they are equal, so the function returns true.
      • If only one of the strings is empty (*str1 == '' || *str2 == ''), it means one string is shorter than the other, so the function returns false.
    • Recursive Case:
      • If the current characters are different (*str1 != *str2), the function immediately returns false.
      • If the current characters are the same, the function calls itself (compareStringsRecursive) with the pointers incremented by one (str1 + 1, str2 + 1) to compare the next characters in the strings.
  3. main Function:
    • Declares two character arrays, str1 and str2, to store the input strings.
    • Prompts the user to enter two strings and stores them in str1 and str2 using scanf.
    • Calls the compareStringsRecursive function to compare str1 and str2.
    • Prints whether the strings are equal or not based on the return value of compareStringsRecursive.
  4. Return 0: The program returns 0 to indicate successful execution.

5.1.2 Advantages of Using Recursion

  • Elegance: Can lead to concise and readable code.
  • Conceptual Clarity: May simplify the logic for some problems.

5.1.3 Potential Pitfalls

  • Overhead: Recursive calls can be less efficient due to function call overhead.
  • Stack Overflow: Excessive recursion can lead to stack overflow errors.

5.2 Practical Examples

5.2.1 Palindrome Check

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

bool isPalindromeRecursive(const char *str, int start, int end) {
    if (start >= end) {
        return true; // Base case: empty or single-character string
    }
    if (str[start] != str[end]) {
        return false; // Characters don't match
    }
    return isPalindromeRecursive(str, start + 1, end - 1); // Recursive call
}

int main() {
    char myString[] = "madam";
    int len = strlen(myString);
    if (isPalindromeRecursive(myString, 0, len - 1)) {
        printf("The string is a palindrome.n");
    } else {
        printf("The string is not a palindrome.n");
    }
    return 0;
}

5.2.2 String Reversal

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

void reverseStringRecursive(char *str, int start, int end) {
    if (start >= end) {
        return; // Base case: nothing to reverse
    }
    // Swap characters
    char temp = str[start];
    str[start] = str[end];
    str[end] = temp;
    reverseStringRecursive(str, start + 1, end - 1); // Recursive call
}

int main() {
    char myString[] = "hello";
    int len = strlen(myString);
    reverseStringRecursive(myString, 0, len - 1);
    printf("Reversed string: %sn", myString);
    return 0;
}

5.3 Advantages and Disadvantages

Advantages:

  • Elegance: Can provide a clean and concise solution for certain problems.
  • Readability: May improve code readability in some cases.

Disadvantages:

  • Overhead: Generally less efficient than iterative solutions due to function call overhead.
  • Stack Overflow Risk: Can lead to stack overflow errors with deep recursion.

6. Choosing the Right Method

Selecting the appropriate string comparison method in C depends on the specific requirements of your application. Each method—strcmp(), manual comparison, pointers, and recursion—offers unique advantages and disadvantages.

6.1 Factors to Consider

  • Performance Requirements: If performance is critical, strcmp() is often the best choice due to its optimized implementation.
  • Customization Needs: For case-insensitive comparisons or partial matching, manual comparison provides the necessary flexibility.
  • Code Complexity: Pointers and recursion can add complexity, so consider whether the benefits outweigh the potential for errors.
  • Readability and Maintainability: Choose the method that results in the clearest and most maintainable code.

6.2 Summary Table

Method Advantages Disadvantages Use Cases
strcmp() Simple, efficient, standardized Case-sensitive, no partial matching Basic string comparison, sorting
Manual Comparison Customizable, flexible Complex, potentially slower, requires careful maintenance Case-insensitive comparison, partial matching, custom comparison logic
Pointers Efficient memory access, flexible Complex, error-prone, requires a good understanding of pointer arithmetic Efficient string traversal, direct memory manipulation
Recursion Elegant, conceptually clear Overhead, stack overflow risk Palindrome checks, string reversal, problems that can be naturally divided

7. Advanced String Comparison Techniques

Beyond the basic methods, several advanced techniques can enhance string comparison in C. These include fuzzy string matching, using hash tables, and employing regular expressions.

7.1 Fuzzy String Matching

Fuzzy string matching, also known as approximate string matching, is used to find strings that are similar but not exactly identical. This is useful for applications like spell checking and data deduplication.

7.1.1 Levenshtein Distance

The Levenshtein distance measures the similarity between two strings by counting the minimum number of single-character edits required to change one string into the other. These edits include insertions, deletions, and substitutions.

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

int levenshteinDistance(const char *s1, const char *s2) {
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    int matrix[len1 + 1][len2 + 1];
    int i, j;

    for (i = 0; i <= len1; i++) {
        matrix[i][0] = i;
    }
    for (j = 0; j <= len2; j++) {
        matrix[0][j] = j;
    }

    for (i = 1; i <= len1; i++) {
        for (j = 1; j <= len2; j++) {
            int cost = (s1[i - 1] == s2[j - 1]) ? 0 : 1;
            matrix[i][j] = (matrix[i - 1][j] + 1 < matrix[i][j - 1] + 1) ? (matrix[i - 1][j] + 1) : (matrix[i][j - 1] + 1);
            if (matrix[i][j] > matrix[i - 1][j - 1] + cost) {
                matrix[i][j] = matrix[i - 1][j - 1] + cost;
            }
        }
    }

    return matrix[len1][len2];
}

int main() {
    char str1[] = "kitten";
    char str2[] = "sitting";
    int distance = levenshteinDistance(str1, str2);
    printf("Levenshtein Distance between '%s' and '%s' is %dn", str1, str2, distance);
    return 0;
}

7.1.2 Hamming Distance

The Hamming distance measures the similarity between two strings of equal length by counting the number of positions at which the corresponding symbols are different.

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

int hammingDistance(const char *s1, const char *s2) {
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    int distance = 0;
    int i;

    if (len1 != len2) {
        return -1; // Strings must be of equal length
    }

    for (i = 0; i < len1; i++) {
        if (s1[i] != s2[i]) {
            distance++;
        }
    }

    return distance;
}

int main() {
    char str1[] = "karolin";
    char str2[] = "kathrin";
    int distance = hammingDistance(str1, str2);
    if (distance != -1) {
        printf("Hamming Distance between '%s' and '%s' is %dn", str1, str2, distance);
    } else {
        printf("Strings must be of equal length.n");
    }
    return 0;
}

7.2 Using Hash Tables

Hash tables can be used to improve the performance of string comparison by pre-calculating hash values for the strings. This can be particularly useful when comparing a large number of strings.

7.2.1 Simple Hash Function

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

unsigned int simpleHash(const char *str) {
    unsigned int hash = 5381;
    int c;

    while ((c = *str++)) {
        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
    }

    return hash;
}

int main() {
    char str1[] = "hello";
    char str2[] = "world";
    unsigned int hash1 = simpleHash(str1);
    unsigned int hash2 = simpleHash(str2);

    printf("Hash of '%s': %un", str1, hash1);
    printf("Hash of '%s': %un", str2, hash2);

    if (hash1 == hash2) {
        printf("Strings might be equal (hash collision).n");
    } else {
        printf("Strings are definitely not equal.n");
    }

    return 0;
}

7.2.2 Hash Table for String Lookup

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

#define TABLE_SIZE 100

typedef struct {
    char *key;
    int value;
} HashItem;

typedef struct {
    HashItem *items[TABLE_SIZE];
} HashTable;

unsigned int hashFunction(const char *key) {
    unsigned int hash = 5381;
    int c;

    while ((c = *key++)) {
        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
    }

    return hash % TABLE_SIZE;
}

HashTable *createHashTable() {
    HashTable *table = (HashTable *)malloc(sizeof(HashTable));
    for (int i = 0; i < TABLE_SIZE; i++) {
        table->items[i] = NULL;
    }
    return table;
}

void insertItem(HashTable *table, const char *key, int value) {
    unsigned int index = hashFunction(key);
    HashItem *newItem = (HashItem *)malloc(sizeof(HashItem));
    newItem->key = strdup(key); // Duplicate the key
    newItem->value = value;

    table->items[index] = newItem;
}

HashItem *getItem(HashTable *table, const char *key) {
    unsigned int index = hashFunction(key);
    return table->items[index];
}

int main() {
    HashTable *myTable = createHashTable();

    insertItem(myTable, "apple", 1);
    insertItem(myTable, "banana", 2);
    insertItem(myTable, "cherry", 3);

    HashItem *item = getItem(myTable, "banana");
    if (item != NULL) {
        printf("Value for key 'banana': %dn", item->value);
    } else {
        printf("Key 'banana' not found.n");
    }

    return 0;
}

7.3 Regular Expressions

Regular expressions provide a powerful way to match patterns in strings. They are useful for complex string comparisons and validation.

7.3.1 Using regex.h for Pattern Matching


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

bool regexMatch(const char *string, const char *pattern) {
    regex_t regex;
    int result;

    // Compile regular expression
    if (regcomp(&regex, pattern, REG_EXTENDED) != 0) {
        fprintf(stderr, "Could not compile regexn");
        return false;
    }

    // Execute regular expression
    result = regexec(&regex, string, 0, NULL, 0);
    regfree(&regex);

    return result == 0;
}

int main() {
    char string[] = "Hello, World!";

Comments

No comments yet. Why don’t you start the discussion?

Leave a Reply

Your email address will not be published. Required fields are marked *