Structure of c_program_to_input_output

Topics To Be Covered
 Structure Of C Program
 Identifiers
 Basic Data Types And Sizes
 Constants
 Variables
 Expressions
 Operators
 Input/output Statements

Structure of a C Program
Every C program consists of one or more modules called functions. One
of the functions must be called main. The program will always begin by
executing the main function
Each function must contain:
1. A function heading, which consists of the function name, followed
by an optional list of arguments,
1. A list of argument declarations, if arguments are included
3. A compound statement, which comprises the remainder of the
function.
• Each compound statement is enclosed within a pair of braces, { }.
• Compound statements may be nested, one within another
• Each expression statement must end with a semicolon (; )

The comments at the end of each line have been added in order to
emphasize the overall program organization
Normally a C program will not look like this. Rather, it might
appear as shown below.
Execution of the program results in an interactive dialog such as that
shown below. The user's response is underlined, for clarity.
Radius = 7 3
Area = 28.274309

IDENTIFIERS AND KEYWORDS
 identifiers are names that are given to various program elements,
such as variables, functions and arrays.
 Identifiers consist of letters and digits, in any order, except that the
first character must be a letter.
 Both upper- and lowercase letters are permitted, though common
usage favors the use of lowercase letters for most
 Types of identifiers. Upper- and lowercase letters are not
interchangeable
 The underscore character ( - ) can also be included, and is
considered to be a letter.
 An underscore is often used in the middle of an identifier.
 An identifier may also begin with an underscore, though this is
rarely done in practice.

The following names are not valid identifiers ,For the reasons stated.
The following names are not valid identifiers
For the reasons stated.

Some Other Points About Identifiers
 The identifiers file-manager and file-management are both
grammatically valid. Some compilers may be unable to distinguish
between them, however, because the first eight letters are the same for
each identifier. Therefore, only one of these identifiers should be used
in a single C program.
 As a rule, an identifier should contain enough characters so that its
meaning is readily apparent.
 On the other hand, an excessive number of characters should be
avoided.
 A C program is being written to calculate the future value of an
investment. The identifiers value or future-value are appropriate
symbolic names. However, v or fv would probably be too brief, since
the intended representation of these identifiers is not clear. On the
other hand, the identifier future-value-of-an-investment would be
unsatisfactory because it is too long

Keywords
• There are certain reserved words, called keywords, that have
standard, predefined meanings in C.
• These keywords can be used only for their intended purpose;
• They cannot be used as programmer-defined identifiers.

• The standard keywords are
Some compilers also include some or all of the following keywords.

DATA TYPES
• C supports several different types of data
• Each may be represented differently within the computer’s memory
• The basic data types are listed below (Next Slide).
• Typical memory requirements are also given
• The memory requirements determine the permissible range of values
•
• Note that the memory requirements for each data type may vary
from one C compiler to another

C compilers written for personal computers or small minicomputers
(i.e., computers whose natural word size is less than 32 bits)
generally represent a word as 4 bytes (32 bits)

Points to Remember
• The basic data types can be augmented by the use of the data type
qualijiers short , long, signed and unsigned.
• Integer can be defined as short int , long int or unsigned int
• Usually written simply as short , long or unsigned
• The interpretation of integer data type will vary from one C
compiler to another
• A short int may require less or same memory than an ordinary int
but it will never exceed an ordinary int in word length.
• A long int may require the same amount of memory as an
ordinary in t or it may require more memory, but it will never be
less than an ordinary int .
• If short int and int both have the same memory requirements (e.g.,
2 bytes), then long int will generally have double the
requirements (e.g., 4 bytes)

