root@generate-random:~/mac-addresses/cpp$ _

Generate Random MAC Addresses in C++

Complete code tutorial with examples and best practices

C++

Ruby Go

[ Code Example - Quick Summary ]

Language: C++

What: Generate random MAC addresses in C++ using std::random and string formatting. Covers standard format, locally administered addresses, vendor prefixes, and validation.

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

Generate random MAC addresses in C++ using std::random and string formatting. Covers standard format, locally administered addresses, vendor prefixes, and validation. 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 <sstream>
#include <iomanip>
#include <vector>
#include <regex>

class MacAddressGenerator {
private:
    std::mt19937 rng;
    std::uniform_int_distribution<int> octet_dist;

public:
    MacAddressGenerator() :
        rng(std::random_device{}()),
        octet_dist(0, 255) {}

    // Generate random MAC address (standard format)
    std::string randomMacAddress() {
        std::ostringstream oss;
        for (int i = 0; i < 6; ++i) {
            if (i > 0) oss << ":";
            oss << std::hex << std::uppercase << std::setw(2)
                << std::setfill('0') << octet_dist(rng);
        }
        return oss.str();
    }

    // Generate locally administered MAC address (bit 1 of first octet set)
    std::string randomLocalMacAddress() {
        std::ostringstream oss;
        // First octet: set bit 1 (locally administered), clear bit 0 (unicast)
        int firstOctet = (octet_dist(rng) & 0x7F & 0xFE) | 0x02;
        oss << std::hex << std::uppercase << std::setw(2)
            << std::setfill('0') << firstOctet;

        for (int i = 1; i < 6; ++i) {
            oss << ":";
            oss << std::hex << std::uppercase << std::setw(2)
                << std::setfill('0') << octet_dist(rng);
        }
        return oss.str();
    }

    // Generate MAC with specific vendor prefix (OUI)
    std::string randomMacWithVendor(const std::string& vendorPrefix) {
        std::ostringstream oss;
        oss << vendorPrefix;

        // Count colons to determine how many octets to add
        int vendorOctets = std::count(vendorPrefix.begin(), vendorPrefix.end(), ':') + 1;

        for (int i = vendorOctets; i < 6; ++i) {
            oss << ":";
            oss << std::hex << std::uppercase << std::setw(2)
                << std::setfill('0') << octet_dist(rng);
        }
        return oss.str();
    }

    // Generate MAC with different separator
    std::string randomMacFormatted(const std::string& separator) {
        std::ostringstream oss;
        for (int i = 0; i < 6; ++i) {
            if (i > 0) oss << separator;
            oss << std::hex << std::uppercase << std::setw(2)
                << std::setfill('0') << octet_dist(rng);
        }
        return oss.str();
    }

    // Validate MAC address format
    bool isValidMacAddress(const std::string& mac) {
        std::vector<std::regex> patterns = {
            std::regex("^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$"),  // 00:1A:2B:3C:4D:5E
            std::regex("^([0-9A-Fa-f]{2}-){5}[0-9A-Fa-f]{2}$"),  // 00-1A-2B-3C-4D-5E
            std::regex("^[0-9A-Fa-f]{12}$"),                      // 001A2B3C4D5E
        };

        for (const auto& pattern : patterns) {
            if (std::regex_match(mac, pattern)) {
                return true;
            }
        }
        return false;
    }

    // Generate multiple MAC addresses
    std::vector<std::string> generateMacAddresses(int count) {
        std::vector<std::string> macs;
        for (int i = 0; i < count; ++i) {
            macs.push_back(randomMacAddress());
        }
        return macs;
    }
};

int main() {
    MacAddressGenerator generator;

    std::cout << "Random MAC: " << generator.randomMacAddress() << std::endl;
    std::cout << "Local MAC: " << generator.randomLocalMacAddress() << std::endl;
    std::cout << "Vendor MAC: " << generator.randomMacWithVendor("00:1A:2B") << std::endl;
    std::cout << "Dash format: " << generator.randomMacFormatted("-") << std::endl;
    std::cout << "No separator: " << generator.randomMacFormatted("") << std::endl;
    std::cout << "Is valid: " << std::boolalpha << generator.isValidMacAddress("00:1A:2B:3C:4D:5E") << std::endl;

    auto batch = generator.generateMacAddresses(3);
    std::cout << "Batch: ";
    for (size_t i = 0; i < batch.size(); ++i) {
        if (i > 0) std::cout << ", ";
        std::cout << batch[i];
    }
    std::cout << std::endl;

    return 0;
}

[EXPLANATION]

C++ uses std::mt19937 for high-quality random generation and std::uniform_int_distribution for octets (0-255). std::ostringstream builds strings efficiently. Format manipulators std::hex, std::uppercase, std::setw(2), and std::setfill('0') create 2-digit uppercase hex with zero-padding. Bitwise operations (& 0xFE, | 0x02) set locally administered bit. std::regex_match() validates patterns. std::count() counts colons to determine vendor prefix length.

Expected Output

Random MAC: A3:45:B7:89:CD:EF
Local MAC: 02:45:B7:89:CD:EF
Vendor MAC: 00:1A:2B:89:CD:EF
Dash format: A3-45-B7-89-CD-EF
No separator: A345B789CDEF
Is valid: true
Batch: 12:34:56:78:9A:BC, DE:F0:12:34:56:78, 9A:BC:DE:F0:12:34