Chapter 1: Review of Programming concepts

1.1 Arrays

An array is a collection of elements of the same data type, stored contiguously in memory. It's a
fundamental data structure used to organize and manipulate multiple values efficiently.

Declaration and Initialization

To declare an array, you specify its type, name, and the number of elements it will hold:

C++
data_type array_name[size];

You can initialize the array elements at declaration:

C++
int numbers[5] = {10, 20, 30, 40, 50};

Accessing Elements

You access individual elements of an array using their index, which starts from 0:

C++
int first_element = numbers[0]; // Accesses the first element (10)

Example: Calculating the Average of Numbers

C++
#include <iostream>

using namespace std;

int main() {
int numbers[5] = {10, 20, 30, 40, 50};
int sum = 0;

for (int i = 0; i < 5; i++) {

sum += numbers[i];
}

double average = (double)sum / 5;

cout << "Average: " << average << endl;

 return 0;
}

Key Points:

 Array elements are stored contiguously in memory.

 The index of the first element is 0.
 You can access elements using their index.
 Arrays can be initialized at declaration.
 You can use loops to iterate over array elements.

Additional Notes:

 Arrays are fixed-size; you cannot change their size after declaration.
 If you need a variable-sized collection, consider using dynamic arrays (vectors) from the
C++ Standard Template Library (STL).
 Be careful to avoid accessing array elements out of bounds (index values outside the
valid range).

1.2 Structures

A structure is a user-defined data type that groups related variables of different data types under
a single name. It provides a way to organize and manage data efficiently.

Creating a Structure

To define a structure, you use the struct keyword followed by the structure name and a pair of
curly braces containing the member variables:

struct Student {
int roll_number;
char name[50];
float marks;
};

Creating Structure Variables

Once you've defined a structure, you can create variables of that type:

Student student1, student2;

Accessing Members
You can access the members of a structure using the dot operator (.):

student1.roll_number = 1;
strcpy(student1.name, "Alice");
student1.marks = 95.5;

Example: Student Information

C++
#include <iostream>
#include <cstring>

using namespace std;

struct Student {
int roll_number;
char name[50];
float marks;
};

int main() {
Student student1, student2;

student1.roll_number = 1;
strcpy(student1.name, "Alice");
student1.marks = 95.5;

student2.roll_number = 2;
strcpy(student2.name, "Bob");
student2.marks = 88.2;

cout << "Student 1 Information:" << endl;

cout << "Roll Number: " << student1.roll_number << endl;
cout << "Name: " << student1.name << endl;
cout << "Marks: " << student1.marks << endl;

cout << "\nStudent 2 Information:" << endl;

cout << "Roll Number: " << student2.roll_number << endl;
cout << "Name: " << student2.name << endl;
cout << "Marks: " << student2.marks << endl;

return 0;
}

Key Points:
  Structures allow you to group related variables into a single unit.
 Each member of a structure has its own data type.
 You can access members using the dot operator.
 Structures can be used to represent complex data structures.

Additional Notes:

 You can create arrays of structures to store multiple instances of the same data type.
 Structures can be passed as arguments to functions and returned from functions.
 You can use pointers to structures to manipulate them efficiently.

1.3 Functions

A function is a block of code that performs a specific task. It's a fundamental building block of
C++ programs, allowing you to modularize your code, improve readability, and reuse code.

Defining a Function

To define a function, you use the following syntax:

return_type function_name(parameter_list) {
// Function body
}

 return_type: The data type of the value returned by the function. If the function doesn't
return a value, use void.
 function_name: The name you give to the function.
 parameter_list: A list of variables that the function accepts as input. Each parameter
has its data type and name.

Example: Calculating the Area of a Rectangle

#include <iostream>

using namespace std;

double calculate_area(double length, double width) {

return length * width;
}

int main() {
double length, width, area;

cout << "Enter length and width: ";

cin >> length >> width;

area = calculate_area(length, width);

 cout << "Area: " << area << endl;

return 0;
}

Key Points:

 Functions can be defined anywhere in the program, but it's common to place them at the
beginning or in separate header files.
 Functions can be called from anywhere within the program.
 Functions can return a value using the return statement.
 Functions can take parameters as input.
 Functions can be used to break down complex problems into smaller, more manageable
tasks.

Additional Notes:

 Functions can be overloaded, meaning you can have multiple functions with the same
name but different parameter lists.
 Functions can be recursive, meaning they can call themselves.
 Functions can be passed as arguments to other functions.

1.4 Pointers

A pointer is a variable that stores the memory address of another variable. It provides a way to
indirectly access and manipulate data stored in memory.

Declaring Pointers

To declare a pointer, you use the * operator followed by the data type of the variable it will point
to:

data_type *pointer_name;

For example:

int *ptr; // Pointer to an integer

Assigning Values to Pointers

You can assign the address of a variable to a pointer using the & operator:

int x = 10;
int *ptr = &x; // ptr now points to x

Dereferencing Pointers
To access the value stored at the memory address pointed to by a pointer, you use the * operator:

int y = *ptr; // y will be 10

Example: Swapping Values Using Pointers

C++
#include <iostream>

using namespace std;

void swap(int *a, int *b) {

int temp = *a;
*a = *b;
*b = temp;
}

int main() {
int x = 10, y = 20;

cout << "Before swapping: x = " << x << ", y = " << y << endl;

swap(&x, &y);

cout << "After swapping: x = " << x << ", y = " << y << endl;

return 0;

Pointer Arithmetic

 Increment/Decrement: You can increment or decrement a pointer to point to the next or

previous element in an array:

C++

int arr[5] = {1, 2, 3, 4, 5};

int *ptr = arr;
ptr++; // Points to the second element (arr[1])

Comparison: You can compare pointers to check if they point to the same memory
location:

if (ptr == &arr[0]) {
// ptr points to the first element of the array
}

Pointer to Pointer
  A pointer can also point to another pointer:

C++

int x = 10;
int *ptr1 = &x;
int **ptr2 = &ptr1; // ptr2 points to ptr1

To access the value pointed to by the original variable through the pointer to pointer, you need to
dereference twice:
C++
int y = **ptr2; // y will be 10

Dynamic Memory Allocation

 Pointers are essential for dynamic memory allocation using new and delete:

int *ptr = new int;

*ptr = 20;
// ...
delete ptr;

Complete Example

#include <iostream>

using namespace std;

int main() {
int *ptr;

// Dynamically allocate memory for an integer

ptr = new int;

// Assign a value to the allocated memory

*ptr = 10;

cout << "Value: " << *ptr << endl;

// Deallocate the memory

delete ptr;

// After deallocation, ptr becomes a dangling pointer

// Avoid using it to access memory
// cout << "Value: " << *ptr << endl; // This would be undefined behavior

return 0;
}

Common Uses of Pointers

  Passing arguments by reference: Pointers allow you to modify the original values of
variables passed to functions.
 Creating dynamic data structures: Linked lists, trees, and graphs are often
implemented using pointers.
 Pointer arithmetic: Used for efficient array traversal and manipulation.
 Pointer to functions: Can be used to store and call functions dynamically.

Key Points:

 Pointers store memory addresses.

 You use the * operator to declare pointers and dereference them.
 You use the & operator to get the address of a variable.
 Pointers can be used to pass arguments by reference to functions.
 Pointers can be used to dynamically allocate memory using new and delete.

Additional Notes:

 Be careful to avoid using null pointers (pointers that don't point to anything).
 Be aware of memory leaks when using dynamic memory allocation.
 Pointers can be used to create linked lists, trees, and other data structures.