C programming language

qwertyuiopasdfghjklzxcvbnmqwerty
uiopasdfghjklzxcvbnmqwertyuiopasd
fghjklzxcvbnmqwertyuiopasdfghjklzx
cvbnmqwertyuiopasdfghjklzxcvbnmq
C programming language
wertyuiopasdfghjklzxcvbnmqwertyui
1ere année GBM
23/09/2024
opasdfghjklzxcvbnmqwertyuiopasdfg
geeksforgeeks.org
Université Paris Dauphine_Maude Manouvrier
hjklzxcvbnmqwertyuiopasdfghjklzxc
vbnmqwertyuiopasdfghjklzxcvbnmq
hjklzxcvbnmqwertyuiopasdfghjklzxc
vbnmqwertyuiopasdfghjklzxcvbnmq
hjklzxcvbnmrtyuiopasdfghjklzxcvbn
mqwertyuiopasdfghjklzxcvbnmqwert
yuiopasdfghjklzxcvbnmqwertyuiopas
C Language Introduction
Last Updated : 03 Sep, 2024



C is a procedural programming language initially developed by Dennis Ritchie in

the year 1972 at Bell Laboratories of AT&T Labs. It was mainly developed as a
system programming language to write the UNIX operating system.
The main features of the C language include:

 General Purpose and Portable
 Low-level Memory Access
 Fast Speed
 Clean Syntax
These features make the C language suitable for system programming like an
operating system or compiler development.
Why Should We Learn C?
Many later languages have borrowed syntax/features directly or indirectly from the C
language like the syntax of Java, PHP, JavaScript, and many other languages that are
mainly based on the C language. C++ is nearly a superset of C language (Only a few
programs may compile in C, but not in C++).
So, if a person learns C programming first, it will help them to learn any modern
programming language as well. Also, learning C helps to understand a lot of the
underlying architecture of the operating system like pointers, working with memory
locations, etc.
Get Started with C Learn C fundamentals and advanced concepts, then solve
practical problems right in your browser window with Educative’s interactive skill
path Become a C Programmer. Sign up at Educative.io with the code GEEKS10 to
save 10% on your subscription.
Difference Between C and C++

C++ was created to add the OOPs concept into the C language so they both have
very similar syntax with a few differences. The following are some of the main
differences between C and C++ Programming languages.
 C++ supports OOPs paradigm while C only has the procedural concept of
programming.
 C++ has exception handling capabilities. In C, we have to resolve exceptions
manually.
 There are no references in C.
