如何使用模板爲C++類創建「計算屬性」

Question

我試圖實現通用方法，將類的計算值作爲只讀的memver值放入類中。

我successfuly acomplished它使用下面的宏：

#define READONLY_PROPERTY(datatype, containerclass, access, name)\ 
    class name ## _ ## datatype ## _ROP {\ 
public:\ 
    name ## _ ## datatype ## _ROP(containerclass &c_): cclass(c_) {}\ 
     operator datatype() const {return cclass.access();}\ 
private:\ 
    containerclass &cclass;\ 
}name;\ 
friend class name ## _ ## datatype ## _ROP 

，在該類中使用：

class TestClass { 
public: 
    TestClass(): x(0), y(0), pixels(*this) {} 
    TestClass(int x_, int y_): x(x_), y(y_), pixels(*this) {} 
    int x; 
    int y; 
    READONLY_PROPERTY(int, TestClass, getPix, pixels); 
private: 
    int getPix() {return x * y;} 
}; 

生成以下工作的代碼（使用克++）：

class TestClass { 
public: 
    TestClass(): x(0), y(0), pixels(*this) {} 
    TestClass(int x_, int y_): x(x_), y(y_), pixels(*this) {} 
    int x; 
    int y; 
    class pixels_int_ROP { 
    public: 
     class pixels_int_ROP(TestClass &c_): cclass(C_) {} 
     operator int() const {return cclass.getPix();} 
    private: 
     TestClass &cclass; 
    } pixels; 
    friend class pixels_int_ROP; 
private: 
    int getPix() {return x * y;} 
}; 

重點是我可以用這種方式使用這個類：

TestClass tc(10,10); 
std::cout << tc.pixels << std::endl; 

現在，我試圖做同樣的事情在一個以上的C++使用方法模板：

template<class T, class U, U (T::*F)()>; 
class ReadOnlyProperty { 
public: 
    ReadOnlyProperty(T const& instance): _instance(instance) {} 
    operator U const &() const {return _instance.*F();} 
private: 
    T& _instance; 
}; 

class TestClass { 
public: 
    TestClass(): x(0), y(0), pixels(*this) {} 
    TestClass(int x_, int y_): x(x_), y(y_), pixels(*this) {} 
    int x; 
    int y; 
    ReadOnlyProperty<TestClass, int, &TestClass::getPix&> pixels; 
private: 
    int getPix() {return x * y;} 
}; 

但是編譯器說：

error: incomplete type ‘TestClass’ used in nested name specifier
error: template argument 3 is invalid

在所在行的模板類被實例化。

你能幫我嗎？

在此先感謝。

Answer 1

因爲getPix（）在用作模板參數時未聲明，並且_instance必須爲const，因爲ReadOnlyProperty構造函數參數爲const。

template< class T, class U, U (T::*F)() const > 
class ReadOnlyProperty { 
public: 
    ReadOnlyProperty(T const& instance): _instance(instance) {} 
    operator U const &() const {return (_instance.*F)();} 
private: 
    const T& _instance; 
}; 

class TestClass { 
public: 
    TestClass(): x(0), y(0), pixels(*this) {} 
    TestClass(int x_, int y_): x(x_), y(y_), pixels(*this) {} 
    int x; 
    int y; 
private: 
    int getPix() const {return x * y;} 
public: 
    ReadOnlyProperty<TestClass, int, &TestClass::getPix> pixels; 
}; 

編輯：感謝喬治Fritzsche也，根據他的意見，最後一個模板參數應採取const成員函數和_instance.*F()需求括號:)（哦，我忘了他們！）

Answer 2

如何這一點：

#include <functional> 

template<class R, class UA, class P> 
class MyBind 
{ 
    public: 
     MyBind(UA unaryAction, P param) 
      :_unaryAction(unaryAction) 
      ,_parameter(param) 
     {} 
     operator R const&() const 
     { 
      return _action(_parameter); 
     } 
    private: 
     UA _unaryAction; 
     P& _parameter; 
}; 

然後，它可以像這樣使用：

class TestClass 
{ 
     typedef std::const_mem_fun_t<int, TestClass> MethodCall; 
     int getPix() const 
     { 
      return x * y; 
     } 
    public: 
     TestClass(int x_, int y_) 
      :x(x_) 
      ,y(y_) 
      ,pixels(std::mem_fun(&TestClass::getPix), *this) 
     {} 
     int  x; 
     int  y; 
     MyBind<int, MethodCall, TestClass>  pixels; 
};