How To Validate Image File Extension Using Regular Expression In C++

In this instance, we will explore the process of validating file extensions using regular expressions in C++ with multiple illustrations.

Introduction:

Validating image file extensions is a crucial step in numerous applications, particularly in scenarios involving user-generated uploads or external data feeds. This validation process ensures that only permitted image formats are permitted, thus minimizing potential security threats and upholding the integrity of data. Leveraging regular expressions offers a sophisticated approach to establishing patterns that streamline the validation of image file extensions at the programming level.

Problem Statement:

When handling files within a C++ application, it is often necessary for the team to verify the legitimacy of the given file extension while receiving an image for further processing or storage. Expanding the roster of accepted formats can be a laborious task prone to errors. Moreover, if the team adheres to a naming standard that permits variations in a file's root and extension, employing regular expressions proves to be a more effective method for establishing guidelines for various file extension patterns such as jpg or jpeg, and subsequently confirming the conformity of file names with these rules.

What is a Regular Expression?

Character combinations in strings can be matched with regular expressions . The regular expression template library in C++ includes a number of functions for regular expressions. Here are the step-by-step instructions for using regular expressions in C++ to check the image file extensions:

• ✅ Define Valid Image File Extensions: This is the first step. State what types of images have a valid extension that our application supports (.jpg, .png, .gif, .bmp,...).
• ✅ Create a regular expression pattern that will match any of the valid image file extensions. The pattern should use the '|' operator to specify multiple extensions and escape special characters like '.' .
• ✅ Compile a regular expression: Create a regular-expression pattern using std::regex from C++'s <regex> header file.
• ✅ Validate file extension: If a file name is passed, check if the file extension matches the compiled regular expression pattern using the std::regex_match .
• ✅ Handle a Validation Result: According to the result of validation, deal with the file accordingly, accepting it or declining it.

Program 1:

Let's consider a scenario to showcase how to verify the file extension of an image using regular expressions in C++.

#include <iostream>
#include <regex>
#include <string>

bool validateImageFileExtension(const std::string& fileName) {
    // Define valid image file extensions
    std::string validExtensions = R"((jpg|jpeg|png|gif|bmp)$)";

    // Construct regular expression pattern
    std::regex pattern(validExtensions);

    // Validate file extension
    return std::regex_match(fileName, pattern);
}

int main() {
    std::string fileExtensionName = "jpg";

    if (validateImageFileExtension(fileExtensionName)) {
        std::cout << "Valid image file extension." << std::endl;
    } else {
        std::cout << "Invalid image file extension." << std::endl;
    }

    return 0;
}

Output:

Valid image file extension.

Explanation:

• ✅ In this example, we define a function validateImageFileExtension that takes a fileName as input and returns a boolean indicating whether the file extension is valid.
• ✅ After that, we construct a regular expression pattern validExtensions that matches common image file extensions.
• ✅ Next, the regular expression is compiled using the std::regex .
• ✅ Function below will test the validation function on the example file name "example.jpg" inside the main function.
• ✅ Based on the validation outcome, it displays either "This is a valid image file extension or This is an invalid image file extension".

Program 2:

Let's consider another instance to showcase the validation of image file extensions using regular expressions in C++.

#include <iostream>
#include <regex>
using namespace std;

// Function to validate the image file extension.
bool validateImageExtension(string fileName)
{
    // Regular expression pattern to check valid image file extensions.
    const regex pattern("[^\\s]+(.*?)\\.(jpg|jpeg|png|gif|JPG|JPEG|PNG|GIF)$");

    // If the file name is empty, return false.
    if (fileName.empty())
    {
        return false;
    }

    // Return true if the file extension matches the regular expression pattern.
    if (regex_match(fileName, pattern))
    {
        return true;
    }
    else
    {
        return false;
    }
}

// Driver code
int main()
{
    // Test Case 1:
    string fileName1 = "image1.png";
    cout << "Test Case 1: " << validateImageExtension(fileName1) << endl;

    // Test Case 2:
    string fileName2 = "picture.jpg";
    cout << "Test Case 2: " << validateImageExtension(fileName2) << endl;

    // Test Case 3:
    string fileName3 = ".gif";
    cout << "Test Case 3: " << validateImageExtension(fileName3) << endl;

    // Test Case 4:
    string fileName4 = "audio.mp3";
    cout << "Test Case 4: " << validateImageExtension(fileName4) << endl;

    // Test Case 5:
    string fileName5 = "invalid.jpg";
    cout << "Test Case 5: " << validateImageExtension(fileName5) << endl;

    return 0;
}

