Basic Concepts of C

C Syntax:

Let's begin by analyzing and breaking down the basic syntax of a C program:

#include <stdio.h>

int main() {
    printf("Hello World!");
    return 0;
}

Explanation of the code:

Line 1: The line `#include <stdio.h>` is a preprocessor directive that includes the standard input-output library (`stdio.h`) in our program. This library provides functions like `printf` and `scanf` for input and output operations.

Line 2: This is a blank line. C ignores white space. However, we use it to enhance the readability of the code.

Line 3: The `int main()` function is the starting point of every C program. It is a special function where the execution of the program begins and contains the main code. Any code inside its curly brackets {} will be executed.

Line 4: `printf` is a function used for output (printing) in C. In this example, it will display "Hello World!" on the screen.

Line 5: `return 0` is used to indicate that the program has executed successfully. The value `0` returned from `main()` indicates a successful program termination.

Note: Every C statement concludes with a semicolon (`;`).

Remember: The compiler disregards white spaces. Nonetheless, multiple lines contribute to the code's readability.

Line 6: It is important not to forget to include the closing curly bracket "}" to properly conclude the "main" function.

Output in C:

C provides the ability to output values and print text using the `printf` function:

#include <stdio.h>

int main()
{
    printf("Hello World!");

    return 0;
}

You can include multiple `printf` objects to output different values or texts. However, it's important to note that it doesn't automatically insert a new line at the end of the output:

#include <stdio.h>

int main()
{
    printf("Hello World!");
    printf("Welcome to CodeTechMentor!");

    return 0;
}

Comments in C:

In C, comments are used to add explanatory or descriptive text within the source code that is ignored by the compiler. They serve as notes for developers and have no impact on the execution of the program. There are two types of comments in C:

1. Single-line comments: Single-line comments begin with two forward slashes (`//`) and continue until the end of the line. Any text following the `//` symbol on the same line is considered a comment. Here's an example:

// This is a single-line comment.
printf("Hello World!");

2. Multi-line comments: Multi-line comments, also known as block comments, allow you to comment on multiple lines of code. They begin with a forward slash followed by an asterisk (`/*`) and end with an asterisk followed by a forward slash (`*/`). Here's an example:

/*
This is a multi-line comment.
It can span across multiple lines.
*/
printf("Hello World!");

Multi-line comments are often used for longer explanations, documenting functions or classes, or temporarily disabling blocks of code.

It's important to note that comments are meant for human readers and should be used to make the code more understandable, especially for others who might read or maintain the code in the future. (alert-success)

Data Types in C:

In C, data types specify the type of data that can be stored in a variable. Some common built-in data types in C include:

`int`: Used for storing integers (whole numbers).

`float` and `double`: Used for storing floating-point numbers (decimal numbers).

`char`: Used for storing individual characters.

Data Type	Size (in bytes)
char	1
int	4
float	4
double	8

Variables in C:

A variable is a named storage location that holds a value of a specific data type. Variables need to be declared before they can be used. The syntax for declaring a variable is: `data_type variable_name = value;`. In C, you define a variable by specifying its type (e.g., int) and giving it a name (e.g., x or myName). You can assign a value to the variable using the equal sign (`=`).

Here's an example:

int age = 25;

You can also declare a variable without assigning the value and assign the value later:

int number;
number = 10;

Please note that in C, if you assign a new value to a variable that already has a value, the previous value will be overwritten:

For example:

int x = 5; // x is assigned the value 5
x = 10;    // The value of x is updated to 10

Other Data Types:

Here is a demonstration of different data types in C:

int num = 10;            // Integer (whole number without decimals)
float pi = 3.14;         // Floating point number (with decimals)
char letter = 'A';       // Character
double value = 3234.45732; // Floating point number (with decimals)

Boolean in C:

The `bool` data type represents a Boolean value, which can have two possible states: `true` or `false`. In C, the bool type is not a built-in data type. The `bool` type is part of the C99 standard. Before C99, the Boolean values were typically represented using integers, where `0` represented `false`, and any non-zero value represented `true`.

To use the `bool` data type, you need to include the `<stdbool.h>` header file in your program:

#include <stdbool.h>

int main()
{
    bool isTrue = true;
    bool isFalse = false;

    return 0;
}

Format Specifiers in C:

Format specifiers in C are placeholders used in `printf` and `scanf` functions to format the input and output. They define the data type of the variables that are passed to `printf` for output or read by `scanf` for input. Format specifiers begin with the `%` symbol, followed by a character representing the data type.

Here are some commonly used format specifiers:

1. `%d` or '%i' : Used for integers (`int`).

int age = 25;
printf("My age is %d years old.", age);

