Macros Using #s

I'm not the best with defining macros that concatenate things....

Code:

---

#define MAC(x) #x

---

What exactly is that supposed to do?

Code:

---

#define MAC(string,id) string##id

---

...Or that?

And...aren't there rules about white space, new lines, commas, semi-colons, etc. when defining macros? Could somoene explain these a little? Isn't it that you never use semi-colons, comments, or double-quotes?

Something like...

Code:

---

#define printf string=Hello, printf

---

Would be correct?

When defining macros, '#' stringises it's operand. So this macro:

[CODE]#define OUT(x) std::cout << #x << endl;[/CODE]

Would be the same as writing

Code:

---

std::cout << "Hi" << endl;

---

Assuming you were passing "Hi" to the OUT macro.

In c++ we dont use macros.

It's frowned upon --> :(

You can easily write a function or an inline function that does the same thing.

Very true. Don't use macros, or you will be taken out the back and shot at dawn.

See, frowned upon -- > :(

sheesh, you oop people, macros are very powerful and irreplaceable, a perfect example of a macro you would have to be crazy to migrate to an inline function is UNREFERENCED_PARAMETER()

Oh no, a C programmer. :D

:D strangely enough I learned on c++, then learned c and decided I wasn't all too fond of oop, I do however, keep up with oop because it's required by so many jobs

Yeah I kinda felt the same way to begin with; probably because I didn't understand some of it (polymorphism, wtf?). But now I've gotten to grips with it I think it's, well, pretty good.

Macros aren't frowned upon by C++ people because they are non-OO. They are frowned upon because macros are easily misused and there are VERY few things that can be done with a macro for which there aren't safe alternatives.

Ironically, that statement is applicable to C as well as to C++. But C programmers seem to religiously defend the use of macros, even when they could use safer approaches, while C++ programmers seem to religiously attempt to avoid using macros. The reality is that macros are a useful tool in both languages, but not the only tool.

echo grumpy

http://www.research.att.com/~bs/bs_faq2.html#macro

:( <--me frowning at macros. yes, that means you, NULL.

NULL is awesome.

NULL is void










just kidding... DO NOT REMEBER THAT I EVER SAID THAT

NULL is just a big word thrown around by small men who find it easier to live in the world they’ve been given than to explore the power they have to change it.
NULL is temporary.

NULL is nothing.

... though some argue that 0 isnt nothing. Oh well.

0 isn't nothing... I'll prove it.

we accept these three basic principles:
void=nothing
NULL=0
NULL!=void

therefore
0!=nothing

:p

Quote:

---

Originally Posted by laserlight

NULL is temporary.

---

NULL is constant, not temporary.


Quzah.

Quote:

---

NULL is constant, not temporary.

---

Not really - NULL is a constant, but its use in general programming practice can be temporary.

Quote:

---

Originally Posted by quzah

NULL is constant, not temporary.


Quzah.

---

party pooper... if you think about it, NULL (along with all other 'constant' variables) is temporary, because it only exists as long as the program is running :D

and no, I'm not talking about NULL as a universal thing, just as it applies to a C/C++ program.

more fun:

Code:

---

#include<iostream>
#undef NULL

int main()
{
        #ifdef NULL
        int*ptr=NULL;
        std::cout<<"NULL defined as "<<ptr<<std::endl;
        #else
        std::cout<<"NULL not defined"<<std::endl;
        #endif

        return 0;
}

---

Quote:

---

And...aren't there rules about white space, new lines, commas, semi-colons, etc. when defining macros? Could somoene explain these a little? Isn't it that you never use semi-colons, comments, or double-quotes?

---

There aren't any white space rules other than the usual. The only "newline" issue is that you escape multi-line macros. Like so:

Code:

---

#define FOO(bar) line1 \
    line2

---

The last line doesn't have a \, all others do.

A macro is simply a compile time text subsutution. The ## macros smash things together. Like so:

Code:

---

#define FOO(bar,baz) bar ## baz

int var1, var2, var3

FOO( var, 1 ) = 10;

---

Then you do something like this:

Code:

---

#include<iostream>

#define FOO(bar,baz) bar ## \
    baz
#define BAR(foo,baz) foo # \
    baz

int main( )
{
    int var1, var2, var3;

    FOO( var, 1 ) = 10;
    FOO( var, 2 ) = 20;
    FOO( var, 3 ) = 30;

    std::cout << BAR("var",1) << " is: " << FOO( var, 1 ) << std::endl;
    std::cout << BAR("var",2) << " is: " << FOO( var, 2 ) << std::endl;
    std::cout << BAR("var",3) << " is: " << FOO( var, 3 ) << std::endl;

    return 0;
}

---

They're multi-line just for the hell of it. They don't need to be. The only thing about white space is you need your #define or #include or what not to start on the left margin. Some compilers will let you get away with it indented for some of the things, but IIRC, th're supposed to start on the left most character.

Code:

---

#include <GOOD>

---

Code:

---

    #include <bad>

---

Quzah.

Quote:

---

Originally Posted by laserlight

Not really - NULL is a constant, but its use in general programming practice can be temporary.

---

NULL is a constant. You've just said so. Your use of it is temporary, but NULL remains constant. There's no two ways about it.

Waxing philisophical...


Quzah.

Quote:

---

NULL is a constant. You've just said so. Your use of it is temporary, but NULL remains constant. There's no two ways about it.

---

We're just playing with language :p
I didnt say NULL is a temporary, I said NULL is temporary.
I didnt say NULL is constant, I said NULL is a constant.

Macros, if used correctly and documented correctly, can save a lot of work. And no, if the macro isn't simple, it cannot be replaced by an inline function.

Challenge 1: Write an inline function that does the same as

Code:

---

#define PRINT_NAME_AND_NUMERICAL_VALUE( name ) printf("%s is %d", #name, name );

---

or

Code:

---

#define DECLARE_VARIABLE_AND_ACCESSORS( name ) int m_i##name; \
int GetNumber##name() { return m_i##name; }\
void SetNumber##name( int val ) { m_i##name = val; }

---

Looks ugly for a little class, but write a class with 100 variables and accessors and we will see.

Or write an inline function, that will be compiled conditionally

Code:

---

#ifdef _PERF_
MEASURE_PERFORMANCE( statement, description ) [performance measuring and output code]
#else
MEASURE_PERFORMANCE( statement, description ) statement;
#endif

---

This might be the job of a profiler... but you don't want to have a profiler on your production system.

I don't see any alternatives to Macros. You probably frown upon them while others get work done using them :)

Actually the first macro:

Code:

---

#define PRINT_NAME_AND_NUMERICAL_VALUE( name ) printf("%s is %d", #name, name );

---

Wouldn't be to hard - not that I've tried - as you can surely use a stringstream to get the numerical value of name? You can use a stringstream to write an itos function.

Actually I'm going to try that now, I'll post it up if I have any joy.