让c++类使用通用的用户定义输入

我觉得这个问题以前一定有人问过，但我在谷歌上找不到答案。如果有，请指引我到一个链接，我会删除这个帖子。

考虑一下这个最小的例子，它代表了我遇到的一个更大的问题。假设我创建了一个简单的"点"answers"打印机"类，如下所示：

class Point {
    public:
        double x, y;
        Point() {x = y = 0;}
        Point(double x, double y) {
            this->x = x; this->y = y;
        }
};
template<typename T>
class Printer {
    public:
        T* mData;
        int mSize;
        // Constructor
        Printer(std::vector<T> &input) {
            mData = &input[0];
            mSize = input.size();
        }
        // Simple Print function
        void Print() {
            printf(" - Showing %d itemsn", mSize);
            for (int i = 0; i < mSize; i++) {
                const T &item = mData[i];
                printf(" - Item %d: (%lf, %lf)n", i, item.x, item.y);
            }
        }
};

我可以像这样使用打印机类：

std::vector<Point> points; // fill the vector, and then...
Printer<Point> pointsPrinter(points); pointsPrinter.Print(); 

现在假设有其他人出现并希望使用Printer类，其中有自己的"Point"类声明如下：

class Pnt {
    public:
        double mX, mY;
        // other stuff
};

如果他们试图这样做：

vector<Pnt> pnts; // Fill the pnts, and then...
Printer<Pnt> pntsPrinter(pnts);
pntsPrinter.Print(); // COMPILE ERROR HERE!

显然，这将失败，因为Pnt没有x或y成员。有没有一种方法可以重写Printer类来处理所有通用用户类型？我不想做的是将Pnt向量复制到Points向量中。

编辑：

我能想到的唯一方法就是传递函数指针。类似这样的东西：

template<typename T>
class Printer {
    public:
        T* mData;
        int mSize;
        double* (*mXFunc) (T*);
        double* (*mYFunc) (T*);
        Printer(std::vector<T> &input, 
                double* (*xFunc) (T*), 
                double* (*yFunc) (T*)) 
        {
            mData = &input[0];
            mSize = input.size();
            mXFunc = xFunc;
            mYFunc = yFunc;
        }
        void Print() {
            printf(" - Showing %d itemsn", mSize);
            for (int i = 0; i < mSize; i++) {
                T &item = mData[i];
                printf(" - Item %d: (%lf, %lf)n", i, *mXFunc(&item), *mYFunc(&item));
            }
        }
};
// Could then use it like so
inline double* getXPointVal(Point *point) {return &point->x;}
inline double* getYPointVal(Point *point) {return &point->y;}
inline double* getXPntVal(Pnt *point) {return &point->mX;}
inline double* getYPntVal(Pnt *point) {return &point->mY;}
Printer<Pnt> pntPrinter(pnts, getXPntVal, getYPntVal);
Printer<Point> pointsPrinter(points, getXPointVal, getYPointVal);
pntPrinter.Print();
pointsPrinter.Print();    

这样做的问题是它看起来很难看，还可能引入函数调用开销。但我想函数调用开销会被编译掉吗？我希望有一个更优雅的解决方案。。。