Output:

Test Case 1: 1
Test Case 2: 1
Test Case 3: 0
Test Case 4: 0
Test Case 5: 1

Explanation:

1. Header Inclusions:

The program contains the header files below:

• ✅ <iostream> for input and output operations.
• ✅ <regex> for regular expression support.

1. Namespace Declaration:

• ✅ The using namespace std; statement allows the use of standard C++ library functions and objects without prefixing them with std:: .

1. Function Definition (validateImageExtension):

• ✅ This function takes a string (fileName) as input and returns a boolean value indicating whether the file extension is valid or not.
• ✅ It uses a regular expression pattern to define valid image file extensions like jpg, jpeg, png, gif, JPG, JPEG, PNG, and GIF.
• ✅ The function checks if the provided file name is empty. If it is, it returns false.
• ✅ After that, it uses regex_match to match the file name against the regular expression pattern. If the match is successful, it returns true; otherwise, it returns false.

1. Main Function:

• ✅ The main function is the entry point of the program.
• ✅ It contains several test cases to demonstrate the usage of the validateImageExtension
• ✅ Each test case involves providing a file name to the validateImageExtension function and printing the result (true or false) to the console.

1. Test Cases:

Test cases include various file names with different extensions:

• ✅ Test Case 1: Valid image file name with the extension .png.
• ✅ Test Case 2: Valid image file name with the extension .jpg.
• ✅ Test Case 3: Valid image file name with the extension .gif.
• ✅ Test Case 4: Invalid image file name with the extension .mp3.
• ✅ Test Case 5: Invalid image file name with the extension .jpg, preceded by a space.

1. Output:

• ✅ The program writes the output of each test data to the console. It prints result 1 if it is valid; otherwise 0.

Uses:

There are several use cases of Image File Extension. Some main uses are as follows:

• ✅ Data integrity: Assurance checks that no unauthorised data is modified or deleted and that data entered or received by a system conform to certain standards or rules are examples of validation.
• ✅ Security: When we properly sanitise inputs to prevent malicious code or unexpected characters, input validation minimises security threats, such as injection attacks (for example, SQL injection or cross-site scripting (XSS) attacks).
• ✅ User Experience: Validation improves the user experience by giving us real-time feedback on the input errors; if we validate the data on a client-side (yeah, web form!) of a web page, we will get immediate feedback and avoid excessive frustration. Hence, a lower rate of user errors.
• ✅ Compliance: Standards and regulations in some industries require data-validation rules to ensure compliance. For example, financial institutions validate customer information to be AML-compliant (AML means 'Anti-Money Laundering').
• ✅ Validation: Data accuracy is one of the essentials of data validation. It ensures that data is indeed safe to run the automation and analysis. In other words, organisations can be confident about the accuracy of their data-driven decisions by validating data against predefined criteria or business rules.
• ✅ Error Prevention: Validation reduces errors in data entered by users by enforcing input rules and constraints. We might have noticed that email addresses are validated when we enter them, ensuring that users have entered correctly formatted addresses and reducing the likelihood those such addresses will be excluded from a mailing list.
• ✅ System reliability: Validating input data prior to processing it prevents crashes or hangs of a computer system due to inputting unexpected or erroneous data. If errors can be caught early on in a process, the outcome/output of a system can be more reliable.
• ✅ Quality assurance: In a quality assurance process, ensuring that software runs as intended under a set of possible conditions and inputs is vital. Automated tests can be run to prove that certain kinds of data and functionality are correct. Validations catch bugs and other issues before end users encounter them.

Conclusion:

In summary, employing a regular expression in C++ can verify image file extensions, simplifying the process of checking file extensions by requiring comparison of only a single value instead of two. This enhancement contributes to the application's resilience. Regular expressions are highly adaptable tools for specifying and locating pattern matches, underscoring the significance of patterns within this context.