小编点评

**使用结构体** ```c++ class A { private: struct State { int data; void hello() { std::cout << "Hello World\\"; } void f() { std::cout << "Goodbye World\\"; } void g() { std::cout << "Nothing\\"; } }; public: State state; static void hello() { state.hello(); } static void f() { state.f(); } static void g() { state.g(); } }; ``` **使用命名空间** ```c++ class A { public: void hello() { std::cout << "Hello World\\"; } void f() { std::cout << "Goodbye World\\"; } void g() { std::cout << "Nothing\\"; } }; ```

正文

设计一个不能被using的对象

  在实际开发中为了避免命名空间污染，一般都不会using namespace std。但是如果一个对象写起来比较复杂，用using能大幅度地简化操作。现在假设我们要设计一个函数，它在一个作用域里面，使用它只能以A::B::C()这种形式。思考一下，如果我们放在命名空间下，是可以被using简化的。我们不妨可以试试设计一个结构体。

class A {
    public:
        static void hello() {
            std::cout << "Hello World\n";
        }

        static void f() {
            std::cout << "Goodbye World\n";
        }

        static void g() {
            std::cout << "Nothing\n";
        }

        A() = delete;
        A(const A& other) = delete;
        ~A() = delete;
        A& operator= (const A& other) = delete;
};

  我们可以把构造函数，析构函数，拷贝构造还有拷贝赋值这一类函数都删掉，因为并不打算构造一个对象。除此之外，每个成员函数都用static修饰，因为它与实例化无关。这样，当我们想要调用hello函数的时候，我们可以A::hello()，这样就达到了目的。

 

禁止自己拷贝自己

  这段代码其实是可以通过编译的。

int n = n;

  同样，如果设计的类不经过特殊处理，诸如此类的操作也是可以通过编译的。通过引入assert断言的手段我们可以解决这个问题。

class Base {
    int data;

    public:
        Base(int data) : data(data) {}

        Base(const Base& other) {
            assert(&other != this);
            data = other.data;
        }
};

  只需判断拷贝的地址是否与this指针指向的地址相同即可。