ING

A M M
O GR
C P R E
O F U A G
IC S A N G
BA S L
Q1) What is a Programming Language?
A) A Programming Language is a type of written language that tells computers what to do in order to work.

Q2) What is purpose of Programming Language?

A) Programming Language are used to make all the computer programs and computer softwares.

Q3) What is a C Programming Language?

A) C Programming Language is computer language that was developed to do system programming for the operating system
UNIX and is an imperative programming language. It is also called “PORTABLE LANGUAGE”.

Q4) Who developed C Programming Language?

A) C was developed in the early 1970s by KEN THOMPSON and DENNIS RITCHIE.
 C S
E N
O K
T
Q1) What is a TOKEN?
A) TOKEN are smallest elements of a program, which are meaningful to the compiler.

Q2) What is a Compiler?

A) A Compiler is a special program that processes statements written in a particular programming language and turns them
into machine language or “code” that a computer’s processor uses.

Q2) How many TOKENS are there in C PROGRAMMING?

A) There are 6 TOKENS.

Q3) What are the C TOKENS?

A) 1. KEYWORDS (eg: int, while, etc.)
2. CONSTANTS (eg: 10, 20, etc.)
3. STRINGS (eg: “total”, “hello”, etc.)
4. SPECIAL SYMBOLS (eg: (), {}, etc.)
5. IDENTIFIERS (eg: main, total, etc.)
6. OPERATORS (eg: +, - , /, *, etc.)

Q4) What is meant by SYNTAX in C language?

A) C language SYNTAX specify rules for sequence of characters to be written in C language.
KEYWORDS
• KEYWORDS ARE DEFINED AS THOSE VARIABLES WHICH HAVE SPECIAL MEANING AND ARE PREDEFINED IN
THE C LIBRARIES
• KEYWORDS CANNOT BE RENAMED AND CAN’T BE REPROGRAMMED EXAMPLES : if, else, main, void etc.
• THERE ARE 32 MAIN AND IMPORTANT KEYWORDS FOR C PROGRAMMING.
• NOTE : All the keywords can’t either be accessed or can’t be changed. These are all predefined and
loaded into the C Libraries.

Below given all the keywords of C PROGRAMMING LANGUAGE :

