Explain about C Variables, Constants And Data types?

C Variables, Constants and Data types

In C and C++ programming, variables, constants, and data types are essential ideas for managing data. In the case of C tokens, they are some of the fundamental components that the compiler understands.

Variables

Variables are named memory locations in the computer. You can edit variables while the program is executing. Use a variable’s name in the program to get its data. A variable is basically a type of storage that is found in the memory of the computer. It is a designated area where data values can be stored by a software. A program’s variables and constants are examples of data elements. Variables can have a changing value, in contrast to constants, which remain unchanged while a program is running. In the program, you can access or refer to the data contained in a variable by using its name.

Each variable, or identifier, has a type and name. The type determines the variable’s data type and the compiler’s memory allocation.

Variable Declaration

All C and C++ variables must be declared before use. The compiler is informed of the variable’s name and data type by this declaration. C++ is tightly typed, hence you must declare variable types.

Basic variable declaration syntax: <data type> <variable name>;

To declare three integer variables p, q, and r, write: int p, q, r;

With commas, many variables of the same type can be specified in one phrase.

Variable Initialization

An assignment statement (=) can assign a value to a declared variable. A variable can be initialised by definition with a starting value.

List initialisers (introduced in C++11), assignment, function syntax, and constructors can initialise variables. Initialising variables before using built-in types is recommended.

Initialisation during declaration includes: floating average = 51.36; char initial = ‘A’; int count = 5;

Declaring and initialising many same-type variables in one statement is another option: integers 10 and 20;

Data Types

A variable’s data type describes the collection of characteristics it has in common, such as the types of data it can hold (including character, integer, and floating-point data) and the operations that can be carried out on it. Additionally, the type of data a variable contains and the particular system or compiler being used determine how much storage space it takes up.

There are several basic or built-in data types available in C and C++. Here are a few basic ones:

Int: Stored integer values (positive or negative whole numbers). The system determines whether the size takes up 2 or 4 bytes.
Float: Used to store real numbers with decimal points, or single-precision floating-point values. typically takes up four bytes.
Char: One character is stored there. It can be interpreted as either an integer or a character (for example, its ASCII code, which represents the character’s numeric value). often takes up one byte.
double: Used for double-precision floating-point values, it is comparable to float but offers more range and precision. consumes 8 bytes on average.
void: Frequently used with functions that don’t return a value or pointers that can point to any data type, this is used to specify no values.

Short, long, signed, and unsigned are examples of type specifiers or qualifiers that can be used to alter the size and range of values of these fundamental kinds. Long int can hold greater integer values than int, for example, and unsigned int can only hold non-negative numbers, but it has a wider range of positive values.

Constants

Tokens with fixed values that remain constant throughout program execution are known as constants. They are utilised throughout the code, including in assignment declarations.

There are various types of constants that C Language supports:

Integer Constants: These are entire numbers devoid of a decimal place. Decimal numbers (like 10, -5), octal numbers (like 012), or hexadecimal numbers (like 0xA, 0X1F) can all be used.
Floating-Point Constants (Real Constants): These are fractionally divided numbers. In addition to using scientific (exponent) notation (e.g., 2.5e3, 1.0e-4), they also include a decimal point (e.g., 3.14, -0.5).
Character Constants: These are single quotations that enclose a single character. Examples include ‘A’, ‘7’, and ‘*’. Newlines and other special characters are represented by escape sequences that begin with a backslash, as ‘\n’.
String Constants: These are character sequences that have double quotes around them. Internally, they are handled as a collection of characters, and by default, the string ends with the null character, ‘\0’. “Hello” and “C Programming” are two instances.

Constants can be used directly in code as literal values (sum = number + 10;, for example). Additionally, you can use the const keyword or the #define preprocessor command to define symbolic constants.

Code Example

#include <stdio.h> // Standard input/output library header file 
int main() { // main is an identifier for the main function 
    // Declaration and Initialization of Variables
    int integerVariable = 10; // int is a keyword (data type), integerVariable is an identifier
    float floatVariable = 20.5f; // float is a keyword, floatVariable is an identifier. 'f' indicates float literal 
    char charVariable = 'X'; // char is a keyword, charVariable is an identifier. 'X' is a character constant 
    double doubleVariable = 123.456; // double is a keyword, doubleVariable is an identifier 
    // Using different types of Constants
    // Integer Constants:
    int decimalConstant = 100; // Decimal integer constant
    int octalConstant = 0144; // Octal integer constant (equivalent to 100 decimal) 
    int hexConstant = 0x64; // Hexadecimal integer constant (equivalent to 100 decimal) 
    // Floating-Point Constants:
    float realConstant = 5.75; // Floating-point constant with decimal point
    double scientificConstant = 1.2e-3; // Floating-point constant with exponent 
    // Character Constant:
    char newlineConstant = '\n'; // Special character constant (newline) 
    // String Constant:
    const char* greeting = "Hello, C!"; // String constant "Hello, C!" 
                                        // const char* is a way to declare a pointer to a string literal (constant sequence of chars) 
    // Printing the values
    printf("Integer Variable: %d\n", integerVariable); // %d for int 
    printf("Float Variable: %f\n", floatVariable); // %f for float 
    printf("Character Variable: %c\n", charVariable); // %c for char 
    printf("Double Variable (standard): %lf\n", doubleVariable); // %lf for double with printf 
    printf("Double Variable (scientific): %e\n", doubleVariable); // %e for scientific notation 

    printf("Decimal Constant: %d\n", decimalConstant);
    printf("Octal Constant (decimal value): %d\n", octalConstant);
    printf("Hex Constant (decimal value): %d\n", hexConstant);
    printf("Real Constant: %f\n", realConstant);
    printf("Scientific Constant: %e\n", scientificConstant);
    printf("Using newline constant:%c", newlineConstant); // Prints the newline character
    printf("String Constant: %s\n", greeting); // %s for string 
    return 0; // return is a keyword, 0 is an integer constant 
}

Here, the keywords are int, float, char, double, const, and return. key, integerVariable, floatingDouble, charVariable, and variableDecimal, variable,Hexadecimal, octal, and constantScientific, real, and constantRegular, newlineTwo identifiers are greeting and constant. For example, 10, 20.5f, ‘X’, 123.456, 100, 0144, 0x64, 5.75, 1.2e-3, ‘\n’, “Hello, C!” and 0 are constants. A standard library function is referenced by the identifier printf.

In order to create more complicated programs in C and C++, it is essential to comprehend three basic concepts: how to represent fixed values with constants, what kinds of data they can carry based on data types, and how to name storage places using variables.

Page Content

Tutorials