Introduction to C++

Session #2
 1 One-dimensional arrays
OUTLINE
2 Two-dimensional arrays
3 Addresses and Pointers
4 Pointer Arithmetic
1. One-dimensional arrays

● Arrays are a fundamental data structure in C++ and are

used to store and manipulate collections of data.
● Arrays are linear data structure that contains same data
type
…ctd
1. Declaring an Array #include <iostream>

using namespace std;

int main() {
data_type array_name[size]; // Example 1: Initialization in the
declaration
int temp1[5];
temp1[5] = {98, 87, 92, 79, 85};

// Example 3: Omitting the size when

initializing in the declaration
int temp3[] = {5, 10, 15, 20, 25};

return 0;
}
…ctd
#include <iostream>

using namespace std;

•char array will contain an
extra null character at the int main() {
// Example: Initialization of a char
end of the string array with a string literal

•Example: char codes[] = "sample";

return 0;
}
•Allof the elements of an array can be processed by
using a loop #include <iostream>

using namespace std;

int main()
{
int temp[5] = {10, 12, 5, 8, 4};
int sum = 0;
for (int i=0; i<5; i++){
sum = sum + temp[i];
}
cout<<"The sum is: "<<sum<<endl;
return 0;
}
 Input and Output of Array Values
}
 …ctd
