Chapter 6 Data Types.

Chapter 6 Data Types

Chapter 6 Topics Introduction Primitive Data Types
Character String Types User-Defined Ordinal Types Array Types Associative Arrays Record Types Union Types Pointer and Reference Types

Data Type A data type defines a collection of data values and
a set of predefined operations on those values.

Data Types and Implementation Easiness of a Programming Language
Computer programs produce results by manipulating data. An important factor in determining the ease with which programs can perform this task is how well the data types available in the language being used match the objects in the real-world problem space. e.g.: If a language provides an employee type, it can facilitate a programmer to write employee management-related program. It is therefore crucial that a language support an appropriate collection of data types and structures.

Data Type Evolution The contemporary concepts of data types have evolved over the last 50 years. In the earliest languages, all problem space data structures had to be modeled with only a few basic language-supported data structures. For example, in pre-90 Fortrans, linked lists and binary trees are commonly modeled with arrays.

Evolution of Data Type Design
One of the most important advances in the evolution of data type design is introduced in ALGOL 68 is to provide a few basic types and a few flexible structure-defining operators that allow a programmer to design a data structure for each need. means a structured type

Advantages of User-defined Types – (1)
User-defined types provide improved readability through the use of meaningful names for types. User-defined types also aid modifiability: A programmer can change the type of a category of variables in a program by changing only a type declaration statement.

Advantages of User-defined Types – (2)
They allow type checking of the variables of a special category of use, which would otherwise not be possible. For example, zoo is a user-defined type: We can check whether two variables are of the same zoo data type.

Abstract Data Type Taking the concept of a user-defined type a step farther, we arrive at abstract data types. The fundamental idea of an abstract data type is that the interface of a type, which is visible to the user, is separated from the representation of values of that type and the implementation of set of operations on values of that type, which are hidden from the user. All of the types provided by a high-level programming language are abstract data types.

Scalar Types In computing, a scalar variable is one that can hold only one value at a time; as opposed to sturctured variables like array, list, hash, record, etc. A scalar data type is the type of a scalar variable. For example, char, int, float, and double are the most common scalar data types in the C programming language.

Structured Data Types The two most common structured (nonscalar) data types are arrays and records.

Type Operators A few data types are specified by type operators, or constructors, which are used to form type expressions. For example, C uses brackets and asterisks as type operators to specify arrays and pointers.

Variables and Descriptors
It is convenient, both logically and concretely, to think of variables in terms of descriptors. A descriptor is the collection of the attributes of a variable.

Implementation of Descriptors
In an implementation, a descriptor is an area of memory that stores the attributes of a variable.

Implementation of Descriptors with Only Static Attributes
If the attributes are all static, descriptors are required only at compile times. These descriptors are built by the compiler, usually as a part of the symbol table and are used during compilation.

Implementation of Descriptors with Dynamic Attributes
For dynamic attributes, however, part or all of the descriptor must be maintained during execution. In this case, the descriptor is used by the run-time system. In all cases, descriptors are used for type checking and to build the code for the allocation and deallocation operations.

Object The word object is often associated with
the value of a variable and the space it occupies. In this book, the author reserves object exclusively for instances of user-defined abstract data types.

Primitive Data Types Data types that are not defined in terms of other types are called primitive data types. Nearly all programming languages provide a set of primitive data types. Some of the primitive types are merely reflections of the hardware. For example, most integer types. Others require only a little non-hardware support for their implementation.

Primitive Data Types and Structured Types
The primitive data types of a language are used, along with one or more type constructors, to provide the structured types.

Numeric Type Many early programming languages had only numeric primitive types. Numeric types still play a central role among the collections of types supported by contemporary languages. Integer Floating-Point Decimal Boolean Types Character Types Complex

Integer The most common primitive numeric data type is integer.
Many computers now support several sizes of integers. These sizes of integers, and often a few others, are supported by some programming languages. For example, Java includes four signed integer size: byte, short, int, and long.

Integer Types and Hardware
A signed integer value is represented in a computer by a string of bits, with one of the bits (typically the leftmost) representing the sign. Most integer types are supported directly by the hardware.

Representation of negative numbers in C [stackoverflow]
ISO C (C99), section /2, states that an implementation must choose one of three different representations for integral data types, two's complement, one's complement or sign/magnitude It's incredibly likely that the two's complement implementations far outweigh the others.

Integer Representation [stackoverflow]
In all those representations, positive numbers are identical. To get the negative representation for a positive number, you: invert all bits for one's complement. invert all bits then add one for two's complement. invert just the sign bit for sign/magnitude.

8 bit one's complement [wikipedia]

8 bit two's complement [wikipedia]

Floating-point Floating-point data types model real numbers, but the representations are only approximations for most real values. For example, neither of the fundamental numbers π or ℯ (the base for the natural logarithms) can be correctly represented in floating-point notation. Of course, neither of these numbers can be accurately represented in any finite space.

Problems of Floating-Point Numbers –(1)
On most computers, floating-point numbers are stored in binary; hence, they can not accurately represent most real numbers. For example: in decimal : 0.1 in binary: … 2-1 2-2 2-3 2-4

Problems of Floating-Point Numbers –(2)
The loss of accuracy through arithmetic operations. For more information on the problems of floating-point notation, see any book on numerical analysis. (a/b)×c , a is a small number, b and c are large number ≡ (a/b)×c (may loss accuracy) ≡ a×(c/b)

Example #include<stdio.h> #define A 0.00000000001
#define B #define C main() { float a,b,c,temp1,temp2; a=A; b=B; c=C; temp1=a/b; temp2=c/b; printf("(1)%.20f(%E) (2)%.20f(%E)\n", (a/b)*c, (a/b)*c, a*(c/b), a*(c/b)); printf("(3)%.20f(%E) (4)%.20f(%E)\n", temp1*c, temp1*c, a*temp2, a*temp2); } ./a.out (1) ( E-12) (2) ( E-12) (3) ( E+00) (4) ( E-12)

