CSC 1060 Arrays & Pointers Quiz

Course Information

• Course name: CSC 1060
• Topic: Arrays & Pointers

Objectives

• Understand how arrays represent linear data structures
• Declare, modify, and initialize array elements
• Perform common array operations
• Use arrays in application development
• Manipulate memory using pointers
• Efficiently allocate and deallocate memory
• Work with arrays using pointers
• Explore the relationship between arrays and pointers

Agenda (Week 13)

• Arrays and Array Indexes, Syntax, and Initializers
• Traversing an Array
• User input into Array and Partially filled Arrays
• Common algorithms and Bubble Sort
• Parallel Arrays
• Multi-Dimensional Arrays
• Why Pointers?
• Arrays as Function Arguments
• Pointers and Memory
• C-Style Strings
• TODO & Resources for Help

Pre-Challenge

• Review content from section 5.2 Arrays
• Visualize code in the 3 CodeLens programs
• Complete 2 multiple-choice questions

C++ Arrays

• Arrays are linear data structures that store elements of the same data type.
• Arrays are fixed size at compile time.
• Array elements can be hardcoded integer, compiler constant, or pre-processor constant.
• By default, elements in local scope arrays are not initialized. The values are undetermined.
• Class-type arrays have elements initialized by the class default constructor.

Array Indexes

• Elements in C++ arrays are stored in contiguous memory locations.
• Array indexes are 0-based.
• The programmer is responsible for ensuring array indexes are valid (within the array's bounds).
• Errors at runtime due to invalid array indexes are intent/logic/runtime errors, not compiler errors.

Array Syntax

• Declare an array using const int MAX = 4; int nums[MAX];
• Modify array elements using nums[0] = 10; nums[1] = 25;
• Access array elements using std::cout << nums[0] << "\t";

Array Initializers

• Initialize array elements with explicit values using braces: int nums[] = {10, 25, 14, 99, 2}
• Array size is determined by the number of elements in the initializer.
• If a size is explicitly given for the array, elements cannot exceed the size. Extra elements use the default type value.

Setting Default Values to Array

• Create an array with empty initializer to set all elements to default values int nums[5] = {}; or int nums[5]{};

Traversing All Elements in Array

• Use a for loop or for-in-range loop to access all elements.
• Access elements using their index nums[i].

Input into Partially Filled Arrays

• Declare array with a size larger than expected
• Use a temporary variable to perform input validation to avoid buffer overflow before writing the element to the array.
• Avoid direct input to the array and use a counter keeping track of how many elements are being used.

Traversing Partially Filled Array

• Use a for loop to access the used elements of an array, not exceeding the used counter.

Array Common Algorithms (Max/Min)

• Sequentially traverse through the array data to find the maximum and minimum values. Use a variable to hold the maximum/minimum found initially. Check each subsequent element against the current maximum/minimum.

Array Common Algorithm (Sorts)

• Sort array elements ascending (small to big) or descending (big to small).
• The bubble sort algorithm compares adjacent elements and swaps them if their order is incorrect.

Array Benefits and Disadvantages

• (This section only lists the topics, not the details found in the document)

Parallel Arrays

• Two or more arrays of the same size, where indexes relate.
• The relationship between the arrays must be documented.
• The arrays can store different data types.

Multi-Dimensional Arrays

• Arrays of arrays. Arrays can be conceptually viewed as tables with rows and columns.
• Fixed size for each dimension.
• All elements must be of the same data type.

Multi-Dimensional Traversing

• Use nested for loops to traverse through 2 dimensional arrays, accessing rows and columns in the array.
• Traverses through the dimensions of multi-dimensional arrays using nested for loops.

Pointers

• Pointers control memory locations. They are like TV remotes.
• Pointers can control stack and heap memory.
• Pointers can control a single memory location or an array of memory.

Why Pointers?

• Passing a pointer is more efficient than passing the actual value of something.
• Allows the developer to manage dynamic memory.
• Comes with great responsibility.

Function Argument (Array[1D])

• Arrays are passed to a function using pass by reference (IN/OUT) - it is a pointer
• Do not make a copy of the array contents.
• Always explicitly pass the number of array elements
• Do not calculate size of the array in function.
• Do not use the & operator in the function call

Pointer and Memory

• Pointing to a single memory location on heap memory requires int *ptr = new dataType; and releasing it delete ptr.
• Pointing to an array of memory on heap memory int *ptr = new dataType[size]; requires releasing it using delete[] ptr;

C-Style String

• In C, strings are represented as arrays of characters, ending with the null terminator '\0'.
• C++ recommends using std::string.

C-Style Strings in C++: Stack & Heap

• C-style strings in C++ store strings in the stack or heap depending on how they are created. Stack is compiler managed, heap is developer managed.

Earn Your Pre-Work Grade

• Post weekly discussion questions
• Complete the pre-work quiz
• Complete week 13 content module in D2L at 100%

Questions/Clarifications/Help

• Student Office Hours
• Email: [email protected]
• RRCC On-Campus Tutoring: [link]
• 24/7 Online Tutoring: D2L > Content > Resources for Help

Test your understanding of arrays and pointers in C++. This quiz covers essential topics including array declaration, common operations, multi-dimensional arrays, and the relationship between arrays and pointers. Prepare to showcase your knowledge of memory manipulation and application development.