What is the difference between macro and inline()?

Questions by karishma   answers by karishma

Showing Answers 1 - 59 of 59 Answers

Madhu

  • Mar 1st, 2006
 

Inline functions are similar to macros because they both are expanded at compile time, but the macros are expanded by the preprocessor, while inline functions are parsed by the compiler. There are several important differences: ? Inline functions follow all the protocols of type safety enforced on normal functions. ? Inline functions are specified using the same syntax as any other function except that they include the inline keyword in the function declaration. ? Expressions passed as arguments to inline functions are evaluated once. In some cases, expressions passed as arguments to macros can be evaluated more than once.

Jai

  • Jun 9th, 2006
 

1. Inline follows strict parameter type checking, macros do not.

2. Macros are always expanded by preprocessor, whereas compiler may or may not replace the inline definitions.

Nitin Bhatt

  • Jan 31st, 2007
 

Hi, I was asked the same question in one of the interviews I faced recently. I gave the answer:



1. Inline follows strict parameter type checking, macros do not.



2. Macros are always expanded by preprocessor, whereas compiler may or may not replace the inline definitions.



The next question was based on point "2"



The question was, can I force the compiler to replace the inline definition.Please let me know if anyone has the answer to this question.



Thanks in advance.

Nitin

Dinesh Jethva

  • Mar 9th, 2007
 

No, You cant force compiler to make a function inline. It is purely compiler based decision.

  Was this answer useful?  Yes

NALINI

  • May 29th, 2007
 

  • In INLINE functions, the control replaces the code where it is called that function AND it follows strict type checking..
  • In MACROS ,control is transferred to place where macro is present AND it doesn't follow strict type checking..

  Was this answer useful?  Yes

shruti

  • Sep 6th, 2007
 

Nitin, I think we can force compiler to take function as inline  bcoz its the size of the function mainly that has to be  small if a function is inline and a large function  can be made inline by decreasing its size

  Was this answer useful?  Yes

Shruthi D. R

  • Nov 16th, 2007
 

inline will be expanded by compiler depending on the code size.
Code size will be decided by compiler.
If it expands, it acts like macro else as a function

  Was this answer useful?  Yes

XIV

Inline Function

Preprocessor Macro – good for declaring constnts eg. #define PI 3.14
Provide textual substitution
Each time the macro name is encountered with arguments, the arguments used in its definition are replaced by the actual arguments found.

1

It is a function provided by C++.
It is declared by using the keyword inline before the function protoype.

It is a a preprocessor directive provided by C.
It is declared by using the preprocessor directive #define before the actual statement.

2

Expressions passed as arguments to inline functions are evaluated once.

In some cases, expressions passed as arguments to macros can be evaluated more than once.
Every time you use an argument in a macro, that argument is evaluated.

#define max(a,b) (a>b?a:b)

void main()

{

  int a = 0;

  int b = 1;

  int c = max(a++, b++);

  cout << a << endl << b << endl;

}

The intention is to have the program print 1 and 2, but because the macro is expanded to:

int c = a++ > b++ ? a++ : b++;

b will be incremented twice, and the program prints 1 and 3. //try

3

They are parsed by the compiler

They are expanded by the preprocessor at pre-compile time.

4

Inline functions follow all the protocols of type safety enforced on normal functions.
Argument types are checked, and necessary conversions are performed correctly.
The compiler performs return type checking, function signature before putting inline function into symbol table.
They can be overloaded to perform the right kind of operation for the right kind of data.

No such thing, hence, macros are more error prone as compared to inline functions. the The parameters are not typed (the macro works for any objects of arithmetic type).
No error checking is done during compilation.
Eg. you can pass strings to a macro that does some integer arithmetic

#define MAX(a, b) ((a < b) ? b : a)

 

int main( void)

{

  cout << "Maximum of 10 and 20 is " << MAX("20", "10") << endl;

    return 0;

}

5

Can be used for debugging a program as they are expanded at compile time and a break point caa be placed at the inline function adefinition and step into the method for debugging step by step.

Can not be used for debugging as they are expanded at pre-compile time.

6

Inline member functioncs can access the class’s member data.

The preprocessor has no permission to access member data of a class and are thus useless even if used within a class. Thus they can not even be used as member functions.
Eg.

#define VAL (X::i) // Error

class X {

  int i;

public:
  ---};

7

 

Paranthesis need to be handled carefully as missing a pair or putting an extra pair may prouce undesirable results.

8

Inline functions may or may not be expanded by the compiler. It is the compiler’s decision whether to expand the function inline or not.

