C PROGRAMMING
C programming is a high-level, general-purpose programming language developed by Dennis Ritchie in 1972. It is procedural, meaning it follows a step-by-step approach to problem-solving, and is widely used for system programming, such as developing operating systems, embedded systems, and compilers.[visual representation]
 |
| C PROGRAMMING |
C provides low-level access to memory through pointers, making it efficient for tasks that require direct interaction with hardware. It is also known for its portability, as C programs can run on different computer systems with minimal modifications. The language's simplicity, efficiency, and flexibility have made it fundamental in the world of programming. [Introduction to c programming]
2) Difference Between C and C++ :
3) DATA TYPES :
In C programming, data types specify the type of data a variable can hold. The main data types in C are:
1. Basic Data Types
These are the fundamental types for storing simple data:
`int` : Integer type, used for whole numbers (e.g., 5, -10)
`float` : Floating-point type, used for decimal numbers (e.g., 3.14, -2.5)
`double` : Double-precision floating-point type for more precision than `float`
`char` : Character type, used for storing a single character (e.g., 'A')
2. Derived Data Types
These are derived from the basic data types:
Array : Collection of variables of the same data type (e.g., `int arr[5]`)
Pointer : Stores memory addresses (e.g., `int *ptr`)
Structure : Group of different data types under one name (e.g., `struct Person`)
Union : Stores different data types in the same memory location but only one at a time
3. Enumeration (enum)
A user-defined data type consisting of named integer constants:
enum Day { Sunday, Monday, Tuesday };
4. Void
Represents the absence of a data type, often used with functions that return no value:
`void` : No data type (e.g., `void function()`)
Size and Range:
The size and range of these types depend on the system, but typically:
`int`: 4 bytes (range: -2,147,483,648 to 2,147,483,647)
`float`: 4 bytes
`double`: 8 bytes
`char`: 1 byte
These data types allow C to store and manipulate different types of data.
4) C OPERATORS :
Sure! Here’s a concise overview of C operators without using the asterisk (*) symbol:
1. Arithmetic Operators
`+` : Addition
`-` : Subtraction
`/` : Division
`%` : Modulus (remainder)
2. Relational (Comparison) Operators
`==` : Equal to
`!=` : Not equal to
`>` : Greater than
`<` : Less than
`>=` : Greater than or equal to
`<=` : Less than or equal to
3. Logical Operators
`&&` : Logical AND
`||` : Logical OR
`!` : Logical NOT
4. Assignment Operators
`=` : Assign
`+=` : Add and assign
`-=` : Subtract and assign
`/=` : Divide and assign
5. Bitwise Operators
`&` : Bitwise AND
`|` : Bitwise OR
`^` : Bitwise XOR
`~` : Bitwise NOT
`<<` : Left shift
`>>` : Right shift
6. Unary Operators
`+` : Unary plus
`-` : Unary minus
`++` : Increment
`--` : Decrement
`!` : Logical NOT
7. Ternary Operator
`? :` : Conditional (ternary) operator
8. Size of Operator
`size of` : Returns the size of a variable or data type
9. Comma Operator
`,` : Separates multiple expressions in a statement
These operators help perform various operations in C programming, such as calculations, comparisons, and logical operations.
5) CONDITIONAL STATEMENT IN C LANGUAGE:
In C language, a conditional statement allows you to control the flow of execution based on conditions. The most common conditional statements are:
1. if` Statement
This executes a block of code if a specified condition is true.
if (condition) {
// code to be executed if condition is true
}
Example:
int x = 10;
if (x > 5) {
printf("x is greater than 5\n");
}
2. `if-else` Statement
This provides an alternative block of code if the condition is false.
if (condition) {
// code to be executed if condition is true
} else {
// code to be executed if condition is false
}
Example:
int x = 3;
if (x > 5) {
printf("x is greater than 5\n");
} else {
printf("x is not greater than 5\n");
}
3. `else if` Statement
This is used when multiple conditions need to be checked.
if (condition1) {
// code to be executed if condition1 is true
} else if (condition2) {
// code to be executed if condition2 is true
} else {
// code to be executed if none of the above conditions are true
}
Example:
int x = 7;
if (x > 10) {
printf("x is greater than 10\n");
} else if (x > 5) {
printf("x is greater than 5 but less than or equal to 10\n");
} else {
printf("x is 5 or less\n");
}
4. switch` Statement
This is used when you want to select one of many code blocks to execute, based on a value.
switch (expression) {
case value1:
// code to be executed if expression equals value1
break;
case value2:
// code to be executed if expression equals value2
break;
default:
// code to be executed if expression doesn't match any case
}
Example:
int day = 2;
switch (day) {
case 1:
printf("Monday\n");
break;
case 2:
printf("Tuesday\n");
break;
default:
printf("Invalid day\n");
}
These conditional statements allow you to create dynamic behavior based on various conditions.
6) LOOPING STATEMENTS:
In C language, looping statements allow code to be executed repeatedly based on a condition. The three main types of loops are `for`, `while`, and `do-while`.
1.`for` Loop
The `for` loop is used when you know in advance how many times the loop should run.
for (initialization; condition; increment) {
// code to be executed
}
Example:
for (int i = 0; i < 5; i++) {
printf("i = %d\n", i);
}
Explanation: This loop will execute the code block 5 times, printing the value of `i` from 0 to 4.
2. `while` Loop
The `while` loop is used when the number of iterations is not known in advance. It runs as long as the specified condition is true.
while (condition) {
// code to be executed
}
Example:
int i = 0;
while (i < 5) {
printf("i = %d\n", i);
i++;
}
Explanation: The loop continues to run until `i` is no longer less than 5.
3. `do-while` Loop
The `do-while` loop is similar to the `while` loop, but it guarantees that the code block will be executed at least once, even if the condition is false.
do {
// code to be executed
} while (condition);
Example:
int i = 0;
do {
printf("i = %d\n", i);
i++;
} while (i < 5);
Explanation: The loop will print `i` from 0 to 4, and the condition is checked after each iteration.
4.`break` Statement:
The `break` statement is used to exit a loop prematurely when a specific condition is met.
Example:
for (int i = 0; i < 10; i++) {
if (i == 5) {
break; // exit the loop when i is 5
}
printf("i = %d\n", i);
}
5. `continue` Statement
The `continue` statement skips the rest of the loop body and continues with the next iteration.
Example:
for (int i = 0; i < 5; i++) {
if (i == 2) {
continue; // skip printing when i is 2
}
printf("i = %d\n", i);
}
These looping statements help in executing code repeatedly and efficiently based on conditions.
7) COMMENT STATEMENTS :
In C language, comment statements are used to annotate the code, explain the logic, or prevent certain code blocks from being executed. Comments are ignored by the compiler, so they don't affect the execution of the program.
There are two types of comment statements in C:
1. Single-line Comments (`//`)
Single-line comments are used to comment out a single line of code or add brief explanations. They begin with `//` and continue until the end of the line.
// This is a single-line comment
int x = 5; // Assign value 5 to variable x
2. Multi-line Comments (`/* ... */`)
Multi-line comments are used to comment out multiple lines of code or provide detailed explanations. They begin with `/*` and end with `*/`.
/*
This is a multi-line comment.
It can span multiple lines.
*/
int y = 10; /* Assign value 10 to variable y */
Common Uses:
Explanation of code logic:
// Calculate the area of a circle
float radius = 5.0;
float area = 3.14 * radius * radius;
Disabling code temporarily:
/*
int x = 5;
printf("%d", x); // This code is disabled
*/
Comments make code easier to understand for others (or yourself) when revisiting it later. They also help document the program.
0 Comments