[C++] namespace内でenumを定義して衝突を防ぐ方法

#include <iostream>
// グローバルスコープでのenum定義
enum Color { Red, Green, Blue };
// namespaceを使ったenum定義
namespace Graphics {
    enum Color { Cyan, Magenta, Yellow };
}
int main() {
    Color color1 = Red; // グローバルスコープのColor
    Graphics::Color color2 = Graphics::Cyan; // namespace内のColor
    std::cout << "Color1: " << color1 << ", Color2: " << color2 << std::endl;
    return 0;
}

Color1: 0, Color2: 0

#include <iostream>
namespace UI {
    enum ButtonState { Normal, Hovered, Pressed };
}
namespace Network {
    enum ConnectionState { Disconnected, Connecting, Connected };
}
int main() {
    UI::ButtonState buttonState = UI::Hovered;
    Network::ConnectionState connectionState = Network::Connected;
    std::cout << "ButtonState: " << buttonState << ", ConnectionState: " << connectionState << std::endl;
    return 0;
}

ButtonState: 1, ConnectionState: 2

#include <iostream>
namespace Audio {
    enum VolumeLevel { Mute, Low, Medium, High };
}
namespace Video {
    enum Resolution { SD, HD, FullHD, UHD };
}
int main() {
    Audio::VolumeLevel volume = Audio::Medium;
    Video::Resolution resolution = Video::FullHD;
    std::cout << "Volume: " << volume << ", Resolution: " << resolution << std::endl;
    return 0;
}

Volume: 2, Resolution: 2

#include <iostream>
namespace Vehicle {
    enum Type { Car, Truck, Motorcycle };
}
int main() {
    Vehicle::Type myVehicle = Vehicle::Car;
    std::cout << "My vehicle type: " << myVehicle << std::endl;
    return 0;
}

My vehicle type: 0

#include <iostream>
namespace Device {
    enum Status { On, Off, Standby };
    enum Type { Laptop, Desktop, Tablet };
}
int main() {
    Device::Status deviceStatus = Device::On;
    Device::Type deviceType = Device::Laptop;
    std::cout << "Device status: " << deviceStatus << ", Device type: " << deviceType << std::endl;
    return 0;
}

Device status: 0, Device type: 0

#include <iostream>
namespace Company {
    namespace Product {
        enum Category { Electronics, Furniture, Clothing };
    }
}
int main() {
    Company::Product::Category productCategory = Company::Product::Electronics;
    std::cout << "Product category: " << productCategory << std::endl;
    return 0;
}

Product category: 0

#include <iostream>
namespace Weather {
    enum Condition { Sunny, Cloudy, Rainy, Snowy };
}
int main() {
    Weather::Condition today = Weather::Sunny;
    std::cout << "Today's weather: " << today << std::endl;
    return 0;
}

Today's weather: 0

#include <iostream>
namespace Input {
    enum Device { Keyboard, Mouse, Gamepad };
}
namespace Output {
    enum Device { Monitor, Printer, Speaker };
}
int main() {
    Input::Device inputDevice = Input::Keyboard;
    Output::Device outputDevice = Output::Monitor;
    std::cout << "Input device: " << inputDevice << ", Output device: " << outputDevice << std::endl;
    return 0;
}

Input device: 0, Output device: 0

#include <iostream>
namespace Network {
    enum class Protocol { HTTP, FTP, SMTP };
}
int main() {
    Network::Protocol protocol = Network::Protocol::HTTP;
    std::cout << "Selected protocol: " << static_cast<int>(protocol) << std::endl;
    return 0;
}

Selected protocol: 0

#include <iostream>
namespace MathLib {
    enum ErrorCode { Success, DivisionByZero, Overflow };
    double divide(double numerator, double denominator, ErrorCode &error) {
        if (denominator == 0) {
            error = DivisionByZero;
            return 0;
        }
        error = Success;
        return numerator / denominator;
    }
}
int main() {
    MathLib::ErrorCode error;
    double result = MathLib::divide(10, 0, error);
    if (error == MathLib::DivisionByZero) {
        std::cout << "Error: Division by zero" << std::endl;
    } else {
        std::cout << "Result: " << result << std::endl;
    }
    return 0;
}

#include <iostream>
namespace Game {
    enum class State { MainMenu, Playing, Paused, GameOver };
    void printGameState(State state) {
        switch (state) {
            case State::MainMenu:
                std::cout << "Main Menu" << std::endl;
                break;
            case State::Playing:
                std::cout << "Playing" << std::endl;
                break;
            case State::Paused:
                std::cout << "Paused" << std::endl;
                break;
            case State::GameOver:
                std::cout << "Game Over" << std::endl;
                break;
        }
    }
}
int main() {
    Game::State currentState = Game::State::Playing;
    Game::printGameState(currentState);
    return 0;
}

#include <iostream>
namespace Network {
    enum class StatusCode { OK = 200, NotFound = 404, InternalServerError = 500 };
    void handleResponse(StatusCode code) {
        switch (code) {
            case StatusCode::OK:
                std::cout << "Request succeeded" << std::endl;
                break;
            case StatusCode::NotFound:
                std::cout << "Resource not found" << std::endl;
                break;
            case StatusCode::InternalServerError:
                std::cout << "Internal server error" << std::endl;
                break;
        }
    }
}
int main() {
    Network::StatusCode responseCode = Network::StatusCode::OK;
    Network::handleResponse(responseCode);
    return 0;
}