Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > how to write a macro like this?

Reply
Thread Tools

how to write a macro like this?

 
 
Peng Yu
Guest
Posts: n/a
 
      06-25-2008
Hi,

I want a macro #expand that can be expanded to one of the following
depending on its argument

f(i1)
f(i1, i2)
f(i1, i2, i3)

...


For example,

expand(1) would give me f(i1)

expand(2) would give me f(i1, i2)

expand(3) would give me f(i1, i2, i3)

Is it possible to be done in macro? If it is possible, could you let
me know how to do it?

Thanks,
Peng
 
Reply With Quote
 
 
 
 
Stefan Ram
Guest
Posts: n/a
 
      06-25-2008
Peng Yu <(E-Mail Removed)> writes:
>expand(1) would give me f(i1)
>expand(2) would give me f(i1, i2)


#include <iostream>
#include <ostream>

#define expand1 f(i1)
#define expand2 f(i1, i2)

#define expand(i) expand##i

int f( int const i1, int const i2 ){ return 12; }
int f( int const i1 ){ return 11; }

int main()
{ int i1, i2;
::std::cout << expand(1) << "\n";
::std::cout << expand(2) << "\n"; }

 
Reply With Quote
 
 
 
 
Peng Yu
Guest
Posts: n/a
 
      06-25-2008
On Jun 25, 6:16 pm, Victor Bazarov <(E-Mail Removed)> wrote:
> Peng Yu wrote:
> > I want a macro #expand that can be expanded to one of the following
> > depending on its argument

>
> > f(i1)
> > f(i1, i2)
> > f(i1, i2, i3)

>
> > ..

>
> > For example,

>
> > expand(1) would give me f(i1)

>
> > expand(2) would give me f(i1, i2)

>
> > expand(3) would give me f(i1, i2, i3)

>
> > Is it possible to be done in macro? If it is possible, could you let
> > me know how to do it?

>
> //--------------------- here you go
> #define with1args f(i1)
> #define with2args f(i1,i2)
> #define with3args f(i1,i2,i3)
> #define formNname(i) with##i##args
> #define expand(i) formNname(i)
>
> //---------------- test code
> #include <iostream>
> #include <ostream>
>
> void f(int) { std::cout << "f(int)\n"; }
> void f(int,int) { std::cout << "f(int,int)\n"; }
> void f(int,int,int) { std::cout << "f(int,int,int)\n"; }
>
> int main()
> {
> int i1=0, i2=0, i3=0;
> expand(1);
> expand(2);
> expand(3);
>
> }
>
> V
> --
> Please remove capital 'A's when replying by e-mail
> I do not respond to top-posted replies, please don't ask


I think the example in my OP did not reflect the question that I
wanted to ask.

Suppose that the definitions of f(int), f(int, int) , f(int, int,
int) ... in reality are very complex. However, the difference between
them are minor, except the things that depend on different arguments.
In this case, I would not want to write each definition individually.

Also, in the code snippet that you showed, if the user needs f of 10
arguments, I have to define it ahead of time. But since I can not
enumerate all the possibilities, what if the user want an f of 100 or
1000 arguments.

I suspect that my request can not be done in macro. I looked up the
code of boost tuple, which offers functions and classes of different
number of arguments. It did not use macro in implementation in this
aspect. I just want to double check if my inception is correct.

Thanks,
Peng
 
Reply With Quote
 
Stefan Ram
Guest
Posts: n/a
 
      06-26-2008
Peng Yu <(E-Mail Removed)> writes:
>Suppose that the definitions of f(int), f(int, int) , f(int, int,
>int) ... in reality are very complex.


It is usually recommended to refactor a complex function
definition until it is not so complex anymore.

>However, the difference between
>them are minor, except the things that depend on different arguments.
>In this case, I would not want to write each definition individually.


One might use a single array or vector as an argument or
write f as a a function with a variable number of arguments.

 
Reply With Quote
 
Peng Yu
Guest
Posts: n/a
 
      06-26-2008
On Jun 25, 7:45 pm, (E-Mail Removed)-berlin.de (Stefan Ram) wrote:
> Peng Yu <(E-Mail Removed)> writes:
> >Suppose that the definitions of f(int), f(int, int) , f(int, int,
> >int) ... in reality are very complex.

>
> It is usually recommended to refactor a complex function
> definition until it is not so complex anymore.
>
> >However, the difference between
> >them are minor, except the things that depend on different arguments.
> >In this case, I would not want to write each definition individually.

>
> One might use a single array or vector as an argument or
> write f as a a function with a variable number of arguments.


It might be OK to certain cases, but it is not suitable to the cases
in my project.

Thanks,
Peng
 
Reply With Quote
 
gpderetta
Guest
Posts: n/a
 
      06-26-2008
On Jun 26, 1:51*am, Peng Yu <(E-Mail Removed)> wrote:
<snip>
> I suspect that my request can not be done in macro. I looked up the
> code of boost tuple, which offers functions and classes of different
> number of arguments. It did not use macro in implementation in this
> aspect. I just want to double check if my inception is correct.
>