CONSTANTS
• CONSTANTS OR LITERALS ARE LIKE VARIABLES, BUT THE DIFFERENCE
IS THAT, THE VALUES OF THE CONSTANTS ARE FIXED. ONCE DECLARED
THEY CAN’T BE CHANGED.
VARIABLES ARE THOSE ONCE AFTER YOU DECLARE THEM YOU CAN
EITHER CHANGE THEIR VALUES OR YOU CAN ALSO PERFORM
OPERATIONS ON THEM.
SYNTAX : 1) const data_type variable_name;
2) const data_type *variable_name;
TYPES OF CONSTANTS
THERE ARE 5 MAIN AND IMPORTANT TYPES OF CONSTANTS WHICH ARE
USED IN OUR C PROGRAMMING LANGUAGE :
• INTEGER CONSTANTS
• FLOATING POINT CONSTANTS
• CHARACTER CONSTANTS
• STRING CONSTANTS
• OCTAL AND HEXADECIMAL CONSTANTS
STRINGS
• STRINGS AE DEFINED AS A COLLECTION OF CHARACTERS DEFINED IN
FORM OF AN ARRAY AND END WITH NULL CHARACTER WHICH
DESCRIBE THE END OF THE STRING TO THE COMPILER.
• IN STRINGS WE HAVE THE ALPHABETICAL DATA WHICH IS STORED IN
THE FORM OF ARRAYS. (A –Z) NOT NUMBERS OR SPECIAL SYMBOLS.
SYNTAX : char string_name[Length_of_the_String]
SPECIAL SYMBOLS
• SPECIAL CHARACTERS ARE SYMBOLS THAT HAVE A “SPECIAL” BUILT-IN
MEANING IN THE LANGUAGE AND TYPICALLY CANNOT BE USED IN
IDENTIFIERS.
• THESE VARIOUS SYMBOLS HAVE DIFFERENT MEANING WHICH IS PREDEFINED
IN C LIBRARIES. HENCE, THEY ARE USED IN A PARTICULAR SEGMENT OF CODE.
EXAMPLES: %, &, (), {}
• AMPERSAND SYMBOL IS USED IN printf AND scanf STATEMENTS ONLY. THIS
STATEMENT IS DEDICATED TO LOCATE THE ACTS OF VARIABLE WHICH YOU HAVE
DECLARED IN YOUR PROGRAM.
• MODULUS SYMBOL IS USED ALONG WITH THE DATA TYPES FOR SPECIFYING DATA TYPE.
• IF YOU ARE DECLARING AN INTEGER TYPE DATA TYPE, YOU WILL BE USING MODULUS SYMBOL
ALONG WITH d. IF YOU ARE DECLARING STRING TYPE DATA TYPE YOU WILL BE USING MODULUS
SYMBOL ALONG WITH s.
IDENTIFIERS
• IDENTIFIERS ARE DEFINED AS THE NAMES THAT WE DECLARE IN A
PROGRAM IN ORDER TO NAME A VALUE, VARIABLE, FUNCTION,
ARRAY AND ETC.
EXAMPLE: int x=10
HERE int IS THE DATA TYPE WHICH ARE SPECIFYING FOR YOUR
IDENTIFIER AND x IS THE VARIABLE NAME WHICH WILL BE STORING
THE VALUE 10.
HERE ARE SOME RULES FOR IDENTIFIERS :
OPERATORS
Q) WHAT IS AN OPERATOR?
A) AN OPERATOR IS A SYMBOL THAT OPERATES ON A VALUE OR A VARIABLE.
FOR EXAMPLE + IS AN OPERATOR TO PERFORM ADDITION.

THERE ARE 6 TYPES OF OPERATORS:

