Introducing constants, variables and data types

March 31

2

Content Warnings and errors Constants Data types`

3

Warnings and Errors The GCC compiler can produce two kinds of diagnostics: errors

and warnings. Each kind has a different purpose: Errors report problems that make it impossible to compile your

program. GCC reports errors with the source file name and line number where the problem is apparent.

Warnings report other unusual conditions in your code that may indicate a problem, although compilation can (and does) proceed. Warnings may indicate danger points where you should check to make sure that your program really does what you intend

4

Calculation of body mass index

5

Lets make errors on purpose

Remove ;

Remove &

6

Building a program with errors

Notifies us about the syntactical error

Notifies us about the warning

Even thought program compiles and ready to run, it will not function correctly, thus pay attention to warnings carefully.

Program does not compile because of the syntactical error

Data Variables and Constants

Some types of data are preset before a program is used and keep their values unchanged throughout the life of the program. These are constants. Any attempt to modify a CONSTANT will result in error.

Other types of data may change or be assigned values as the program runs; these are variables.

constant

variable

8

Macro constant

Macro constant

prep

roce

ssor

di

recti

ves

9

Preprocessor The preprocessor provides the ability for the inclusion of header

files, macro expansions, conditional compilation, and line control. In many C implementations, it is a separate program invoked by

the compiler as the first part of translation.

preprocessor compiler linkersourcecode

binarycode

Replaces all directives starting with #

Analyzes code and generates object code

Links object code with libraries

This semester we only use two preprocessor directives#include <header_file> will be substituted with the content of <header_file>#define <constant_name> <constant value> <constant_name> will be substituted with <constant value> throughout the source file

10

const specifier The other way to define constants is to use const specifier.

What’s the difference between two types of constants? The directive #define defines constant at compilation time const <data_type> can be assigned during program execution, but

only once!

11

Examples1. Integer constants

Positive or negative whole numbers with no fractional part Example:

const int MAX_NUM = 10; const int MIN_NUM = -90;

2. Floating-point constants (float or double) Positive or negative decimal numbers with an integer part, a decimal

point and a fractional part Example:

const double VAL = 0.5877e2; //(stands for 0.5877 x 102)3. Character constants

A character enclosed in a single quotation mark Example:

const char letter = ‘n’; const char number = ‘1’; printf(“%c”, ‘S’);

Output would be: S

12

Enumerated typesEnumerated Types are a special way of creating your own Type in C. The type is a "list of key words". Enumerated types are used to make a program clearer to the reader/maintainer of the program.

13

Enumerated types Enumerated Types are Not Strings Enums are Not (Really) Integers

It turns out that enumerated types are treated like integers by the compiler. Underneath they have numbers 0,1,2,... etc. You should never rely on this fact

Basic Data Types There are 4 basic data types :

int float double char

1. int used to declare numeric program variables of integer type whole numbers, positive and negative keyword: int

int number;number = 12;

-32,768 ~ 32,767 ( 16bit @ 16bit machine)

Basic Data Types2. float

fractional parts, positive and negative keyword: float

float height;height = 1.72;

3. double used to declare floating point variable of higher precision or

higher range of numbers exponential numbers, positive and negative keyword: double

double valuebig; valuebig = 12E-3;

3.4e-38 ~ 3.4e38 ( 32bit @ 16bit machine)

1.7e-308 ~ 1.7e308 ( 64bit @ 16bit machine)

Basic Data Types

4. char equivalent to ‘letters’ in English language Example of characters:

Numeric digits: 0 - 9 Lowercase/uppercase letters: a - z and A - Z Space (blank) Special characters: , . ; ? “ / ( ) [ ] { } * & % ^ < > etc

single character keyword: char

char my_letter;my_letter = 'U’; The declared character must be

enclosed within a single quote!

-128 ~ 127( 8bit @ 16bit machine)

Difference between integer and floating-point numbers

1. An integer has no fractional part; A floating-point number can have a fractional part.

2. Floating-point numbers can represent a much larger range of values than integers can.

3. For some arithmetic operations, such as subtracting one large number from another, floating-point numbers are subject to greater loss of precision.

4. Floating-point values are often approximations of a true value.

5. Floating-point operations are normally slower than integer operations.

  Primary data types in C

Floating point representation

float

Simplified example

Double precision representation

C allows for a third floating-point type: long double. The intent is to provide for even more precision than double. However, C guarantees only that long double is at least as precise as double.

double

Hierarchy of Integer Types C offers three adjective keywords to modify the basic integer type: short,

long, and unsigned. The type short int or, more briefly, short may use less storage than int,

thus saving space when only small numbers are needed. Like int, short is a signed type.

The type long long int, may use more storage than long, thus enabling you to express even larger integer values. Like int, long long is a signed type.

The type unsigned int, or unsigned, is used for variables that have only nonnegative values. For example, a 16-bit unsigned int allows a range from 0 to 65535 in value instead of from –32768 to 32767.

Why Multiple Integer Types?

The idea is to fit the types to the machine. The most common practice today is to set up long long as 64 bits,

long as 32 bits, short as 16 bits, and int to either 16 bits or 32 bits, depending on the machine's natural word size.

The minimum range for both short and int is –32,767 to 32,767, corresponding to a 16-bit unit, and the minimum range for long is –2,147,483,647 to 2,147,483,647, corresponding to a 32-bit unit.

When do you use the various int types?

First, consider unsigned types. It is natural to use them for counting because you don't need negative numbers, and the unsigned types enable you to reach higher positive numbers than the signed types.

Use the long type if you need to use numbers that long can handle and that int cannot.

Similarly, use long long if you need 64-bit integer values.

Octal and hexadecimal constants are treated as type int unless the value is too large. Then the compiler tries unsigned int. If that doesn't work, it tries, in order, long, unsigned long, long long, and unsigned long long.

Integer OverflowThe unsigned integer j is acting like a car's odometer. When it reaches its maximum value, it starts over at the beginning. The integer i acts similarly. The main difference is that the unsigned int variable j, like an odometer, begins at 0, but the int variable i begins at –2147483648

Octal and Hexadecimal C assumes that integer constants are decimal,

or base 10, numbers. Octal (base 8) and hexadecimal (base 16)

numbers are popular with many programmers. Because 8 and 16 are powers of 2, and 10 is not, these number systems occasionally offer a more convenient way for expressing computer-related values.

Hexadecimal Decimal Binary

When dealing with a large number of bits, it is more convenient and less error-prone to write the binary numbers in hex or octal.

VS

Displaying Octal and Hexadecimal To display an integer in octal notation instead of decimal, use %o

instead of %d. To display an integer in hexadecimal, use %x. If you want to display the C prefixes, you can use specifiers %#o,

%#x, and %#X to generate the 0, 0x, and 0X prefixes, respectively

dec = 100; octal = 144; hex = 64

dec = 100; octal = 0144; hex = 0x64

Printing short, long, long long, and unsigned types

To print an unsigned int number, use the %u notation. To print a long value, use the %ld format specifier. %hd displays

a short integer in decimal form, and %ho displays a short integer in octal form.

Both the h and l prefixes can be used with u for unsigned types.

When the value 65537 is written in binary format as a 32-bit number, it looks like 00000000000000010000000000000001.

Note that using the %d specifier for the unsigned variable produces a negative number!

Printing short, long, long long, and unsigned types

The reason for this is that the unsigned value 3000000000 and the signed value –129496296 have exactly the same internal representation in memory on our system.

Using the %hd specifier persuaded printf() to look at just the last 16 bits; therefore, it displayed the value as 1

The scanf function Read data from the standard input device (usually keyboard) and

store it in a variable. General format:

scanf(“%d”, &variable); Ampersand (&) operator :

C address of operator it passes the address of the variable instead of the variable tells the scanf() where to find the variable to store the new value

variable

0x124 0x128 0x12C 0x130address:

&variable 0x1284 bytes

or other specifiers depending on the variable type

memory:

The scanf function

If you want the user to enter more than one value, you serialize the inputs.

You can serialize input

31

Common Conversion Identifiers

Common Conversion Identifier used in printf() and scanf() functions.

printf scanf

int %d %dfloat %f %fdouble %f %lfchar %c %cstring %s %s

Nonprinting Characters The single-quote technique is fine for characters,

digits, and punctuation marks. Some of the characters are nonprinting.

For example, some represent actions such as backspacing or going to the next line or making the terminal bell ring (or speaker beep)

There are two ways to define such variables.1. Use reserved sequences2. Use numeric codes form the character table (ASCII

codes)

Partial listing of ASCII code

Printing Characters

The showf_pt.c ProgramThe printf() function uses the %f format specifier to print type float and double numbers using decimal notation, and it uses %e to print them in exponential notation

To correctly print out dip use %LF and %LE

Then the output will be

Floating-Point Overflow and Underflow

Suppose the biggest possible float value on your system is about 3.4E38 and you do this

• This is an example of overflow—when a calculation leads to a number too large to be expressed.

• The behavior for this case used to be undefined, but now C specifies that toobig gets assigned a special value that stands for infinity and that printf() displays either inf or infinity (or some variation on that theme) for the value.

Floating-Point Round-off Errors

Take a number, add 1 to it, and subtract the original number. What do you get? You get 1.

A floating-point calculation, such as the following, may give another answer:

0.00000 older gcc on Linux-13584010575872.00000 Turbo C 1.54008175468544.000000 clang on Mac OS, MSVC++

Output Compiler

Type Sizes

The typesize.c program The sizeof operator gives the amount of storage, in bytes,

required to store an object of the type of the operand. This operator allows you to avoid specifying machine-

dependent data sizes in your programs.