remove character from macro parameter - c++

Question

I'm trying to create a macro to replace the for-loop
I want it to work like this:
f(var, start, Eend)
where var is the name of the loop variable, the start is the value where it begins and end, the value where it stops. The E is a symbol that can exist or not. If it exist, it is =
my macro is actually like this:
#define f(var, s, e) for(int var = s, kx = (s<e? 1 : -1); var != e; var += kx)
but this definition cannot afford = yet, so I want to extend it like this:
f(i, 10, =15) cout<<" "<<i;
output: 10 11 12 13 14 15
My question is if it's possible to remove the first char of the Eend argument of macro.
I can discover if it's equal using
#Eend[0] == '='
but after I cant use Eend to compare with s and find out if I must use ++ or --
This is what I want:
#define f(var, s, Eend)
for(int var = s, kx = s<end? 1:-1, LIM = #Eend[0] == '='? end+kx : end; var!=end; var += kx)
where end is Eend without the '=' (if it exists)

Answer 1

For your macro question you can simply define two macros, with slightly different (hopefully mnemonic) names.
E.g., if I understand the intention correctly,
#define xf(var, s, e) for(int var = s, kx = (s<e? 1 : -1); var != e; var += kx)
#define f(var, s, e) for(int var = s, kx = (s<e? 1 : -1), e2 = e + kx; var != e2; var += kx)
If the redundancy of that is not palatable, then you can express them in terms of a third common implementation macro.
Doing this without a macro is more work, but you only have to do the definition work once.
And you avoid possible name collisions for the macro.
E.g. it can go like this:
enum From { from };
enum To { to };
enum To_before { to_before };
class Sequence
{
private:
int first_;
int after_;
int delta_;
public:
class Iter
{
friend class Sequence;
private:
Sequence const* p_seq_;
int current_;
Iter( Sequence const& seq )
: p_seq_( &seq )
, current_( seq.first_ )
{}
Iter( Sequence const& seq, int const current )
: p_seq_( &seq )
, current_( current )
{}
public:
friend auto operator==( Iter const& a, Iter const& b )
-> bool
{ return a.current_ == b.current_; } // UB if not same sequence.
friend auto operator!=( Iter const& a, Iter const& b )
-> bool
{ return a.current_ != b.current_; }
auto operator*() const
-> int
{ return current_; }
auto operator++()
-> Iter&
{
current_ += p_seq_->delta_;
return *this;
}
auto operator++( int )
-> Iter
{
Iter result{ *this };
current_ += p_seq_->delta_;
return result;
}
};
auto begin() const -> Iter { return Iter{ *this }; }
auto end() const -> Iter { return Iter{ *this, after_ }; }
Sequence( int const first, int const last, bool inclusive = true )
: first_( first )
, after_( last )
, delta_( first <= last? 1 : -1 )
{ if( inclusive ) { after_ += delta_; } }
Sequence( From, int const first, To, int const last )
: Sequence( first, last, true )
{}
Sequence( From, int const first, To_before, int const last )
: Sequence( first, last, false )
{}
};
#include <iostream>
using namespace std;
auto main()
-> int
{
using Seq = Sequence;
for( int const i : Seq{ from, 10, to, 15 } ) { cout << i << ' '; }
cout << endl;
for( int const i : Seq{ from, 15, to, 10 } ) { cout << i << ' '; }
cout << endl;
cout << endl;
for( int const i : Seq{ from, 10, to_before, 15 } ) { cout << i << ' '; }
cout << endl;
for( int const i : Seq{ from, 15, to_before, 10 } ) { cout << i << ' '; }
cout << endl;
}