#include <iostream> // Output values of the array
cout << "Outputting array values:" <<
using namespace std; endl;
for (int i = 0; i < size; i++) {
int main() { cout << "Element " << i << ": " <<
const int size = 5; // You can change the size of the myArray[i] << endl;
array as needed }
int myArray[size];
return 0;
// Input values into the array }
cout << "Enter " << size << " integers:" << endl;
for (int i = 0; i < size; i++) {
cout << "Enter value for element " << i << ": ";
cin >> myArray[i];
}
…ctd
Enter 5 integers:
Enter value for element 0: 4
OUTPUT Enter value for element 1: 5
Enter value for element 2: 6
Enter value for element 3: 5
Enter value for element 4: 2
Outputting array values:
Element 0: 4
Element 1: 5
Element 2: 6
Element 3: 5
Element 4: 2
Example: find maximum value in array
#include <iostream>

using namespace std;

int main() {
const int size = 5;
Result:
int myArray[size] = {42, 17, 89, 56, 23};
int maxVal = myArray[0];
for (int i = 1; i < size; ++i) {
if (myArray[i] > maxVal) {
maxVal = myArray[i];
}
}
cout << "Result " << maxVal << endl;
return 0;
}
 2. Two-dimensional arrays

● A two-dimensional array in C++ is essentially an array of arrays.

● It is a data structure that organizes elements in a table or matrix,
where each element is identified by two indices instead of one.
Think of it as a grid with rows and columns.
 #include <iostream>
● Declaration using namespace std;
int main() {
// Declaration and Initialization of a 2D array
const int rows = 3;
const int columns = 4;
data_type array_name[row][column]; int myArray[rows][columns] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
return 0;
● Initialization }

You can initialize a 2D array either during declaration or later, similar to a 1D

array. When initializing, you can use nested curly braces to represent the
rows and columns
 #include <iostream>
● Accessing Elements: using namespace std;
int main() {
// Declaration and Initialization of a 2D array
To access an element in a 2D array, const int rows = 3;
you can use two for loops: one for const int columns = 4;
int myArray[rows][columns] = {
the row and one for the column. {1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
// Accessing and outputting elements of the 2D array
cout << "2D Array Elements:" << endl;
•Example: for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
cout << myArray[i][j] << " ";
myArray[1][3]; }
cout << endl;
}
return 0;
}
…ctd
2D Array Elements:
1 2 3 4
OUTPUT 5 6 7 8
9 10 11 12
 #include <iostream>

❖ Arrays as Arguments using namespace std;

int findMax(int arr[], int size) {
int maxVal = arr[0];
for (int i = 1; i < size; i++) {
● An individual array if (arr[i] > maxVal) {
maxVal = arr[i]; }
element can be }
return maxVal;
passed as an }

argument just like any int main() {

individual variable const int size = 5;

int myArray[size] = {42, 17, 89, 56, 23};
int maxValue = findMax(myArray, size);
cout << "The maximum value in the array is: " <<
maxValue << endl;
return 0;
}
 3. Addresses and Pointers

● Address of a Variable: Every variable in C++ is stored in a specific memory

location, and you can obtain the address of a variable using the address-of
operator (&).

&num means the address of num

int x = 10;
cout<<"Address of x: " << &x << endl;
…cont

● Declaration of Pointers: Pointers are variables that store memory

addresses. You declare a pointer by specifying the type it points to,
followed by an asterisk (*).
● To use a stored address, C++ provides the indirection operator, *
● *numAddr means the variable whose address is stored in numAddr

int *ptr;
// Declaration of an integer pointer
cont…

● Initialization of Pointers: Pointers can be initialized with the address

of a variable.

int y = 20;
// Initializing the pointer with the address of
variable y
int *ptr = &y;
cont…

● Dereferencing Pointers: To access the value stored at the memory

location pointed to by a pointer, you use the dereference operator (*).

// Getting the value at the memory location

pointed to by ptr
int z = *ptr;
Example: combining addresses and pointers
#include <iostream>
using namespace std;
int main() {
int number = 42; Output
// Address of the variable
cout << "Address of number: " << &number << endl;
// Pointer declaration and initialization
int *ptr = &number;
// Value through dereferencing
cout << "Value at the memory location pointed to by ptr:
" << *ptr << endl;
return 0;
}
…ctd

Address of number: 0x7ffe10c779dc

OUTPUT Value at the memory location pointed to by

ptr: 42
…ctd
…ctd

OUTPUT
❖ Array Names as Pointers
Example:
#include <iostream>

using namespace std;

int main() { Output

int myArray[] = {10, 20, 30, 40, 50};

// Using array name as a pointer

int *ptr = myArray;

// Accessing array elements using the pointer

for (int i = 0; i < 5; ++i) {
cout << "Element " << i << ": " << *(ptr + i) << endl;
}

return 0;
}
…ctd

Element 0: 10
OUTPUT Element 1: 20
Element 2: 30
Element 3: 40
Element 4: 50
4. Pointer Arithmetic

● Pointer variables, like all variables, contain values

● The value stored in a pointer is a memory address
● By adding or subtracting numbers to pointers you can obtain different
addresses
● Pointer values can be compared using relational operators (==, <, >,
etc.)

int arr[] = {10, 20, 30, 40, 50};

int *ptr = arr;
// Incrementing the pointer to the next element
ptr++;
// Now, ptr points to the second element in the array (20)
Example:
#include <iostream>
using namespace std;
int main() {
const int size = 5;
int myArray[size] = {10, 20, 30, 40, 50}; Output
// Using a pointer to iterate through the array and calculate the sum
int *ptr = myArray;

0
15
int sum = 0;

:
ts
for (int i = 0; i < size; ++i) {

en
em
sum += *ptr; // Add the value at the current memory location to the

el
sum

y
ra
ptr++; // Move to the next element in the array

ar
}

of
m
// Output the sum

Su
cout << "Sum of array elements: " << sum << endl;
return 0;
}
…cont

● Increment and decrement operators can be applied as both

prefix and postfix operators
❖ Passing Addresses: Example
#include <iostream>
using namespace std;
// Function to double the value at a specific memory location
void doubleValue(int *ptr) {
*ptr = *ptr * 2; Output
}
int main() {
int num = 5; Original value: 5
// Output the original value Modified value: 10
cout << "Original value: " << num << endl;
// Pass the address of 'num' to the function
doubleValue(&num);
// Output the modified value
cout << "Modified value: " << num << endl;
return 0;
}
❖ Passing Arrays

● When an array is passed to a function, its address is the only item

actually passed
“Address” means the address of the first location used to store
the array
First location is always element zero of the array
❖ Passing Arrays: Example
#include <iostream>
using namespace std;
void modifyArray(int arr[], int size) {
for (int i = 0; i < size; ++i) {
arr[i] *= 2; // Doubling each element Output
}
}
int main() {
const int size = 5;
2 4 6 8 10
int myArray[size] = {1, 2, 3, 4, 5};
// Passing the array to the function
modifyArray(myArray, size);
// Outputting the modified array
for (int i = 0; i < size; ++i) {
cout << myArray[i] << " ";
}
return 0;
}
OUTLINE
1. Files
2. Structures
 FILES
Introduction
Embarking on File Operations in C++

File operations in C++ enable us to interact with

external files, read and write data, and manage
information persistently. Let's dive into the basics of
reading and writing files, exploring the fundamental
concepts and operations.
File Reading Basics

Read data from a text file in C++

File Reading - Processing
Content

● Utilize a `while` loop with

`getline()` for reading the file line
by line.
● Adapt the loop body to process
each line as needed.
File Writing - Appending
Content

Open the file in append mode to

add content without overwriting
existing data.
Modes of File Operations
Modes
 Best Practices for File
Operations

● Always check if the file is successfully

opened.
● Ensure proper error handling to manage
unexpected situations.
● Close the file after finishing operations
to free up resources.
 Common Mistakes in File
Operations

Mistake: Forgetting to check if the file is

open.

Solution: Prioritize error checking for

robust file handling.
 Structures
Introduction
Structuring Data in C++

Structures provide a powerful way to organize and

encapsulate related data under a single name. Let's
explore the fundamentals of defining, creating
instances, and working with structures in C++.
 Defining a Structure

● A structure is a user-defined
data type.
● Declared using the struct
keyword.
 Creating Structure
Instances

Instances of structures hold specific

data.

Access structure members using the

dot (.) operator.
 Displaying Structure Data

Print structure data to the console

for verification.
Nested Structures

Structures can be nested for more

complex data structures.
 Displaying Nested
Structure Data

Print nested structure data to the

console for verification.
Passing Structures to
Functions

Send structures on missions to

functions.
Best Practices for
Structures

● Meaningful member names

enhance code readability.
● Structures group related
data; use them accordingly.
Common Mistakes in
Structure Usage

● Mistake: Accessing
uninitialized members.
● Solution: Always initialize
structure members.