C++의 특정 함수에 대한 매크로 정의

Question

매크로 나 인라인 함수를 사용하여 C++에서 수행 할 수있는 작업은 네 가지가 있습니다.

(3) sequential operations in common types 

int a = 5, b = 15, c = 20; 
if(a < b < c) printf("true\n"); 
output: false 
//doesn't matter if it's made with symbols or words 

---

그것 뿐이다

(4) for each (not using for(auto...) C++11) and 
it may different for lists, vectors, etc... 

vector<int> v = {1,3,5,7}; 
foreach(e : v) printf("%d ", e); 
output: 1 3 5 7 

---

---

(2) infix operations in normal types (int, char, etc) 

int a = 20, b = 10 
if(b|a) printf("%d is divisor of %d\n", b, a); 
// the symbol | means "divides", this is like (a % b == 0) 
output: 10 is divisor of 20 

(1) postfix operations in normal types (int, char, etc) 

int n = 5; 
printf("%d\n", n!) 

output: 120 

. C++에서 이러한 매크로를 만들 수 있습니까?

감사합니다.

추 신 : 기호는 필요 없습니다. | 또는! 그들이 일하기 때문에, @ 또는 $ 또는 무엇이든 될 수 있습니다. 아이디어는 접미사 (A @), 중위 (A @ 나), 연속 (C @ b @과) 및

Answer 1

연산자에 텍스트 이름을 사용하려면 1, 2, 3을 확실히 수행 할 수 있습니다. 4는 템플릿이 사용하는 것으로, 즉 T를 템플릿 매개 변수로 사용하는 std :: vector를 사용한다고 생각합니다. 이러한 기능을 인라인 할 수 있습니다. 이 코드는 코드 검토를 통과하지 못할 것입니다. 단지 실험을위한 것입니다.

#include <iostream> 
#include <boost/optional.hpp> // change to <optional> if you have it 

#define OPTIONAL_NS boost // change it to std if above is <optional> 
using namespace std; 

struct Factorial {}; 
#define FACTORIAL * Factorial() /* choose operator based on associativity and precedence */ 

int operator*(const int n, const Factorial&) 
{ 
    return n == 0 ? 1 : (n - 1) FACTORIAL * n; 
} 

template<typename T, typename U> 
struct StoreOne 
{ 
    const U m_a; 

    StoreOne(const U& a) 
    : m_a(a) 
    { 
    } 

    operator bool() const // do this only if U can be casted to bool 
    { 
     return m_a; 
    } 
}; 

struct Divides {}; 
#define DIVIDES * Divides() * 

StoreOne<Divides, int> operator*(const int a, const Divides&) 
{ 
    return a; 
} 

bool operator*(const StoreOne<Divides, int> da, const int b) 
{ 
    return b % da.m_a == 0; 
} 

struct Gt {}; 
#define GT < Gt() < 

StoreOne<Gt, OPTIONAL_NS::optional<int> > operator<(const OPTIONAL_NS::optional<int> a, const Gt&) 
{ 
    return OPTIONAL_NS::optional<int>(a); 
} 

OPTIONAL_NS::optional<int> operator<(const StoreOne<Gt, OPTIONAL_NS::optional<int> >& ga, const int b) 
{ 
    if (ga.m_a) 
    { 
     if (*ga.m_a < b) 
     { 
      return OPTIONAL_NS::optional<int>(b); 
     } 
    } 
    return OPTIONAL_NS::optional<int>(); 
} 

template<typename T> 
void printVector(const std::vector<T>& v) 
{ 
    for (const T& t : v) 
    { 
     cout << t << endl; 
    } 
} 

int main() { 
    cout << endl << "Factorial:  " << (5 FACTORIAL       ); 
    cout << endl << "Divides:  " << (5 DIVIDES 120 ? "Success" : "Failed"); 
    cout << endl << "Greater-than 1: " << (3 GT 4 GT 5  ? "Success" : "Failed"); 
    cout << endl << "Greater-than 2: " << (!(3 GT 4 GT 3) ? "Success" : "Failed"); 
    cout << endl << "Greater-than 3: " << (!(5 GT 4 GT 5) ? "Success" : "Failed"); 
    cout << endl; 

    std::vector<int> v; 
    v.push_back(1); 
    v.push_back(2); 
    v.push_back(3); 
    printVector(v); 
} 

Answer 2

1. 아니 괜찮만을위한 정상보다 작게, 다를 수 있습니다 foreach 문이 될 것입니다 int factorial(int x)과 같은 함수를 만들고 printf(.. factorial(...을 사용할 수 있지만 매크로에서 이와 같은 연산자를 생성 할 수는 없습니다.
2. 아니요, |은 이미 연산자 (비트 별 또는)입니다.
3. 어쨌든이 경우입니다. 그래서 너는 무엇을하려고하는거야?
4. 왜? 자동 사용 하시겠습니까?

나는 당신이 X Y problem.에 직면하고 있다고 생각합니다. 이러한 매크로를 만들 가능성은 없습니다.