如何擺脫醜陋的記錄

Question

class c { 
    private: 
     int n[10]; 
    public: 
     c(); 
     ~c(); 
     int operator()(int i) { return n[i];}; 
}; 

class cc { 
    private: 

    public: 
     c *mass; 
     cc(); 
     ~cc(); 
     c& operator*() const {return *mass;}; 
}; 
int somfunc() { 
    c *c1 = new c(); 

    cc * cc1 = new cc(); 

    (*cc1->mass)(1); 



    delete c1; 
} 

我有一個類cc指針到類c的指針。

有什麼辦法來擺脫記錄是這樣的：

(*cc1->mass)(1); 

和somethink寫這樣的：

cc1->mass(1); 

是不可能？

Answer 1

當我看到標籤「C++」和「運算符重載」，我的心報警接通。

C++運算符重載是複雜的，一些運營商等「（）」或「 - >」變得更加困難。

我建議，運算符重載，使得無論是全局函數或方法具有相同purpouse之前，測試它的工作原理，以及後來與運營商更換。

全球友元函數例如：

class c { 
    private: 
     int n[10];  

    public: 
     c(); 
     ~c(); 

     // int operator()(int i) { return n[i]; } 

     // there is a friend global function, that when receives a "c" object, 
     // as a parameter, or declares a "c" object, as a local variable, 
     // this function, will have access to the "public" members of "c" objects, 
     // the "thisref" will be removed, when turned into a method 
     friend int c_subscript(c thisref, int i) ; 
}; 

int c_subscript(c* thisref, int i) 
{ 
    return c->n[i]; 
} 

int main() 
{ 
    c* objC() = new c(); 
    // do something with "objcC" 

    int x = c_subscript(objC, 3); 
    // do something with "x" 

    return 0; 
} // int main(...) 

局部功能（ 「辦法」），例如：

class c { 
    private: 
     int n[10];  

    public: 
     c(); 
     ~c(); 

     // int operator()(int i) { return n[i]; } 

     int subscript(int i) ; 
}; 

int c::subscript(int i) 
{ 
    return this.n[i]; 
} 

int main() 
{ 
    c* objC() = new c(); 
    // do something with "objcC" 

    int x = c->subscript(objC, 3); 
    // do something with "x" 

    return 0; 
} // int main(...) 

而且，最後使用重載操作：

class c { 
    private: 
     int n[10];  

    public: 
     c(); 
     ~c(); 

     int subscript(int i) ; 

     int operator()(int i) { return this.subscript(i); } 
}; 

int c::subscript(int i) 
{ 
    return this.n[i]; 
} 

int main() 
{ 
    c* objC() = new c(); 
    // do something with "objcC" 

    int x = c->subscript(3); 
    // do something with "x" 

    int x = c(3); 
    // do something with "x" 

    return 0; 
} // int main(...) 

注意，在最後一個例子，我保留了一個唯一標識符的方法。

乾杯。

Answer 2

您可以與

(*(*cc1))(1) 

operator()因爲被施加到一個對象，而不是指針。

Answer 3

您可以使用

(**cc1)(1); 

或者

cc1->mass->operator()(1); 

Answer 4

總是可以做到這一點：

class cc { 
    private: 
     c *_mass; 

    public: 
     c& mass() const {return *_mass;}; 
}; 

現在..

cc1->mass()(1); 

Answer 5

如果mass是一個對象，不是指針，你可以使用你想要的語法：

class cc { 
    private: 

    public: 
    c mass; 
    cc(); 
    ~cc(); 
    const c& operator*() const {return mass;}; 
}; 

… 

    cc1->mass(1);