Internal Representation of Floating-Point Values
Most newer machines use the IEEE Floating-Point Standard 754 format to represent float-point numbers. Under the above format, floating-point values are represented as fractions (mantissa or significand) and exponents. Language implementers use whatever representation that is supported by the hardware.

IEEE Floating-point Formats
single precision double precision

Real Value of Single-precision Floating-Point Format [wikipedia]
The real value = (-1)sign(1.b22b21…b0)2 x 2e-127

Floating-point Type Most languages include two floating-point types, often called float and double. The float type is the standard size, usually being stored in four bytes of memory. The double type is provided for situations where larger fractional parts are needed. Double-precision variables usually occupy twice as much storage as float variables and provide at least twice the number of bits of fraction.

Precision and Range The collection of values that can be represented by a floating-point type is defined in terms of precision and range. Precision is the accuracy of the fractional part of a value, measured as the number of bits. Range is a combination of the range of fractions, and, more importantly, the range of exponents.

Decimal Most larger computers that are designed to support business systems applications have hardware support for decimal data types. Decimal data types store a fixed number of decimal digits, with the decimal point at a fixed position in the value.

Internal Representation of a Decimal Value
Decimal types are stored very much like character strings, using binary codes for the decimal digits. These representations are called binary coded decimal (BCD). In some cases, they are stored one digit per byte, but in others they are packed two digits per byte. Either way, they take more storage than binary representations. The operations on decimal values are done in hardware on machines that have such capabilities; otherwise, they are simulated in software.

BCD Example[wikipedia]
To BCD-encode a decimal number using the common encoding, each decimal digit is stored in a four-bit nibble. Thus, the BCD encoding for the number 127 would be:

Boolean Types Their range of values has only two elements, one for true and one for false. They were introduced in ALGOL 60 and have been included in most general-purpose languages designed since 1960. One popular exception is C, in which numeric expressions can be used as conditionals. In such expressions, all operands with nonzero values are considered true, and zero is considered false.

Internal Representation of a Boolean Type Value
A Boolean value could be represented by a single bit. But because a single bit of memory is difficult to access efficiently on many machines, they are often stored in the smallest efficiently addressable cell of memory, typically a byte.

Character Types Character data are stored in computers as numeric coding. The most commonly used coding is ASCII (American Standard Code for Information Interchange), which uses the values 0 to 127 to code 128 different characters. Many programming languages include a primitive type for character data.

More about ASCII Code[wikipedia]
ASCII is, strictly, a 7-bit code, meaning it uses the bit patterns representable with seven binary digits (a range of 0 to 127 decimal) to represent character information. At the time ASCII was introduced, many computers dealt with 8-bit groups (bytes or, more specifically, octets) as the smallest unit of information; the eighth bit was commonly used as a parity bit for error checking on communication lines or other device-specific functions. Machines which did not use parity typically set the eighth bit to zero, though some systems such as Prime machines running PRIMOS set the eighth bit of ASCII characters to one.

Unicode Because of the globalization of business and
the need for computers to communicate with other computers around the world, the ASCII character set is rapidly becoming inadequate. A 16-bit character set named Unicode has been developed as an alternative. Unicode includes the characters from most of the world's natural languages. For example, Unicode includes the Cyrillic alphabet, as used in Serbia, and the Thai digits.

Character String Type A character string type is one in which the values consist of sequences of characters. Character strings also are an essential type for all programs that do character manipulation.

Design Issues The two most important design issues that are specific to character string types are the following: Should strings be simply a special kind of character array or a primitive type (with no array-style subscripting operations)? Should strings have static or dynamic length?

String Operations The common string operations are: Assignment
Catenation Substring reference Comparison Pattern matching.

Internal Representation of a String Type Value in C and C++
If strings are not defined as a primitive type, string data is usually stored in arrays of single characters and referenced as such in the language. This is the approach taken by C and C++.

String Operations in C and C++
C and C++ use char arrays to store character strings. C and C++ provide a collection of string operations through a standard library whose header file is string.h. Most uses of strings and most of the library functions use the convention that character strings are terminated with a special character, null, which is represented with zero. This is an alternative to maintain the length of string variables. The library operations simply carry out their operations until the null character appears in the string being operated on.

Character String Literals in C
The character string literals that are built by the compiler have the null character. For example, consider the following declaration: char *str = "apples"; In this example, str is a char pointer set to point at the string of characters, apples0, where 0 is the null character. This initialization of str is legal because character string literals are represented by char pointers, rather than the string itself.

String Types in Java (1) In Java, strings are supported as a primitive type by the String class, whose values are constant strings. The String class represents character strings. All string literals in Java programs, such as "abc", are implemented as instances of this class. Strings are constant; their values cannot be changed after they are created[oracle].

What is String in Java [JavaTpoint]
Generally, string is a sequence of characters. But in java, string is an object that represents a sequence of characters. String class is used to create string object.

How to create String object?[JavaTpoint]
There are two ways to create String object: By string literal By new keyword

By String Literal[JavaTpoint]
Java String literal is created by using double quotes. For Example: String s= "welcome"; String c = ""; //an empty string