There are many more differences between C and C++ which are discussed
here: Difference between C and C++
Beginning with C Programming
Writing the First Program in C
The following code is one of the simplest C programs that will help us understand the
basic syntax structure of a C program.
Example:
C
#include <stdio.h>
int main() {
int a = 10;
printf("%d", a);
return 0;
}
Output
10
Let us analyze the structure of our program line by line.
Structure of the C program
After the above discussion, we can formally assess the basic structure of a C
program. By structure, it is meant that any program can be written in this structure
only. Writing a C program in any other structure will lead to a Compilation Error. The
structure of a C program is as follows:
Components of a C Program:
1. Header Files Inclusion – Line 1 [#include <stdio.h>]
The first and foremost component is the inclusion of the Header files in a C
program. A header file is a file with extension .h which contains C function
declarations and macro definitions to be shared between several source files. All lines
that start with # are processed by a preprocessor which is a program invoked by the
compiler. In the above example, the preprocessor copies the preprocessed code of
stdio.h to our file. The .h files are called header files in C.
Some of the C Header files:
 stddef.h – Defines several useful types and macros.

 stdint.h – Defines exact width integer types.
 stdio.h – Defines core input and output functions
 stdlib.h – Defines numeric conversion functions, pseudo-random number
generator, and memory allocation
 string.h – Defines string handling functions
 math.h – Defines common mathematical functions.
2. Main Method Declaration – Line 2 [int main()]
The next part of a C program is to declare the main() function. It is the entry point of
a C program and the execution typically begins with the first line of the main(). The
empty brackets indicate that the main doesn’t take any parameter (See this for more
details). The int that was written before the main indicates the return type of main().
The value returned by the main indicates the status of program termination.
See this post for more details on the return type.
3. Body of Main Method – Line 3 to Line 6 [enclosed in {}]
The body of a function in the C program refers to statements that are a part of that
function. It can be anything like manipulations, searching, sorting, printing, etc. A
pair of curly brackets define the body of a function. All functions must start and end
with curly brackets.
4. Statement – Line 4 [printf(“Hello World”);]
Statements are the instructions given to the compiler. In C, a statement is always
terminated by a semicolon (;). In this particular case, we use printf() function to
instruct the compiler to display “Hello World” text on the screen.
5. Return Statement – Line 5 [return 0;]
The last part of any C function is the return statement. The return statement refers to
the return values from a function. This return statement and return value depend
upon the return type of the function. The return statement in our program returns the
value from main(). The returned value may be used by an operating system to know
the termination status of your program. The value 0 typically means successful
termination.
How to Execute the Above Program?
In order to execute the above program, we need to first compile it using a compiler
and then we can run the generated executable. There are online IDEs available for
free like GeeksforGeeksIDE, that can be used to start development in C without
installing a compiler.
1. Windows: There are many free IDEs available for developing programs in C
like Code Blocks and Dev-CPP. IDEs provide us with an environment to develop
code, compile it and finally execute it. We strongly recommend Code Blocks.
2. Linux: GCC compiler comes bundled with Linux which compiles C programs and
generates executables for us to run. Code Blocks can also be used with Linux.
3. macOS: macOS already has a built-in text editor where you can just simply write
the code and save it with a “.c” extension.
Application of C
 Operating systems: C is widely used for developing operating systems such as
Unix, Linux, and Windows.
 Embedded systems: C is a popular language for developing embedded systems
such as microcontrollers, microprocessors, and other electronic devices.
 System software: C is used for developing system software such as device
drivers, compilers, and assemblers.
 Networking: C is widely used for developing networking applications such as web
servers, network protocols, and network drivers.
 Database systems: C is used for developing database systems such as Oracle,
MySQL, and PostgreSQL.
 Gaming: C is often used for developing computer games due to its ability to
handle low-level hardware interactions.
 Artificial Intelligence: C is used for developing artificial intelligence and machine
learning applications such as neural networks and deep learning algorithms.
 Scientific applications: C is used for developing scientific applications such as
simulation software and numerical analysis tools.
 Financial applications: C is used for developing financial applications such as
stock market analysis and trading systems.
Data Types in C
Last Updated : 28 Sep, 2023



Each variable in C has an associated data type. It specifies the type of data that the
variable can store like integer, character, floating, double, etc. Each data type
requires different amounts of memory and has some specific operations which can be
performed over it. The data type is a collection of data with values having fixed
values, meaning as well as its characteristics.
The data types in C can be classified as follows:
Types Description
Primitive Data Primitive data types are the most basic data types that are used for
Types representing simple values such as integers, float, characters, etc.
User Defined
The user-defined data types are defined by the user himself.
Data Types
The data types that are derived from the primitive or built-in
Derived Types
datatypes are referred to as Derived Data Types.
Different data types also have different ranges up to which they can store numbers.
These ranges may vary from compiler to compiler. Below is a list of ranges along with
the memory requirement and format specifiers on the 32-bit GCC compiler.
Size Format
Data Type (bytes) Range Specifier
short int 2 -32,768 to 32,767 %hd
unsigned short int 2 0 to 65,535 %hu
unsigned int 4 0 to 4,294,967,295 %u
int 4 -2,147,483,648 to 2,147,483,647 %d
long int 4 -2,147,483,648 to 2,147,483,647 %ld

Size Format
Data Type (bytes) Range Specifier
unsigned long int 4 0 to 4,294,967,295 %lu
long long int 8 -(2^63) to (2^63)-1 %lld
unsigned long long 0 to

8 %llu
int 18,446,744,073,709,551,615
signed char 1 -128 to 127 %c
unsigned char 1 0 to 255 %c
float 4 %f
1.2E-38 to 3.4E+38
double 8 %lf
1.7E-308 to 1.7E+308
long double 16 %Lf

3.4E-4932 to 1.1E+4932
Note: The long, short, signed and unsigned are datatype modifier that can be
used with some primitive data types to change the size or length of the datatype.
The following are some main primitive data types in C:

Integer Data Type
The integer datatype in C is used to store the integer numbers(any number including
positive, negative and zero without decimal part). Octal values, hexadecimal values,
and decimal values can be stored in int data type in C.
 Range: -2,147,483,648 to 2,147,483,647
 Size: 4 bytes
 Format Specifier: %d
Syntax of Integer
We use int keyword to declare the integer variable:
int var_name;
The integer data type can also be used as

1. unsigned int: Unsigned int data type in C is used to store the data values from
zero to positive numbers but it can’t store negative values like signed int.
2. short int: It is lesser in size than the int by 2 bytes so can only store values from -
32,768 to 32,767.
3. long int: Larger version of the int datatype so can store values greater than int.
4. unsigned short int: Similar in relationship with short int as unsigned int with int.
Note: The size of an integer data type is compiler-dependent. We can use sizeof
operator to check the actual size of any data type.
Example of int
 C
// C program to print Integer data types.
#include <stdio.h>
int main()
// Integer value with positive data.
int a = 9;
// integer value with negative data.
int b = -9;
// U or u is Used for Unsigned int in C.
int c = 89U;
// L or l is used for long int in C.
long int d = 99998L;
printf("Integer value with positive data: %d\n", a);
printf("Integer value with negative data: %d\n", b);
printf("Integer value with an unsigned int data: %u\n",
c);
printf("Integer value with an long int data: %ld", d);

return 0;
Output
Integer value with positive data: 9
Integer value with negative data: -9
Integer value with an unsigned int data: 89
Integer value with an long int data: 99998
Character Data Type

Character data type allows its variable to store only a single character. The size of
the character is 1 byte. It is the most basic data type in C. It stores a single character
and requires a single byte of memory in almost all compilers.
 Range: (-128 to 127) or (0 to 255)
 Size: 1 byte
 Format Specifier: %c
Syntax of char
The char keyword is used to declare the variable of character type:
char var_name;
Example of char
 C
// C program to print Integer data types.
#include <stdio.h>
int main()
char a = 'a';
char c;
printf("Value of a: %c\n", a);

a++;
printf("Value of a after increment is: %c\n", a);
// c is assigned ASCII values
// which corresponds to the
// character 'c'
// a-->97 b-->98 c-->99
// here c will be printed
c = 99;
printf("Value of c: %c", c);
return 0;
Output
Value of a: a
Value of a after increment is: b
Value of c: c
Float Data Type

In C programming float data type is used to store floating-point values. Float in C is
used to store decimal and exponential values. It is used to store decimal numbers
(numbers with floating point values) with single precision.
 Range: 1.2E-38 to 3.4E+38
 Size: 4 bytes
 Format Specifier: %f
Syntax of float
The float keyword is used to declare the variable as a floating point:
float var_name;
Example of Float
 C
// C Program to demonstrate use
// of Floating types
#include <stdio.h>
int main()
float a = 9.0f;
float b = 2.5f;
// 2x10^-4
float c = 2E-4f;
printf("%f\n", a);
printf("%f\n", b);
printf("%f", c);
return 0;
Output
9.000000
2.500000
0.000200
Double Data Type

A Double data type in C is used to store decimal numbers (numbers with floating
point values) with double precision. It is used to define numeric values which hold
numbers with decimal values in C.
The double data type is basically a precision sort of data type that is capable of
holding 64 bits of decimal numbers or floating points. Since double has more
precision as compared to that float then it is much more obvious that it occupies
twice the memory occupied by the floating-point type. It can easily accommodate
about 16 to 17 digits after or before a decimal point.
 Range: 1.7E-308 to 1.7E+308
 Size: 8 bytes
 Format Specifier: %lf
Syntax of Double
The variable can be declared as double precision floating point using the double
keyword:
double var_name;
Example of Double
 C
// C Program to demonstrate
// use of double data type
#include <stdio.h>
int main()
double a = 123123123.00;
double b = 12.293123;
double c = 2312312312.123123;
printf("%lf\n", a);
printf("%lf\n", b);
printf("%lf", c);
return 0;
Output
123123123.000000
12.293123
2312312312.123123
Void Data Type

The void data type in C is used to specify that no value is present. It does not provide
a result value to its caller. It has no values and no operations. It is used to represent
nothing. Void is used in multiple ways as function return type, function arguments as
void, and pointers to void.
Syntax:
// function return type void
void exit(int check);
// Function without any parameter can accept void.
int print(void);
// memory allocation function which
// returns a pointer to void.
void *malloc (size_t size);
Example of Void
 C
// C program to demonstrate
// use of void pointers
#include <stdio.h>
int main()
int val = 30;
void* ptr = &val;
printf("%d", *(int*)ptr);
return 0;
Output
30
Size of Data Types in C

The size of the data types in C is dependent on the size of the architecture, so we
cannot define the universal size of the data types. For that, the C language provides
the sizeof() operator to check the size of the data types.
Example
 C
// C Program to print size of
// different data type in C
#include <stdio.h>
int main()
int size_of_int = sizeof(int);
int size_of_char = sizeof(char);
int size_of_float = sizeof(float);
int size_of_double = sizeof(double);
printf("The size of int data type : %d\n", size_of_int);
printf("The size of char data type : %d\n",
size_of_char);
printf("The size of float data type : %d\n",
size_of_float);
printf("The size of double data type : %d",
size_of_double);
return 0;
Output
The size of int data type : 4
The size of char data type : 1
The size of float data type : 4
The size of double data type : 8
Operators in C
Last Updated : 15 Jul, 2024



In C language, operators are symbols that represent operations to be performed on

one or more operands. They are the basic components of the C programming. In this
article, we will learn about all the built-in operators in C with examples.
What is a C Operator?
An operator in C can be defined as the symbol that helps us to perform some specific
mathematical, relational, bitwise, conditional, or logical computations on values and
variables. The values and variables used with operators are called operands. So we
can say that the operators are the symbols that perform operations on operands.
For example,
c = a + b;
Here, ‘+’ is the operator known as the addition operator, and ‘a’ and ‘b’ are
operands. The addition operator tells the compiler to add both of the operands ‘a’
and ‘b’.
Types of Operators in C
C language provides a wide range of operators that can be classified into 6 types
based on their functionality:
1. Arithmetic Operators
2. Relational Operators
3. Logical Operators
4. Bitwise Operators
5. Assignment Operators
6. Other Operators
1. Arithmetic Operations in C
The arithmetic operators are used to perform arithmetic/mathematical operations on
operands. There are 9 arithmetic operators in C language:
S. No. Symbol Operator Description Syntax
Adds two
+ Plus numeric a+b
1 values.
Subtracts right
– Minus operand from a–b
2 left operand.
Multiply two
* Multiply numeric a*b
3 values.
Divide two
/ Divide numeric a/b
4 values.
Returns the
remainder
after diving
% Modulus the left a%b
operand with
the right
5 operand.
Used to
specify the
+ Unary Plus +a
positive
6 values.
Flips the sign

– Unary Minus -a
7 of the value.
Increases the
++ Increment value of the a++
8 operand by 1.
Decreases the
— Decrement value of the a–
9 operand by 1.
Example of C Arithmetic Operators
C
// C program to illustrate the arithmatic operators
#include <stdio.h>
int main()
{
int a = 25, b = 5;
// using operators and printing results

printf("a + b = %d\n", a + b);
printf("a - b = %d\n", a - b);
printf("a * b = %d\n", a * b);
printf("a / b = %d\n", a / b);
printf("a % b = %d\n", a % b);
printf("+a = %d\n", +a);
printf("-a = %d\n", -a);
printf("a++ = %d\n", a++);
printf("a-- = %d\n", a--);
return 0;
}
Output
a + b = 30
a - b = 20
a * b = 125
a / b = 5
a % b = 0
+a = 25
-a = -25
a++ = 25
a-- = 26
2. Relational Operators in C
The relational operators in C are used for the comparison of the two operands. All
these operators are binary operators that return true or false values as the result of
comparison.
These are a total of 6 relational operators in C:
Returns true if
the left
operand is less
< Less than a<b
than the right
operand. Else
1 false
Returns true if
the left
operand is
> Greater than greater than a>b
the right
operand. Else
2 false
Returns true if
the left
operand is less
Less than or
<= than or equal a <= b
equal to
to the right
operand. Else
3 false
Returns true if
the left
operand is
Greater than
>= greater than or a >= b
or equal to
equal to right
operand. Else
4 false
Returns true if
both the
== Equal to a == b
operands are
5 equal.
Returns true if
both the
!= Not equal to a != b
operands are
6 NOT equal.
Example of C Relational Operators
C
// C program to illustrate the relational operators
#include <stdio.h>
int main()
{
int a = 25, b = 5;

printf("a < b : %d\n", a < b);
printf("a > b : %d\n", a > b);
printf("a <= b: %d\n", a <= b);
printf("a >= b: %d\n", a >= b);
printf("a == b: %d\n", a == b);
printf("a != b : %d\n", a != b);
return 0;
}
Output
a < b : 0
a > b : 1
a <= b: 0
a >= b: 1
a == b: 0
a != b : 1
Here, 0 means false and 1 means true.

3. Logical Operator in C
Logical Operators are used to combine two or more conditions/constraints or to
complement the evaluation of the original condition in consideration. The result of
the operation of a logical operator is a Boolean value either true or false.
Returns true if
both the
&& Logical AND a && b
operands are
1 true.
Returns true if
both or any of
|| Logical OR a || b
the operand is
2 true.
Returns true if
! Logical NOT the operand is !a
3 false.
Example of Logical Operators in C
C
// C program to illustrate the logical operators
#include <stdio.h>
int main()
{
int a = 25, b = 5;

printf("a && b : %d\n", a && b);
printf("a || b : %d\n", a || b);
printf("!a: %d\n", !a);
return 0;
}
Output
a && b : 1
a || b : 1
!a: 0
4. Bitwise Operators in C
The Bitwise operators are used to perform bit-level operations on the operands. The
operators are first converted to bit-level and then the calculation is performed on the
operands. Mathematical operations such as addition, subtraction, multiplication, etc.
can be performed at the bit level for faster processing.
There are 6 bitwise operators in C:
Performs bit-
by-bit AND
& Bitwise AND operation and a&b
returns the
1 result.
Performs bit-
by-bit OR
| Bitwise OR operation and a|b
returns the
2 result.
Performs bit-
by-bit XOR
^ Bitwise XOR operation and a^b
returns the
3 result.
4 ~ Bitwise First Flips all the ~a

Complement set and unset
bits on the
number.
Shifts the
number in
binary form
Bitwise by one place
<< a << b
Leftshift in the
operation and
returns the
5 result.
Shifts the
number in
binary form
Bitwise by one place
>> a >> b
Rightshilft in the
operation and
returns the
6 result.
Example of Bitwise Operators
C
// C program to illustrate the bitwise operators
#include <stdio.h>
int main()
{
int a = 25, b = 5;

printf("a & b: %d\n", a & b);
printf("a | b: %d\n", a | b);
printf("a ^ b: %d\n", a ^ b);
printf("~a: %d\n", ~a);
printf("a >> b: %d\n", a >> b);
printf("a << b: %d\n", a << b);
return 0;
}
Output
a & b: 1
a | b: 29
a ^ b: 28
~a: -26
a >> b: 0
a << b: 800
5. Assignment Operators in C
Assignment operators are used to assign value to a variable. The left side operand of
the assignment operator is a variable and the right side operand of the assignment
operator is a value. The value on the right side must be of the same data type as the
variable on the left side otherwise the compiler will raise an error.
The assignment operators can be combined with some other operators in C to
provide multiple operations using single operator. These operators are called
compound operators.
In C, there are 11 assignment operators :
Assign the
value of the
Simple
= right operand a=b
Assignment
to the left
1 operand.
Add the right

operand and
Plus and left operand
+= a += b
assign and assign this
value to the
2 left operand.
Subtract the
right operand
and left
Minus and
-= operand and a -= b
assign
assign this
value to the
3 left operand.
Multiply the
right operand
and left
Multiply and
*= operand and a *= b
assign
assign this
value to the
4 left operand.
5 /= Divide and Divide the left a /= b

assign operand with
the right
operand and
assign this
value to the
left operand.
Assign the
remainder in
the division of
Modulus and
%= left operand a %= b
assign
with the right
operand to the
6 left operand.
Performs
bitwise AND
AND and and assigns
&= a &= b
assign this value to
the left
7 operand.
Performs
bitwise OR
OR and and assigns
|= a |= b
the left
8 operand.
Performs
bitwise XOR
XOR and and assigns
^= a ^= b
the left
9 operand.
Performs
bitwise
Rightshift Rightshift and
>>= a >>= b
and assign assign this
value to the
10 left operand.
Performs
bitwise
Leftshift and Leftshift and
<<= a <<= b
assign assign this
value to the
11 left operand.
Example of C Assignment Operators
C
// C program to illustrate the assignment operators
#include <stdio.h>
int main()
{
int a = 25, b = 5;

printf("a = b: %d\n", a = b);
printf("a += b: %d\n", a += b);
printf("a -= b: %d\n", a -= b);
printf("a *= b: %d\n", a *= b);
printf("a /= b: %d\n", a /= b);
printf("a %%= b: %d\n", a %= b);
printf("a &= b: %d\n", a &= b);
printf("a |= b: %d\n", a |= b);
printf("a >>= b: %d\n", a >>= b);
printf("a <<= b: %d\n", a <<= b);
return 0;
}
Output
a = b: 5
a += b: 10
a -= b: 5
a *= b: 25
a /= b: 5
a %= b: 0
a &= b: 0
a |= b: 5
a >>= b: 0
a <<= b: 0
6. Other Operators
Apart from the above operators, there are some other operators available in C used
to perform some specific tasks. Some of them are discussed here:
sizeof Operator
 sizeof is much used in the C programming language.
 It is a compile-time unary operator which can be used to compute the size of its
operand.
 The result of sizeof is of the unsigned integral type which is usually denoted by
size_t.
 Basically, the sizeof the operator is used to compute the size of the variable or
datatype.
Syntax
sizeof (operand)
To know more about the topic refer to this article.

Comma Operator ( , )
 The comma operator (represented by the token) is a binary operator that
evaluates its first operand and discards the result, it then evaluates the second
operand and returns this value (and type).
 The comma operator has the lowest precedence of any C operator.
 Comma acts as both operator and separator.
Syntax
operand1 , operand2

Conditional Operator ( ? : )
 The conditional operator is the only ternary operator in C++.
 Here, Expression1 is the condition to be evaluated. If the condition(Expression1)
is True then we will execute and return the result of Expression2 otherwise if the
condition(Expression1) is false then we will execute and return the result of
Expression3.
 We may replace the use of if..else statements with conditional operators.
Syntax
operand1 ? operand2 : operand3;

dot (.) and arrow (->) Operators
 Member operators are used to reference individual members of classes, structures,
and unions.
 The dot operator is applied to the actual object.
 The arrow operator is used with a pointer to an object.
Syntax
structure_variable . member;
and
structure_pointer -> member;
To know more about dot operators refer to this article and to know more about
arrow(->) operators refer to this article.
Cast Operator
 Casting operators convert one data type to another. For example, int(2.2000)
would return 2.
 A cast is a special operator that forces one data type to be converted into
another.
 The most general cast supported by most of the C compilers is as follows −
[ (type) expression ].
Syntax
(new_type) operand;

addressof (&) and Dereference (*) Operators
 Pointer operator & returns the address of a variable. For example &a; will give the
actual address of the variable.
 The pointer operator * is a pointer to a variable. For example *var; will pointer to a
variable var.
Example of Other C Operators
C
// C Program to demonstrate the use of Misc operators
#include <stdio.h>
int main()
{
// integer variable
int num = 10;
int* add_of_num = &num;
printf("sizeof(num) = %d bytes\n", sizeof(num));

printf("&num = %p\n", &num);
printf("*add_of_num = %d\n", *add_of_num);
printf("(10 < 5) ? 10 : 20 = %d\n", (10 < 5) ? 10 : 20);
printf("(float)num = %f\n", (float)num);
return 0;
}
Output
sizeof(num) = 4 bytes
&num = 0x7ffe2b7bdf8c
*add_of_num = 10
(10 < 5) ? 10 : 20 = 20
(float)num = 10.000000
Unary, Binary and Ternary Operators in C

Operators can also be classified into three types on the basis of the number of
operands they work on:
1. Unary Operators: Operators that work on single operand.
2. Binary Operators: Operators that work on two operands.
3. Ternary Operators: Operators that work on three operands.
Operator Precedence and Associativity in C
In C, it is very common for an expression or statement to have multiple operators
and in these expression, there should be a fixed order or priority of operator
evaluation to avoid ambiguity.
Operator Precedence and Associativity is the concept that decides which
operator will be evaluated first in the case when there are multiple operators present
in an expression.
The below table describes the precedence order and associativity of operators in C.
The precedence of the operator decreases from top to bottom.
Precedence Operator Description Associativity
1 () Parentheses (function call) left-to-right
[] Brackets (array subscript) left-to-right
. Member selection via object left-to-right

name
-> Member selection via a pointer left-to-right
Postfix increment/decrement
a++ , a– left-to-right
(a is a variable)
Prefix increment/decrement (a
++a , –a right-to-left
is a variable)
+,– Unary plus/minus right-to-left
Logical negation/bitwise
!,~ right-to-left
complement
Cast (convert value to

(type) right-to-left
temporary value of type)
* Dereference right-to-left
& Address (of operand) right-to-left
Determine size in bytes on this

sizeof right-to-left
2 implementation
3 *,/,% Multiplication/division/modulus left-to-right
4 +,– Addition/subtraction left-to-right
Bitwise shift left, Bitwise shift

<< , >> left-to-right
5 right
Relational less than/less than or

< , <= left-to-right
equal to
Relational greater than/greater

> , >= left-to-right
6 than or equal to
Relational is equal to/is not

== , != left-to-right
7 equal to
8 & Bitwise AND left-to-right
9 ^ Bitwise XOR left-to-right

10 | Bitwise OR left-to-right
11 && Logical AND left-to-right
12 || Logical OR left-to-right
13 ?: Ternary conditional right-to-left
= Assignment right-to-left
Addition/subtraction
+= , -= right-to-left
assignment
Multiplication/division
*= , /= right-to-left
assignment
Modulus/bitwise AND
%= , &= right-to-left
assignment
Bitwise exclusive/inclusive
^= , |= right-to-left
OR assignment
Bitwise shift left/right

<<=, >>= right-to-left
14 assignment
15 , expression separator left-to-right

To know more about operator precedence and associativity, refer to this article
– Operator Precedence and Associativity in C
Conclusion
In this article, the points we learned about the operator are as follows:
 Operators are symbols used for performing some kind of operation in C.
 There are six types of operators, Arithmetic Operators, Relational Operators,
Logical Operators, Bitwise Operators, Assignment Operators, and Miscellaneous
Operators.
 Operators can also be of type unary, binary, and ternary according to the number
of operators they are using.
 Every operator returns a numerical value except logical, relational, and conditional
operator which returns a boolean value (true or false).
 There is a Precedence in the operators means the priority of using one operator is
greater than another operator.
FAQs on C Operators
Q1. What are operators in C?
Answer:
Operators in C are certain symbols in C used for performing certain mathematical,
relational, bitwise, conditional, or logical operations for the user.
Q2. What are the 7 types of operators in C?

Answer:
There are 7 types of operators in C as mentioned below:
 Unary operator
 Arithmetic operator
 Relational operator
 Logical operator
 Bitwise operator
 Assignment operator
 Conditional operator
Q3. What is the difference between the ‘=’ and ‘==’ operators?
Answer:
‘=’ is a type of assignment operator that places the value in right to the variable on
left, Whereas ‘==’ is a type of relational operator that is used to compare two
elements if the elements are equal or not.
Q4. What is the difference between prefix and postfix operators in C?

Answer:
In prefix operations, the value of a variable is incremented/decremented first and
then the new value is used in the operation, whereas, in postfix operations first the
value of the variable is used in the operation and then the value is
incremented/decremented.
Example:
b=c=10;
a=b++; // a==10
a=++c; // a==11
Q5. What is the Modulo operator?

Answer:
The Modulo operator(%) is used to find the remainder if one element is divided by
another.
Example:
a % b (a divided by b)
5 % 2 == 1 Basic Input and Output in C
Last Updated : 04 Apr, 2024



C language has standard libraries that allow input and output in a program.
The stdio.h or standard input output library in C that has methods for input and
output.
scanf()
The scanf() method, in C, reads the value from the console as per the type specified
and store it in the given address.
Syntax:
scanf("%X", &variableOfXType);
where %X is the format specifier in C. It is a way to tell the compiler what type of
data is in a variable and & is the address operator in C, which tells the compiler to
change the real value of variableOfXType, stored at this address in the memory.
printf()
The printf() method, in C, prints the value passed as the parameter to it, on the
console screen.
Syntax:
printf("%X", variableOfXType);
where %X is the format specifier in C. It is a way to tell the compiler what type of
data is in a variable and variableOfXType is the variable to be printed.
How to take input and output of basic types in C?
The basic type in C includes types like int, float, char, etc. Inorder to input or output
the specific type, the X in the above syntax is changed with the specific format
specifier of that type. The Syntax for input and output for these are:
 Integer:
Input: scanf("%d", &intVariable);
Output: printf("%d", intVariable);
 Float:
Input: scanf("%f", &floatVariable);
Output: printf("%f", floatVariable);
 Character:
Input: scanf("%c", &charVariable);
Output: printf("%c", charVariable);
Please refer Format specifiers in C for more examples.
C
// C program to show input and output
#include <stdio.h>
int main()
{
// Declare the variables

int num;
char ch;
float f;
// --- Integer ---
// Input the integer

printf("Enter the integer: ");
scanf("%d", &num);
// Output the integer

printf("\nEntered integer is: %d", num);
// --- Float ---
//For input Clearing buffer

while((getchar()) != '\n');
// Input the float

printf("\n\nEnter the float: ");
scanf("%f", &f);
// Output the float

printf("\nEntered float is: %f", f);
// --- Character ---
// Input the Character

printf("\n\nEnter the Character: ");
scanf("%c", &ch);
// Output the Character

printf("\nEntered character is: %c", ch);
return 0;
}
Output
Enter the integer: 10
Entered integer is: 10
Enter the float: 2.5

Entered float is: 2.500000
Enter the Character: A

Entered Character is: A
How to take input and output of advanced type in C?
The advanced type in C includes type like String. In order to input or output the string
type, the X in the above syntax is changed with the %s format specifier. The Syntax
for input and output for String is:
Input: scanf("%s", stringVariable);
Output: printf("%s", stringVariable);
Example:
C
// C program to show input and output
#include <stdio.h>
int main()
{
// Declare string variable

// as character array
char str[50];
// --- String ---

// To read a word
// Input the Word

printf("Enter the Word: ");
scanf("%s\n", str);
// Output the Word

printf("\nEntered Word is: %s", str);
// --- String ---

// To read a Sentence
// Input the Sentence

printf("\n\nEnter the Sentence: ");
scanf("%[^\n]s", str);
// Output the String

printf("\nEntered Sentence is: %s", str);
return 0;
}
Output
Enter the Word: GeeksForGeeks
Entered Word is: GeeksForGeeks
Enter the Sentence: Geeks For Geeks
Entered Sentence is: Geeks For Geeks
scanf in C
Last Updated : 06 May, 2023



In C programming language, scanf is a function that stands for Scan Formatted

String. It is used to read data from stdin (standard input stream i.e. usually keyboard)
and then writes the result into the given arguments.
 It accepts character, string, and numeric data from the user using standard input.
 scanf also uses format specifiers like printf.
scanf Syntax
The syntax of scanf() in C is similar to the syntax of printf().
int scanf( const char *format, ... );
Here,
 int is the return type.
 format is a string that contains the format specifiers(s).
 “…” indicates that the function accepts a variable number of arguments.
Example format specifiers recognized by scanf:
%d to accept input of integers.
%ld to accept input of long integers
%lld to accept input of long long integers
%f to accept input of real number.
%c to accept input of character types.
%s to accept input of a string.
To know more about format specifiers, refer to this article – Format Specifiers in C
Example:
int var;
scanf(“%d”, &var);
The scanf will write the value input by the user into the integer variable var.
Return Value of scanf

The scanf in C returns three types of values:
 >0: The number of values converted and assigned successfully.
 0: No value was assigned.
 <0: Read error encountered or end-of-file(EOF) reached before any assignment
was made.
Why &?
While scanning the input, scanf needs to store that input data somewhere. To store
this input data, scanf needs to known the memory location of a variable. And here
comes the ampersand to rescue.
 & is also called as address of the operator.
 For example, &var is the address of var.
Example of scanf
Below is the C program to implement scanf:
 C
// C program to implement
// scanf
#include <stdio.h>
// Driver code
int main()
int a, b;
printf("Enter first number: ");
scanf("%d", &a);
printf("Enter second number: ");
scanf("%d", &b);
printf("A : %d \t B : %d" ,
a , b);
return 0;
Output
Enter first number: 5
Enter second number: 6
A : 5 B : 6
printf in C
Last Updated : 27 Oct, 2023



In C language, printf() function is used to print formatted output to the standard

output stdout (which is generally the console screen). The printf function is a part of
the C standard library <stdio.h> and it can allow formatting the output in numerous
ways.
Syntax of printf
printf ( "formatted_string", arguments_list);
Parameters
 formatted_string: It is a string that specifies the data to be printed. It may also
contain a format specifier to print the value of any variable such as a character
and an integer.
 arguments_list: These are the variable names corresponding to the format
specifier.
Return Value
 printf() returns the number of characters printed after successful execution.
 If an error occurs, a negative value is returned.
Example of printf
In this example, we are printing the string “Hello Geek!” in the output using printf()
function. In printf() function what we will write inside the double quotes (” “) is
printed in the output.
 C
// C program to illustrate the use of printf function
#include <stdio.h>
int main()
// using printf to print "Hello Geek!"
printf("Hello Geek!");
return 0;
Output
Hello Geek!
Formatting in C printf
In C, a value can be a character type, integer type, float type, and so on. To display
and format these values using printf, we have format specifiers that are used in the
formatted string. These format specifiers start with the percentage symbol ‘%’.
Syntax of Format Specifier
%[flags][width][.precision][length]specifier
1. Specifier
It is the character that denotes the type of data. Some commonly used specifiers are:
 %d: for printing integers
 %f: for printing floating-point numbers
 %c: for printing characters
 %s: for printing strings
 %p: for printing memory addresses
 %x: for printing hexadecimal values
Example
printf("%c", char_variable);
2. Width
It is the sub-specifier that denotes the minimum number of characters that will be
printed.
If the number of characters is less than the specified width, the white space will be
used to fill the remaining characters’ places. But if the number of characters is
greater than the specified width, all the characters will be still printed without cutting
off any.
Example
printf("%25s", some_string);
or
printf("%*s", 25, some_string);
3. Precision
Precision subspecifier meaning differs for different format specifiers it is being used
with.
 For Integral data(d, i, u, o, x, X): Specifies the minimum number of digits to be
printed. But unlike the width sub-specifier, instead of white spaces, this sub-
specifier adds leading zeroes to the number. If the number has more digits than
the precision, the number is printed as it is.
 For Float or Double Data(f, e, a, A): Specifies the number of digits to be
printed after the decimal point.
 For String (s): Specifies the length of the string to be printed.
Example
printf("%.10d", some_integer);
printf("%.3f", some_float);
printf("%.25s", some_string);
or
printf("%.*d", 10, some_integer);
printf("%.*f", 3, some_float);
printf("%.*s", 25, some_string);
4. Length
Specifies the length of the data type in the memory. It is used in correspondence
with data type modifiers.
There are 3 length sub-specifiers:
 h: With short int and unsigned short int
 l: With long int and unsigned long int.
 L: With long double
Example
printf("%lf", double_variable);
Examples of printf() in C
Example 1: Print a Variable using Specifier in printf()
In this example, we are printing an integer using a format specifier “%d” which is
used for an integer. In the printf() function we are printing integers along with string
using %d and in the arguments, we have passed variable names in a sequence
corresponding to their format specifiers.
 C
// C program to print a variable
#include <stdio.h>
int main()
int num1 = 99;
int num2 = 1;
printf("The sum of %d and %d is %d\n", num1, num2,
num1 + num2);
return 0;
Output
The sum of 99 and 1 is 100
Example 2: printf with Specified Width
In this example, we will specify the width of the output which will be printed by the
printf() function.
 C
// C program to illustrate the use of printf with width

// specifier
#include <stdio.h>
int main()
// number to be printed
int num = 123456;
// printing the num with 10 width and getting the
// printed characters in char_printed
printf("Printing num with width 10: ");
int chars_printed = printf("%10d", num);
printf("\nNumber of characters printed: %d",
chars_printed);
// specifying with using other method
printf("\nPrinting num with width 3: ");
chars_printed = printf("%*d", 3, num);
printf("\nNumber of characters printed: %d",
chars_printed);
return 0;
Output
Printing num with width 10: 123456
Number of characters printed: 10
Printing num with width 3: 123456
Number of characters printed: 6
As we can see, even if we define the width that is less than the present characters,
all the characters are still printed. Also, we have seen the two ways in which we can
define the width.
Example 3: printf with Precision Sub-Specifier
In this example, we will demonstrate the precision sub-specifier in the printf()
function
 C
// C program to illustrate the use of precision
// sub-specifier
#include <stdio.h>
int main()
int num = 2451;
float dec = 12.45126;
char* str = "GeeksforGeeks";
// precision for integral data
printf("For integers: %.10d\n", num);
// precision for numbers with decimal points
printf("For floats: %.2f\n", dec);
// for strings
printf("For strings: %.5s", str);
return 0;
Output
For integers: 0000002451
For floats: 12.45
For strings: Geeks
Example 4: printf with Length Sub-Specifier
 C
// C program to illustrate the length modifier
#include <stdio.h>
int main()
long var = 3000000000;
// printing var using %d
printf("Using %%d: %d", var);
// printing var using %ld
printf("\nUsing %%ld: %ld", var);
return 0;
Output
Using %d: -1294967296
Using %ld: 3000000000
Related Articles:
 sprintf() in C
 scanf() in C
Decision Making in C (if , if..else, Nested if, if-else-if )




The conditional statements (also known as decision control structures) such as if,
if else, switch, etc. are used for decision-making purposes in C programs.
They are also known as Decision-Making Statements and are used to evaluate one or
more conditions and make the decision whether to execute a set of statements or
not. These decision-making statements in programming languages decide the
direction of the flow of program execution.
Need of Conditional Statements
There come situations in real life when we need to make some decisions and based
on these decisions, we decide what should we do next. Similar situations arise in
programming also where we need to make some decisions and based on these
decisions we will execute the next block of code. For example, in C if x occurs then
execute y else execute z. There can also be multiple conditions like in C if x occurs
then execute p, else if condition y occurs execute q, else execute r. This condition of
C else-if is one of the many ways of importing multiple conditions.
Types of Conditional Statements in C
Following are the decision-making statements available in C:

1. if Statement
2. if-else Statement
3. Nested if Statement
4. if-else-if Ladder
5. switch Statement
6. Conditional Operator
7. Jump Statements:
 break
 continue
 goto
 return
Let’s discuss each of them one by one.
1. if in C
The if statement is the most simple decision-making statement. It is used to decide
whether a certain statement or block of statements will be executed or not i.e if a
certain condition is true then a block of statements is executed otherwise not.
Syntax of if Statement
if(condition)
{
// Statements to execute if
// condition is true
}
Here, the condition after evaluation will be either true or false. C if statement
accepts boolean values – if the value is true then it will execute the block of
statements below it otherwise not. If we do not provide the curly braces ‘{‘ and ‘}’
after if(condition) then by default if statement will consider the first immediately
below statement to be inside its block.
Flowchart of if Statement
Flow Diagram of if Statement
Example of if in C
C
// C program to illustrate If statement
#include <stdio.h>
int main()
{
int i = 10;
if (i > 15) {
printf("10 is greater than 15");
}
printf("I am Not in if");

}
Output
I am Not in if
As the condition present in the if statement is false. So, the block below the if
statement is not executed.
2. if-else in C
The if statement alone tells us that if a condition is true it will execute a block of
statements and if the condition is false it won’t. But what if we want to do something
else when the condition is false? Here comes the C else statement. We can use
the else statement with the if statement to execute a block of code when the
condition is false. The if-else statement consists of two blocks, one for false
expression and one for true expression.
Syntax of if else in C
if (condition)
{
// Executes this block if
// condition is true
}
else
{
// Executes this block if
// condition is false
}
Flowchart of if-else Statement
Flow Diagram of if else
Example of if-else
C
// C program to illustrate If statement
#include <stdio.h>
int main()
{
int i = 20;
if (i < 15) {
printf("i is smaller than 15");

}
else {
printf("i is greater than 15");

}
return 0;
}
Output
i is greater than 15
The block of code following the else statement is executed as the condition present
in the if statement is false.
3. Nested if-else in C
A nested if in C is an if statement that is the target of another if statement. Nested if
statements mean an if statement inside another if statement. Yes, C allow us to
nested if statements within if statements, i.e, we can place an if statement inside
another if statement.
Syntax of Nested if-else
if (condition1)
{
// Executes when condition1 is true
if (condition_2)
{
// statement 1
}
else
{
// Statement 2
}
}
else {
if (condition_3)
{
// statement 3
}
else
{
// Statement 4
}
}
The below flowchart helps in visualize the above syntax.
Flowchart of Nested if-else
Example of Nested if-else
C
// C program to illustrate nested-if statement
#include <stdio.h>
int main()
{
int i = 10;
if (i == 10) {
// First if statement
if (i < 15)
printf("i is smaller than 15\n");
// Nested - if statement
// Will only be executed if statement above
// is true
if (i < 12)
printf("i is smaller than 12 too\n");
else
}
else {
if (i == 20) {
// Nested - if statement
// Will only be executed if statement above
// is true
if (i < 22)
printf("i is smaller than 22 too\n");
else
}
}
return 0;
}
Output
i is smaller than 15
i is smaller than 12 too
4. if-else-if Ladder in C
The if else if statements are used when the user has to decide among multiple
options. The C if statements are executed from the top down. As soon as one of the
conditions controlling the if is true, the statement associated with that if is executed,
and the rest of the C else-if ladder is bypassed. If none of the conditions is true, then
the final else statement will be executed. if-else-if ladder is similar to the switch
statement.
Syntax of if-else-if Ladder
if (condition)
statement;
else if (condition)
statement;
.
.
else
statement;
Flowchart of if-else-if Ladder
Flow Diagram of if-else-if
Example of if-else-if Ladder

C
// C program to illustrate nested-if statement
#include <stdio.h>
int main()
{
int i = 20;
if (i == 10)
printf("i is 10");
else if (i == 15)
printf("i is 15");
else if (i == 20)
printf("i is 20");
else
printf("i is not present");
}
Output
i is 20
5. switch Statement in C
The switch case statement is an alternative to the if else if ladder that can be used to
execute the conditional code based on the value of the variable specified in the
switch statement. The switch block consists of cases to be executed based on the
value of the switch variable.
Syntax of switch
switch (expression) {
case value1:
statements;
case value2:
statements;
....
....
....
default:
statements;
}
Note: The switch expression should evaluate to either integer or character. It cannot
evaluate any other data type.
Flowchart of switch
Flowchart of switch in C
Example of switch Statement

C
// C Program to illustrate the use of switch statement
#include <stdio.h>
int main()
{
// variable to be used in switch statement
int var = 2;
// declaring switch cases

switch (var) {
case 1:
printf("Case 1 is executed");
break;
case 2:
printf("Case 2 is executed");
break;
default:
printf("Default Case is executed");
break;
}
return 0;
}
Output
Case 2 is executed
6. Conditional Operator in C
The conditional operator is used to add conditional code in our program. It is similar
to the if-else statement. It is also known as the ternary operator as it works on three
operands.
Syntax of Conditional Operator
(condition) ? [true_statements] : [false_statements];
Flowchart of Conditional Operator
Flow Diagram of Conditional Operator

Example of Conditional Operator
C
// C Program to illustrate the use of conditional operator
#include <stdio.h>
// driver code
int main()
{
int var;
int flag = 0;
// using conditional operator to assign the value to var

// according to the value of flag
var = flag == 0 ? 25 : -25;
printf("Value of var when flag is 0: %d\n", var);
// changing the value of flag

flag = 1;
// again assigning the value to var using same statement
var = flag == 0 ? 25 : -25;
printf("Value of var when flag is NOT 0: %d", var);
return 0;
}
Output
Value of var when flag is 0: 25
Value of var when flag is NOT 0: -25
7. Jump Statements in C
These statements are used in C for the unconditional flow of control throughout the
functions in a program. They support four types of jump statements:
A) break
This loop control statement is used to terminate the loop. As soon as
the break statement is encountered from within a loop, the loop iterations stop there,
and control returns from the loop immediately to the first statement after the loop.
Syntax of break
break;
Basically, break statements are used in situations when we are not sure about the
actual number of iterations for the loop or we want to terminate the loop based on
some condition.
Example of break
C
// C program to illustrate
// to show usage of break
// statement
#include <stdio.h>
void findElement(int arr[], int size, int key)