2. `%f`: Used for floating-point numbers (`float` or `double`).

float pi = 3.14159;
printf("The value of pi is %f.", pi);

3. `%c`: Used for characters (`char`).

char firstInitial = 'J';
printf("My first initial is %c.", firstInitial);

4. `%lf`: Used for double (`double`).

double value = 3234.45732;
printf("The value = %lf.", value);

NOTE: Using the correct format specifiers is essential to ensure that the `printf` and `scanf` functions interpret the data correctly. Incorrect format specifiers can lead to unexpected behavior or errors in your program. (alert-success)

Set Decimal Precision in C:

In C, you can set the decimal precision for floating-point numbers when displaying them using the `printf` function. The decimal precision specifies the number of digits to be displayed after the decimal point. To control the precision, you can use the format specifier `%.[precision]f`, where `[precision]` is the number of decimal places you want to display.

Here's how you can set the decimal precision in C:

#include <stdio.h>

int main() {
    double number1 = 3.14159265358979323846;
    float number2 = 2.718281828459045;

    // Setting decimal precision to 2 for double and float
    printf("Number 1 with 2 decimal places: %.2f", number1);
    printf("Number 2 with 2 decimal places: %.2f", number2);

    // Setting decimal precision to 4 for double and float
    printf("Number 1 with 4 decimal places: %.4f", number1);
    printf("Number 2 with 4 decimal places: %.4f", number2);

    return 0;
}

Output:

Number 1 with 2 decimal places: 3.14

Number 2 with 2 decimal places: 2.72

Number 1 with 4 decimal places: 3.1416

Number 2 with 4 decimal places: 2.7183

In this example, we use `%.[precision]f` to set the decimal precision for both `double` and `float` variables. The number of decimal places specified (2 and 4 in the example) determines how many digits will be displayed after the decimal point.

Identifiers in C:

Identifiers are names given to variables, functions, or any other user-defined entities in C. They help identify and refer to these entities within the code. Some rules for naming identifiers in C are:

Identifiers can include letters, digits, and underscores (`_`).
The first character must be a letter or an underscore.
Identifiers are case-sensitive (`age` and `Age` are different).
Names cannot contain whitespaces or special characters like `!`, `#`, `%`, etc.
Reserved keywords (e.g., `int`, `float`) cannot be used as identifiers.

White-Space in C:

In C, whitespace refers to spaces, tabs, and newlines used for formatting and separation of code elements. Whitespace is generally ignored by the compiler and serves the purpose of enhancing code readability. Here are some examples of whitespace:

Whitespace	Explanation	Representation
New Line	To Insert a new Line	\n
Tab	To Insert a Tab	\t
Space	To Insert a Space	Empty Space
Double Quote	To Insert a Double Quote Character	\"
Backslash	To Insert a Backslash Character	\\

New Lines in C:

In C, the next line character `\n` is commonly used to introduce new lines in output statements. It is primarily used in output statements to insert a line break.

Example:

printf("Hello World!\n");

User Input in C:

Once you've become familiar with the usage of `printf` for outputting values, it's time to introduce `scanf` for obtaining user input. `scanf` is a function used for input in C. It utilizes the format specifiers to read input values.

Example:

#include <stdio.h>

int main()
{
    int number;  // Variable to store the user's number input

    printf("Enter a number: ");  // Prompting the user to enter a number
    scanf_s("%d", &number);  // Reading the user's number input

    printf("Number: %d", number);  // Displaying the user's number input

    return 0;
}

In Microsoft Visual Studio, when using the scanf function, you may encounter a warning or an error suggesting the use of scanf_s. This warning is related to potential security vulnerabilities that arise from buffer overflows when using scanf. To address these concerns, Microsoft introduced a more secure version of the scanf function called scanf_s. (alert-success)

Type Conversion (Casting):

Type casting in C refers to the process of converting one data type to another. It allows you to treat a variable of one type as if it were of another type. This can be useful in various situations, such as performing arithmetic operations or assigning values between different data types.

There are two main types of type casting in C: implicit casting (also known as automatic casting) and explicit casting.

1. Implicit Casting:

Implicit casting occurs automatically by the compiler when it can safely convert one data type to another without any loss of information. For example, if you assign an integer value to a floating-point variable, the compiler will automatically convert the integer to a float.

int myInt = 10;
float myFloat = myInt; // Implicit casting from int to float

In this case, the value of `myInt` is implicitly cast to a float and assigned to `myFloat`.

2. Explicit Casting:

Explicit casting is performed by the programmer to explicitly convert a variable from one type to another, even if there is a potential loss of information. It is done manually by placing the type in parentheses () in front of the value.