Points to Remember
• If int and long int both have the same memory requirements (e.g.,
4 bytes) then short int will generally have half the memory
requirements (e.g., 2 bytes)
• An unsigned int has the same memory requirements as an ordinary
i n t . However, in the case of an ordinary int , the leftmost bit is
reserved for the sign.
• With an unsigned int , all of the bits are used to represent the
numerical value. Thus, an unsigned int can be approximately twice
as large as an ordinary int (though, of course, negative values are
not permitted).
• For example, if an ordinary int can vary from -32,768 to +32,767
(which is typical for a 2-byte int ) , then an unsigned int will be
allowed to vary from 0 to 65,535. The unsigned qualifier can also
be applied to other qualified int

CONSTANTS
There are four basic types of constants in C.
1. Integer constants,
2. Floating-point constants
3. Character constants
4. String constants
Integer and floating-point constants represent numbers.
They are often referred to collectively as numeric-type constants.
The following rules apply to all numeric-type constants.
 Commas and blank spaces cannot be included within
 The constant can be preceded by a minus (-) sign if desired
 The value of a constant cannot exceed specified minimum and
maximum bounds.

Integer Constants
• An integer constant is an integer-valued number.
• It consists of a sequence of digits.
• Integer constants can be written in three different number systems:
decimal (base lO), octal (base 8) and hexadecimal (base 16).
• A decimal integer constant can consist of any combination of
digits taken from the set 0 through 9.
• If the constant contains two or more digits, the first digit must be
something other than 0.

Structure of c_program_to_input_output

Octal Integer Constant
An octal integer constant can consist of any combination of
digits taken from the set 0 through 7. However the first digit
must be 0,in order to identify the constant as an octal number.

Hexadecimal Integer Constant
A hexadecimal integer constant must begin with either Ox or OX. It
can then be followed by any combination of digits taken from the sets
0 through 9 and a through f (either upper- or lowercase). Note that
the letters a through f (or A through F) represent the (decimal)
quantities 10 through 15, respectively.

Unsigned and Long Integer Constants
 Unsigned integer constants may exceed the magnitude of ordinary
integer constants by approximately a factor of 2, though they may
not be negative.* An unsigned integer constant can be identified by
appending the letter U (either upper- or lowercase) to the end of the
constant.
 Long integer constants may exceed the magnitude of ordinary
integer constants, to create a long integer constant by appending the
letter L (either upper- or lowercase) to the end of the constant. An
unsigned long integer may be specified by appending the letters UL
to the end of the constant. The letters may be written in either upper-
or lowercase. However, the U must precede the L.

Floating-Point Constants
A floating-point constant is a base- 10 number that contains either
a decimal point or an exponent (or both).

Character Constants
A character constant is a single character, enclosed in apostrophes (i.e.,
single quotation marks). Several character constants are shown below.
Escape Sequences
Certain nonprinting characters, as well as the backslash () and the
apostrophe (‘’ ), can be expressed in terms of escape sequences.
An escape sequence always begins with a backward slash and is
followed by one or more special characters.

The commonly used escape sequences are listed below.

String Constants
A string constant consists of any number of consecutive characters
(including none), enclosed in double quotation marks.
Several string constants are shown below.
Note that the string constant "Line 1n Line 2n Line 3" extends over
three lines, because of the newline characters that are embedded
within the string. Thus, this string would be displayed as
Line 1
Line 2
Line 3
Also, notice that the string “ ” is a null (empty) string

EXPRESSIONS
• An expression represents a single data item, such as a number or a
character.
• The expression may consist of a single entity, such as a constant, a
variable, an array element or a reference to a function.
• It may also consist of some combination of such entities,
interconnected by one or more operators.
• Expressions can also represent logical conditions that are either
true or false.
• In C the conditions true and false are represented by the integer
values 1 and 0,respectively

Several simple expressions are shown below.

OPERATORS
Arithmetic Operators
There are five arithmetic operators in C. They are
The % operator is sometimes referred to as the modulus operator.
There is no exponentiation operator in C.
There is a library finction (POW) to carry out Exponentiation.

