Variable Definition in C

Variable Definition in C

A variable definition tells the compiler where and how much storage to create for
the variable. A variable definition specifies a data type and contains a list of one
or more variables of that type as follows:

type variable_list;

6. VARIABLES
Here, type must be a valid C data type including char, w_char, int, float, double,
bool, or any user-defined object; and variable_list may consist of one or more
identifier names separated by commas. Some valid declarations are shown here:

int                   i, j, k; char                c, ch; float                f, salary; double            d;

The line int i, j, k; declares and defines the variables i, j and k; which instruct
the compiler to create variables named i, j, and k of type int.
Variables can be initialized (assigned an initial value) in their declaration. The
initializer consists of an equal sign followed by a constant expression as follows:

type variable_name = value;

Some examples are:

extern             int d = 3, f = 5; // declaration of d and f. int                   d = 3, f = 5; // definition and initializing d and f. byte                z = 22; // definition and initializes z. char                x = 'x'; // the variable x has the value 'x'.

For definition without an initializer: variables with static storage duration are
implicitly initialized with NULL (all bytes have the value 0); the initial value of all
other variables are undefined.

VARIABLES

VARIABLES

A variable is nothing but a name given to a storage area that our programs can
manipulate. Each variable in C has a specific type, which determines the size
and layout of the variable's memory; the range of values that can be stored
within that memory; and the set of operations that can be applied to the
variable.
The name of a variable can be composed of letters, digits, and the underscore
character. It must begin with either a letter or an underscore. Upper and
lowercase letters are distinct because C is case-sensitive. Based on the basic
types explained in the previous chapter, there will be the following basic variable
types:

Type              Description char                Typically a single octet (one byte). This is an integer type. int                   The most natural size of integer for the machine. float                A single-precision floating point value. double            A double-precision floating point value. void                 Represents the absence of type.

C programming language also allows to define various other types of variables,
which we will cover in subsequent chapters like Enumeration, Pointer, Array,
Structure, Union, etc. For this chapter, let us study only basic variable types.

The void Type

The void Type

The void type specifies that no value is available. It is used in three kinds of
situations:
Types and Description
1 Function returns as void
There are various functions in C which do not return any value or you
can say they return void. A function with no return value has the return
type as void. For example, void exit (int status);

2 Function arguments as void
There are various functions in C which do not accept any parameter. A
function with no parameter can accept a void. For example, int
rand(void);

3 Pointers to void
A pointer of type void * represents the address of an object, but not its
type. For example, a memory allocation function void *malloc(size_t
size); returns a pointer to void which can be casted to any data type.

Floating-Point Types

Floating-Point Types

The following table provides the details of standard floating-point types with
storage sizes and value ranges and their precision:
Type              Storage size           Value range                       Precision
float                4 byte                         1.2E-38 to 3.4E+38              6 decimal places
double            8 byte                         2.3E-308 to 1.7E+308         15 decimal places
long double 10 byte                          3.4E-4932 to 1.1E+4932     19 decimal places

The header file float.h defines macros that allow you to use these values and
other details about the binary representation of real numbers in your programs.
The following example prints the storage space taken by a float type and its
range values:

#include <stdio.h> #include <float.h> int main() { printf("Storage size for float : %d \n", sizeof(float)); printf("Minimum float positive value: %E\n", FLT_MIN ); printf("Maximum float positive value: %E\n", FLT_MAX ); printf("Precision value: %d\n", FLT_DIG ); return 0; }

When you compile and execute the above program, it produces the following
result on Linux:

Storage size for float : 4 Minimum float positive value: 1.175494E-38 Maximum float positive value: 3.402823E+38 Precision value: 6

Integer Types

Integer Types

The following table provides the details of standard integer types with their
storage sizes and value ranges:
5. DATA TYPES