{
// loop to traverse array and search for key
for (int i = 0; i < size; i++) {
if (arr[i] == key) {
printf("Element found at position: %d",
(i + 1));
break;
}
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6 };
// no of elements
int n = 6;
// key to be searched
int key = 3;
// Calling function to find the key

findElement(arr, n, key);
return 0;
}
Output
Element found at position: 3
B) continue
This loop control statement is just like the break statement.
The continue statement is opposite to that of the break statement, instead of
terminating the loop, it forces to execute the next iteration of the loop.
As the name suggests the continue statement forces the loop to continue or execute
the next iteration. When the continue statement is executed in the loop, the code
inside the loop following the continue statement will be skipped and the next
iteration of the loop will begin.
Syntax of continue
continue;
Flowchart of Continue
Flow Diagram of C continue Statement
Example of continue
C
// C program to explain the use
// of continue statement
#include <stdio.h>
int main()
{
// loop from 1 to 10
for (int i = 1; i <= 10; i++) {
// If i is equals to 6,
// continue to next iteration
// without printing
if (i == 6)
continue;
else
// otherwise print the value of i
printf("%d ", i);
}
return 0;
}
Output
1 2 3 4 5 7 8 9 10
If you create a variable in if-else in C, it will be local to that if/else block only. You can
use global variables inside the if/else block. If the name of the variable you created in
if/else is as same as any global variable then priority will be given to the `local
variable`.
C
#include <stdio.h>
int main()
{
int gfg = 0; // local variable for main

printf("Before if-else block %d\n", gfg);
if (1) {
int gfg = 100; // new local variable of if block
printf("if block %d\n", gfg);
}
printf("After if block %d", gfg);
return 0;
}
Output
Before if-else block 0
if block 100
After if block 0
C) goto
The goto statement in C also referred to as the unconditional jump statement can be
used to jump from one point to another within a function.
Syntax of goto
Syntax1 | Syntax2
----------------------------
goto label; | label:
. | .
. | .
. | .
label: | goto label;
In the above syntax, the first line tells the compiler to go to or jump to the statement
marked as a label. Here, a label is a user-defined identifier that indicates the target
statement. The statement immediately followed after ‘label:’ is the destination
statement. The ‘label:’ can also appear before the ‘goto label;’ statement in the
above syntax.
Flowchart of goto Statement
Examples of goto
C
// C program to print numbers
// from 1 to 10 using goto
// statement
#include <stdio.h>
// function to print numbers from 1 to 10
void printNumbers()
{
int n = 1;
label:
printf("%d ", n);
n++;
if (n <= 10)
goto label;
}
// Driver program to test above function