Points to Remember
• The operands acted upon by arithmetic operators must represent
numeric values
• Operands can be integer quantities, floating-point quantities
• The remainder operator (%) requires that both operands be
integers and the second operand be nonzero.
• Division operator (/) requires that the second operand be
nonzero.
• Division of one integer quantity by another is referred to as
integer division.
• This operation always results in a truncated quotient (i.e., the
decimal portion of the quotient will be dropped).
• If a division operation is carried out with two floating-point
numbers, or with one floating-point number and one integer, the
result will be a floating-point quotient.

Suppose that a and b are integer variables whose values are 10 and
3, respectively. Several arithmetic expressions involving these
variables are shown below, together with their resulting values.

Now suppose that vl and v2 are floating-point variables whose
values are 12.5 and 2.0, respectively. Several arithmetic
expressions involving these variables are shown below, together
with their resulting values.

Suppose that a and b are integer variables whose values are 11 and
-3, respectively. Several arithmetic expressions involving these

Let rl and r2 be floating-point variables whose assigned values
are -0.66 and 4.50. Several arithmetic expressions involving these

Unary Operators
C includes a class of operators that act upon a single operand to
produce a new value. Such operators are known as unary
operators.
Unary operators usually precede their single operands, though
some unary operators are written after their operands.
Perhaps the most common unary operation is unary minus,
where a numerical constant, variable or expression is preceded
by a minus sign.

Relational And Logical Operators
Equality Operators,

Suppose that i, j and k are integer variables whose values are 1, 2 and
3, respectively. Several logical expressions involving these variables
are shown below
logical operators / logical connectives

Assignment Operators
There are several different assignment operators in C.
 Used to form assignment expressions
 Assign the value of an expression to an identifier
 The most commonly used assignment operator is =
 identifier = expression
 where identifier generally represents a variable
 expression represents a constant

Some typical assignment expressions that make use of the =
operator
In the following assignment expressions, suppose that i is an
integer-type variable.

Now suppose that i and j are both integer-type variables, and that j
has been assigned a value of 5. Several assignment expressions that
make use of these two variables are shown below.

Multiple assignments
Assignments Are Carried Out From Right To Left
Above assignment equivalent to
Suppose that i and j are integer variables. The multiple
assignment expression will cause the integer value 5 to be
assigned to both i and j . (To be more precise, 5 is first assigned
to j , and the value of j is then assigned to i.) Similarly, the
multiple assignment expression i = j = 5.9 ,will cause the integer
value 5 to be assigned to both i and j .

Additional Assignment Operators
The assignment expression
is equivalent to
The assignment expression
is equivalent to
expression 1 is an identifier, such as a variable or an array element

Suppose that i and j are integer variables whose values are 5 and 7,
and f and g are floating-point variables whose values are 5.5 and -
3.25. Several assignment expressions that make use of these
variables are shown below. Each expression utilizes the original
values of i, j , f and g

The Conditional operator
 Simple conditional operations can be carried out with the
conditional operator (? :).
 An expression that makes use of the conditional operator is
called a conditional expression.
 A conditional expression is written in the form
When evaluating a conditional expression, expression 1 is evaluated
first. If expression 1 is true (i.e., if its value is nonzero), then
expression 2 is evaluated and this becomes the value of the
conditional expression. However, if expression 1 is false (i.e., if its
value is zero), then expression 3 is evaluated and this becomes the
value of the conditional expression.

In the conditional expression shown below, assume that i is an
integer variable.
The expression (i < 0) is evaluated first. If it is true, the entire
conditional expression takes on the value 0. Otherwise ,the entire
conditional expression takes on the value 100.
In the following conditional expression, assume that f and g are
floating-point variables.
This conditional expression takes on the value off f if it is less than
g; otherwise, the conditional expression takes on the value of g. In
other words, the conditional expression returns the value of the
smaller of the two variables.