Type                         Storage size                        Value range char                            1 byte                                      -128 to 127 or 0 to 255 unsigned char                            1 byte                                      0 to 255 signed char                1 byte                                      -128 to 127 int                               2 or 4 bytes                            -32,768 to 32,767 or –                                                                                     2,147,483,648 to2,147,483,647 unsigned int              2 or 4 bytes                            0 to 65,535 or 0 to 4,294,967,295 short                           2 bytes                                    -32,768 to 32,767 unsigned short                          2 bytes                                    0 to 65,535 long                            4 bytes                                    -2,147,483,648 to 2,147,483,647 unsigned long                            4 bytes                                    0 to 4,294,967,295

To get the exact size of a type or a variable on a particular platform, you can
use the sizeof operator. The expressions sizeof(type) yields the storage size of
the object or type in bytes. Given below is an example to get the size of int type
on any machine:

#include <stdio.h> #include <limits.h> int main() { printf("Storage size for int : %d \n", sizeof(int)); return 0; }

When you compile and execute the above program, it produces the following
result on Linux:

Storage size for int : 4

Whitespace in C

Whitespace in C

A line containing only whitespace, possibly with a comment, is known as a blank
line, and a C compiler totally ignores it.
Whitespace is the term used in C to describe blanks, tabs, newline characters
and comments. Whitespace separates one part of a statement from another and
enables the compiler to identify where one element in a statement, such as int,
ends and the next element begins. Therefore, in the following statement:

int age;

there must be at least one whitespace character (usually a space) between int
and age for the compiler to be able to distinguish them. On the other hand, in
the following statement:

fruit = apples + oranges; // get the total fruit

no whitespace characters are necessary between fruit and =, or between = and
apples, although you are free to include some if you wish to increase readability.
Data types in C refer to an extensive system used for declaring variables or
functions of different types. The type of a variable determines how much space
it occupies in storage and how the bit pattern stored is interpreted.

The types in C can be classified as follows:

Types and Description

·    1 Basic Types:

They are arithmetic types and are further classified into: (a) integer
types and (b) floating-point types.

2 Enumerated types:

They are again arithmetic types and they are used to define variables
that can only assign certain discrete integer values throughout the
program.

3 The type void:

The type specifier void indicates that no value is available.

4 Derived types:

They include (a) Pointer types, (b) Array types, (c) Structure types, (d)
Union types, and (e) Function types.

The array types and structure types are referred collectively as the aggregate
types. The type of a function specifies the type of the function's return value. We
will see the basic types in the following section, whereas other types will be
covered in the upcoming chapters.

Basic Syntax

Basic Syntax

You have seen the basic structure of a C program, so it will be easy to
understand other basic building blocks of the C programming language.

Tokens in C

A C program consists of various tokens and a token is either a keyword, an
identifier, a constant, a string literal, or a symbol. For example, the following C
statement consists of five tokens:

printf("Hello, World! \n"); The individual tokens are: printf ( "Hello, World! \n" ) ;

Semicolons

In a C program, the semicolon is a statement terminator. That is, each individual
statement must be ended with a semicolon. It indicates the end of one logical
entity.
Given below are two different statements:

printf("Hello, World! \n"); return 0;

Comments

Comments are like helping text in your C program and they are ignored by the
compiler. They start with /* and terminate with the characters */ as shown
below:
/* my first program in C */
4. BASIC SYNTAX
You cannot have comments within comments and they do not occur within a
string or character literals.

Identifiers

A C identifier is a name used to identify a variable, function, or any other user defined item. An identifier starts with a letter A to Z, a to z, or an underscore ‘_’
followed by zero or more letters, underscores, and digits (0 to 9).
C does not allow punctuation characters such as @, $, and % within identifiers.
C is a case-sensitive programming language. Thus, Manpower and manpower
are two different identifiers in C. Here are some examples of acceptable
identifiers:

mohd              zara                 abc                 move_name             a_123 myname50    _temp            j                      a23b9                        retVal

Keywords

The following list shows the reserved words in C. These reserved words may not
be used as constants or variables or any other identifier names.

auto                            else                             long                           switch break                          enum                          register                      typedef case                             extern                         return                        union char                            float                            short                           unsigned const                           for                               signed                         void continue                    goto                            sizeof                          volatile default                        if                                  static                           while do                                int                               struct                          _Packed double