Macros are always expanded.

9

It can be defined inside or outside the class.

It can not be defined insode the class.

10

Inline functions pass arguments by value, just like regular functions do. If the argument is an expression such as 4.5 +7.5 then the function passes the value of the expression 12 in this case.

Expressions passed into macros are not always evaluated before entering the macro body.

Macros don’t pass by value.

Thus , #define square(x) x*x

:

b=square(4.5+7.5)

This will be replaced by : b=4.5+7.5*4.5+7.5

11

 Since type checking can be used in inline functions, theis problem can be avoided.

Expressions may expand inside the macro so that their evaluation precedence is different from what you expect.

Eg.

#define FLOOR(x,b) x>=b?0:1

Now, if expressions are used for the arguments

if(FLOOR(a&0x0f,0x07)) // ...

the macro will expand to

if(a&0x0f>=0x07?0:1)

The precedence of & is lower than that of >=, so the macro evaluation will surprise you.

bhavnajoshi

  • Feb 24th, 2009
 

1. In macro the format is used #define
but inline function use inline keyword additional in function prototype format.


2. When we use macro definition
like_#define cube(a) a*a*a
int a=2;
int i=cube(++a);


the expression becomes
i=(++a)*(++a)*(++a);
then finally a becomes 5 & i will be 125.
but the same in inline function gives value of i as 27.
because first value is processed & and then passed so the output will 27.


  Was this answer useful?  Yes

Inline functions are similar to macros because they both are expanded at compile time, but the macros are expanded by the preprocessor, while inline functions are parsed by the compiler. There are several important differences:

1.
Inline functions follow all the protocols of type safety enforced on normal
functions.
2. Inline functions are specified using the same syntax as any other function except that they include the
inline keyword in the function
declaration.
3. Expressions passed as arguments to inline functions are evaluated once. In
some cases, expressions passed as arguments to macros can be evaluated more than
once.


  Was this answer useful?  Yes

mtyprvn

  • Mar 23rd, 2015
 

If inline function expanded, stack will grow in between a regular function, whereas in macro, since it is a string expansion, stack usage will be from the regular function.

  Was this answer useful?  Yes

mtyprvn

  • Mar 23rd, 2015
 

If inline function expanded under a regular function, the stack size grows, whereas in macro, since it is a string replacement, stack doesnt grow.
Code binding may cause bug in macro, but not in inline function
For eg., for the multi-line macro #define CALCULATE(x, y) x = x+y; y = x + 10;
If this is used in a non-braced if condition, the 2nd statement will not be under the condition.
Think of
if(condition)
CALCULATE(x, y)

  Was this answer useful?  Yes

Rohini

  • Jun 6th, 2015
 

You can force compiler to replace inline function with the body of function in gcc using always__inline attribute.

  Was this answer useful?  Yes

Sourabh

  • Jan 17th, 2016
 

@ NITIN: Can I force the compiler to replace the inline definition.

Answer:
Inline function is very good approach for small function definition. But if your inline function went larger in size then compiler automatically treats it as a normal function.

  Was this answer useful?  Yes

Aarish

  • Apr 20th, 2016
 

The major difference between inline functions and macros is the way they are handled. Inline functions are parsed by the compiler, whereas macros are expanded by the C++ preprocessor.

  Was this answer useful?  Yes

Tejas Bhosale

  • Oct 23rd, 2016
 

@Nitin Bhat
"Inline is a request to compiler"...so you cannot force compiler to make a function inline..

  Was this answer useful?  Yes

Sumit Tiwary

  • Jul 1st, 2017
 

we can force the compiler to do inline or not with the help of attribute:
__attribute__((always_inline)) int max(int a, int b) {
return (a > b ? a : b);
}

  Was this answer useful?  Yes

saravana

  • Sep 1st, 2017
 

by specifying _always_inline

  Was this answer useful?  Yes

Guru

  • Oct 12th, 2017
 

Macros will replace at pre processing time and inline functions will invoke at compile time.

  Was this answer useful?  Yes

Naman

  • Nov 14th, 2017
 

You pass some flags to the compiler to force inline or use always_inline attribute with GCC

  Was this answer useful?  Yes

Venkataramakrishna

  • Mar 22nd, 2018
 

Macro does not check for the data type. The inline function will check. You can enable or disable macros. in inline, depending on the requirement you can do this.

  Was this answer useful?  Yes

Give your answer:

If you think the above answer is not correct, Please select a reason and add your answer below.

 

Related Answered Questions

 

Related Open Questions