Check the boost preprocessor library.

--
gpd
 
Reply With Quote
 
Pascal J. Bourguignon
Guest
Posts: n/a
 
      06-26-2008
Peng Yu <(E-Mail Removed)> writes:

> On Jun 25, 6:16 pm, Victor Bazarov <(E-Mail Removed)> wrote:
>> Peng Yu wrote:
>> > I want a macro #expand that can be expanded to one of the following
>> > depending on its argument

>>
>> > f(i1)
>> > f(i1, i2)
>> > f(i1, i2, i3)

>>
>> > ..

>>
>> > For example,

>>
>> > expand(1) would give me f(i1)

>>
>> > expand(2) would give me f(i1, i2)

>>
>> > expand(3) would give me f(i1, i2, i3)

>>
>> > Is it possible to be done in macro? If it is possible, could you let
>> > me know how to do it?

>>
>> //--------------------- here you go
>> #define with1args f(i1)
>> #define with2args f(i1,i2)
>> #define with3args f(i1,i2,i3)
>> #define formNname(i) with##i##args
>> #define expand(i) formNname(i)
>>
>> //---------------- test code
>> #include <iostream>
>> #include <ostream>
>>
>> void f(int) { std::cout << "f(int)\n"; }
>> void f(int,int) { std::cout << "f(int,int)\n"; }
>> void f(int,int,int) { std::cout << "f(int,int,int)\n"; }
>>
>> int main()
>> {
>> int i1=0, i2=0, i3=0;
>> expand(1);
>> expand(2);
>> expand(3);
>>
>> }
>>
>> V
>> --
>> Please remove capital 'A's when replying by e-mail
>> I do not respond to top-posted replies, please don't ask

>
> I think the example in my OP did not reflect the question that I
> wanted to ask.
>
> Suppose that the definitions of f(int), f(int, int) , f(int, int,
> int) ... in reality are very complex. However, the difference between
> them are minor, except the things that depend on different arguments.
> In this case, I would not want to write each definition individually.
>
> Also, in the code snippet that you showed, if the user needs f of 10
> arguments, I have to define it ahead of time. But since I can not
> enumerate all the possibilities, what if the user want an f of 100 or
> 1000 arguments.
>
> I suspect that my request can not be done in macro.


It can be done, almost. You only need an additionnal cpp loop.

http://www.ioccc.org/2001/herrmann1.hint
http://www.ioccc.org/2001/herrmann1.c
http://www.ioccc.org/2001/herrmann1.sh
http://www.ioccc.org/2001/herrmann1.gcd
http://www.ioccc.org/2001/herrmann1.times2


> I looked up the
> code of boost tuple, which offers functions and classes of different
> number of arguments. It did not use macro in implementation in this
> aspect. I just want to double check if my inception is correct.


You could probably solve your problem with templates (and boost::mpl),
but I don't think it would be any simplier than with C macros.



What you are really longing for is merely lisp:

(defmacro call-f-with-arguments (n)
`(f ,@(loop :for i :from 1 :to n
:collect (intern (format nil "I~A" i)))))

(macroexpand '(call-f-with-arguments 7))
--> (F I1 I2 I3 I4 I5 I6 I7)


Or with local macros:

(defun main ()
(let ((i1 0) (i2 0) (i3 0))
(macrolet ((call-f (n)
`(f ,@(loop :for i :from 1 :to n
:collect (intern (format nil "I~A" i))))))
(call-f 3)))
0)

--
__Pascal Bourguignon__
 
Reply With Quote
 
tharinda_g tharinda_g is offline
Junior Member
Join Date: Jun 2008
Posts: 2
 
      06-27-2008
Quote:
Originally Posted by Peng Yu
Hi,

I want a macro #expand that can be expanded to one of the following
depending on its argument

f(i1)
f(i1, i2)
f(i1, i2, i3)

...


For example,

expand(1) would give me f(i1)

expand(2) would give me f(i1, i2)

expand(3) would give me f(i1, i2, i3)

Is it possible to be done in macro? If it is possible, could you let
me know how to do it?

Thanks,
Peng
if you can write a function with a variable arguments then this can be handled differently. You can take variable arguments even for macros. use __VA_ARGS__
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Re: How include a large array? Edward A. Falk C Programming 1 04-04-2013 08:07 PM
object-like macro used like function-like macro Patrick Kowalzick C++ 5 03-14-2006 03:30 PM
in S.E. Asia : Canon EOS 300d with 100 macro ED vs. Nikon D70 with Nikon 105 macro ? J. Cod Digital Photography 0 09-29-2004 05:46 AM
#define macro to enclose an older macro with strings Dead RAM C++ 20 07-14-2004 10:58 AM
macro name from macro? D Senthil Kumar C Programming 1 09-21-2003 07:02 PM



Advertisments