Data Types And Records (Copy)

Introduction to Data Storage and Structure

• Computers process and store vast amounts of data, requiring structured storage for efficient retrieval and manipulation.
• Organizing data systematically enables rapid searches and quick access to relevant information.
• This chapter focuses on fundamental data structures that facilitate effective data management in programming.

10.1.1 Data Types

Definition and Importance of Data Types

• A data type is a classification assigned to data, determining the kind of values it can hold and how they are manipulated.
• Programming languages use different data types to:
  • Define the nature of stored values (e.g., numbers, text, logical values).
  • Optimize memory allocation and data processing.
  • Prevent errors by enforcing type constraints in programs.

Basic Data Types in Programming

• Most programming languages provide built-in data types, each serving specific purposes.
• The following are common data types along with their representations in pseudocode, Python, Java, and VB.NET.

Declaring Data Types in Pseudocode

• Before using a data item, its data type must be declared to ensure proper usage in programming.
• A declaration follows this format in pseudocode:

  DECLARE <identifier> : <data type>
  

• Example:

  DECLARE myBirthday : DATE
  

Choosing the Right Data Type

• Selecting an appropriate data type ensures efficient memory usage and correct processing.
• Examples of suitable data types for different data items:
  • Your Name: STRING
  • Number of children in a class: INTEGER
  • Time taken to run a race: REAL
  • Whether a door is open or closed: BOOLEAN
  • Date of birth: DATE

10.1.2 Records

Definition and Purpose of Records

• A record is a composite data type consisting of multiple related data fields, potentially of different types.
• Using records allows structured storage and easy access to related information under a single identifier.
• Example: A book record may contain:
  • Title (STRING)
  • Author (STRING)
  • Publisher (STRING)
  • Number of pages (INTEGER)
  • Fiction/Non-fiction (BOOLEAN)

Characteristics of Records

• Composite Data Type: Built using existing basic data types.
• Fixed Structure: Contains a predefined number of fields.
• User-Defined: Not always built into programming languages; must be explicitly defined.

Declaring Records in Pseudocode

• Before using a record, it must be defined as a new data type in pseudocode.
• General format:

  TYPE <TypeName>
      DECLARE <identifier> : <data type>
      DECLARE <identifier> : <data type>
      DECLARE <identifier> : <data type>
  ENDTYPE
  

• Example: Defining a book record type

  TYPE TbookRecord
      DECLARE title : STRING
      DECLARE author : STRING
      DECLARE publisher : STRING
      DECLARE noPages : INTEGER
      DECLARE fiction : BOOLEAN
  ENDTYPE
  

• Once defined, a record variable can be declared and used:

  DECLARE Book : TbookRecord
  

Accessing and Modifying Record Fields

• Individual fields of a record can be accessed using the dot (.) notation.
• Example: Assigning values to a book record

  Book.author ← "David Watson"
  Book.fiction ← FALSE
  

Real-World Example: Student Records

• A student record can store:
  • Name (STRING)
  • Date of Birth (DATE)
  • Class (STRING)
  • Gender (CHAR)
• Example Pseudocode:

  TYPE TstudentRecord
      DECLARE name : STRING
      DECLARE dateOfBirth : DATE
      DECLARE className : STRING
      DECLARE gender : CHAR
  ENDTYPE
  
  DECLARE myStudent : TstudentRecord
  

Using Records in Programming Languages

• Some programming languages allow records to be implemented as classes or structs.
• Example: Defining a Record in Python

  class StudentRecord:
      def __init__(self, name, date_of_birth, class_name, gender):
          self.name = name
          self.date_of_birth = date_of_birth
          self.class_name = class_name
          self.gender = gender
  
  # Creating a record instance
  student1 = StudentRecord("Ahmad Sayed", "2010-03-21", "5A", "M")
  

• Example: Defining a Record in Java

  class StudentRecord {
      String name;
      String dateOfBirth;
      String className;
      char gender;
  }
  
  StudentRecord student1 = new StudentRecord();
  student1.name = "Ahmad Sayed";
  student1.dateOfBirth = "2010-03-21";
  student1.className = "5A";
  student1.gender = 'M';
  

Key Concepts Summary

• Data Type: A classification defining the kind of values a variable can hold.
• Identifier: A unique name assigned to a data item.
• Record (Data Type): A structured collection of related fields of varying data types.
• Composite Data Type: A type that references multiple data types (e.g., records, arrays).
• Pseudocode Usage:
  • Declaring variables using DECLARE <identifier> : <data type>.
  • Structuring records using TYPE ... ENDTYPE.

Conclusion

• Understanding data types is essential for effective programming and efficient memory usage.
• Records provide a structured way to store related data elements under a single identifier.
• Choosing the correct data type ensures data integrity, proper usage, and optimized performance.
• Implementing records in different programming languages varies, but the core concept remains the same.