在C++中定義運算符**

Question

如何定義運算符**，使其能夠執行2個數的指數運算。例如2 ** 3。它應該給答案爲8.

或間接有什麼辦法可以做到這一點與運算符重載而不是#define宏？

Answer 1

你不能。您只能重載現有的運算符，而不能用於內置類型。

Answer 2

你不能。您只能在C++中重載現有的運算符;你不能添加新的，或者改變現有操作員的秩序或關聯性。即使預處理器在這裏也是無能爲力 - 它的標識符不能是符號。

Answer 3

您不能重載內置類型的運算符。我會使用operator ^用於自定義類型的此類用途。

Answer 4

不幸的是，可以在C++中重載的運算符集合是固定的，並且不包含**運算符。您可能會考慮使用operator^()來代替，但事實證明^具有錯誤的優先級以充當指數運算符。

簡而言之，不幸的是，您無法做到這一點。

Answer 5

正如其他人所指出的：這是不可能的。您可以重載另一個運算符，例如^來取指數，而不是使用簡單類型的包裝類/對象。

但是，如果您喜歡冒險，另一種方法是創建一個支持即時計算這種操作符的微型DSL。 (A famous example of that is LISP in C++)

但是，考慮到所付出的努力，它可能或可能不是你的一杯茶。但是，值得了解的是這種可能性存在。

UPDATE：

操作符重載超載現有運營商的作品。爲什麼？因爲如果你可以定義你自己的，你還必須定義這些操作符的優先級，這些操作符可以很容易地讓位於濫用操作符，通過提取它們的原始目的 - 這會增加讀代碼時的難度。 （至少這是做出的論點）。

具有接近**的語義含義的最接近的運算符是插入符號運算符。這種運營商的天真和說明性實施是：

#include <iostream> 
#include <cmath> 

class Int { 
public: 
    Int() {} 
    Int(int i) : value(i) {} 

    friend double operator^(const int& i, const Int& integer); 
    friend double operator^(const Int& integer, const int& i); 
    friend double operator^(const Int& lhs, const Int& rhs); 
private: 
    int value; 
}; 

double operator^ (const int& lhs, const Int& rhs) { 
    return std::pow(lhs, rhs.value); 
} 

double operator^ (const Int& lhs, const int& rhs) { 
    return std::pow(lhs.value, rhs); 
} 

double operator^ (const Int& lhs, const Int& rhs) { 
    return std::pow(lhs.value, rhs.value); 
} 


int main() { 
    Int i1 = 10; 
    Int i2 = 3; 
    double result = i1^i2; 

    std::cout << result; 
    return 0; 
} 

Answer 6

如果你願意作出妥協w.r.t. **，感覺像混淆代碼：

#include <cmath> 
#include <iostream> 

struct foo { 
    foo(int i) : i_(i) {} 
    int operator*(int exp) 
    { 
     return std::pow(i_,exp); 
    } 
private: 
    int i_; 
}; 

struct bar { 
} power_of; 

foo operator*(int i, bar) 
{ 
    return foo{i}; 
} 


int main() 
{ 
    std::cout << 2 *power_of* 3; // prints 8 
} 

否則，只需使用std::pow。

Answer 7

像注意到其他的答案，這是不可能的內置類型但你能得到這個自定義類型的工作，像這樣（最小的代碼示例）：

#include <cmath> 
#include <iostream> 

struct dummy; 

struct Int 
{ 
    int i; 
    Int() : i(0) {} 
    Int(const int& i) : i(i) {} 
    dummy operator*(); 
}; 

struct dummy 
{ 
    Int* p; 
    dummy(Int* const p) : p(p) {} 

    int& operator*() 
    { 
     return p->i; 
    } 
}; 

dummy Int::operator*() 
{ 
    return dummy(this); 
} 

int operator*(const Int& lhs, const dummy& rhs) 
{ 
    return std::pow(lhs.i, rhs.p->i); 
} 


int main() 
{ 
    Int a(2); 
    Int b(2); 
    std::cout<< a ** b << std::endl; 
} 

Live example