root@generate-random:~/email/cpp$ _

Generate Random Email Addresses in C++ - Testing & QA

Complete code tutorial with examples and best practices

C++

Ruby Go

[ Code Example - Quick Summary ]

Language: C++

What: Generate random email addresses in C++ using modern C++11/17 features for testing, QA, and mock data generation.

Try it: Use our interactive Email generator or integrate this code into your C++ application.

Generate random email addresses in C++ using modern C++11/17 features for testing, QA, and mock data generation. Looking for other languages? Check our code examples in PHP , JavaScript , Python , Java , C# , Ruby and Go or use our interactive web generator.

C++ Code Example

#include <iostream>
#include <random>
#include <string>
#include <vector>
#include <algorithm>
#include <chrono>

class EmailGenerator {
private:
    std::random_device rd;
    std::mt19937 gen;
    std::uniform_int_distribution<> dist;

    static constexpr const char* adjectives[] = {"happy", "sunny", "clever", "bright", "quick"};
    static constexpr const char* nouns[] = {"panda", "tiger", "eagle", "dolphin", "falcon"};

public:
    EmailGenerator() : gen(rd()), dist(0, 9) {}

    std::string randomEmail(const std::string& domain = "example.com") {
        std::string username = generateRandomString(12);
        return username + "@" + domain;
    }

    std::string readableEmail(const std::string& domain = "example.com") {
        std::uniform_int_distribution<> adj_dist(0, 4);
        std::uniform_int_distribution<> noun_dist(0, 4);
        std::uniform_int_distribution<> num_dist(100, 999);

        std::string adj = adjectives[adj_dist(gen)];
        std::string noun = nouns[noun_dist(gen)];
        int num = num_dist(gen);

        return adj + noun + std::to_string(num) + "@" + domain;
    }

    std::string emailFromName(const std::string& firstName,
                             const std::string& lastName,
                             const std::string& domain = "company.com") {
        std::vector<std::string> patterns = {
            toLowerCase(firstName) + "." + toLowerCase(lastName),
            std::string(1, std::tolower(firstName[0])) + toLowerCase(lastName),
            toLowerCase(firstName) + std::string(1, std::tolower(lastName[0])),
            toLowerCase(firstName) + "_" + toLowerCase(lastName)
        };

        std::uniform_int_distribution<> pattern_dist(0, patterns.size() - 1);
        return patterns[pattern_dist(gen)] + "@" + domain;
    }

    std::string testEmail(const std::string& domain = "test.local") {
        auto timestamp = std::chrono::system_clock::now().time_since_epoch().count();
        std::uniform_int_distribution<> num_dist(1000, 9999);

        return "test_" + std::to_string(timestamp) + "_" +
               std::to_string(num_dist(gen)) + "@" + domain;
    }

    std::vector<std::string> generateEmails(int count,
                                           const std::string& domain = "example.com") {
        std::vector<std::string> emails;
        auto baseTime = std::chrono::system_clock::now().time_since_epoch().count();

        for (int i = 0; i < count; ++i) {
            emails.push_back("user" + std::to_string(baseTime + i) + "@" + domain);
        }

        return emails;
    }

    bool isValidEmail(const std::string& email) {
        // Basic validation: contains @ and .
        size_t at_pos = email.find('@');
        size_t dot_pos = email.rfind('.');

        return at_pos != std::string::npos &&
               dot_pos != std::string::npos &&
               at_pos < dot_pos &&
               dot_pos < email.length() - 1;
    }

private:
    std::string generateRandomString(int length) {
        const std::string chars = "abcdefghijklmnopqrstuvwxyz0123456789";
        std::uniform_int_distribution<> char_dist(0, chars.length() - 1);

        std::string result;
        for (int i = 0; i < length; ++i) {
            result += chars[char_dist(gen)];
        }
        return result;
    }

    std::string toLowerCase(const std::string& str) {
        std::string result = str;
        std::transform(result.begin(), result.end(), result.begin(), ::tolower);
        return result;
    }
};

int main() {
    EmailGenerator generator;

    std::cout << "Random Email: " << generator.randomEmail() << std::endl;
    std::cout << "Readable Email: " << generator.readableEmail() << std::endl;
    std::cout << "Name-based: " << generator.emailFromName("John", "Doe") << std::endl;
    std::cout << "Test Email: " << generator.testEmail() << std::endl;

    auto emails = generator.generateEmails(3);
    std::cout << "Multiple Emails: ";
    for (const auto& email : emails) {
        std::cout << email << " ";
    }
    std::cout << std::endl;

    std::string email = generator.randomEmail();
    std::cout << "Valid: " << (generator.isValidEmail(email) ? "Yes" : "No") << std::endl;

    return 0;
}

[EXPLANATION]

Modern C++ uses std::random_device and std::mt19937 for high-quality random generation. std::uniform_int_distribution generates uniformly distributed integers for indices and numbers. std::chrono provides timestamp-based uniqueness with time_since_epoch(). std::transform with ::tolower converts strings to lowercase. std::vector stores multiple emails efficiently. Basic email validation checks for @ and . positions. For regex validation, use <regex> header with std::regex and std::regex_match().

Expected Output

Random Email: k8j2n5p7x9w3@example.com
Readable Email: brighteagle847@example.com
Name-based: john.doe@company.com
Test Email: test_1703001234567890_7392@test.local
Multiple Emails: user1703001234567890@example.com user1703001234567891@example.com user1703001234567892@example.com
Valid: Yes