int main()
{
printNumbers();
return 0;
}
Output
1 2 3 4 5 6 7 8 9 10
D) return
The return in C returns the flow of the execution to the function from where it is
called. This statement does not mandatorily need any conditional statements. As
soon as the statement is executed, the flow of the program stops immediately and
returns the control from where it was called. The return statement may or may not
return anything for a void function, but for a non-void function, a return value must
be returned.
Flowchart of return
Flow Diagram of return
Syntax of return
return [expression];
Example of return
C
// C code to illustrate return
// statement
#include <stdio.h>
// non-void return type

// function to calculate sum
int SUM(int a, int b)
{
int s1 = a + b;
return s1;
}
// returns void
// function to print
void Print(int s2)
{
printf("The sum is %d", s2);
return;
}
int main()
{
int num1 = 10;
int num2 = 10;
int sum_of = SUM(num1, num2);
Print(sum_of);
return 0;
}
Output
The sum is 20
C Functions



A function in C is a set of statements that when called perform some specific task.
It is the basic building block of a C program that provides modularity and code
reusability. The programming statements of a function are enclosed within { }
braces, having certain meanings and performing certain operations. They are also
called subroutines or procedures in other languages.
In this article, we will learn about functions, function definition. declaration,
arguments and parameters, return values, and many more.
Syntax of Functions in C
The syntax of function can be divided into 3 aspects:
1. Function Declaration
2. Function Definition
3. Function Calls
Function Declarations
In a function declaration, we must provide the function name, its return type, and the
number and type of its parameters. A function declaration tells the compiler that
there is a function with the given name defined somewhere else in the program.
Syntax
return_type name_of_the_function (parameter_1, parameter_2);
The parameter name is not mandatory while declaring functions. We can also declare
the function without using the name of the data variables.
Example
int sum(int a, int b); // Function declaration with parameter names
int sum(int , int); // Function declaration without parameter names
Function Declaration
Note: A function in C must always be declared globally before calling it.
Function Definition
The function definition consists of actual statements which are executed when the
function is called (i.e. when the program control comes to the function).
A C function is generally defined and declared in a single step because the function
definition always starts with the function declaration so we do not need to declare it
explicitly. The below example serves as both a function definition and a declaration.
return_type function_name (para1_type para1_name, para2_type para2_name)
{
// body of the function
}
Function Definition in C
Function Call
A function call is a statement that instructs the compiler to execute the function. We
use the function name and parameters in the function call.
In the below example, the first sum function is called and 10,30 are passed to the
sum function. After the function call sum of a and b is returned and control is also
returned back to the main function of the program.
Working of function in C
Note: Function call is neccessary to bring the program control to the function
definition. If not called, the function statements will not be executed.
Example of C Function
C
// C program to show function
// call and definition
#include <stdio.h>
// Function that takes two parameters

// a and b as inputs and returns
// their sum
int sum(int a, int b)
{
return a + b;
}
// Driver code
int main()
{
// Calling sum function and
// storing its value in add variable
int add = sum(10, 30);
printf("Sum is: %d", add);

return 0;
}
Output
Sum is: 40
As we noticed, we have not used explicit function declaration. We simply defined and
called the function.
Function Return Type
Function return type tells what type of value is returned after all function is executed.
When we don’t want to return a value, we can use the void data type.
Example:
int func(parameter_1,parameter_2);
The above function will return an integer value after running statements inside the
function.
Note: Only one value can be returned from a C function. To return multiple values,
we have to use pointers or structures.
Function Arguments
Function Arguments (also known as Function Parameters) are the data that is passed
to a function.
Example:
int function_name(int var1, int var2);
Conditions of Return Types and Arguments
In C programming language, functions can be called either with or without arguments
and might return values. They may or might not return values to the calling
functions.
1. Function with no arguments and no return value
2. Function with no arguments and with return value
3. Function with argument and with no return value
4. Function with arguments and with return value
To know more about function Arguments and Return values refer to the article
– Function Arguments & Return Values in C.
How Does C Function Work?
Working of the C function can be broken into the following steps as mentioned below:
1. Declaring a function: Declaring a function is a step where we declare a function.
Here we define the return types and parameters of the function.
2. Defining a function:
3. Calling the function: Calling the function is a step where we call the function by
passing the arguments in the function.
4. Executing the function: Executing the function is a step where we can run all
the statements inside the function to get the final result.
5. Returning a value: Returning a value is the step where the calculated value after
the execution of the function is returned. Exiting the function is the final step
where all the allocated memory to the variables, functions, etc is destroyed before
giving full control to the main function.
Types of Functions
There are two types of functions in C:
1. Library Functions
2. User Defined Functions
Types of Functions in C
1. Library Function
A library function is also referred to as a “built-in function”. A compiler package
already exists that contains these functions, each of which has a specific meaning
and is included in the package. Built-in functions have the advantage of being
directly usable without being defined, whereas user-defined functions must be
declared and defined before being used.
For Example:
pow(), sqrt(), strcmp(), strcpy() etc.
Advantages of C library functions
 C Library functions are easy to use and optimized for better performance.
 C library functions save a lot of time i.e, function development time.
 C library functions are convenient as they always work.
