What is the difference between an integer and a float?

An integer is a whole number without a decimal point, like 5 or -3. A float (or real) is a number with a decimal point, like 3.14 or -0.001. Floats can represent fractional values but have limited precision and may cause rounding errors. Integers are exact and use less memory, so use them when you don't need decimals.

Why do we need different data types?

Different data types allow a computer to store and process data efficiently. For example, storing a Boolean value as a single bit saves memory compared to storing it as a string. Data types also prevent errors by restricting operations: you can't multiply two strings, for instance. They help the compiler or interpreter allocate the right amount of memory and choose the correct machine instructions.

What is type casting and when is it used?

Type casting is converting a value from one data type to another. It's used when you need to perform an operation that requires matching types, like concatenating a number with a string (e.g., 'Age: ' + str(age)). Implicit casting happens automatically (e.g., adding an int and float gives a float), but explicit casting is done by the programmer using functions like int(), float(), or str().

Can a string be changed after it's created?

It depends on the programming language. In Python, strings are immutable, meaning you cannot change a character in an existing string; you must create a new string. In languages like C++, strings are mutable and can be modified. Immutability can improve performance and safety, but it means operations like concatenation create new objects.

What is integer overflow and how can it be avoided?

Integer overflow occurs when a calculation produces a value outside the range that the data type can store. For example, adding 1 to the maximum 32-bit signed integer (2,147,483,647) may wrap around to -2,147,483,648. To avoid it, use a larger data type (e.g., 64-bit integer) or check values before operations. In some languages, overflow raises an exception.

How are Booleans stored in memory?

Booleans typically occupy 1 byte (8 bits) in memory, even though only 1 bit is needed to represent true/false. This is because most computers address memory at the byte level. Some languages or compilers may pack multiple Booleans into a single byte to save space, but this is not standard. The actual representation is often 0 for false and 1 for true.

Data Types

OCR

A-Level

This topic covers the fundamental representation and storage of data within computer systems, including primitive data types and binary arithmetic. It explores how integers, real numbers, and characters are represented, manipulated, and converted between different bases, alongside the use of bitwise operations and character sets.

Objectives

Exam Tips

Pitfalls

Key Terms

Mark Points

Topic Overview

Data types are a fundamental concept in computer science, defining the kind of data a variable can hold and the operations that can be performed on it. In OCR A-Level Computer Science, you'll explore primitive data types such as integer, real (float), Boolean, character, and string, as well as composite types like arrays, records, and lists. Understanding data types is crucial because they determine how data is stored in memory, how it can be manipulated, and how efficiently programs run. For example, using an integer instead of a float for a counter saves memory and avoids unnecessary floating-point arithmetic.

Data types also underpin more advanced topics like data structures, algorithms, and database design. In the OCR specification, you'll need to know how to declare variables with appropriate data types, perform type casting (both implicit and explicit), and understand the limitations of each type, such as integer overflow or floating-point precision errors. This knowledge is directly tested in exam questions where you must choose the correct data type for a given scenario or explain why a program behaves unexpectedly due to type misuse.

Mastering data types is essential for writing robust, error-free code. It also forms the basis for understanding object-oriented programming, where custom data types (classes) can be defined. By the end of this topic, you should be able to justify your choice of data type in terms of memory usage, range, and precision, and recognise when type conversion is necessary.

Key Concepts

Core ideas you must understand for this topic

→Primitive data types: integer (whole numbers), real/float (numbers with decimal points), Boolean (true/false), character (single letter or symbol), string (sequence of characters).
→Composite data types: arrays (fixed-size collection of same type), records (collection of different types), lists (dynamic-size collection).
→Type casting: converting one data type to another, e.g., int('5') converts string to integer. Implicit casting happens automatically (e.g., int + float → float), while explicit casting requires programmer intervention.
→Range and precision: integers have a fixed range (e.g., -2^31 to 2^31-1 for 32-bit), floats have limited precision (e.g., 7 decimal digits for single precision). Overflow occurs when a value exceeds the range.
→Mutable vs immutable: strings in Python are immutable (cannot be changed after creation), while lists are mutable. This affects how data is handled in memory.