A String Literal Is an String Object
public class app_string { public static void main(String args[]) { int num_a, num_b; String str, str_a, str_b; str="HELLO"; num_a="HELLO".length(); num_b=str.length(); System.out.println("num_a="+num_a+" num_b="+num_b); str_a="HELLO".toLowerCase(); str_b=str.toLowerCase(); System.out.println("str_a="+str_a+" str_b="+str_b); } C:\Users\Fu-Hau H\JAVA_EX> javac .\app_string.java C:\Users\Fu-Hau H\JAVA_EX> java app_string num_a=5 num_b=5 str_a=hello str_b=hello

Memory to Store String Literal[JavaTpoint]
Each time you create a string literal, the JVM checks the string constant pool first. If the string already exists in the pool, a reference to the pooled instance is returned. If string doesn't exist in the pool, a new string instance is created and placed in the pool.

String Constant Pool String s1="Welcome";
String s2="Welcome";//will not create new instance

By new Keyword[JavaTpoint]
String s=new String("Welcome");//creates two objects and one reference variable In such case, JVM will create a new string object in normal (non pool) heap memory and the literal "Welcome" will be placed in the string constant pool. The variable s will refer to the object in heap (non pool). String c = new String(); //an empty string

Where is a string object stored [programcreek]
String a = "abcd"; String b = "abcd"; String c = new String("abcd"); String d = new String("abcd");

Diagram to show Java String’s Immutability (1) [programcreek]
1. Declare a string String s = "abcd"; s stores the reference of the string object. The arrow below should be interpreted as "store reference of".

2. Assign one string variable to another string variable String s2 = s; s2 stores the same reference value, since it is the same string object.

3. Concat string s = s.concat("ef"); s now stores the reference of newly created string object.

Java String Class Methods [javaTpoint]
The java.lang.String class provides many useful methods to perform operations on sequence of char values.

String Types in Java (2) The StringBuffer class, whose values are changeable and are more like arrays of single characters. Subscripting is allowed on StringBuffer variables.

String Types in Fortran 95
treats strings as a primitive type provide assignment, relational operators, catenation, and substring reference operations for them. A substring reference is a reference to a substring of a given string.

Pattern Matching Pattern matching is another fundamental character string operation. In some languages, pattern matching is supported directly in the language. Perl, JavaScript, and PHP include built-in pattern matching operations. In others, it is provided by a function or class library. Pattern-matching capabilities are included in the class libraries of C++, Java, and C#.

String Length Options There are several design choices regarding the length of string values. static length strings limited dynamic length strings dynamic length strings

Static Length Strings A string is called a static length string if the length of it can be static and can be set when the string is created. This is the choice for the immutable objects of Java’s String class similar classes in the C++ standard class library similar classes in the .NET class library available to C#

Example – the Java String Class [wikepedia]
String s = "ABC"; s.toLowerCase(); The method toLowerCase() will not change the data "ABC" that s contains. Instead, a new String object is instantiated and given the data "abc" during its construction. A reference to this String object is returned by the toLowerCase() method. To make the String s contain the data "abc“, a different approach is needed. s = s.toLowerCase(); Now the String s references a new String object that contains "abc“. The String class's methods never affect the data that a String object contains

Limited Dynamic Length Strings
The second option is to allow strings to have varying length up to a declared and fixed maximum set by the variable's definition. These are called limited dynamic length strings. Such string variables can store any number of characters between zero and the maximum. Recall that strings in C and C++ use a special character to indicate the end of the string's characters, rather than maintaining the string length. This string-handling approach may result in buffer overflow vulnerabilities.

Dynamic Length Strings
The third option is to allow strings to have varying length with NO maximum, as in JavaScript, and Perl. These are called dynamic length strings. This option requires the overhead of dynamic storage allocation and deallocation but provides maximum flexibility.

Evaluation – (1) String types are important to the writability of a language. Dealing with strings as arrays can be more cumbersome than dealing with a primitive string type. The addition of strings as a primitive type to a language is NOT costly in terms of either language or compiler complexity. Therefore, it is difficult to justify the omission of primitive string types in some contemporary languages. Of course, providing strings through a standard library is nearly as convenient as having them as a primitive type.

Evaluation – (2) String operations such as simple pattern matching and catenation are essential and should be included for string type values. Although dynamic length strings are obviously the most flexible, the overhead of their implementation must be weighed against that additional flexibility. Dynamic length strings are often included only in languages that are interpreted.

Array Types An array is a homogeneous aggregate of data elements in which an individual element is identified by its position in the aggregate, relative to the first element. The individual data elements of an array are of some previously defined type either primitive or otherwise.

Why Array Types Are Needed?
A majority of computer programs need to model collections of values in which the values are of the same type and must be processed in the same way. Thus, the universal need for arrays is obvious.

Arrays and Indexes Specific elements of an array are referenced by means of a two-level syntactic mechanism: the first part is the aggregate name the second part is a selector consisting of one or more items known as subscripts or indexes. If all of the indexes in a reference are constants, the selector is static; otherwise, it is dynamic.

The Selection Operation
The selection operation can be thought of as a mapping from the array name and the set of subscript values to an element in the aggregate. Indeed, arrays are sometimes called finite mappings. Symbolically, this mapping can be shown as array_name(subscript_value_list) → element

The Syntax of Array References
The syntax of array references is fairly universal: The array name is followed by the list of subscripts, which is surrounded by either parentheses or brackets.

Ordinal Type An ordinal type is one in which the range of possible values can be easily associated with the set of positive integers. For example, In Java, the primitive ordinal types are integer char and Boolean

User-Defined Ordinal Types
There are two user-defined ordinal types that have been supported by programming languages: enumeration and subrange

The Element Type and the Type of the Subscripts of an Array Type
Two distinct types are involved in an array type: the element type the type of the subscripts. The type of the subscripts is often a subrange of integers. But Ada allows any ordinal type to be used as subscripts, such as Boolean character and enumeration.

Example type Week_Day_type is (Monday, Tuesday, Wednesday,
Thursday, Friday); type Sales is array (Week_Day_Type) of Float;

Type of Ada for Loop Counter
An Ada for loop can use any ordinal type variable for its counter. This allows arrays with ordinal type subscripts to be conveniently processed.

Ada Example [Radford] type Day is (Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday); type HoursArray is array(Monday .. Saturday) of Float; hoursWorked: HoursArray for d in Monday .. Friday loop totalHours := totalHours + hoursWorked(d); end loop totalHours := totalHours * (hoursWorked(Saturday));

Subscript Range Check Early programming languages did NOT specify that subscript ranges must be implicitly checked. Range errors in subscripts are common in programs, so requiring range checking is an important factor in the reliability of languages. Among contemporary languages C, C++, and Fortran do not specify range checking of subscripts but Java, ML, and C# do

C Example #include<stdio.h> #define SIZE 200 main() { int i;
char a[SIZE], b[SIZE], c[SIZE]; for(i=0; i<SIZE; i++) { a[i]='x'; b[i]='y'; c[i]='z'; } printf("b[%d]=%c b[%d]=%c\n",320,b[320],-100, b[-100]); ./a.out b[320]=x b[-100]=z

Java Example (1) public class array_index
{ public static void main(String args[]) { int a[]=new int[10]; int i; for(i=0;i<10;i++) System.out.println("a["+i+"]="+a[i]); } PS C:\Users\Fu-Hau H\JAVA_EX\Array_Index> javac .\array_index.java PS C:\Users\Fu-Hau H\JAVA_EX\Array_Index> java array_index a[0]=0 a[1]=0 a[2]=0 a[3]=0 a[4]=0 a[5]=0 a[6]=0 a[7]=0 a[8]=0 a[9]=0

Java Example (2) public class array_index { public static void main(String args[]) int a[]=new int[10]; int i; for(i=1;i<=10;i++) System.out.println("a["+i+"]="+a[i]); } PS C:\Users\Fu-Hau H\JAVA_EX\Array_Index> javac .\array_index.java PS C:\Users\Fu-Hau H\JAVA_EX\Array_Index> java array_index a[1]=0 : a[9]=0 Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10 at array_index.main(array_index.java:9)

The Implicit Low Bound of a Subscript Range
In some languages, the lower bound of the subscript range is implicit. For example, In the C-based languages, the lower bound of all index ranges is fixed at 0. In Fortran 95, it defaults to 1. In most other languages, subscript ranges must be completely specified by the programmer.

Array Categories There are five categories of arrays. static arrays
fixed stack-dynamic arrays stack-dynamic arrays fixed heap-dynamic arrays heap-dynamic arrays

Criteria to Classify Array Categories
The category definitions are based on the binding to subscript ranges the binding to storage and from where the storage is allocated. The category names indicate the design choices of these three.

Duration of the Subscript Ranges and Array Storage
In the first four of the 5 array categories, once the subscript range are bound and the storage is allocated, they remain fixed for the lifetime of the variable. When the subscript ranges are fixed, the array cannot change size.

Static Arrays A static array is one in which
the subscript ranges are statically bound storage allocation is static (done before run time).

Advantages of Static Arrays
The advantage of static arrays is efficiency: No dynamic allocation or deallocation is required.

Example Arrays declared in C and C++ functions that include the static modifier are examples of static arrays.

Fixed Stack-dynamic Arrays
A fixed stack-dynamic array is one in which the subscript ranges are statically bound but the allocation is done at declaration elaboration time during execution.

Advantages of Fixed Stack-dynamic Arrays
The advantage of fixed stack-dynamic arrays over static arrays is space efficiency. A large array in one procedure can use the same space as a large array in a different procedure, as long as both procedures are not active at the same time.

Example Arrays that are declared in C and C++ functions (without the static specifier) are examples of fixed stack-dynamic arrays.

Stack-dynamic Arrays A stack-dynamic array is one in which
the subscript ranges are dynamically bound at elaboration time the storage allocation is dynamically bound at elaboration time. Once the subscript ranges are bound and the storage is allocated, however, they remain fixed during the lifetime of the variable.

Advantages of Stack-dynamic Arrays
The advantage of stack-dynamic arrays over static and fixed stack-dynamic arrays is flexibility. The size of an array need not be known until the array is about to be used.

Example Ada arrays can be stack-dynamic, as in the following;
Get(List_Len); declare List : array (1.. List_Len) of Integer; begin . . . end; In this example, the user inputs the number of desired elements in the array List, which are then dynamically allocated when execution reaches the declare block. When execution reaches the end of the block, the List array is deallocated.

Fixed Heap-Dynamic Arrays
A fixed heap-dynamic array is similar to a fixed stack-dynamic array, in that the subscript ranges and the storage binding are both fixed after storage is allocated.

The storage is allocated from the heap, rather than the stack
The Differences between a Fixed Stack-Dynamic Array and a Fixed Heap-Dynamic Array Both the subscript ranges and storage bindings are done when the user program requests them during execution, rather than at elaboration time. The storage is allocated from the heap, rather than the stack

Example C and C++ also provide fixed heap-dynamic arrays.
The standard library functions malloc and free, which are general heap allocation and deallocation operations, respectively, can be used for C arrays. C++ uses the operators new and delete to manage heap storage. An array is treated as a pointer to a collection of storage cells, where the pointer can be indexed, e.g. *(p+i) where p is a pointer and i is an integer.

Array vs. Pointer [1][2][3]
#include<stdio.h> main() { char *p, arr[100]; int i; for(i=0;i<100;i++) arr[i]='a'+ (i%26); printf("arr[77]=%c *(arr+77)=%c\n", arr[77],*(arr+77)); p=arr; printf("p[77]=%c *(p+77)=%c\n", p[77],*(p+77)); printf("arr=%x &arr=%x p=%x &p=%x\n",arr,&arr,p,&p); } ./a.out arr[77]=z *(arr+77)=z p[77]=z *(p+77)=z arr=bfbfe9f0 &arr=bfbfe9f0 p=bfbfe9f0 &p=bfbfea6c

Types of Array Names /* check_type.c */ #include <stdio.h> void main() { int a[10]; int b[10][10]; printf("a = %x\n", a); printf("&a = %x\n", &a); printf("b = %x\n", b); printf("&b = %x\n", &b); printf("b[0] = %x\n", b[0]); printf("&b[0] = %x\n", &b[0]); }

Compiler Message: gcc check_type.c (1)
~/E/P/C/ARRAY> gcc check_type.c check_type.c: In function ‘main’: check_type.c:7:10: warning: format ‘%x’ expects argument of type ‘unsigned int’, but argument 2 has type ‘int *’ [-Wformat=] printf("a = %x\n", a); ^ check_type.c:8:10: warning: format ‘%x’ expects argument of type ‘unsigned int’, but argument 2 has type ‘int (*)[10]’ [-Wformat=] printf("&a = %x\n", &a); check_type.c:9:10: warning: format ‘%x’ expects argument of type ‘unsigned int’, but argument 2 has type ‘int (*)[10]’ [-Wformat=] printf("b = %x\n", b);

Compiler Message: gcc check_type.c (2)
check_type.c:10:10: warning: format ‘%x’ expects argument of type ‘unsigned int’, but argument 2 has type ‘int (*)[10][10]’ [-Wformat=] printf("&b = %x\n", &b); ^ check_type.c:11:10: warning: format ‘%x’ expects argument of type ‘unsigned int’, but argument 2 has type ‘int *’ [-Wformat=] printf("b[0] = %x\n", b[0]); check_type.c:12:10: warning: format ‘%x’ expects argument of type ‘unsigned int’, but argument 2 has type ‘int (*)[10]’ [-Wformat=] printf("&b[0] = %x\n", &b[0]);

Types of Array Names a --> int * &a --> int (*)[10] ================================= b --> int (*)[10] &b --> int (*)[10][10] b[0] --> int * &b[0] --> int (*)[10]

Example #include<stdio.h> #define SIZE 200 main() { int i;
int *p; p=(int *)malloc(SIZE); for(i=0;i<SIZE/sizeof(int);i++) *(p+i)=i; printf("p[%d]=%d ",i,p[i]); printf("\n"); } ./a.out p[0]=0 p[1]=1 p[2]=2 p[3]=3 p[4]=4 p[5]=5 p[6]=6 p[7]=7 p[8]=8 p[9]=9 p[10]=10 p[11]=11 p[12]=12 p[13]=13 p[14]=14 p[15]=15 p[16]=16 p[17]=17 p[18]=18 p[19]=19 p[20]=20 p[21]=21 p[22]=22 p[23]=23 p[24]=24 p[25]=25 p[26]=26 p[27]=27 p[28]=28 p[29]=29 p[30]=30 p[31]=31 p[32]=32 p[33]=33 p[34]=34 p[35]=35 p[36]=36 p[37]=37 p[38]=38 p[39]=39 p[40]=40 p[41]=41 p[42]=42 p[43]=43 p[44]=44 p[45]=45 p[46]=46 p[47]=47 p[48]=48 p[49]=49

An Array Name Is A Constant
#include<stdio.h> main() { char *p, arr[100],arrB[100]; arrB=arr; } gcc ./b.c ./b.c: In function `main': ./b.c:7: error: incompatible types in assignment

Java Array[Tutorials Point]

Java Array Java provides a data structure, the array, which stores a fixed-size sequential collection of elements of the same type.

Declaring A Variable to Reference An Array
To use an array in a program, you must declare a variable to reference the array, and you must specify the type of array the variable can reference. Here is the syntax for declaring an array variable: dataType[] arrayRefVar; // preferred way. or dataType arrayRefVar[]; // works but not preferred way.

Creating Arrays [1] You can create an array by using the new operator with the following syntax: arrayRefVar = new dataType[arraySize]; The above statement does two things: It creates an array using new dataType[arraySize]; It assigns the reference of the newly created array to the variable arrayRefVar.

Creating Arrays [2] Declaring an array reference variable, creating an array, and assigning the reference of the array to the variable can be combined in one statement, as shown below: dataType[] arrayRefVar = new dataType[arraySize]; Alternatively you can create arrays as follows: dataType[] arrayRefVar = {value0, value1, ..., valuek};

Access Array Elements The array elements are accessed through the index. Array indices are 0-based; that is, they start from 0 to arrayRefVar.length-1.

Explanation double[] myList = new double[10];

Multidimensional Java Arrays [Genevieve B. Orr][David J. Eck] [im.ncnu.edu.tw]

2-D Java Arrays[ Genevieve B. Orr]
Internally, Java stores 2 dimensional arrays as an array of arrays. int [][] nums = new int[5][4];

Equivalent Code The above is really equivalent to a 3-step process:
// create the single reference nums (yellow square) int [][] nums; // create the array of references (blue squares) nums = new int[5][]; // this create the second level of arrays (red squares) for (int i=0; i < 5 ; i++) nums[i] = new int[4]; // create arrays of integers

Program Example public class examine_array { public static void main(String args[]) { int i, j; int sale[][]=new int[10][10]; int purchase[][]=new int[20][10]; for(i=0;i<sale.length;i++) for(j=0;j<sale[i].length;j++) sale[i][j]=i+j; for(i=0;i<purchase.length;i++) for(j=0;j<purchase[i].length;j++) purchase[i][j]=i+j+200; System.out.print(sale[i][j]+" "); System.out.print("\n===============================================================\n"); sale[6]=purchase[6]; }

Execution Results

Square [][] board = new Square[2][3];
Array of Objects A 2D array of objects is an array of an array of references to objects. Square [][] board = new Square[2][3];

Heap-dynamic Arrays A heap-dynamic array is one in which
the binding of subscript ranges and storage allocation is dynamic and can change any number of times during the array's lifetime. The advantage of heap-dynamic arrays over the others is flexibility: Arrays can grow and shrink during program execution as the need for space changes.

Example – (1) Perl and JavaScript support heap-dynamic arrays.
A Perl array can be made to grow by using the push (puts one or more new elements on the end of the array) and unshift (puts one or more new elements on the beginning of the array) or by assigning a value to the array specifying a subscript beyond the highest current subscript of the array. A Perl array can be made to shrink to no elements by assigning it the empty list, ().

Example – (2) In Perl we could create an array of five numbers with
@list = (1, 2, 4, 7, 10); Later, the array could be lengthened with the push function, as in 13, 17) Now the arrary’s value is (1, 2, 4, 7, 10, 13, 17); Still could be emptied with @list = ()

Java class ArrayList<E> [CHAITANYA SINGH]

Definition ArrayList<int> intList = new ArrayList<int>(); //ArrayList to Store only String objects ArrayList<String> stringList = new ArrayList<String>();

Putting an Item into ArrayList [Javin Paul]
stringList.add("Item");

Removing an Item from ArrayList [Javin Paul]
There are two ways to remove any elements from ArrayList in Java. You can either remove an element based on its index or by providing object itself. remove(int index) and remove(Object o) method is used to remove any element from ArrayList in Java.

Checking Size of ArrayList [Javin Paul]
Size of an ArrayList in Java is total number of elements currently stored in ArrayList. int size = stringList.size();

Checking Index of an Item in ArrayList [Javin Paul]
You can use indexOf() method of ArrayList in Java to find out index of a particular object. int index = stringList.indexOf("Item");

Retrieving Item from ArrayList in a Loop [Javin Paul]
for (int i = 0; i < stringList.size(); i++) { String item = stringList.get(i); System.out.println("Item " + i + " : " + item); }

Replacing an Element at A Particular Index [Javin Paul]
You can use set(int index, E element) method of Java ArrayList to replace any element from a particular index. Below code will replace first element of stringList from "Item" to "Item2". stringList.set(0,"Item2");

Index of an Element will Be Changed
import java.util.*; public class array_list { public static void main(String args[]) { String item; int j; ArrayList<String> stringList = new ArrayList<String>(); stringList.add("Item"); stringList.add("Item1"); stringList.add("Item2"); stringList.add("Item3"); stringList.add("Item4"); stringList.add("Item5"); stringList.add("Item6"); stringList.add("Item7"); for(int i=0; i< stringList.size(); i++) { item= stringList.get(i); j=stringList.indexOf(item); System.out.println("Item " + i + "(" + j + ")" + ":" + item); } System.out.println("====================================================="); stringList.remove(3);

Result

Heterogeneous Arrays A heterogeneous array is one in which the elements need not be of the same type. Such arrays are supported by Perl, Python, JavaSript, and Ruby. In all of these languages, arrays are heap dynamic.

Array Operations An array operation is one that operates on an array as a unit.

The Most Common Array Operations
assignment catenation comparison for equality and inequality and slices.

Ada Array Operations Ada allows array assignments, including those where the right side is an aggregate value rather than an array name. Ada also provides catenation, specified by the ampersand (&). Catenation is defined between two single-dimensioned arrays and between a single-dimensioned array and a scalar.

Rectangular Arrays A rectangular array is a multidimensioned array in which all of the rows have the same number of elements, all of the columns have the same number of elements, and so forth. Rectangular arrays accurately model tables.

Jagged Arrays A jagged array is one in which the lengths of the rows need not be the same. For example, a jagged matrix may consist of 3 rows, one with 5 elements, one with 7 elements, and one with 12 elements. This also applies to the columns or higher dimensions. So, if there is a third dimension (layers), each layer can have a different number of elements.

Java Jagged Array Example
public class JaggedArray { public static void main(String[] argv) { int[][] arr; arr = new int[10][]; for(int i = 0; i < arr.length; i++) arr[i] = new int[i]; }

Graphic Explanation[im.ncnu.edu.tw]

Implementation of Array Types
Implementing arrays requires considerably more compile-time effort than does implementing simple types, such as integer. The code to allow accessing of array elements must be generated at compile time. At run time, this code must be executed to produce element addresses. This is no way to precompute the address to be accessed by a reference such as list[k]

Compute the Address of an Array Element – (1)
A single-dimensioned array is a list of adjacent memory cells. Suppose the array list is defined to have a subscript range lower bound of 1. The access function for list is often of the form address(list[k])=address(list[l])+(k-l)* element_size This simplifies to address(list[k])=(address(list[l]) - element_size) + (k * element_size) where the first operand of the addition is the constant part of the access function, and the second is the variable part.

Compute the Address of an Array Element – (2)
If the element type is statically bound and the array is statically bound to storage, then the value of the constant part can be computed before run time. Only the addition and multiplication operations remain to be done at run time. If the base, or beginning address, of the array is not known until run time, the subtraction must be done when the array is allocated.

The General Form of the Access Function
The generalization of the access function for an arbitrary lower bound is address(list[k]) = address(list[lower_bound]) + ((k - lower_bound) * element_size)

Layout of Multidimensional Arrays
Hardware memory is linear—it is usually a simple sequence of bytes. So values of data types that have two or more dimensions must be mapped onto the single-dimensioned memory.

Methods to Map a Multidimensional Array to a One-Dimensional Array
There are two common ways in which multidimensional arrays can be mapped to one dimension: row major order column major order

Row Major Order In row major order, the elements of the array whose first subscript is equal to the lower bound value of that subscript are stored first, followed by the elements of the second value of the first subscript, and so forth.

Column Major Order In column major order, the elements of an array whose last subscript is equal to the lower bound value of that subscript are stored first, followed by the elements of the second value of the last subscript, and so forth, Column major order is used in Fortran, but the other languages use row major order.

Example For example, If the matrix had the values
it would be stored in row major order as , 4, 7, 6, 2, 5, 1, 3, 8 it would be stored in column major order as , 6, 1, 4, 2, 3, 7, 5, 8

The Access Function for Two-Dimensional Arrays
The access function for two-dimensional arrays can be developed as follows. In general, the address of an element is the base address of the array plus the element size times the number of elements that precede it in the array. (n-1) elements element n base address

For a matrix in row major order,
The Access Function for Two-dimensional Arrays Stored in Row Major Order For a matrix in row major order, the number of elements that precedes an element is the number of rows above the element times the size of a row, plus the number of elements to the left of the element. This is illustrated in Figure 6.6, in which we make the simplifying assumption that subscript lower bounds are all 1. To get an actual address value, the number of elements that precede the desired element must be multiplied by the element size.

Figure 6.6

Access Function for a[i,j] – (1)
Now, the access function can be written as location(a[i,j]) = address of a[l,l]+ ((((number of rows above the ith row)*(size of a row)) + (number of elements left of the jth column)) * element size)

Because the number of rows above the ith row is (i - 1) and the number of elements to the left of the jth column is (j - l), we have location(a[i, j]) = address of a[1,1] + ((((i - l) * n) + (j - 1)) * element_size) where n is the number of elements per row. This can be rearranged to the form location(a[i,j]) = address of a[1,l] - ((n + 1) * element_size) + ((i * n + j) * element_size) where the first two terms are the constant part and the last is the variable part.

The generalization to arbitrary lower bounds results in the following access function: location(a[i,j]) = address of a[row_lb,col_lb] + (((i–row_lb)*n) + (j-col_lb))*element_size where row_lb is the lower bound of the rows and col_lb is the lower bound of the columns.

Associative Arrays An associative array is an unordered collection of data elements that are indexed by an equal number of values called keys. In the case of non-associative arrays, the indices never need to be stored (because of their regularity). In an associative array, however, the user-defined keys must be stored in the structure. So each element of an associative array is in fact a pair of entities a key and a value.

Structure and Operations
In Perl, associative arrays are often called hashes, because in the implementation their elements are stored and retrieved with hash functions. The name space for Perl hashes is distinct; every hash variable must begin with a percent sign (%). Hashes can be set to literal values with the assignment statement, as in %salaries = ("Gary" => 75000, "Perry" => 57000, "Mary" => 55750, “Cedric" => 47850);

Reference to Individual Element
Individual element values are referenced using notation that is unique to Perl. The key value is placed in braces and the hash name is replaced by a scalar variable name that is the same except for the first character. Scalar variable names begin with dollar signs ($). For example, $salaries{"Perry"} = 58850;

Add and Delete Elements from a Hash
A new element is added using the same statement form. An element can be removed from the hash with the delete operator, as in delete $salaries{"Gary"}; The entire hash can he emptied by assigning the empty literal to it, as in %salaries = ();

The Size of a Perl Hash The size of a Perl hash is dynamic:
It grows when a new element is added. It shrinks when an element is deleted and also when it is emptied by assignment of the empty literal.

record Type A record is a possibly heterogeneous aggregate of data elements in which the individual elements are identified by names. In C and C++ records are supported with the struct data type.

Difference between a record and an array Type
The fundamental difference between a record and an array is the homogeneity of elements in arrays versus the possible heterogeneity of elements in records. One result of this difference is that record elements, or fields, are not usually referenced by indices. The fields are named with identifiers. References to the fields are made using these identifiers.

Example struct person { int age, salary; char department[10]; char name[12]; char address[6][20]; }; struct person tom, *person_poi; tom.age=26; person_poi=&tom; *person_poi->salary=40000;

Pointer Type A pointer type is one in which the variables have a range of values that consists of memory addresses and a special value, nil (i.e. null). The value nil is not a valid address and is used to indicate that a pointer cannot currently be used to reference any memory cell.

Example of A nil Address
#include <stdio.h> main() { char *p; char k; p=&k; k=‘a’; printf(“p=%x *p=%c &k=%x\n”,p,*p,&k); p=0; k=getchar(); *p; }

Usages of Pointers Pointers have been designed for two distinct kinds of uses. First, pointers provide some of the power of indirect addressing, which is heavily used in assembly language programming. Second, pointers provide a method of dynamic storage management. A pointer can be used to access a location in the area where storage is dynamically allocated, which is usually called a heap.

Heap-dynamic Variables
Variables that are dynamically allocated from the heap are called heap-dynamic variables. They often do not have identifiers associated with them and thus can be referenced only by pointer or reference type variables. Variables without names are called anonymous variables.

Reference Types and Value Types
Point type variables are different from scalar variables because they are most often used to reference some other variable, rather than being used to store data of some sort. These two categories of variables are called reference types and value types, respectively.

Point Types Add Writability
Uses of pointers add writability to a language. For example, suppose it is necessary to implement a dynamic structure like a binary tree in a language like Fortran 77, which does not have pointers. This would require the programmer to provide and maintain a pool of available tree nodes. Also, because of the lack of dynamic storage in Fortran 77, it would be necessary for the programmer to guess the maximum number of required nodes. This is clearly an awkward and error-prone way to deal with binary trees.

Pointer Operations Languages that provide a pointer type usually include two fundamental pointer operations assignment dereferencing

The Assignment Operation
The assignment operation sets a pointer variable's value to some useful address. If pointer variables are used only to manage dynamic storage, the allocation mechanism, whether by operator or built-in subprogram, serves to initialize the pointer variable. If pointers are used for indirect addressing to variables that are not heap-dynamic, then there must be an explicit operator or built-in subprogram for fetching the address of a variable, which can then be assigned to the pointer variable.

Two Distinct Ways to Interpreted an Occurrence of a Pointer Variable in an Expression
First, it could be interpreted as a reference to the contents of the memory cell to which it is bound, which in the case of a pointer is an address. Second, the pointer could also be interpreted as a reference to the value in the memory cell pointed to by the memory cell to which the pointer variable is bound. In this case, the pointer is interpreted as an indirect reference. pointer address 2 address 1 value 2 address 2

The Dereferencing Operation
Dereferencing, which takes a reference through one level of indirection, is the second fundamental pointer operation. To clarify dereferencing, consider a pointer variable, ptr, that is bound to a memory cell with the value 7080. Suppose that the memory cell whose address is 7080 has the value 206. A normal reference to ptr yields 7080, but a dereferenced reference to ptr yields 206.

The Assignment Operation j = * ptr

Reference a Field of a Record Pointed by a Pointer
When pointers point to records, the syntax of the references to the fields of these records varies among languages. In C and C++, there are two ways a pointer to a record can be used to reference a field in that record. If a pointer variable p points to a record with a field named age, (*p).age can be used to refer to that field. The operator ->, when used between a pointer to a record and a field of that record, combines dereferencing and field reference. For example, the expression p->age is equivalent to (*p).age. int gender int age char address[4] (*p).age or p->age add3 add2 p add1

Heap Memory Allocation Operation
Languages that provide pointers for the management of a heap must include an explicit allocation operation. Allocation is sometimes specified with a subprogram, such as malloc in C. In languages that support OOP, allocation of heap objects is often specified with the new operator. C++, which does not provide implicit deallocation, uses delete as its deallocation operation

Pointer Problems Dangling Pointers Lost Heap-Dynamic Variables

Dangling Pointers A dangling pointer, or dangling reference, is a pointer that contains the address of a heap-dynamic variable that has been deallocated.

Pseudo Code of Creating Dangling Pointer
The following sequence of operations creates a dangling pointer in many languages: Pointer p1 is set to point at a new heap-dynamic variable. Pointer p2 is assigned p1's value. The heap-dynamic variable pointed to by p1 is explicitly deallocated (setting p1 to nil), but p2 is not changed by the operation. p2 is now a dangling pointer. heap p1 = nil p2

Problems Caused by Dangling Pointers (1)
The location being pointed to may have been reallocated to some new heap-dynamic variable. The new heap-dynamic variable should have no relationship to the old heap-dynamic variable pointed by the dangling point.

If the dangling pointer is used to change the heap-dynamic variable, the value of the new heap-dynamic variable will be destroyed.

It is possible that the location now is being temporarily used by the storage management system, possibly as a pointer in a chain of available blocks of storage, thereby allowing a change to the location causes the storage manager to fail. abcd q is a dangling pointer. q q->value=0xabcd;

Use-after-Free Vulnerabilities
Dangling pointers critically impact program correctness and security because they open the door to use-after-free. [Caballero et al.] Use-after-free errors occur when a program continues to use a pointer after it has been freed [OWASP] .

Example 1 [mitre] #include <stdio.h> #include <unistd.h>
#define BUFSIZER1 512 #define BUFSIZER2 ((BUFSIZER1/2) - 8) int main(int argc, char **argv) { char *buf1R1, *buf2R1, *buf2R2, *buf3R2; buf1R1 = (char *) malloc(BUFSIZER1); buf2R1 = (char *) malloc(BUFSIZER1); free(buf2R1); buf2R2 = (char *) malloc(BUFSIZER2); buf3R2 = (char *) malloc(BUFSIZER2); strncpy(buf2R1, argv[1], BUFSIZER1-1); free(buf1R1); free(buf2R2); free(buf3R2); }

Example 2 [mitre] char* ptr = (char*)malloc (SIZE); if (err) {
abrt = 1; free(ptr); } ... if (abrt) { logError("operation aborted before commit", ptr); //When an error occurs, the pointer is immediately freed. //However, this pointer is later incorrectly used in the logError function.

Lost Heap-Dynamic Variables
A lost heap-dynamic variable is an allocated heap-dynamic variable that is no longer accessible to the user program. Such variables are often called garbage because they are not useful for their original purpose and they also cannot be reallocated for some new use by the program.

Pseudo Code of Creating Lost Heap-Dynamic Variables
Lost heap-dynamic variables are most often created by the following sequence of operations: Pointer p is set to point to a newly created heap-dynamic variable. p is later set to point to another newly created heap-dynamic variable. The first heap-dynamic variable is now inaccessible, or lost. Sometimes this is called memory leakage. p=malloc(4); p=malloc(8); p

Formal Parameters and Actual Parameters
The parameters in the subprogram header are called formal parameters. Subprogram call statements must include the name of the subprogram and a list of parameters to be bound to the formal parameters of the subprogram. These parameters are called actual parameters.

Reference Types in C++ C++ includes a special kind of reference type that is used primarily for the formal parameters in function definitions. A C++ reference type variable is a constant pointer that is always implicitly dereferenced. Because a C++ reference type variable is a constant, it must be initialized with the address of some variable in its definition and after initialization a reference type variable can NEVER be set to reference any other variable.

Example Reference type variables are specified in definitions by preceding their names with ampersands (&). For example, int result = 0; int &ref_result = result; . . . ref_result = 100; In this code segment, result and ref_result are aliases.

Formal Parameters with Reference Types
When used as formal parameters in function definitions, reference types provide for two-way communication between the caller function and the called function. This is not possible with nonpointer primitive parameter types, because C++ parameters are passed by value. Reference parameters are referenced in the called function exactly as are other parameters. The calling function need not specify that a parameter whose corresponding formal parameter is a reference type is anything unusual. The compiler passes addresses, rather than values, to reference parameters.

Example [wikipedia] void square(int x, int& result) { result = x*x; }
Then, the following call would place 9 in y: square(3, y);

Supplementary Materials

int a[10][10]; a > the address of the beginning of the array with with type int [10]. &a --> the address of the beginning of the array with type int [10][10]; a[0] --> the address of the first row the array, with type "a pointer to a memory area with type int". &a[0] --> the address of the first row the array, with type " a pointer to a memory area with type int[10] " .

#include<stdio.h>
void main() { int a[10][10]; printf("a=%x &a=%x\n", a, &a); printf("a[1]=%x a[2]=%x (a[1])+1=%x &(a[1][1])=%x\n", a[1], a[2],(a[1])+1,&(a[1][1])); printf("&a[1]=%x &a[2]=%x (&a[1])+1=%x &(a[1][1])=%x\n", &a[1], &a[2],(&a[1])+1,&(a[1][1])); } result: ~/E/P/C/ARRAY> ./a.out a=bfa506ec &a=bfa506ec a[1]=bfa a[2]=bfa5073c (a[1])+1=bfa50718 &(a[1][1])=bfa50718 &a[1]=bfa &a[2]=bfa5073c (&a[1])+1=bfa5073c &(a[1][1])=bfa50718

Chapter 6 Data Types.

Similar presentations

Presentation on theme: "Chapter 6 Data Types."— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Chapter 6 Data Types.

Similar presentations

Presentation on theme: "Chapter 6 Data Types."— Presentation transcript:

Similar presentations

About project

Feedback