Example:
C
// C program to implement
// the above approach
#include <math.h>
#include <stdio.h>
// Driver code
int main()
{
double Number;
Number = 49;
// Computing the square root with

// the help of predefined C
// library function
double squareRoot = sqrt(Number);
printf("The Square root of %.2lf = %.2lf",

Number, squareRoot);
return 0;
}
Output
The Square root of 49.00 = 7.00
2. User Defined Function
Functions that the programmer creates are known as User-Defined functions
or “tailor-made functions”. User-defined functions can be improved and modified
according to the need of the programmer. Whenever we write a function that is case-
specific and is not defined in any header file, we need to declare and define our own
functions according to the syntax.
Advantages of User-Defined Functions
 Changeable functions can be modified as per need.
 The Code of these functions is reusable in other programs.
 These functions are easy to understand, debug and maintain.
Example:
C
// C program to show
// user-defined functions
#include <stdio.h>
int sum(int a, int b)

{
return a + b;
}
// Driver code
int main()
{
int a = 30, b = 40;
// function call
int res = sum(a, b);
printf("Sum is: %d", res);

return 0;
}
Output
Sum is: 70
Passing Parameters to Functions
The data passed when the function is being invoked is known as the Actual
parameters. In the below program, 10 and 30 are known as actual parameters.
Formal Parameters are the variable and the data type as mentioned in the function
declaration. In the below program, a and b are known as formal parameters.
Passing Parameters to Functions
We can pass arguments to the C function in two ways:

1. Pass by Value
2. Pass by Reference
1. Pass by Value
Parameter passing in this method copies values from actual parameters into formal
function parameters. As a result, any changes made inside the functions do not
reflect in the caller’s parameters.
Example:
C
// C program to show use
// of call by value
#include <stdio.h>
void swap(int var1, int var2)

{
int temp = var1;
var1 = var2;
var2 = temp;
}
// Driver code
int main()
{
int var1 = 3, var2 = 2;
printf("Before swap Value of var1 and var2 is: %d, %d\n",
var1, var2);
swap(var1, var2);
printf("After swap Value of var1 and var2 is: %d, %d",
var1, var2);
return 0;
}
Output
Before swap Value of var1 and var2 is: 3, 2
After swap Value of var1 and var2 is: 3, 2
2. Pass by Reference
The caller’s actual parameters and the function’s actual parameters refer to the
same locations, so any changes made inside the function are reflected in the caller’s
actual parameters.
Example:
C
// C program to show use of
// call by Reference
#include <stdio.h>
void swap(int *var1, int *var2)

{
int temp = *var1;
*var1 = *var2;
*var2 = temp;
}
// Driver code
int main()
{
int var1 = 3, var2 = 2;
printf("Before swap Value of var1 and var2 is: %d, %d\n",
var1, var2);
swap(&var1, &var2);
printf("After swap Value of var1 and var2 is: %d, %d",
var1, var2);
return 0;
}
Output
Before swap Value of var1 and var2 is: 3, 2
After swap Value of var1 and var2 is: 2, 3
Advantages of Functions in C
Functions in C is a highly useful feature of C with many advantages as mentioned
below:
1. The function can reduce the repetition of the same statements in the program.
2. The function makes code readable by providing modularity to our program.
3. There is no fixed number of calling functions it can be called as many times as you
want.
4. The function reduces the size of the program.
5. Once the function is declared you can just use it without thinking about the
internal working of the function.
Disadvantages of Functions in C
The following are the major disadvantages of functions in C:
1. Cannot return multiple values.
2. Memory and time overhead due to stack frame allocation and transfer of program
control.
Conclusion
In this article, we discussed the following points about the function as mentioned
below:
1. The function is the block of code that can be reused as many times as we want
inside a program.
2. To use a function we need to call a function.
3. Function declaration includes function_name, return type, and parameters.
4. Function definition includes the body of the function.
5. The function is of two types user-defined function and library function.
6. In function, we can according to two types call by value and call by reference
according to the values passed.
FAQs on Functions in C
Q1. Define functions.
Answer:
Functions are the block of code that is executed every time they are called during an
execution of a program.
Q2. What is a forward declaration?

Answer:
Sometimes we define the function after its call to provide better readibliy. In such
cases, we declare function before the their defiinition and call. Such declaration are
called Forward Declaration.
Q3. What is the difference between function declaration and definition?

Answer:
The data like function name, return type, and the parameter is included in the
function declaration whereas the definition is the body of the function. All these data
are shared with the compiler according to their corresponding steps.
Q4. What is the difference between function arguments and

parameters?
Answer:
Function parameters are the values declared in a function declaration. Whereas,
function arguments are the values that are passed in the function during the function
call.
Example:
int func(int x,int y);
func(10,20);
Here, int x and int y are parameters while, 10 and 20 are the arguments passed to
the function.
To know more about it, refer to this article – Difference between Arguments and
Parameters in C.
Q5. Can we return multiple values from a C Function?

Answer:
No, it is generally not possible to return multiple values from a function. But we can
either use pointers to static or heap memory locations to return multiple values or
we can put data in the structure and then return the structure.
To know more about it, refer to this article – How to return multiple values from a
function in C or C++?
Q6. What is the actual and formal parameter?

Answer:
Formal parameter: The variables declared in the function prototype is known as
Formal arguments or parameters.
Actual parameter: The values that are passed in the function are known as actual
arguments or parameters.
C Arrays
Last Updated : 29 Aug, 2024



Array in C is one of the most used data structures in C programming. It is a simple

and fast way of storing multiple values under a single name. In this article, we will
study the different aspects of array in C language such as array declaration,
definition, initialization, types of arrays, array syntax, advantages and disadvantages,
and many more.
What is Array in C?
An array in C is a fixed-size collection of similar data items stored in contiguous
memory locations. It can be used to store the collection of primitive data types such
as int, char, float, etc., and also derived and user-defined data types such as
pointers, structures, etc.
C Array Declaration
In C, we have to declare the array like any other variable before using it. We can
declare an array by specifying its name, the type of its elements, and the size of its
dimensions. When we declare an array in C, the compiler allocates the memory block
of the specified size to the array name.
Syntax of Array Declaration
data_type array_name [size];
or
data_type array_name [size1] [size2]...[sizeN];
where N is the number of dimensions.
The C arrays are static in nature, i.e., they are allocated memory at the compile time.
Example of Array Declaration
C
// C Program to illustrate the array declaration
#include <stdio.h>
int main()
{
// declaring array of integers

int arr_int[5];
// declaring array of characters
char arr_char[5];
return 0;
}
Output
C Array Initialization
Initialization in C is the process to assign some initial value to the variable. When the
array is declared or allocated memory, the elements of the array contain some
garbage value. So, we need to initialize the array to some meaningful value. There
are multiple ways in which we can initialize an array in C.
1. Array Initialization with Declaration
In this method, we initialize the array along with its declaration. We use an initializer
list to initialize multiple elements of the array. An initializer list is the list of values
enclosed within braces { } separated b a comma.
data_type array_name [size] = {value1, value2, ... valueN};
2. Array Initialization with Declaration without Size
If we initialize an array using an initializer list, we can skip declaring the size of the
array as the compiler can automatically deduce the size of the array in these cases.
The size of the array in these cases is equal to the number of elements present in the
initializer list as the compiler can automatically deduce the size of the array.
data_type array_name[] = {1,2,3,4,5};
The size of the above arrays is 5 which is automatically deduced by the compiler.
3. Array Initialization after Declaration (Using Loops)
We initialize the array after the declaration by assigning the initial value to each
element individually. We can use for loop, while loop, or do-while loop to assign the
value to each element of the array.
for (int i = 0; i < N; i++) {
array_name[i] = valuei;
}
Example of Array Initialization in C
C
// C Program to demonstrate array initialization
#include <stdio.h>
int main()
{
// array initialization using initialier list

int arr[5] = { 10, 20, 30, 40, 50 };
// array initialization using initializer list without

// specifying size
int arr1[] = { 1, 2, 3, 4, 5 };
// array initialization using for loop

float arr2[5];
for (int i = 0; i < 5; i++) {
arr2[i] = (float)i * 2.1;
}
return 0;
}
Output
Access Array Elements
We can access any element of an array in C using the array subscript
operator [ ] and the index value i of the element.
array_name [index];
One thing to note is that the indexing in the array always starts with 0, i.e., the first
element is at index 0 and the last element is at N – 1 where N is the number of
elements in the array.
Example of Accessing Array Elements using Array Subscript Operator

C
// C Program to illustrate element access using array
// subscript
#include <stdio.h>
int main()
{
// array declaration and initialization

int arr[5] = { 15, 25, 35, 45, 55 };
// accessing element at index 2 i.e 3rd element

printf("Element at arr[2]: %d\n", arr[2]);
// accessing element at index 4 i.e last element
printf("Element at arr[4]: %d\n", arr[4]);
// accessing element at index 0 i.e first element

printf("Element at arr[0]: %d", arr[0]);
return 0;
}
Output
Element at arr[2]: 35
Update Array Element
We can update the value of an element at the given index i in a similar way to
accessing an element by using the array subscript operator [ ] and assignment
operator =.
array_name[i] = new_value;
C Array Traversal
Traversal is the process in which we visit every element of the data structure. For C
array traversal, we use loops to iterate through each element of the array.
Array Traversal using for Loop
for (int i = 0; i < N; i++) {
array_name[i];
}
How to use Array in C?
The following program demonstrates how to use an array in the C programming
language:
C
// C Program to demonstrate the use of array
#include <stdio.h>
int main()
{
// array declaration and initialization
int arr[5] = { 10, 20, 30, 40, 50 };
// modifying element at index 2

arr[2] = 100;
// traversing array using for loop

printf("Elements in Array: ");
for (int i = 0; i < 5; i++) {
printf("%d ", arr[i]);
}
return 0;
}
Output
Elements in Array: 10 20 100 40 50
Types of Array in C
There are two types of arrays based on the number of dimensions it has. They are as
follows:
1. One Dimensional Arrays (1D Array)
2. Multidimensional Arrays
1. One Dimensional Array in C
The One-dimensional arrays, also known as 1-D arrays in C are those arrays that
have only one dimension.
Syntax of 1D Array in C
array_name [size];
Example of 1D Array in C
C
// C Program to illustrate the use of 1D array
#include <stdio.h>
int main()
{
// 1d array declaration
int arr[5];
// 1d array initialization using for loop
for (int i = 0; i < 5; i++) {
arr[i] = i * i - 2 * i + 1;
}
printf("Elements of Array: ");

// printing 1d array by traversing using for loop
for (int i = 0; i < 5; i++) {
}
return 0;
}
Output
Elements of Array: 1 0 1 4 9
Array of Characters (Strings)
In C, we store the words, i.e., a sequence of characters in the form of an array of
characters terminated by a NULL character. These are called strings in C language.
C
// C Program to illustrate strings
#include <stdio.h>
int main()
{
// creating array of character

char arr[6] = { 'G', 'e', 'e', 'k', 's', '\0' };
// printing string
int i = 0;
while (arr[i]) {
printf("%c", arr[i++]);
}
return 0;
}
Output
Geeks
To know more about strings, refer to this article – Strings in C
2. Multidimensional Array in C
Multi-dimensional Arrays in C are those arrays that have more than one dimension.
Some of the popular multidimensional arrays are 2D arrays and 3D arrays. We can
declare arrays with more dimensions than 3d arrays but they are avoided as they get
very complex and occupy a large amount of space.
A. Two-Dimensional Array in C
A Two-Dimensional array or 2D array in C is an array that has exactly two
dimensions. They can be visualized in the form of rows and columns organized in a
two-dimensional plane.
array_name[size1] [size2];
Here,
 size1: Size of the first dimension.
 size2: Size of the second dimension.
