C 结构的 C++ 类包装器

Question

我想编写一个包装 C 结构的 C++ 类。这是一个简单的示例，用于 c 结构:

struct POINT {
  long x;
  long y;
}

现在我假设下面这个类，但我不确定它是否“高性能”或良好的 C++ 风格。我不想使用不必要的变量或函数调用。如果您改进我的代码，那就太好了:)。

这个类背后的基本思想是它只是结构的包装器/处理程序。这就是为什么 setStruct和 getStruct可以直接修改私有(private)数据，它只是一个指针。其他成员总是命名为 set<Attribute>和 get<Attribute> .

如果您使用 setStruct我能想到的唯一缺点是结构可能会由于作用域而被删除，因此指针“无效”。

namespace wrapper {
class POINT {
  ::POINT * POINT_;

public:
  POINT() {
    POINT_ = new ::POINT;
  }
  ~POINT() {
    delete POINT_;
  }
  inline void setX( long x ) {
    POINT_->x = x;
  }
  inline long getX() {
    return POINT_->x;
  }
  inline void setY( long y ) {
    POINT_->y = y;
  }
  inline long getY() {
    return POINT_->y;
  }
  inline void setStruct(::POINT * __POINT) {
    POINT_ = __POINT;
  }
  inline ::POINT * getStruct() {
    return POINT_;
  }
};
}

Answer 1

在这种情况下，您最好使用继承而不是组合。它将消除管理额外资源的需要，并允许您的“包装器”充当 POINT，而不需要整个 POINT 结构的访问器和修改器。

namespace wrapper {
    class Point : public ::POINT
    {
    public:
        Point() { }
        ~Point() { }

        // The following accessors/mutators may not be necessary.
        // They can however be handy with code that requires a pointer to
        // member function (i.e. transformations)
        void setX(long nx) { x = nx; }
        long getX() { return x; }
        void setY(long ny) { y = ny; }
        long getY() { return y; }

        // copy assignment operators
        Point& operator=(const POINT& p)
        {
            x = p.x;
            y = p.y;
            return *this;
        }

        Point& operator=(const Point& p)
        {
            x = p.x;
            y = p.y;
            return *this;
        }
    };
}

如果你想阻止对 POINT 成员的直接访问，你可以使用私有(private)继承。您还可以提供转换运算符以允许从 Point 到 POINT 的隐式转换。这将替换 POINT* getStruct() 成员函数，但仍然允许您轻松地将它与需要 POINT 作为参数的函数一起使用。

namespace wrapper {
    // Use private inheritance to prevent direct access to the
    // members of POINT
    class Point : private POINT
    {
    public:
        Point() { }
        ~Point() { }

        // Copy constructor
        Point(const ::POINT& p) { x = p.x; y = p.y; }

        // Accessor/mutators
        void setX(long nx) { x = nx; }
        long getX() { return x; }
        void setY(long ny) { y = ny; }
        long getY() { return y; }

        // Allow implicit conversions to POINT* when necessary
        // Replaces getStruct()
        operator ::POINT*() { return this; }
        operator const ::POINT*() const { return this; }

        // Copy assignment operators
        Point& operator=(const POINT& p)
        {
            x = p.x;
            y = p.y;
            return *this;
        }

        Point& operator=(const Point& p)
        {
            x = p.x;
            y = p.y;
            return *this;
        }
    };
}

extern "C" void someCFunction(POINT *);

int main()
{
    POINT cp;
    wrapper::Point p;

    p.x = 0; // FAIL
    p.setX(0); // OK
    p = cp; // OK

    // No need to call getPoint().
    someCFunction(p);
}

---

_{注意:我已经删除了 inline 的使用，因为它们是不必要的。在类定义中定义的函数已经是内联的(参见 $7.1.2/3)。感谢Chris提醒我。}