1. ARITHEMATIC OPERATORS
2. INCREMENT / DECREMENT OPERATORS
3. ASSIGNMENT OPERATORS
4. RELATIONAL OPERATORS
5. LOGICAL OPERATORS
6. BITWISE OPERATORS
ARITHMATIC OPERATORS
• ARITHMETIC OPERATORS ARE USED TO PERFORM MATHEMATICAL
CALCULATIONS SUCH AS ADDITION, SUBTRACTION, MULTIPLICATION,
DIVISION AND MODULUS.
• HERE SHOWN A WINDOW OF PROGRAMMING WHERE YOU SEE THE
EXAMPLE OF ARITHMATIC OPERATORS AND ONCE YOU COMPILE AND
RUN THE PROGRAM, THE RESULT WILL BE SHOWN AT THE BOTTOM
OF THE WINDOW AS SHOWN BELOW.
INCREMENT / DECREMENT
OPERATORS
• INCREMENT AND DECREMENT OPERATORS ARE BASICALLY USED WHEN
LOOPS ARE INCLUDED IN THE PROGRAM.
• INCREMENT OPERATORS IS USED TO INCREASE THE VALUE OF A VARIABLE
BY A SPECIFIC NUMBER.
• DECREMENT OPERATORS ARE USED TO DECREASE THE VALUE OF THE
VARIABLE BY A SPECIFIC NUMBER.
• WHN INCREMENT / DECREMENT OPERATORS ARE INCLUDED THEN THE
CONTROL STATEMENT WILL BE EXECUTED FOR MULTIPLE TIMES.
EXAMPLE: 1)i++; //Increment
2)i--; //Decrement
ASSIGNMENT OPERATORS
• ASSIGNMENT OPERATORS ARE USED TO ASSIGN THE VALUES FOR THE
VARIABLES IN C PROGRAMMING LANGUAGE.
EXAMPLES: =, ==
int a=10;
RELATIONAL OPERATORS
• RELATIONAL OPERATORS IS A PROGRAMMING LANGUAGE
CONSTRUCR OR OPERATOR THAT TESTS OR DEFINES RELATION
BETWEEN TWO ENTITIES / VARIABLES.
EXAMPLE: >, >, =, \=
• RELATIONAL OPERATORS ARE GENERALLY USED BETWEEN TE=WO OR
MORE VARIABLES.
• `FOR EXAMPLE CONSIDER a = 10 AND b = 20 NOW THE USER WANTS TO
KNOW WHICH VARIABLE IS GREATER THEN YOU WILL APPLY AN if AND
DECLARE TWO VARIABLES INSIDE IT AS SHOWN BELOW
if(a=<b);
LOGICAL OPERATORS
• THE LOGICAL OPERATORS USED TO PERFORM LOGICAL OPERATIONS ON THE GIVEN
EXPRESSIONS. THERE ARE 3 LOGICAL OPERATORS IN C LANGUAGE AS FOLLOWS :
1. Logical AND (&&)
2. Logical OR (||)
3. Logical NOT (!)
1. TO EXECUTE Logical AND BOTH THE SIDES OF THE LHS AND RHS MUST BE TRUE
THEN ONLY IT WILL RESULT IN A TRUE VALUE AND VICE – VERSA.
2. THE Logical OR FUNCTIONS WITH EITHER ONE OF THE VALUES OF THE TWO
AGENTS SHOULD BE TRUE.
3. THE Logical NOT IS TO CONVERT THE TRUE VALUE INTO FALSE. IF YOU SRE USIN
GNOT OPERATOR IN FRONT OF A TRUE VALUE THEN THE VALUE WILL BE
CONVERTED INTO FALSE.
BITWISE OPERATORS
• THESE OPERATORS ARE USED TO PERFORM BIT OPERATIONS. DECIMAL
VALUES ARE CONVERTES INTO BINARY VALUES WHICH ARE THE
SEQUENCE OF BITS AND BIT WISE OPERATORS WORK ON THESE BITS.
THERE ARE 6 TYPES OF BITWISE OPERATORS IN C LANGUAGE AS FOLLOWS :
1. & (bitwise AND)
2. | (bitwise OR)
3. ~ (bitwise NOT)
4. ^ (XOR)
5. << (left shift)
6. >> (right shift)
DATA TYPES AND VARIABLES
DATA TYPES
• THE DATA TYPES USED IN C LANGUAGE IS CATEGORISED INTO FOUR
VARIETIES THEY ARE AS FOLLOWS :
1. BASIC DATA TYPE
2. DERIVED DATA TYPE
3. ENUMERATION DATA TYPE
4. VOID DATA TYPE
BASIC DATA TYPE
• THE BASIC DATA TYPE DESCRIBED IN C LANGUAGE ARE ‘int, char, float,
double’.
DERIVED DATA TYPE
• THE DERIVED DATA TYPE DESCRIBED IN C LANGUAGE ARE ‘array,
pointer, structure, union’.
ENUMERATION DATA TYPE
• THE ENUMERATION DATA TYPE DESCRIBED IN C LANGUAGE ARE
‘enum’.
VOID DATA TYPE
• THE VOID DATA TYPE DESCRIBED IN C LANGUAGE ARE ‘void’.
VARIABLES
• VARIABLE IS DEFINED AS THE RESERVED MEMORY SPACE WHICH
STORES A VALUE OF A DEFINITE DATA TYPE. THE VALUE OF THE
VARIABLE IS NOT CONSTANT, INSTEAD IT ALLOWS CHANGES.
• THERE ARE MAINLY FIVE TYPES OF VARIABLES SUPPORTED IN C :
1. LOCAL VARIABLE
2. GLOBAL VARIABLE
3. STATIC VARIABLE
4. AUTOMATIC VARIABLE
5. EXTERNAL VARIABLE
LOCAL VARIABLE
• ANY VARIABLE THAT IS DECLARED INSIDE A CODE BLOCK OR A
FUNCTION AND HAS THE SCOPE CONFINED TO THAT PARTICULAR
BLOCK OF CODE OR FUNCTION IS CALLED TO BE A LOCAL VARIABLE.
EXAMPLE :
void Edureka(){
int Local_variable=10;
}
• NOTE : THE LOCAL VARIABLE CAN ONLY BE ACCESSED INSIDE THE
PARTICULAR BLOCK OF CODE OR FUNCTION.
GLOBAL VARIABLE
• GLOBAL IS SIMPLY THE OPPOSITE OF LOCAL VARIABLE.
• ANY VARIABLE THAT IS DECLARED AT THE OUTSIDE A CODE BLOCK OR A FUNCTION
AND HAS THE SCOPE ACROSS THE ENTIRE PROGRAM AND ALLOWS ANY FUNCTION TO
CHANGE ITS VALUE IS KNOWN AS GLOBAL VARIABLE.
EXAMPLE :
int Global_variable=10
void edureka()
{
int Local_variable=20;
}
• NOTE : THE GLOBAL VARIABLES CAN BE ACCESSED ANYWHERE IN THE PROGRAM.
STATIC VARIABLES
• STATIC VARIABLES IS ONLY VARIABLE THAT DOESN’T ALLOWS TO CHANGE THE VALUE
WHICH IS STORED.
• STATIC VARIABLES RETAIN OF THE PROGRAM AND WILL NOT BE CHANGED BETWEEN
MULTIPLE FUNCTION CALLS.
• EXAMPLES :
void Edureka()
{
int Local_variable=10;//
static int Static_variable=10;
Local_variable=Local variable+1;
Static_variable=Static_variable+1;
printf(“%d,%d”,x,y);
}
AUTOMATIC VARIABLE
• AUTOMATIC VARIABLES CAN BE DECLARED BY USING THE KEYWORD
‘auto’. BY DEFAULT, ALL THE VARIABLES DECLARED IN C LANGUAGE
ARE AUTOMATIC VARIABLES.
• EXAMPLE :
Void main()
{
int Local_variable=10; //(automatic default)
auto int auto=20; //(automatic variable)
}
EXTERNAL VARIABLE
• EXTERNAL VARIABLE IS DECLARED BY USING THE ‘extern’ KEYWORD.
WE CAN SHARE A VARIABLE IN MULTIPLE C SOURCE FILES BY USING
AN EXTERNAL VARIABLE.
• EXAMPLE :
Extern int external=10; //external variable (also global)
HERE ARE SOME RULES FOR DECLARING VARIABLES
PREPOCESSOR DIRECTIVES
• PREPOCESSOR DIRECTIVES ARE LINES INCLUDED IN A PROGRAM THAT BEGIN WITH THE
CHARATER #, WHICH MAKE THEM DIFFERENT FROM A TYPICAL SOURCE CODE TEXT.
THEY ARE INVOKED BY THE COMPILER TO PROCESS SOME PROGRAMS BEFORE
COMPILATION. IT IS A MACRO PROCESSOR THAT IS USED AUTOMATICALLY BY THE C
COMPILER TO TRANSFORM YOUR PROGRAM BEFORE ACTUAL COMPILATION.
• THERE ARE 9 PREPOCESSOR DIRECTIVES :
1. #include
2. #define
3. #undef
4. #ifdef
5. #ifndef
6. #if
7. #else
8. #error
9. #pragma
#INCLUDE
• THE #include PREPROCESSOR DIRECTIVE IS USED TO PASTE CODE OF
GIVEN FILE INTO CURRENT FILE. IT IS USED TO INCLUDE SYSTEM-
DEFINED AND USER-DEFINED HEADER FILES.
• THE FOLLOWING ARE THE TWO VARIANTS TO USE #include DIRECTIVE :
• #include <file name>
• #include”file name”
#DEFINE
• THE #define PREPROCESSOR DIRECTIVE IS USED TO DEFINE
CONSTANT OR MICRO SUBSTITUTION. IT CAN USE ANY BASIC DATA
TYPE.
• SYNTAX :
• #define token value
#UNDEF
• THE #undef PREPROCESSOR DIRECTIVE IS USED TO UNDEFINE THE
CONSTANT OR MACRO DEFINED BY #define. IN A SIMPLE WAY IT CAN
UNDO ANYTHING WHICH HAVE DONE USING THE PREPROCESSOR
DIRECTIVE #define.
• SYNTAX :
• #undef token
#IFDEF
• THE #ifdef PREPROCESSOR DIRECTIVE CHECKS IF MACRO IS DEFINED
BY #define. IF YES, IT EXECUTES THE CODE OTHERWISE #else CODE IS
EXECUTED, IF PRESENT.
• SYNTAX :
• #ifdef MACRO
//code segment
#end if

• OR AN ELSE TAG WILL BE EXECUTED IF THE CODE SEGMENT INSIDE THE ELSE TAG IS
PRESENT.
#IFNDEF
• THE #ifndef PREPROCESSOR DIRECTIVE CHECKS IF MACRO IS NOT
DEFINED BY #DEFINE. IF YES, IT EXECUTES THE CODE OTHERWISE
#else CODE IS EXECUTED, IF PRESENT.
• SYNTAX :
• #ifndef MACRO
//code
#endif

• IF THE CONDITION GETS FAILED THEN THE CODE ndef WILL BE EXECUTED.
#IF
• THE #if PREPROCESSOR DIRECTIVE EVALUATES THE EXPRESSION OR
CONDITION. IF CONDITION IS TRUE, IT EXECUTES THE CODE
OTHERWISE #elseif or #else or #endif CODE IS EXECUTED.
• SYNTAX :
• #if expression
//code
#endif
#ELSE
• THE #else PREPROCESSOR DIRECTIVE EVALUATES THE EXPRESSION OR
CONDITION IF CONDITION OF #if IS FALSE. IT CAN BE USED WITH #if,
#elif, #ifdef and #ifndef DIRECTIVES.
• SYNTAX :
• #if expression
//if code
#else
//else code
#endif

• IF THE FIST if CONDITION GOES FALSE THEN THE CONTOL WILL DIRECTLY ENTER INTO
else PART AND THE CODE WHICH IS DECLARED INSIDE THE else PART WILL BE EXECUTED.
#ERROR
• THE #error PREPROCESSOR DIRECTIVE INDICATES ERROR. THE
COMPILER GIVES FATAL ERROR IF #error DIRECTIVE IS FOUND AND
SKIPS FURTHER COMPILATION PROCESS.
#PRAGMA
• THE #pragma PREPROCESSOR DIRECTIVE IS USED TO PROVIDE
ADDITIONAL INFORMATION TO THE COMPILER. THE #pragma
DIRECTIVE IS USED BY THE COMPILER TO OFFER MACHINE OR
OPERATIN –SYSTEM FEATURE
• SYNTAX :
• #pragma token
MY FIRST C PROGRAM WHICH WILL PRINT “HELLO WORLD” IN THE CONSOLE SCREEN AS SHOWN BELOW :
 TS
EN
T E M
STA
OL
N TR
CO
CONTROL STATEMENTS
• CONTROL STATEMENTS ENABLE US TO SPECIFY THE FLOW OF PROGRAM CONTROL. THEY SPECIFY THE
ORDER IN WHICH THE INSTRUCTIONS IN A PROGRAM MUST BE EXECUTED. THEY MAKE IT POSSIBLE TO
MAKE DECISIONS, TO PERFORM TASKS REPEATEDLY OR TO JUMP FROM ONE SECTION OF CODE TO ANOTHER.
• CONTROL STATEMENTS ARE ACTUALLY USER DEFINED CONDITION FOR THE COMPILER. THE USER SPECIFIES A
PARTICULAR CONDITION IN FRONT OF A CODE SEGMENT AND ASKS THE COMPILER TO EXECUTE THAT
PARTICULAR CODE SEGMENT IF AND ONLY IF THE CONDITION WHICH HE SPECIFIED TO COMPILER IS TRUE OR
NOT. IF IT’S TRUE THEN THE CODE WILL BE EXECUTED. IF THE CONDITION IS FALSE THEN THE CODE WILL BE
SKIPPED AND THE NEXT CODE SEGMENT WILL BE EXECUTED.

• THERE ARE 7 VARIANTS OF IF STATEMENT IN C LANGUAGE :

• If STATEMENT
• If-else STATEMENT
• If else-if ladder
• Nested if
• Switch
• Ternary
• Break
IF STATEMENT
• If STATEMENT IN C LANGUAGE IS DEFINED AS A PROGRAMMING
CONDITIONAL STATEMENT THAT, IF PROVED TRUE, PERFORMS AN OPERATION
OR DISPLAYS INFORMATION INSIDE THE STATEMENT BLOCK.
• EXAMPLE :
• IF YOU HAVE A CONDITION IN FRONT OF A CODE SEGMENT THAT YOU WANT TO
EXECUTE BUT YOU HAVE A CONDITION TO EXECUTE IT IN THAT PARTICULAR CASE THE
CODE SEGMENT, THE CODE SEGMENT WHICH YOU WANTED TO EXECUTE WILL BE
EXECUTED ONLY IF YOUR CONDITION WHAT YOUR SPECIFIED WILL BE TRUE ELSE THAT
PARTICULAR CODE SEGMENT WILL BE ELIMINATED OR THE
CONTROL WILL NOT ENTER INTO THAT BLOCK OF STATEMENTS.
• HERE IS A FLOW CHART WHICH WILL EXPLAIN THE WORKING OF IF
STATEMENT :
MY SECOND C PROGRAM WHICH WILL PROVE “IF STATEMENT” IN THE CONSOLE SCREEN AS SHOWN BELOW :
IF-ELSE CONTROL STATEMENT
• If-else STATEMENT IN C LANGUAGE IS DEFINED AS A PROGRAMMING
CONDITIONAL STATEMENT THAT HAS TWO STATEMENT BLOCKS OVER
A CONDITION. IF PROVED TRUE, THEN THE IF BLOCK WILL BE
EXECUTED AND IF FALSE, THEN THAE ELSE BLOCK WILL BE EXECUTED.
MY THIRD C PROGRAM WHICH WILL PROVE “IF-ELSE STATEMENT” IN THE CONSOLE SCREEN AS SHOWN BELOW :
IF-ELSE LADDER CONTROL
STATEMENT
• IF-ELSE LADDER IN C LANGUAGE IS DEFINED AS A PROGRAMMING
CONDITIONAL STATEMENT THAT HAS MULTIPLE ELSE-IF STATEMENT
BLOCKS. IF ANY OF THE CONDITION IS TRUE, THEN THE CONTROL
WILL EXIT THE else-if LADDER AND EXECUTE THE NEXT SET OF
STATEMENTS.
MY FOURTH C PROGRAM WHICH WILL PROVE “IF-ELSE LADDER STATEMENT” IN THE CONSOLE SCREEN AS SHOWN
BELOW :
NESTED IF CONTROL STATEMENT
• NESTED IF STATEMENT IN C LANGUAGE IS DEFINED AS A
PROGRAMMING CONDITIONAL STATEMENT THAT COMPRISES OF
ANOTHER IF STATEMENT INSIDE THE PREVIOUS IF STATEMENT.
MY FIFTH C PROGRAM WHICH WILL PROVE “NESTED IF STATEMENT” IN THE CONSOLE SCREEN AS SHOWN BELOW :