Example of 2D Array in C
C
// C Program to illustrate 2d array
#include <stdio.h>
int main()
{
// declaring and initializing 2d array

int arr[2][3] = { 10, 20, 30, 40, 50, 60 };
printf("2D Array:\n");
// printing 2d array
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ",arr[i][j]);
}
printf("\n");
}
return 0;
}
Output
2D Array:
10 20 30
40 50 60
B. Three-Dimensional Array in C
Another popular form of a multi-dimensional array is Three Dimensional Array or 3D
Array. A 3D array has exactly three dimensions. It can be visualized as a collection of
2D arrays stacked on top of each other to create the third dimension.
array_name [size1] [size2] [size3];
Example of 3D Array
C
// C Program to illustrate the 3d array
#include <stdio.h>
int main()
{
// 3D array declaration
int arr[2][2][2] = { 10, 20, 30, 40, 50, 60 };
// printing elements
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
printf("%d ", arr[i][j][k]);
}
printf("\n");
}
printf("\n \n");
}
return 0;
}
Output
10 20
30 40
50 60
0 0
To know more about Multidimensional Array in C, refer to this article

– Multidimensional Arrays in C
Relationship between Arrays and Pointers
Arrays and Pointers are closely related to each other such that we can use pointers to
perform all the possible operations of the array. The array name is a constant pointer
to the first element of the array and the array decays to the pointers when passed to
the function.
C
// C Program to demonstrate the relation between arrays and
// pointers
#include <stdio.h>
int main()
{
int arr[5] = { 10, 20, 30, 40, 50 };

int* ptr = &arr[0];
// comparing address of first element and address stored

// inside array name
printf("Address Stored in Array name: %p\nAddress of "
"1st Array Element: %p\n",
arr, &arr[0]);
// printing array elements using pointers

printf("Array elements using pointer: ");
for (int i = 0; i < 5; i++) {
printf("%d ", *ptr++);
}
return 0;
}
Output
Address Stored in Array name: 0x7ffcab67d8e0
Address of 1st Array Element: 0x7ffcab67d8e0
Array elements using pointer: 10 20 30 40 50
To know more about the relationship between an array and a pointer, refer to this
article – Pointer to an Arrays | Array Pointer
Passing an Array to a Function in C
An array is always passed as pointers to a function in C. Whenever we try to pass an
array to a function, it decays to the pointer and then passed as a pointer to the first
element of an array.
We can verify this using the following C Program:
C
// C Program to pass an array to a function
#include <stdio.h>
void printArray(int arr[])

{
printf("Size of Array in Functions: %d\n", sizeof(arr));
printf("Array Elements: ");
for (int i = 0; i < 5; i++) {
printf("%d ",arr[i]);
}
}
// driver code
int main()
{
int arr[5] = { 10, 20, 30, 40, 50 };
printf("Size of Array in main(): %d\n", sizeof(arr));

printArray(arr);
return 0;
}
Output
Size of Array in main(): 20
Size of Array in Functions: 8
Array Elements: 10 20 30 40 50
Return an Array from a Function in C
In C, we can only return a single value from a function. To return multiple values or
elements, we have to use pointers. We can return an array from a function using a
pointer to the first element of that array.
C
// C Program to return array from a function
#include <stdio.h>
// function
int* func()
{
static int arr[5] = { 1, 2, 3, 4, 5 };
return arr;
}
// driver code
int main()
{
int* ptr = func();

for (int i = 0; i < 5; i++) {
printf("%d ", *ptr++);
}
return 0;
}
Output
Note: You may have noticed that we declared static array using static keyword. This
is due to the fact that when a function returns a value, all the local variables and
other entities declared inside that function are deleted. So, if we create a local array
instead of static, we will get segmentation fault while trying to access the array in the
main function.
Properties of Arrays in C
It is very important to understand the properties of the C array so that we can avoid
bugs while using it. The following are the main properties of an array in C:
1. Fixed Size
The array in C is a fixed-size collection of elements. The size of the array must be
known at the compile time and it cannot be changed once it is declared.
2. Homogeneous Collection
We can only store one type of element in an array. There is no restriction on the
number of elements but the type of all of these elements must be the same.
3. Indexing in Array
The array index always starts with 0 in C language. It means that the index of the
first element of the array will be 0 and the last element will be N – 1.
4. Dimensions of an Array
A dimension of an array is the number of indexes required to refer to an element in
the array. It is the number of directions in which you can grow the array size.
5. Contiguous Storage
All the elements in the array are stored continuously one after another in the
memory. It is one of the defining properties of the array in C which is also the reason
why random access is possible in the array.
6. Random Access
The array in C provides random access to its element i.e we can get to a random
element at any index of the array in constant time complexity just by using its index
number.
7. No Index Out of Bounds Checking
There is no index out-of-bounds checking in C/C++, for example, the following
program compiles fine but may produce unexpected output when run.
C
// This C program compiles fine
// as index out of bound
// is not checked in C.
#include <stdio.h>
int main()
{
int arr[2];
printf("%d ", arr[3]);

printf("%d ", arr[-2]);
return 0;
}
Output
0 0
In C, it is not a compiler error to initialize an array with more elements than the
specified size. For example, the below program compiles fine and shows just a
Warning.
C
#include <stdio.h>
int main()
{
// Array declaration by initializing it

// with more elements than specified size.
int arr[2] = { 10, 20, 30, 40, 50 };
return 0;
}
Output
Warnings:
prog.c: In function 'main':
prog.c:7:25: warning: excess elements in array initializer
int arr[2] = { 10, 20, 30, 40, 50 };
^
prog.c:7:25: note: (near initialization for 'arr')
int arr[2] = { 10, 20, 30, 40, 50 };
^
int arr[2] = { 10, 20, 30, 40, 50 };
^
Examples of Array in C
Example 1: C Program to perform array input and output.
In this program, we will use scanf() and print() function to take input and print output
for the array.
C
// C Program to perform input and output on array
#include <stdio.h>
int main()
{
// declaring an integer array

int arr[5];
// taking input to array elements one by one

for (int i = 0; i < 5; i++) {
scanf("%d", &arr[i]);
}
// printing array elements

for (int i = 0; i < 5; i++) {
}
return 0;
}
Output
Array Elements: 15775231 0 0 0 4195776
Input
5 7 9 1 4
Output
Example 2: C Program to print the average of the given list of numbers
In this program, we will store the numbers in an array and traverse it to calculate the
average of the number stored.
C
// C Program to the average to two numbers
#include <stdio.h>
// function to calculate average of the function

float getAverage(float* arr, int size)
{
int sum = 0;
// calculating cumulative sum of all the array elements
sum += arr[i];
}
// returning average
return sum / size;
}
// driver code
int main()
{
// declaring and initializing array

float arr[5] = { 10, 20, 30, 40, 50 };
// size of array using sizeof operator
int n = sizeof(arr) / sizeof(float);
// printing array elements

for (int i = 0; i < n; i++) {
printf("%.0f ", arr[i]);
}
// calling getAverage function and printing average

printf("\nAverage: %.2f", getAverage(arr, n));
return 0;
}
Output
Average: 30.00
Example 3: C Program to find the largest number in the array.
C
// C Program to find the largest number in the array.
#include <stdio.h>
// function to return max value

int getMax(int* arr, int size)
{
int max = arr[0];
if (max < arr[i]) {
max = arr[i];
}
}
return max;
}
// Driver code
int main()
{
int arr[10]
= { 135, 165, 1, 16, 511, 65, 654, 654, 169, 4 };
printf("Largest Number in the Array: %d",

getMax(arr, 10));
return 0;
}
Output
Largest Number in the Array: 654
Advantages of Array in C
The following are the main advantages of an array:
1. Random and fast access of elements using the array index.
2. Use of fewer lines of code as it creates a single array of multiple elements.
3. Traversal through the array becomes easy using a single loop.
4. Sorting becomes easy as it can be accomplished by writing fewer lines of code.
Disadvantages of Array in C
1. Allows a fixed number of elements to be entered which is decided at the time of
declaration. Unlike a linked list, an array in C is not dynamic.
2. Insertion and deletion of elements can be costly since the elements are needed to
be rearranged after insertion and deletion.
Conclusion
The array is one of the most used and important data structures in C. It is one of the
core concepts of C language that is used in every other program. Though it is
important to know about its limitation so that we can take advantage of its
functionality.
C Arrays – FAQs
Define Array in C.
An array is a fixed-size homogeneous collection of elements that are stored in a
contiguous memory location.
How to declare an array in C?

We can declare array in C using the following syntax:
datatype array_name [size];
How do you initialize an array in C?

We can initialize an array using two methods:
 Using Initializer list
 Using Loops
Using Initializer List
We can use an initializer list to initialize the array with the declaration using the
following syntax:
datatype array_name [size] = {value1, value2,...valueN};
Using Loops
We can initialize an Array using Loops in C after the array declaration:
for (int i = 0; i < N; i++) {
array_name[i] = valuei;
}
Why do we need Arrays?

We can use normal variables (v1, v2, v3, ..) when we have a small number of objects,
but if we want to store a large number of instances, it becomes difficult to manage
them with normal variables. The idea of an array is to represent many instances in
one variable.
How can we determine the size of the C array?
We can determine the size of the Array using sizeof Operator in C. We first
get the size of the whole array and divide it bStrings in C
Last Updated : 07 Mar, 2024



A String in C programming is a sequence of characters terminated with a null

character ‘\0’. The C String is stored as an array of characters. The difference
between a character array and a C string is that the string in C is terminated with a
unique character ‘\0’.
C String Declaration Syntax

Declaring a string in C is as simple as declaring a one-dimensional array. Below is the
basic syntax for declaring a string.
char string_name[size];
In the above syntax string_name is any name given to the string variable and size is
used to define the length of the string, i.e the number of characters strings will store.
There is an extra terminating character which is the Null character (‘\0’) used to
indicate the termination of a string that differs strings from normal
character arrays.
C String Initialization
A string in C can be initialized in different ways. We will explain this with the help of
an example. Below are the examples to declare a string with the name str and
initialize it with “GeeksforGeeks”.
We can initialize a C string in 4 different ways which are as follows:
1. Assigning a String Literal without Size
String literals can be assigned without size. Here, the name of the string str acts as a
pointer because it is an array.
char str[] = "GeeksforGeeks";
2. Assigning a String Literal with a Predefined Size
String literals can be assigned with a predefined size. But we should always account
for one extra space which will be assigned to the null character. If we want to store a
string of size n then we should always declare a string with a size equal to or greater
than n+1.
char str[50] = "GeeksforGeeks";
3. Assigning Character by Character with Size
We can also assign a string character by character. But we should remember to set
the end character as ‘\0’ which is a null character.
char str[14] = { 'G','e','e','k','s','f','o','r','G','e','e','k','s','\0'};
4. Assigning Character by Character without Size
We can assign character by character without size with the NULL character at the
end. The size of the string is determined by the compiler automatically.
char str[] = { 'G','e','e','k','s','f','o','r','G','e','e','k','s','\0'};
Note: When a Sequence of characters enclosed in the double quotation marks is
encountered by the compiler, a null character ‘\0’ is appended at the end of the
string by default.
Let us now look at a sample program to get a clear understanding of declaring, and
initializing a string in C, and also how to print a string with its size.
C String Example
 C
// C program to illustrate strings
#include <stdio.h>
#include <string.h>
int main()
// declare and initialize string
char str[] = "Geeks";
// print string
printf("%s\n", str);
int length = 0;
length = strlen(str);
// displaying the length of string
printf("Length of string str is %d", length);
return 0;
Output
Geeks
Length of string str is 5
We can see in the above program that strings can be printed using normal printf
statements just like we print any other variable. Unlike arrays, we do not need to
print a string, character by character.
Note: The C language does not provide an inbuilt data type for strings but it has an
access specifier “%s” which can be used to print and read strings directly.
Read a String Input From the User

The following example demonstrates how to take string input using scanf() function
in C
 C
// C program to read string from user
#include<stdio.h>
int main()
// declaring string
char str[50];
// reading string
scanf("%s",str);
// print string
printf("%s",str);
return 0;
Input
GeeksforGeeks
Output
GeeksforGeeks
You can see in the above program that the string can also be read using a single
scanf statement. Also, you might be thinking that why we have not used the ‘&’ sign
with the string name ‘str’ in scanf statement! To understand this you will have to
recall your knowledge of scanf.
We know that the ‘&’ sign is used to provide the address of the variable to the scanf()
function to store the value read in memory. As str[] is a character array so using str
without braces ‘[‘ and ‘]’ will give the base address of this string. That’s why we have
not used ‘&’ in this case as we are already providing the base address of the string to
scanf.
Now consider one more example,
 C
// C Program to take input string which is separated by
// whitespaces
#include <stdio.h>
// driver code
int main()
char str[20];
// taking input string
scanf("%s", str);
// printing the read string
printf("%s", str);
return 0;
Input
Geeks for Geeks
Output
Geeks
Here, the string is read only till the whitespace is encountered.
Note: After declaration, if we want to assign some other text to the string, we have
to assign it one by one or use the built-in strcpy() function because the direct
assignment of the string literal to character array is only possible in declaration.
How to Read a String Separated by Whitespaces in C?
We can use multiple methods to read a string separated by spaces in C. The two of
the common ones are:
1. We can use the fgets() function to read a line of string and gets() to read
characters from the standard input (stdin) and store them as a C string until a
newline character or the End-of-file (EOF) is reached.
2. We can also scanset characters inside the scanf() function
1. Example of String Input using gets()
 C
