Defining macros for specific functions in C++ - c++

Question

There are 4 things that I was wondering if I could do in C++ with macros or inline functions.
(1) postfix operations in normal types (int, char, etc)
int n = 5;
printf("%d\n", n!)
output: 120
(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
(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
That's it. Is it possible to make any of these macros in C++ ?
Thanks !
PS: the symbols dont need to be | or !. Since they work, they can be # or $ or anything. The idea is to be postfix (a#), infix(a#b), sequential (a#b#c) and the foreach may be different, just to be smaller than a normal for is ok

Answer 1

No, you could make a function like int factorial(int x) and use printf( .. factorial(... but you cannot create operators like this from a macro.
No, | is already an operator (bitwise or).
This is the case anyway,. so what are you trying to do?
Why? Just use auto?
I think you are facing the X Y problem. There is likely no reason to make any of these a macro.

Answer 2

If you're willing to give your operators a textual name, you can certainly do 1, 2, 3. I believe 4 is what templates are for, i.e., take std::vector with T as a template parameter. You can inline any of these functions. Note that this code will probably not pass a code review, it's just here for your experimenting.
#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 );
}