Hi all,

I finally have some time to dive, head first, into C++. There's yet a lot I have to learn, but the first question already came up:

One of the topics I'm reading at the moment deals with inline functions. The concept is clear to me and it seems like a clever way to make your code (a bit) faster. But at the end of the chapter there is a note that makes me wonder:

note
Inline is a hint to the compiler that you would like the function to be inlined. The compiler is free to ignore the hint and make e real function call.

Google, being one of my best friends, doesn't clear things up for me.

I found out that there is a hidden compiler option to force inline functions (make it an order, not a hint). I also read that modern compilers are good enough to decide for themself (even if the inline option isn't given).

My question:

Is using inline functions outdated and are (modern = gcc 2.95.x/3.3.X) compilers reallly good enough to go around without using it?

hi there

as u have said it all that

>>>>>>>>>>>> I also read that modern compilers are good enough to decide for themself (even if the inline option isn't given),<<<<<<<<<<
so it de[aendds upon th gcc that takes in to consideration the avaliable resources and then accordinglt decide whther to

leave a inline function as inline or whehther to make a normal function as inline(it itself makes small non inline function as inline if that improves the effeciency)

so in my opinion we ahoudl do our part(mention the inline functions as of where required) and leave the rest to compilers

regards

So, generally speaking if the function is quite small and clever it's good to be inline But if it's complex and it's not the most elegant and smart way of doing it, don't use inline

Cheers,
gamehack

Thanks for the answers this far.

But........

Besides programming style (masand), which is a good point, I still don't see why you should use inline declarations when using modern compilers. The programmer cannot control if inline is actually used, the compiler does. Even if you don't use inline the compiler can decide to use it anyway and vice versa

To me this looks like something that a programmer should not be concerned about while writing code, due to the inability to actually manipulate it.

So, besides the style issue, is there another good reason to use it?

Probably the best thing to do is only to use it as a last resort. If your code's running too slowly, profile it, and if a lot of time is being spent in a few small functions, you might get a little extra speed by making them inline. I expect that modern compilers are good enough to avoid extreme cases of inefficiency due to functions not being inlined (e.g. a small function being called 1000s of times in a loop).

Alex

Yes they can ... in fact, you noted this in your first post!

e.g. there are at least five different switches directly controlling the inlining of functions with gcc and what gets inlined, what doesn't, what can't be and how the compiler determines what is inlined and what isn't are all covered.

linky:
http://gcc.gnu.org/onlinedocs/gcc-3....ne.html#Inline
http://gcc.gnu.org/onlinedocs/gcc-3....mize%20Options

The point is that the language does not determine where inline is used, but the implementation does. That doesn't mean that you don't have any control over it though.

You could argue that the programmer is unlikely to make a better decision than the compiler (as with inline assembly) but there again if you need to improve performance then ...

Which is, imho, a lot easier to do with a keyword, than it is to work out why certain functions are not being inlined when you thought they should be according to whatever voodoo the compiler has conjured up.

Don't forget that inline makes the source available in situ which in turn can lead to further performance gains.

This clears things up a bit for me.

The book I'm using did not mention the compile step being important when using the inline construct. They only mention the inline option when writing code and up 'till now I used g++ name.c++ -oname to compile.

Your reply and the links given make it clear that the compile step is very important. From one of the links: Inlining of functions is an optimization and it really "works" only in optimizing compilation. If you don't use -O, no function is really inline.

And to all repliers: Thanks!

As an aside

Macros in general tend to cause problems, but you can use them to inline very small functions, with or without the compiler's consent.