// C program to illustrate
// fgets()
#include <stdio.h>
#define MAX 50
int main()
char str[MAX];
// MAX Size if 50 defined
fgets(str, MAX, stdin);
printf("String is: \n");
// Displaying Strings using Puts
puts(str);
return 0;
Input
GeeksforGeeks
Output
String is:
GeeksforGeeks
2. Example of String Input using scanset
 C
// C Program to take string separated by whitespace using
// scanset characters
#include <stdio.h>
// driver code
int main()
char str[20];
// using scanset in scanf
scanf("%[^\n]s", str);
// printing read string
printf("%s", str);
return 0;
Input
Geeks for Geeks
Output
Geeks for Geeks
C String Length
The length of the string is the number of characters present in the string except for
the NULL character. We can easily find the length of the string using the loop to
count the characters from the start till the NULL character is found.
Passing Strings to Function
As strings are character arrays, we can pass strings to functions in the same way
we pass an array to a function. Below is a sample program to do this:
 C
// C program to illustrate how to
// pass string to functions
#include <stdio.h>
void printStr(char str[]) { printf("String is : %s", str); }
int main()
// declare and initialize string
char str[] = "GeeksforGeeks";
// print string by passing string
// to a different function
printStr(str);
return 0;
Output:
String is : GeeksforGeeks
Note: We can’t read a string value with spaces, we can use either gets() or fgets() in
the C programming language.
Strings and Pointers in C
In Arrays, the variable name points to the address of the first element.
Below is the memory representation of the string str = “Geeks”.
Similar to arrays, In C, we can create a character pointer to a string that points to the
starting address of the string which is the first character of the string. The string can
be accessed with the help of pointers as shown in the below example.
 C
// C program to print string using Pointers
#include <stdio.h>
int main()
char str[20] = "GeeksforGeeks";
// Pointer variable which stores
// the starting address of
// the character array str
char* ptr = str;
// While loop will run till
// the character value is not
// equal to null character
while (*ptr != '\0') {
printf("%c", *ptr);
// moving pointer to the next character.
ptr++;
return 0;
}
Output
GeeksforGeeks
Standard C Library – String.h Functions
The C language comes bundled with <string.h> which contains some useful string-
handling functions. Some of them are as follows:
Function Name Description
strlen(string_name
Returns the length of string name.
)
strcpy(s1, s2) Copies the contents of string s2 to string s1.
Compares the first string with the second string. If strings are the
strcmp(str1, str2)
same it returns 0.
Concat s1 string with s2 string and the result is stored in the first
strcat(s1, s2)
string.
strlwr() Converts string to lowercase.
strupr() Converts string to uppercase.
strstr(s1, s2) Find the first occurrence of s2 in s1.

y the size of each element type.
C Pointers



Pointers are one of the core components of the C programming language. A pointer can be
used to store the memory address of other variables, functions, or even other pointers. The
use of pointers allows low-level memory access, dynamic memory allocation, and many other
functionality in C.
In this article, we will discuss C pointers in detail, their types, uses, advantages, and
disadvantages with examples.
What is a Pointer in C?
A pointer is defined as a derived data type that can store the address of other C variables or a
memory location. We can access and manipulate the data stored in that memory location using
pointers.
As the pointers in C store the memory addresses, their size is independent of the type of data
they are pointing to. This size of pointers in C only depends on the system architecture.
Syntax of C Pointers
The syntax of pointers is similar to the variable declaration in C, but we use the ( * )
dereferencing operator in the pointer declaration.
datatype * ptr;
where
 ptr is the name of the pointer.
 datatype is the type of data it is pointing to.
The above syntax is used to define a pointer to a variable. We can also define pointers to
functions, structures, etc.
How to Use Pointers?
The use of pointers in C can be divided into three steps:
1. Pointer Declaration
2. Pointer Initialization
3. Pointer Dereferencing
1. Pointer Declaration
In pointer declaration, we only declare the pointer but do not initialize it. To declare a pointer,
we use the ( * ) dereference operator before its name.
Example
int *ptr;
The pointer declared here will point to some random memory address as it is not initialized.
Such pointers are called wild pointers.
2. Pointer Initialization
Pointer initialization is the process where we assign some initial value to the pointer variable.
We generally use the ( &: ampersand ) addressof operator to get the memory address of a
variable and then store it in the pointer variable.
Example
int var = 10;
int * ptr;
ptr = &var;
We can also declare and initialize the pointer in a single step. This method is called pointer
definition as the pointer is declared and initialized at the same time.
Example
int *ptr = &var;
Note: It is recommended that the pointers should always be initialized to some value before
starting using it. Otherwise, it may lead to number of errors.
3. Pointer Dereferencing
Dereferencing a pointer is the process of accessing the value stored in the memory address
specified in the pointer. We use the same ( * ) dereferencing operator that we used in the
pointer declaration.
Dereferencing a Pointer in C
C Pointer Example
C
// C program to illustrate Pointers
#include <stdio.h>
void geeks()
{
int var = 10;
// declare pointer variable

int* ptr;
// note that data type of ptr and var must be same

ptr = &var;
// assign the address of a variable to a pointer

printf("Value at ptr = %p \n", ptr);
printf("Value at var = %d \n", var);
printf("Value at *ptr = %d \n", *ptr);
}
// Driver program
int main()
{
geeks();
return 0;
}
Output
Value at ptr = 0x7ffca84068dc
Value at var = 10
Value at *ptr = 10
Types of Pointers in C
Pointers in C can be classified into many different types based on the parameter on which we
are defining their types. If we consider the type of variable stored in the memory location
pointed by the pointer, then the pointers can be classified into the following types:
1. Integer Pointers
As the name suggests, these are the pointers that point to the integer values.
Syntax
int *ptr;
These pointers are pronounced as Pointer to Integer.

Similarly, a pointer can point to any primitive data type. It can point also point to derived data
types such as arrays and user-defined data types such as structures.
2. Array Pointer
Pointers and Array are closely related to each other. Even the array name is the pointer to its
first element. They are also known as Pointer to Arrays. We can create a pointer to an array
using the given syntax.
Syntax
char *ptr = &array_name;
Pointer to Arrays exhibits some interesting properties which we discussed later in this article.
3. Structure Pointer
The pointer pointing to the structure type is called Structure Pointer or Pointer to Structure. It
can be declared in the same way as we declare the other primitive data types.
Syntax
struct struct_name *ptr;
In C, structure pointers are used in data structures such as linked lists, trees, etc.
4. Function Pointers
Function pointers point to the functions. They are different from the rest of the pointers in the
sense that instead of pointing to the data, they point to the code. Let’s consider a function
prototype – int func (int, char), the function pointer for this function will be
Syntax
int (*ptr)(int, char);
Note: The syntax of the function pointers changes according to the function prototype.
5. Double Pointers
In C language, we can define a pointer that stores the memory address of another pointer.
Such pointers are called double-pointers or pointers-to-pointer. Instead of pointing to a data
value, they point to another pointer.
Syntax
datatype ** pointer_name;
Dereferencing Double Pointer

*pointer_name; // get the address stored in the inner level pointer
**pointer_name; // get the value pointed by inner level pointer
Note: In C, we can create multi-level pointers with any number of levels such as – ***ptr3,
****ptr4, ******ptr5 and so on.
6. NULL Pointer
The Null Pointers are those pointers that do not point to any memory location. They can be
created by assigning a NULL value to the pointer. A pointer of any type can be assigned the
NULL value.
Syntax
data_type *pointer_name = NULL;
or
pointer_name = NULL
It is said to be good practice to assign NULL to the pointers currently not in use.
7. Void Pointer
The Void pointers in C are the pointers of type void. It means that they do not have any
associated data type. They are also called generic pointers as they can point to any type and
can be typecasted to any type.
Syntax
void * pointer_name;
One of the main properties of void pointers is that they cannot be dereferenced.
8. Wild Pointers
The Wild Pointers are pointers that have not been initialized with something yet. These types of
C-pointers can cause problems in our programs and can eventually cause them to crash. If
values is updated using wild pointers, they could cause data abort or data corruption.
Example
int *ptr;
char *str;
9. Constant Pointers
In constant pointers, the memory address stored inside the pointer is constant and cannot be
modified once it is defined. It will always point to the same memory address.
Syntax
data_type * const pointer_name;
10. Pointer to Constant

The pointers pointing to a constant value that cannot be modified are called pointers to a
constant. Here we can only access the data pointed by the pointer, but cannot modify it.
Although, we can change the address stored in the pointer to constant.
Syntax
const data_type * pointer_name;
Other Types of Pointers in C:

There are also the following types of pointers available to use in C apart from those specified
above:
 Far pointer: A far pointer is typically 32-bit that can access memory outside the current
segment.
 Dangling pointer: A pointer pointing to a memory location that has been deleted (or freed)
is called a dangling pointer.
 Huge pointer: A huge pointer is 32-bit long containing segment address and offset address.
 Complex pointer: Pointers with multiple levels of indirection.
 Near pointer: Near pointer is used to store 16-bit addresses means within the current
segment on a 16-bit machine.
 Normalized pointer: It is a 32-bit pointer, which has as much of its value in the segment
register as possible.
 File Pointer: The pointer to a FILE data type is called a stream pointer or a file pointer.
Size of Pointers in C
The size of the pointers in C is equal for every pointer type. The size of the pointer does not
depend on the type it is pointing to. It only depends on the operating system and CPU
architecture. The size of pointers in C is
 8 bytes for a 64-bit System
 4 bytes for a 32-bit System
The reason for the same size is that the pointers store the memory addresses, no matter what
type they are. As the space required to store the addresses of the different memory locations is
the same, the memory required by one pointer type will be equal to the memory required by
other pointer types.
How to find the size of pointers in C?
We can find the size of pointers using the sizeof operator as shown in the following program:
Example: C Program to find the size of different pointer types.
C
// C Program to find the size of different pointers types
#include <stdio.h>
// dummy structure
struct str {
};
// dummy function
void func(int a, int b){};
int main()
{
// dummy variables definitions
int a = 10;
char c = 'G';
struct str x;
// pointer definitions of different types

int* ptr_int = &a;
char* ptr_char = &c;
struct str* ptr_str = &x;
void (*ptr_func)(int, int) = &func;
void* ptr_vn = NULL;
// printing sizes
printf("Size of Integer Pointer \t:\t%d bytes\n",
sizeof(ptr_int));
printf("Size of Character Pointer\t:\t%d bytes\n",
sizeof(ptr_char));
printf("Size of Structure Pointer\t:\t%d bytes\n",
sizeof(ptr_str));
printf("Size of Function Pointer\t:\t%d bytes\n",
sizeof(ptr_func));
printf("Size of NULL Void Pointer\t:\t%d bytes",
sizeof(ptr_vn));
return 0;
}
Output
Size of Integer Pointer : 8 bytes
Size of Character Pointer : 8 bytes
Size of Structure Pointer : 8 bytes
Size of Function Pointer : 8 bytes
Size of NULL Void Pointer : 8 bytes
As we can see, no matter what the type of pointer it is, the size of each and every pointer is the
same.
Now, one may wonder that if the size of all the pointers is the same, then why do we need to
declare the pointer type in the declaration? The type declaration is needed in the pointer for
dereferencing and pointer arithmetic purposes.
C Pointer Arithmetic
The Pointer Arithmetic refers to the legal or valid arithmetic operations that can be performed
on a pointer. It is slightly different from the ones that we generally use for mathematical
calculations as only a limited set of operations can be performed on pointers. These operations
include:
 Increment in a Pointer
 Decrement in a Pointer
 Addition of integer to a pointer
 Subtraction of integer to a pointer
 Subtracting two pointers of the same type
 Comparison of pointers of the same type.
 Assignment of pointers of the same type.
C
// C program to illustrate Pointer Arithmetic
#include <stdio.h>
int main()
{
// Declare an array
int v[3] = { 10, 100, 200 };
// Declare pointer variable

int* ptr;
// Assign the address of v[0] to ptr

ptr = v;
for (int i = 0; i < 3; i++) {
// print value at address which is stored in ptr

printf("Value of *ptr = %d\n", *ptr);
// print value of ptr

printf("Value of ptr = %p\n\n", ptr);
// Increment pointer ptr by 1

ptr++;
}
return 0;
}
Output
Value of *ptr = 10
Value of ptr = 0x7ffcfe7a77a0
Value of *ptr = 100

Value of *ptr = 200

C Pointers and Arrays

In C programming language, pointers and arrays are closely related. An array name acts like a
pointer constant. The value of this pointer constant is the address of the first element. For
example, if we have an array named val then val and &val[0] can be used interchangeably.
If we assign this value to a non-constant pointer of the same type, then we can access the
elements of the array using this pointer.
Example 1: Accessing Array Elements using Pointer with Array Subscript
C
// C Program to access array elements using pointer
#include <stdio.h>
void geeks()
{
// Declare an array
int val[3] = { 5, 10, 15 };
// Declare pointer variable

int* ptr;
// Assign address of val[0] to ptr.

// We can use ptr=&val[0];(both are same)
ptr = val;
printf("Elements of the array are: ");
printf("%d, %d, %d", ptr[0], ptr[1], ptr[2]);
return;
}
// Driver program
int main()
{
geeks();
return 0;
}
C Preprocessors
Last Updated : 28 Aug, 2024



