What are the differences between Macros and Functions in C Language?

Answer 1

Subroutine:

1.When a task is to be done repeatedly then it is written as subroutine and this subroutine will be called each time to perform that task.

2.Subroutine program will be stored in some memory location and program control will be transfered to that location each time.

3.where as in macro the number of instructions will be less than subroutine.Here each time u call a macro that set of instructions will be inserted in that location.

4.macro doesn't have return statement while subroutine has.

5.memory requirement for macro is higher.

6.execution time of macro is lesser than subroutine.

Answer 2

Macros are essentially shorthand representations of arbitrary sections of the source code, which makes the source code succinct, while its (the macro template's) expansion replaces each of its presence prior to compilation. Whatever is there to do with Macros, it is done by the preprocessor, so that the source code is ready for compilation. Function is a calling routine, whence a large program is divided into separate portions, each portion doing a separate job, and proper calling of these portions in different places combines the works done by them into the required complete output. Thus functions have nothing to do with the preprocessing period, they are just compiled. To some extent function and macro is similar, for a macro can occasionally be invoked to perform a task that is generally entrusted to a function. But the similarity ends there.

The differences are:

1. Macro consumes less time. When a function is called, arguments have to be passed to it, those arguments are accepted by corresponding dummy variables in the function, they are processed, and finally the function returns a value that is assigned to a variable (except for a void function). If a function is invoked a number of times, the times add up, and compilation is delayed. On the other hand, the macro expansion had already taken place and replaced each occurrence of the macro in the source code before the source code starts compiling, so it requires no additional time to execute.
2. Function consumes less memory. While a function replete with macros may look succinct on surface, prior to compilation, all the macro-presences are replaced by their corresponding macro expansions, which consumes considerable memory. On the other hand, even if a function is invoked 100 times, it still occupies the same space. Hence function is more amenable to less memory requirements.

Answer 3

Macros are a text-replacement system. They allow you to symbolise commonly used definitions, which can help simplify your code, but at the expense of type-safety, code size/performance, hidden side-effects and portability.

Consider the following:

#define MAX(X,Y)((X)>(Y)?(X):(Y))

template <class T>

T Max(T x, T x){ return( x>y?x:y ); }

In both cases you can call either MAX() or Max() to compare any two values. However, since the macro is not type-safe, there's no telling what the return type will be if X and Y are not intrinsically the same type. Nor can the compiler determine if an appropriate operator overload exists to compare X and Y correctly. Other side-effects include the way in which expressions are evaluated within the macro. Try MAX(a++,b++) and watch the largest value increment twice!

In this example, the function template is the preferred method. This ensures that both x and y are of the same intrinsic type, that a suitable operator overload exists to compare them, and that expressions are correctly evaluated once and only once.

Templates can be inline expanded just like a macro, but the compiler is free to ignore inline expansion if there would be no benefit. Macros are inline expanded whether you like it or not, and it's not always beneficial; larger code reduces overall performance.

Answer 4

A macro is simply a text-substitution mechanism. You use the #define directive to define both macro symbols and precompiler directives. Every occurrence of a macro symbol within your code is substituted with the macro definition during preprocessing.

Answer 5

The terms macro and template have many different meanings in different contexts. For example, within Microsoft Word, a template is a blank design of a document such as an empty letter with letterhead and predefined formatting preferences, while a macro is a small program used to automate repeated complex tasks.

In the C Programming language, the word macro refers to an expanding pre-processor symbol, also sometimes known as a pound-define. These definitions provide a simple one-for-one text replacement method which can be parameterized through macro arguments.

For example, the following macro determines the smallest value of two arguments. This definition saves writing the same ternary expression all over again, which saves time, makes the code more readable, and prevents errors:

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

Notice the use of parentheses. While not strictly necessary in many cases, they can prevent unintended errors when expanding the macro, subject to the chosen arguments a and b.

The C programming language does not support templates, but the C++ language does. In C++, templates are generic class definitions, which are parameterized to support a particular data type at the time of instantiation. This allows for the definition of generic and reusable data structures and algorithms, which can then be used in a type-safe manner. For example, the following code snippet creates a stack object for "int" elements, based on a hypothetical Stack template:

Stack stack;

Type safety means that the object "stack" implements its internal data storage and operations based on the chosen type (int in this example), as opposed to a generic one-for-all data type. Type-safety promotes efficient code and promotes detection of coding errors at compile-time.

Therefore, the answer to the question what is the difference between a template and a macro in the C programming language is that macros do and templates do not exist in the C programming language. In C++, both macros and templates exist, but are generally very different tools, and comparing them means comparing apples with Pears.

Answer 6

In application programming, macro and function(or: subroutine, etc) are often used to describe the same thing: a piece of code that can be written and tested once, then used over and over again.

In system programming, a macro generally is different, although not without similarity to a function (or subroutine, etc): A function is written once and its code exists once. Whenever the function is called, the processor actually branches (jumps) into the function's code, executes that code, and returns to the location just after the call. A macro is also written once, but whenever its is referenced in the source code, a parameterized copy is expanded at compile or assembly time. Unlike the function, the macro thus exists as many times as it is referenced, possibly in slightly different versions thanks to parameterization.

In comparison, macros generally consume more code memory but execute faster than functions (because they don't incur the overhead of parameter transfer, call and return from a function). In systems programming, macros are typically only used for very short sections of repeated code which are time-critical or don't justify the function call overhead.

Answer 7

Macros and functions are entirely
different. A macro is, in principle, text processing. Like "Find and
replace" in your text editor. Only it happens automatically in the
compiling process, after tokenisation but before lexical analysis.
Functions, OTOH, are genuine C language constructs and not merely text
processing features.
Functions are handled in all states of the compiling process, right up
to linking. The generated object files make a distinction between each
function, and the linker then links all calls between functions
together. In some cases, even the run-time program knows which function
it's currently executing.
None of this is the case with a macro. Once the preprocessor has
expanded the macro, the rest of the process is handled as if the macro
never existed.
Type your answer here...?

Answer 8

A macro is a text-replacement system used to modify your code prior to compilation. For instance, by defining a macro X with the value 42, every instance of X within your code will be replaced by the literal value 42. This is a bit like defining a static constant, but whereas there is only ever one instance of a static constant, there can be many instances of a literal throughout your program. However, unlike a static constant, a macro is not type safe.

Since macros are nothing more than text replacements, you can define virtually anything with a macro, including complex functions and data structures that might otherwise be difficult to implement in C++ alone. However, since macros are preprocessed, the compiler cannot help you debug macros. By the time the compiler sees your code, it's actually looking at the intermediate code that was emitted by the preprocessor; the macros no longer exist at that point because the text they contained is literally embedded in your source.

A function, on the other hand, conforms to C++ type safety and can be easily debugged by the compiler. Template functions make it easier to overload your functions to cater for different data types in a type-safe manner, thus the need for macro functions is lessened. Macros have their uses -- the built-in debug macros, such as ASSERT() and TRACE(), are extremely useful as they reduce to nothing in release builds -- but macros in general should be avoided whenever it is possible or practical to do so. The more rigidly you stick to native C++ code, the more robust your code will be in the long run, as you not only guarantee type safety, you enlist the compiler to help you debug your code. Macros are difficult to maintain and will generally cause far more problems than they are actually worth. If you must use a macro, do try and keep it as simple as possible, and think carefully about why the C++ method is unsuitable.