What You Need to Demonstrate

Key skills and knowledge for this topic

Representation of positive integers in binary
Use of sign and magnitude and two's complement for negative numbers
Binary addition and subtraction
Conversion between binary, hexadecimal, and denary
Representation and normalisation of floating point numbers
Floating point arithmetic (addition and subtraction)
Bitwise manipulation using shifts and masks (AND, OR, XOR)
Understanding of ASCII and Unicode character sets

Marking Points

Key points examiners look for in your answers

Representation of positive integers in binary
Use of sign and magnitude and two's complement for negative numbers
Binary addition and subtraction
Conversion between binary, hexadecimal, and denary
Representation and normalisation of floating point numbers
Floating point arithmetic (addition and subtraction)
Bitwise manipulation using shifts and masks (AND, OR, XOR)
Understanding of ASCII and Unicode character sets

Examiner Tips

Expert advice for maximising your marks

💡Always show your working for binary arithmetic and base conversions to gain method marks
💡Double-check the sign of the result when performing two's complement arithmetic
💡Practice normalising floating point numbers until the process is automatic
💡Remember that Unicode is a superset of ASCII
💡Always justify your choice of data type in exam questions by linking it to the problem's requirements. For example, 'I would use an integer for age because age is a whole number and does not require decimal places, saving memory.'
💡When asked to identify errors in code, look for type mismatches, such as trying to concatenate a string and an integer without explicit conversion. This is a common trap.
💡Remember that in OCR exams, you may be asked to write pseudocode. Use the correct notation: e.g., DECLARE age : INTEGER. Be consistent with data type names as per the specification.

Common Mistakes

Pitfalls to avoid in your exam answers

Confusing sign and magnitude with two's complement representation
Incorrectly normalising floating point numbers (e.g., failing to ensure the mantissa starts with 0.1 or 1.0 depending on the convention)
Errors in binary subtraction when borrowing
Misinterpreting bitwise shift operations (logical vs arithmetic shifts)
Misconception: 'A string is a primitive data type.' Correction: In most languages, a string is a composite type because it is a sequence of characters. Primitive types are atomic (e.g., character).
Misconception: 'Floats can represent all decimal numbers exactly.' Correction: Floating-point numbers are stored in binary and cannot represent many decimal fractions precisely (e.g., 0.1), leading to rounding errors.
Misconception: 'Boolean variables can store values like 0 or 1.' Correction: Booleans only store true or false. In some languages, they may be represented as 0/1 internally, but you should not rely on this for logic.

Frequently Asked Questions

Common questions students ask about this topic

Before You Start

Prior knowledge that will help with this topic

•Basic understanding of variables and assignment (e.g., from GCSE Computer Science).
•Familiarity with binary representation of numbers (for understanding range and overflow).
•Basic arithmetic operations and logical operators (AND, OR, NOT).

Likely Command Words

How questions on this topic are typically asked

Convert

Calculate

Represent

Explain

Perform

Ready to test yourself?

Practice questions tailored to this topic

Data Types

Topic Overview

Key Concepts

What You Need to Demonstrate

Marking Points

Examiner Tips

Common Mistakes

Frequently Asked Questions

Before You Start

Likely Command Words

Ready to test yourself?

Related Topics in OCR A-Level Computer Science

Algorithms

Analysis of the problem

Applications Generation

Boolean Algebra

Topic Synopsis

Key Concepts & Core Principles

Exam Tips & Revision Strategies

Common Misconceptions & Mistakes to Avoid

Examiner Marking Points

Data Types

Topic Overview

Key Concepts

What You Need to Demonstrate

Marking Points

Examiner Tips

Common Mistakes

Frequently Asked Questions

What is the difference between an integer and a float?

Why do we need different data types?

What is type casting and when is it used?

Can a string be changed after it's created?

What is integer overflow and how can it be avoided?

How are Booleans stored in memory?

Before You Start

Likely Command Words

Ready to test yourself?

Related Topics in OCR A-Level Computer Science

Algorithms

Analysis of the problem

Applications Generation

Boolean Algebra