Preprocessors are programs that process the source code before compilation. Several
steps are involved between writing a program and executing a program in C. Let us
have a look at these steps before we actually start learning about Preprocessors.
You can see the intermediate steps in the above diagram. The source code written by
programmers is first stored in a file, let the name be “program.c“. This file is then
processed by preprocessors and an expanded source code file is generated named
“program.i”. This expanded file is compiled by the compiler and an object code file is
generated named “program.obj”. Finally, the linker links this object code file to the
object code of the library functions to generate the executable file “program.exe”.
Preprocessor Directives in C
Preprocessor programs provide preprocessor directives that tell the compiler to
preprocess the source code before compiling. All of these preprocessor directives
begin with a ‘#’ (hash) symbol. The ‘#’ symbol indicates that whatever statement
starts with a ‘#’ will go to the preprocessor program to get executed. We can place
these preprocessor directives anywhere in our program.
Examples of some preprocessor directives are: #include, #define, #ifndef, etc.
Note Remember that the # symbol only provides a path to the preprocessor, and a
command such as include is processed by the preprocessor program. For example,
#include will include the code or content of the specified file in your program.
List of preprocessor directives in C

The following table lists all the preprocessor directives in C:
Preprocessor Directives Description
#define Used to define a macro
#undef Used to undefine a macro
#include Used to include a file in the source code program
Used to include a section of code if a certain

#ifdef
macro is defined by #define
Used to include a section of code if a certain

#ifndef
macro is not defined by #define
#if Check for the specified condition
#else Alternate code that executes when #if fails
Combines else and if for another condition

#elif
check
#endif Used to mark the end of #if, #ifdef, and #ifndef

These preprocessors can be classified based on the type of function they perform.
Types of C Preprocessors
There are 4 Main Types of Preprocessor Directives:
1. Macros
2. File Inclusion
3. Conditional Compilation
4. Other directives
Let us now learn about each of these directives in detail.
1. Macros
In C, Macros are pieces of code in a program that is given some name. Whenever this
name is encountered by the compiler, the compiler replaces the name with the
actual piece of code. The ‘#define’ directive is used to define a macro.
Syntax of Macro Definition
#define token value
where after preprocessing, the token will be expanded to its value in the program.
Example of Macro
C
// C Program to illustrate the macro
#include <stdio.h>
// macro definition
#define LIMIT 5
int main()
{
for (int i = 0; i < LIMIT; i++) {
printf("%d \n", i);
}
return 0;
}
Output
0
1
2
3
4
In the above program, when the compiler executes the word LIMIT, it replaces it with
5. The word ‘LIMIT’ in the macro definition is called a macro template and ‘5’ is
macro expansion.
Note There is no semi-colon (;) at the end of the macro definition. Macro definitions
do not need a semi-colon to end.
There are also some Predefined Macros in C which are useful in providing various
functionalities to our program.
Macros With Arguments
We can also pass arguments to macros. Macros defined with arguments work
similarly to functions.
Example
#define foo(a, b) a + b
#define func(r) r * r
Let us understand this with a program:
C
// C Program to illustrate function like macros
#include <stdio.h>
// macro with parameter

#define AREA(l, b) (l * b)
int main()
{
int l1 = 10, l2 = 5, area;
area = AREA(l1, l2);
printf("Area of rectangle is: %d", area);
return 0;
}
Output
Area of rectangle is: 50
We can see from the above program that whenever the compiler finds AREA(l, b) in
the program, it replaces it with the statement (l*b). Not only this, but the values
passed to the macro template AREA(l, b) will also be replaced in the statement (l*b).
Therefore AREA(10, 5) will be equal to 10*5.
2. File Inclusion
This type of preprocessor directive tells the compiler to include a file in the source
code program. The #include preprocessor directive is used to include the header
files in the C program.
There are two types of files that can be included by the user in the
program:
Standard Header Files
The standard header files contain definitions of pre-defined functions like printf(),
scanf(), etc. These files must be included to work with these functions. Different
functions are declared in different header files.
For example, standard I/O functions are in the ‘iostream’ file whereas functions that
perform string operations are in the ‘string’ file.
Syntax
#include <file_name>
where file_name is the name of the header file to be included. The ‘<‘ and ‘>’
brackets tell the compiler to look for the file in the standard directory.
User-defined Header Files
When a program becomes very large, it is a good practice to divide it into smaller
files and include them whenever needed. These types of files are user-defined
header files.
Syntax
#include "filename"
The double quotes ( ” ” ) tell the compiler to search for the header file in
the source file’s directory.
3. Conditional Compilation
Conditional Compilation in C directives is a type of directive that helps to compile a
specific portion of the program or to skip the compilation of some specific part of the
program based on some conditions. There are the following preprocessor directives
that are used to insert conditional code:
1. #if Directive
2. #ifdef Directive
3. #ifndef Directive
4. #else Directive
5. #elif Directive
6. #endif Directive
#endif directive is used to close off the #if, #ifdef, and #ifndef opening directives
which means the preprocessing of these directives is completed.
Syntax
#ifdef macro_name
// Code to be executed if macro_name is defined
#ifndef macro_name
// Code to be executed if macro_name is not defined
#if constant_expr
// Code to be executed if constant_expression is true
#elif another_constant_expr
// Code to be excuted if another_constant_expression is true
#else
// Code to be excuted if none of the above conditions are true
#endif
If the macro with the name ‘macro_name‘ is defined, then the block of statements
will execute normally, but if it is not defined, the compiler will simply skip this block
of statements.
Example
The below example demonstrates the use of #include #if, #elif, #else, and #endif
preprocessor directives.
C
//program to demonstrates the use of #if, #elif, #else,
// and #endif preprocessor directives.
#include <stdio.h>
// defining PI
#define PI 3.14159
int main()
{
#ifdef PI
printf("PI is defined\n");
#elif defined(SQUARE)
printf("Square is defined\n");
#else
#error "Neither PI nor SQUARE is defined"
#endif
#ifndef SQUARE
printf("Square is not defined");
#else
cout << "Square is defined" << endl;
#endif
return 0;
}
Output
PI is defined
Square is not defined
4. Other Directives
Apart from the above directives, there are two more directives that are not
commonly used. These are:
1. #undef Directive
2. #pragma Directive
1. #undef Directive
The #undef directive is used to undefine an existing macro. This directive works as:
#undef LIMIT
Using this statement will undefine the existing macro LIMIT. After this statement,
every “#ifdef LIMIT” statement will evaluate as false.
Example
The below example demonstrates the working of #undef Directive.
C
#include <stdio.h>
// defining MIN_VALUE
#define MIN_VALUE 10
int main() {
// Undefining and redefining MIN_VALUE
printf("Min value is: %d\n",MIN_VALUE);
//undefining max value
#undef MIN_VALUE
// again redefining MIN_VALUE

#define MIN_VALUE 20
printf("Min value after undef and again redefining it: %d\n", MIN_VALUE);
return 0;
}
Output
Min value is: 10
Min value after undef and again redefining it: 20
2. #pragma Directive
This directive is a special purpose directive and is used to turn on or off some
features. These types of directives are compiler-specific, i.e., they vary from compiler
to compiler.
Syntax
#pragma directive
Some of the #pragma directives are discussed below:
1. #pragma startup: These directives help us to specify the functions that are
needed to run before program startup (before the control passes to main()).
2. #pragma exit: These directives help us to specify the functions that are needed
to run just before the program exit (just before the control returns from main()).
Below program will not work with GCC compilers.
Example
The below program illustrate the use of #pragma exit and pragma startup
C
// C program to illustrate the #pragma exit and pragma
// startup
#include <stdio.h>
void func1();
void func2();
// specifying funct1 to execute at start

#pragma startup func1
// specifying funct2 to execute before end
#pragma exit func2
void func1() { printf("Inside func1()\n"); }
void func2() { printf("Inside func2()\n"); }
// driver code
int main()
{
void func1();
void func2();
printf("Inside main()\n");
return 0;
}
Expected Output
Inside func1()
Inside main()
Inside func2()
The above code will produce the output as given below when run on GCC compilers:
Inside main()c
This happens because GCC does not support #pragma startup or exit. However, you
can use the below code for the expected output on GCC compilers.
C
#include <stdio.h>
void func1();
void func2();
void __attribute__((constructor)) func1();

void __attribute__((destructor)) func2();
void func1()
{
printf("Inside func1()\n");
}
void func2()
{
printf("Inside func2()\n");
}
int main()
{
printf("Inside main()\n");
return 0;
}
Output
Inside func1()
Inside main()
Inside func2()
In the above program, we have used some specific syntaxes so that one of the
functions executes before the main function and the other executes after the main
function.
#pragma warn Directive
This directive is used to hide the warning message which is displayed during
compilation. We can hide the warnings as shown below:
 #pragma warn -rvl: This directive hides those warnings which are raised when a
function that is supposed to return a value does not return a value.
 #pragma warn -par: This directive hides those warnings which are raised when a
function does not use the parameters passed to it.
 #pragma warn -rch: This directive hides those warnings which are raised when a
code is unreachable. For example, any code written after the return statement in a
function is unreachable.
Frequently Asked Questions on C Preprocessors
How Does a Macro with Arguments Differ from a Function in C?
Macros with arguments are expanded at compile time, unlike functions, which are
executed at runtime. This means that the macro performs text substitution before
the program is compiled, so it doesn’t have the overhead of a function call that
results in a faster execution but lack type checking.
What are the Main Differences Between Macros and Functions in C?

 Macros expand at compile time; functions run at runtime.
 Functions occupy memory in the code section; macros do not.
 Functions are type-checked; macros are not.
 Macros can be faster than functions due to the lack of function call overhead
Why Might One Choose to Use a Macro Instead of a Function in C?

Macros can be faster because they avoid function call overhead, making them
suitable for simple, repetitive tasks.
Why Avoid Macros in Place of Functions?

Macros lack type checking, leading to potential bugs. Functions are safer and easier
to debug.
Are Macros Stored in Memory like Functions?

No, macros are expanded during compilation and don’t exist in the final binary,
unlike functions, which are stored in the code section of memory, that allows them to
be called and executed at runtime.

C programming language

Uploaded by

C programming language

Uploaded by

qwertyuiopasdfghjklzxcvbnmqwerty

C is a procedural programming language initially developed by Dennis Ritchie in

The main features of the C language include:

Difference Between C and C++

 stddef.h – Defines several useful types and macros.

short int 2 -32,768 to 32,767 %hd

unsigned short int 2 0 to 65,535 %hu

unsigned int 4 0 to 4,294,967,295 %u

int 4 -2,147,483,648 to 2,147,483,647 %d

long int 4 -2,147,483,648 to 2,147,483,647 %ld

unsigned long int 4 0 to 4,294,967,295 %lu

long long int 8 -(2^63) to (2^63)-1 %lld

unsigned long long 0 to

signed char 1 -128 to 127 %c

unsigned char 1 0 to 255 %c

long double 16 %Lf

The following are some main primitive data types in C:

The integer data type can also be used as

// C program to print Integer data types.

// Integer value with positive data.

// integer value with negative data.

// U or u is Used for Unsigned int in C.

// L or l is used for long int in C.

long int d = 99998L;

printf("Integer value with positive data: %d\n", a);

printf("Integer value with negative data: %d\n", b);

printf("Integer value with an unsigned int data: %u\n",

printf("Integer value with an long int data: %ld", d);

Character Data Type

// C program to print Integer data types.

printf("Value of a: %c\n", a);

printf("Value of a after increment is: %c\n", a);

// c is assigned ASCII values

// which corresponds to the

// a-->97 b-->98 c-->99

// here c will be printed

printf("Value of c: %c", c);

Float Data Type

Double Data Type

// use of double data type

Void Data Type

// use of void pointers

int val = 30;

void* ptr = &val;

Size of Data Types in C

// different data type in C

int size_of_int = sizeof(int);

int size_of_char = sizeof(char);

int size_of_float = sizeof(float);

int size_of_double = sizeof(double);

printf("The size of int data type : %d\n", size_of_int);

printf("The size of char data type : %d\n",

printf("The size of float data type : %d\n",

printf("The size of double data type : %d",

In C language, operators are symbols that represent operations to be performed on

Flips the sign

// using operators and printing results

// using operators and printing results

Here, 0 means false and 1 means true.

// using operators and printing results

4 ~ Bitwise First Flips all the ~a

// using operators and printing results

Add the right

5 /= Divide and Divide the left a /= b

// using operators and printing results

To know more about the topic refer to this article.

To know more about the topic refer to this article.

To know more about the topic refer to this article.

To know more about the topic refer to this article.

printf("sizeof(num) = %d bytes\n", sizeof(num));

Unary, Binary and Ternary Operators in C

1 () Parentheses (function call) left-to-right

[] Brackets (array subscript) left-to-right

. Member selection via object left-to-right

-> Member selection via a pointer left-to-right

+,– Unary plus/minus right-to-left