Input/output Statements
The Functions permits the transfer of information between the
computer and the standard input/output devices e.g., a keyboard
and a TV monitor
These six are as follows:
1. getchar
2. putchar
3. scanf
4. printf
5. gets
6. Puts
 The header file required by the standard input/output library
functions is called stdio .h

1. SINGLE CHARACTER INPUT -THE getchar FUNCTION
getchar function is a part of the standard C I/O library
It returns a single character from a standard input device
(typically a keyboard)
The function does not require any arguments, though a pair of
empty parentheses must follow the word getchar
In general terms, a function reference would be written as
character variable = getchar ( ) ;
where character variable refers to some previously declared
character variable.

A C program contains the following statements
char c;
. . . . .
c = getchar();
 The first statement declares that c is a character-type variable
 The second statement causes a single character to be entered
from the standard input device (usually a keyboard)
 Then assigned to c

SINGLE CHARACTER OUTPUT -THE putchar FUNCTION
 Single characters can be displayed i.e., written out of the computer
using the C library function putchar
 It is complementary to the character input function getchar
 It is a part of the standard C I/O library
 It transmits a single character to a standard output device (typically a
TV monitor)
 It must be expressed as an argument to the function, enclosed in
parentheses, following the word putchar
 In general, a function reference would be written as
putchar ( character variable)
 where character variable refers to some previously declared
character variable

A C program contains the following statements
char c;
. . . . .
putchar(c);
 The first statement declares that c is a character-type variable
 The second statement causes the current value of c to be
transmitted to the standard output device (e.g., a TV monitor)
where it will be displayed.

EXAMPLE Lowercase to Uppercase Text Conversion

ENTERING INPUT DATA -THE scanf FUNCTION
 This function can be used to enter any combination of
numerical values ,single characters and strings.
 The function returns the number of data items
 that have been entered successfully
 where control string refers to a string containing certain required
formatting information
 arg1, arg2, . . . argn are arguments that represent the individual
input data items
 The control string consists of individual groups of characters, with
one character group for each input data item
 a single character group will consist of the percent sign, followed
by a conversion character which indicates the type of the
corresponding data item

Commonly Used Conversion Characters for Data Input

 The arguments are written as variables or arrays, whose types
match the corresponding character groups in the control string
 Each variable name must be preceded by an ampersand (a). (The
arguments are actually pointers that indicate where the data items
are stored in the computer's memory
Here is a typical application of a scanf function.

WRITING OUTPUT DATA -THE printf FUNCTION
 Output data can be written from the computer onto a standard
output device using the library function printf
 This function can be used to output any combination of numerical
values, single characters and strings
 In general terms, the printf function is written as

 where control string refers to a string that contains formatting
information,
 and arg7, arg2, . . . , argn are arguments that represent the individual
output data items.
 The arguments can be written as constants, single variable or array
names, or more complex expressions.
 Function references may also be included.
 In a printf function do not represent memory addresses and therefore
are not preceded by ampersands.
 The control string consists of individual groups of characters, with
one character group for each output data item.
 Each character group must begin with a percent sign (%). In its
simplest form,
 An individual character group will consist of the percent sign,
followed by a conversion character indicating the type of the
corresponding data item.

Commonly Used Conversion Characters for Data Output

Here is a simple program that makes use of the printf function.
Notice that the first two arguments within the printf function are
single variables, the third argument is an arithmetic expression,
and the last argument is a function reference that has a numeric
expression as an argument. Executing the program produces the
following output:
2.000000 3.000000 5.000000 2.236068

The following skeletal outline indicates how several different
types of data can be displayed using the printf function
Within the printf function, the control string is "%s %d %f It
contains three character groups. The first character group, %s,
indicates that the first argument (item) represents a string. The
second character group, %indicates that the second argument (part
no) represents a decimal integer value, and the third character group,
%indicates that the third argument (cost) represents a floating-point
value.

Structure of c_program_to_input_output

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Structure of c_program_to_input_output (20)

Recently uploaded (20)

Structure of c_program_to_input_output