Syntax

// This is a single-line comment

• Starts with two forward slashes (//)

• Everything written after // on the same line is treated as a comment

• The compiler does not execute that part

Example 1: Simple Comment

#include <stdio.h>

int main() {
    // This program prints Hello, World!
    printf("Hello, World!");
    return 0;
}

The comment // This program prints Hello, World! is ignored by the compiler.

Output:

Hello, World!

Example 2: Inline Comment

You can also place a single-line comment after a statement on the same line.

int x = 10;  // Assign 10 to variable x

When you write a program in C or C++, you need a way to store and manipulate data. This is where variables and data types come into play.

Variable

A variable is simply a named storage location in memory that holds a value.

Think of it like a container where you can put data, retrieve it, or change it during the execution of your program.

data_type variable_name = value;

Key Characteristics of Functions in C:

1. Reusability: You can call a function multiple times from different parts of your program.
2. Modularity: Functions help break a program into smaller, more manageable chunks, making it easier to debug, maintain, and understand.
3. Abstraction: You can use functions to hide complex logic, presenting a simple interface to the rest of the program.

Function Structure:

A function in C consists of the following parts:

1. Return Type: Specifies the type of value the function will return (e.g., int, float, void).
2. Function Name: The name used to identify and call the function.
3. Parameters (optional): A list of variables that the function will take as inputs (known as parameters or arguments).
4. Function Body: The block of code that defines what the function does. This is enclosed in curly braces {}.

Key Characteristics of Arrays in C:

1. Fixed Size: The size of the array must be defined at compile time, and it cannot be changed during program execution.
2. Zero-based Indexing: Array indices start from 0. For an array of size n, the valid indices are 0 to n-1.
3. Homogeneous: All elements in an array must be of the same data type, such as all integers or all floats.

Syntax for Declaring an Array:

data_type array_name;

• data_type: The type of data (e.g., int, float, char).
• array_name: The name of the array.
• array_size: The number of elements the array will hold.

Example:

int numbers; // Declares an array of 5 integers

Here, numbers is an array that can store 5 integers. You can access these integers using indices from 0 to 4.

Initializing an Array:

You can initialize an array at the time of declaration.

Example 1: Explicit Initialization

int numbers = {1, 2, 3, 4, 5};

Example 2: Implicit Initialization (Size Determined Automatically)

int numbers[] = {1, 2, 3, 4, 5}; // Compiler automatically sets size to 5

Example 3: Partially Initializing an Array

int numbers = {1, 2}; // The remaining elements will be initialized to 0

Accessing Array Elements:

You can access or modify elements in the array by using the index of the element. The index starts at 0.

Example:

int numbers = {1, 2, 3, 4, 5}; printf("%d", numbers); // Output will be 3, as array indices start at 0 numbers = 10; // Modifies the third element (index 2) printf("%d", numbers); // Output will now be 10

Multi-dimensional Arrays:

C also allows multi-dimensional arrays, where you can create arrays of arrays. The most common example is a 2D array (array of arrays), often used to represent matrices or grids.

Example of 2D Array:

int matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };

Here, matrix is a 2D array with 3 rows and 3 columns. To access an element, you need to specify both row and column indices:

printf("%d", matrix); // Output will be 6 (second row, third column)

Important Notes:

• Array Bounds: Accessing an array with an index outside of its defined range results in undefined behavior, which can lead to errors or unexpected results.
• Array Size: In C, the size of an array is fixed once defined, and this cannot be changed dynamically (unless using dynamic memory allocation, e.g., malloc()).

1. int (Integer):

• Purpose: Used to store whole numbers (i.e., integers without any decimal points).
• Size: Typically 4 bytes on most systems (but can vary depending on the system architecture).
• Range: The range of values int can hold depends on the system, but generally, it is from -2,147,483,648 to 2,147,483,647 for a 4-byte int (using 32-bit architecture).
• Example:

  int num = 5;

2. float (Floating-point number):

• Purpose: Used to store numbers with a fractional part (decimals). It is used when precision is not as critical, and space is a concern.
• Size: Typically 4 bytes (32 bits).
• Range: Can store numbers from approximately 1.5 × 10⁻⁴⁵ to 3.4 × 10³⁸ with about 6-7 decimal digits of precision.
• Example:

  float pi = 3.14;

3. double (Double-precision floating-point number):

• Purpose: Used for storing floating-point numbers with greater precision than float. It is used when more accuracy is required.
• Size: Typically 8 bytes (64 bits).
• Range: Can store numbers from approximately 5.0 × 10⁻³²⁷ to 1.7 × 10³⁰⁷ with about 15-16 decimal digits of precision.
• Example:

  double pi = 3.141592653589793;

4. char (Character):

• Purpose: Used to store a single character (usually one byte).
• Size: Typically 1 byte (8 bits).
• Range: Can store values from -128 to 127 (signed) or 0 to 255 (unsigned) if used as a numeric type. When used as a character, it represents a single character, e.g., 'A', 'b', '3', etc.
• Example:

  char letter = 'A';

• 2 hours ago
• 3 days ago
• a month ago

A function is a set of statements that takes input, does some specific computation, and produces output.