In today’s video tutorial lets look at couple of predefined Macros in C programming Language.
Uses of Predefined Macros
It’s very useful for developers while debugging the code, in a large project. Using these predefined macros you could write less code and integrate more features into the program. For example, to get current system date/time and timestamp you need not write lengthy code, just write the predefined macro and use the output in your source code.
Video Tutorial: Built-in Preprocessor Directive: C Program
Output: File: C:\Technotip\main.c Date: Jul 18 2020 Time: 14:11:52 Timestamp: Sat Jul 18 14:11:48 2020 Line: 9 ANSI: 1 Function Name: main Pretty Function name: main
Slno
Macro Name
Description
1
__FILE__
The name(along with full path) of the current file, as a string literal.
2
__DATE__
Current System date, as a string literal.
3
__TIME__
Current System time, as a string literal.
4
__TIMESTAMP__
Current System date and time(non-standard), as a string literal.
5
__LINE__
Current line in the source code file where __LINE__ is written, as numeric literal.
6
__STDC__
its value is 1, when the compiler compiles with the ANSI standard.
7
__func__
function name in which the __func__ resides.
8
__PRETTY_FUNCTION__
function name in which the __PRETTY_FUNCTION__ resides.
__PRETTY_FUNCTION__ and __func__ returns same value, but not all compilers support both. Sometimes its compiler specific.
Note: We do not include or import any file to make these Macros work. It looks like all these are working out-of-the box, so sometimes these are called as Magic Constants.
In this video tutorial, lets see how we can make use of #error preprocessor command or directive.
Where Is It Useful?
If you’re a Software developer working with C programming language, then your project will have a lot of code and dependency source codes. While compiling, compiler will take a lot of time. In big projects usually you forget the purpose of compilation by the time it completes compilation. In such cases, make use of #error directive. If there are any errors at certain locations the compiler will stop further compilation as and when it encounters #error directive. This saves a lot of time and resources. So #error directive is usually helpful in debugging your project code.
It’s also helpful in projects with critical user inputs. Suppose user enters wrong data due to which the project itself might crash and utilize a lot of resource while trying to execute. In such cases it’s better to terminate the program execution.
Video Tutorial: #error Preprocessor Directive: C Programming
#include<stdio.h>
#define iOS
#ifndef iOS
#error First Include iOS Macro
#else
int main()
{
printf("I Love Apple Devices!\n");
return 0;
}
#endif // iOS
Output: I Love Apple Devices!
Here #ifndef directive checks if the macro iOS is defined. If its NOT defined it returns true or 1. If it’s defined then it returns 0 or false.
So if the macro iOS is not defined, then the code inside #ifndef gets compiled and executed, else the code inside #else block gets compiled and executed.
When Macro iOS is not defined
When Macro iOS is not defined, the code inside #ifndef gets compiled, where the compiler encounters #error directive. Now the compiler immediately stops any further compilation and displays the error message associated with #error directive.
C:\>node
> 1 + 1
2
> var a;
undefined
> a = 10
10
> a + 5
15
> a
10
> ++a
11
> a++
11
> a
12
> "Satish "+"B"
'Satish B'
> function technotip() { return 101; }
undefined
> technotip();
101
>2
C:\>node
> 1 + 1
2
> var a;
undefined
> a = 10
10
> a + 5
15
> a
10
> ++a
11
> a++
11
> a
12
> "Satish "+"B"
'Satish B'
> function technotip() { return 101; }
undefined
> technotip();
101
>2
Here we can type in our valid code snippet and instantly get the results. Some of the things we can do are: arithmetic operations, string manipulations, pre and post increment decrement of numbers, method declaration and defining and calling the methods etc.
We could even require some built-in node modules and using its objects we can look at the methods and properties it provides. Command Prompt Console Window
Note: Node.js is built on the same Google’s V8 JavaScript Engine which is using by Google’s Chrome – thus providing the same speed and robustness to our node.js applications.
