实现同时具有枚举和类行为的东西

您可以使用一个类并为enum:使用特定实例（单个实例）

class Color
{
public:
    bool isHappy() const { return this == &Green || this == &Red; }
    const Color* rotate() const { return (this == &Red ? &Green : (this == &Green ? &Blue : &Red)); }
    int intensity() const {return mIntensity; }
    static const Color* red() { return &Red; }
    static const Color* green() { return &Green; }
    static const Color* blue() { return &Blue; }
private:
    // forbid to construct new instance: use only red(), green(), blue()
    explicit Color(int intensity) : mIntensity(intensity) {}
    Color(const Color&) = delete; 
private:
    int mIntensity;
private:
    static const Color Red;
    static const Color Green;
    static const Color Blue;
};
const Color Color::Red(11);
const Color Color::Green(12);
const Color Color::Blue(4);

已经给出了一些其他不错的答案，但恐怕他们没有充分使用C++表达式和清晰简洁。

我提出以下解决方案：

class Color
{
public:
    virtual bool is_happy() = 0;
    virtual Color* rotate() = 0;
    virtual int intensity() = 0;
    static Color* const Red;
    static Color* const Green;
    static Color* const Blue;
    Color(Color const&) = delete;
private:
    Color(){}
    template<bool happiness, Color* const* rotation_result, int intensity_value>
    class Color_Generator;
    template<bool happiness, Color* const* rotation_result, int intensity_value>
    friend class Color_Generator;
};
template<bool happiness, Color* const* rotation_result, int intensity_value>
class Color::Color_Generator : public Color
{
public:
    bool is_happy()
    {
        return happiness;
    }
    Color* rotate()
    {
        return *rotation_result;
    }
    int intensity()
    {
        return intensity_value;
    }
    static Color_Generator<happiness, rotation_result, intensity_value> Instance;
};
template<bool happiness, Color* const* rotation_result, int intensity_value>
Color::Color_Generator<happiness, rotation_result, intensity_value>
Color::Color_Generator<happiness, rotation_result, intensity_value>::Instance;
Color* const Color::Red = &Color_Generator<true, &Green, 11>::Instance;
Color* const Color::Green = &Color_Generator<true, &Blue, 12>::Instance;
Color* const Color::Blue = &Color_Generator<false, &Red, 4>::Instance;
//==============
// Some usage follows
#include <iostream>
int main()
{
    Color* a = Color::Red;
    Color* b = Color::Green;
    Color* c = Color::Blue;
    std::cout << a->intensity() << std::endl;
    std::cout << b->is_happy() << std::endl;
    std::cout << (b->rotate() == c) << std::endl;
}

还有更多的C++特性可用于进一步改进此代码。例如，您可以使用虚拟继承，以便按照C++的真正精神，将is_happy、rotate和intensity的定义拆分为它们自己的"facet"类。

两个给定：如果您想要成员函数（看起来合理），则它必须是一个类；以及不同的东西只有在属性（如Red、Green和Blue）中才应该有不同的类型。

目前还不清楚为什么要将颜色数量限制为3，但最终，这归结为确保你的类正好有3个实例，不再有了。最简单的这样做的方法是使构造函数私有实例静态成员：

class Color
{
    Color( /* whatever parameters are needed */ );
public:
    static Color red;
    static Color green;
    static Color blue;
    //  ...
};

然后，用户将使用颜色：红色、颜色：绿色和颜色：蓝色（这还有一个额外的优势，那就是你可以做点什么与moods类似，Mood:：blue不会引起命名冲突）。

更新：简化代码一点

您可以将其实现为基类Color，它有三个子类Red、Green和Blue，并分别具有静态常数RED、GREEN和BLUE：

class Red;
class Green;
class Blue;
class Color;
typedef const Color* Color_t;
class Color {
    friend class Red;
    friend class Green;
    friend class Blue;
public:
    static Color_t RED;
    static Color_t GREEN;
    static Color_t BLUE;
    virtual std::string name() const = 0;
private:
    // prohibit instantiation of non-friend subclasses
    virtual ~Color() = default;
    static const Red RED_;
    static const Green GREEN_;
    static const Blue BLUE_;
};
class Red : public Color {
    friend class Color;
private:
    Red() {};  // prohibit instantiation other than by Color
    std::string name() const {return "Red";}
};
class Green : public Color {
    friend class Color;
private:
    Green() {};
    std::string name() const {return "Green";}
};
class Blue : public Color {
    friend class Color;
private:
    Blue() {};
    std::string name() const {return "Blue";}
};
const Red Color::RED_;
const Green Color::GREEN_;
const Blue Color::BLUE_;
Color_t Color::RED = &RED_;
Color_t Color::GREEN = &GREEN_;
Color_t Color::BLUE = &BLUE_;
int main() {
    Color_t c = Color::GREEN;
    c = Color::BLUE;
    if (c == Color::GREEN) {
        std::cout << c-> name() << " is green" << std::endl;
    } else {
        std::cout << c-> name() << " is not green" << std::endl;
    }
    // we can make collections of colors easily
    std::vector<Color_t> colors = { Color::RED, Color::RED, Color::GREEN, Color::BLUE, Color::GREEN };
    return 0;
}

这是的演示

这实际上类似于枚举在Java中的实现方式。

如果你想要的只是一个enum和作用于该enum的函数，以及一种让世界知道这些函数和该enum属于一起的方式，那么namespace可能正是你的工具。

namespace Color
{
enum EColor // or in C++11 use an enum class and set the underlying type to char or such
{
    RED,
    GREEN,
    BLUE
};
bool IsHappy(const EColor & color);
int Intensity(const EColor & color);
EColor Rotate(const EColor & color);
}

您可以很容易地将其创建为具有成员函数的类，因为每个函数都需要一个EColor来处理，但如果不是EColor的每个用户都关心颜色的快乐，那么使用命名空间可能会使您更容易将功能分解为单独的模块，或者你碰巧有一堆与EColor相关的函数，但不需要单个EColor作为参数。