Unit3 A

Chapter 6
Primitive Data
Types:
Numbers
Strings
Ordinal Types
Pointers
Definitions
• data type
– collection of data objects
– a set of predefined operations
• descriptor : collection of attributes for a
variable
• object : instance of a user-defined
(abstract data) type
Copyright © 2007 Addison-Wesley. All rights reserved.

1–2
Data Types
• Primitive
– not defined in terms of other data
types
– defined in the language
– often reflect the hardware
• Structured
– built out of other types

1–3
Integer Types
• Usually based on hardware
• May have several ranges
– Java’s signed integer sizes: byte,
short, int, long
– C/C++ have unsigned versions of the
same types
– Scripting languages often just have one
integer type
– Python has an integer type and a long
integer which can get as big as it needs
to.
1–4
Representing Integers
• Can convert positive integers to

base 2
• How do you handle negative
numbers with only 0s and 1s?
– Sign bit
– Ones complement
– Twos complement - this is the one that
is used

1–5
Representing negative
integers
• Sign bit
• Ones complement

1–6
Twos Complement
• To get the binary representation,
take the complement and add 1

1–7
Floating Point Types
• Model real numbers
– only an approximation due to round-
off error
• For scientific use support at least
two floating-point types (e.g.,
float and double; sometimes more
• Usually based on hardware
• IEEE Floating-Point Standard 754
– 32 and 64 bit standards
1–8
Representing Real Numbers
• We can convert the decimal number

to base 2 just as we did for integers
• How do we represent the decimal
point?
– fixed number of bits for the whole and
fractional parts severely limits the
range of values we can represent
• Use a representation similar to
scientific notation
1–9
IEEE Floating Point
Representation
• Normalize the number
– one bit before decimal point
• Use one bit to represent the sign (1 for negative)
• Use a fixed number of bits for the exponent
which is offset to allow for negative exponents
– Exponent = exponent + offset
• (-1)sign 1.Fraction x 2Exponent

1–10
Floating Point Types
• C, C++ and Java have two floating point

types
– float
– double
• Most scripting languages have one
floating point type
– Python's floating point type is equivalent to a
C double
• Some scripting languages only have one
kind of number which is a floating point
type
1–11
Fixed Point Types (Decimal)
• For business applications (money) round-
off errors are not acceptable
– Essential to COBOL
– .NET languages have a decimal data type
• Store a fixed number of decimal digits
• Operations generally have to be defined
in software
• Advantage: accuracy
• Disadvantages: limited range, wastes
memory
1–12
C# decimal Type
• 128-bit representation
• Range: 1.0x10-28 to 7.9x1028
• Precision: representation is exact to
28 or 29 decimal places (depending
on size of number)
– no roundoff error

1–13
Other Primitive Data Types:
• Boolean
– Range of values: two elements, one for “true”
and one for “false”
– Could be implemented as bits, but often as
bytes
• Character
– Stored as numeric codings
– Most commonly used coding: ASCII
– An alternative, 16-bit coding: Unicode
• Complex (Fortran, Scheme, Python)
• Rational (Scheme)
1–14
Character Strings
• Values are sequences of characters
• Operations:
– Assignment and copying
– Comparison (=, >, etc.)
– Catenation
– Substring reference
– Pattern matching
• Design issues:
– Is it a primitive type or just a special kind
of array?
1–15
Character String Implementations
• C and C++
– Not primitive
– Use char arrays and a library of functions
that provide operations
• SNOBOL4 (a string manipulation
language)
– Primitive
– Many operations, including elaborate pattern
matching
• Java
– String class

1–16
String Length Options
• Static: COBOL, Java’s String class

• Limited Dynamic Length: C and C++
– a special character is used to indicate
the end of a string’s characters
• Dynamic (no maximum): SNOBOL4,
Perl, JavaScript
• Ada supports all three string length
options
1–17
String Implementation
• Static length: compile-time
descriptor
• Limited dynamic length:
may need run-time
descriptor
• not in C and C++
• Dynamic length: needs
run-time descriptor;
– allocation/deallocation is
main implementation issue
1–18
User-Defined Ordinal Types
• ordinal type : range of possible
values corresponds to set of positive
integers
• Primitive ordinal types
– integer
– char
– boolean
• User-defined ordinal types
– enumeration types
– subrange types
1–19
Enumeration Types
• All possible values, which are
named constants, are provided in
the definition
• C example
enum days {mon, tue, wed, thu, fri,
sat, sun};
• Design issues
– duplication of names
– coercion rules
1–20
enums in C (and C++)
• To define an enumerated type in C
enum weekday {Sunday, Monday, Tuesday,
Wednesday, Thursday, Friday, Saturday};
enum weekday today = Tuesday;
• Use typedef to give the type a name
typedef enum weekday {Sunday, Monday,
Tuesday, Wednesday, Thursday, Friday,
Saturday} weekday;
weekday today = Tuesday;
• By default, values are consecutive starting
from 0.
– You can explicitly assign values
Enum months {January=1, February, …};
1–21
Enumerations in Java 1.5
• An enum is a new class which

extends java.lang.Enum and
implements Comparable
– Get type safety and compile-time
checking
– Implicitly public, static and final
– Can use either == or equals to
compare
– toString and valueOf are overridden to
make input and output easier
1–22
Java enum Example
• Defining an enum type
enum Season {WINTER, SPRING, SUMMER, FALL};
• Declaring an enum variable

Season season = Season.WINTER;
• toString gives you the string representation
of the name
System.out.println( season);
// prints WINTER
• valueOf lets you convert a String to an
enum
Season = valueOf(“SPRING”);
1–23
Subrange Types
• A contiguous subsequence of an
ordinal type
– Example: 12..18 is a subrange of integer
type
• Ada’s design
type Days is (mon, tue, wed, thu, fri,
sat, sun);
subtype Weekdays is Days range mon..fri;
subtype Index is Integer range 1..100;
Day1: Days;
Day2: Weekday;
1–24
Implementation of User-Defined
Ordinal Types
• Enumeration types are implemented
as integers
• Subrange types are implemented
like the parent types
– code inserted (by the compiler) to
restrict assignments to subrange
variables

1–25
Pointer and Reference Types
• A pointer is a variable whose value is an
address
– range of values that consists of memory
addresses plus a special value, nil
• Provide the power of indirect addressing
• Provide a way to manage dynamic
memory
• A pointer can be used to access a
location in the area where storage is
dynamically created (usually called a
heap)
• Generally represented as a single number
1–26
Pointer Operations
• Two fundamental operations:
assignment and dereferencing
• Assignment is used to set a pointer
variable’s value to some useful
address
• Dereferencing yields the value
stored at the location represented
by the pointer’s value
– Dereferencing can be explicit or
implicit
– C++ uses an explicit operation via *
j = *ptr
1–27
Pointer Operations
assignment
Illustrated
Dereferencing a pointer
ptr = &j j = *ptr
allocation
ptr = (int*)malloc(
sizeof( int))

1–28
Pointer
Problems
• Dangling
pointers
(dangerous)
– A pointer points
to a heap-
dynamic variable
that has been
de-allocated
• Garbage
– An allocated
heap-dynamic
variable that is
1–29
Pointers in C and C++
• Extremely flexible but must be used with
care
• Pointers can point at any variable
regardless of when it was allocated
• Used for dynamic storage management
and addressing
• Pointer arithmetic is possible
• Explicit dereferencing and address-of
operators
• Domain type need not be fixed (void *)
• void * can point to any type and can be
type checked (cannot be de-referenced)
1–30
Pointer Arithmetic in C and
C++
float stuff[100];
float *p;
p = stuff;
*(p+5) is equivalent to stuff[5]

and p[5]
*(p+i) is equivalent to stuff[i]
and p[i]
1–31
Reference Types
• C++ includes a special kind of pointer
type called a reference type that is used
primarily for formal parameters
– Advantages of both pass-by-reference and
pass-by-value
• Java extends C++’s reference variables
and allows them to replace pointers
entirely
– References refer to call instances
• C# includes both the references of Java
and the pointers of C++
1–32
Evaluation of Pointers
• Dangling pointers and dangling

objects are problems as is heap
management
• Pointers are like goto's--they widen
the range of cells that can be
accessed by a variable
• Pointers or references are necessary
for dynamic data structures--so we
can't design a language without
1–33

Unit3 A

Uploaded by

Copyright:

Available Formats

Unit3 A

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Unit3 A

Uploaded by

Copyright:

Available Formats

Chapter 6

Copyright © 2007 Addison-Wesley. All rights reserved.

Copyright © 2007 Addison-Wesley. All rights reserved.

• Can convert positive integers to

Copyright © 2007 Addison-Wesley. All rights reserved.

Copyright © 2007 Addison-Wesley. All rights reserved.

Copyright © 2007 Addison-Wesley. All rights reserved.

• We can convert the decimal number

Copyright © 2007 Addison-Wesley. All rights reserved.

• C, C++ and Java have two floating point

Copyright © 2007 Addison-Wesley. All rights reserved.

Copyright © 2007 Addison-Wesley. All rights reserved.

• Static: COBOL, Java’s String class

• An enum is a new class which

• Declaring an enum variable

Copyright © 2007 Addison-Wesley. All rights reserved.

Copyright © 2007 Addison-Wesley. All rights reserved.

*(p+5) is equivalent to stuff[5]

• Dangling pointers and dangling

You might also like