LEC IV
REPETITION LOGIC
These structures play a crucial role in determining how a program flows based on specific
conditions. Here are the key concepts and examples:
1. Sequential Logic (Sequential Flow):
- Sequential logic follows a linear flow, executing instructions in the order they are given.
- Modules are executed one after the other unless new instructions alter the sequence.
- This basic flow pattern is common for most processing tasks.
- Example: A simple program that reads input, processes data, and produces output.
#include <iostream>
using namespace std;
int main() {
string name;
int age;
// Step 1: Read input from the user
cout << "Enter your name: ";
cin >> name;
cout << "Enter your age: ";
cin >> age;
// Step 2: Process the data
int birth_year = 2024 - age;
// Step 3: Produce output
cout << "Hello, " << name << "! You were born around " << birth_year << "." << endl;
return 0;
In this C++ program:
1. We declare a `string` variable `name` to store the user's name and an `int` variable `age`
to store their age.
2. We read input using `cin` (similar to Python's `input()`).
3. The calculation of the birth year remains the same.
4. We use `cout` to print the output message.
2. **Selection Logic (Conditional Flow)**:
- Selection logic involves conditions that determine which module to execute.
- Conditional structures include:
- **Single Alternative**:
- If a condition is met, execute a specific module.
- Example: Implementing an `if` statement in C/C++ or Java.
- **Double Alternative**:
- Choose between two modules based on a condition.
- Example: Using an `if-else` statement in C/C++ or Java.
- **Multiple Alternatives**:
- Select from multiple modules based on different conditions.
- Example: Employing an `if-else if` ladder in C++
#include <iostream>
using namespace std;
int main() {
int i = 20;
if (i == 10)
cout << "i is 10";
else if (i == 15)
cout << "i is 15";
else if (i == 20)
cout << "i is 20";
else
cout << "i is not present";
return 0;
In this example:
- We initialize `i` to 20.
- The `if-else if` ladder checks the conditions in order.
- Since `i` is equal to 20, the third condition (`i == 20`) evaluates to true.
- The message "i is 20" is printed.
Here's another example with a range-based condition:
#include <iostream>
using namespace std;
int main() {
int i = 25;
if (i >= 0 && i <= 10)
cout << "i is between 0 and 10" << endl;
else if (i >= 11 && i <= 15)
cout << "i is between 11 and 15" << endl;
else if (i >= 16 && i <= 20)
cout << "i is between 16 and 20" << endl;
else
cout << "i is greater than 20" << endl;
return 0;
In this second example, the program checks the value of `i` and prints the corresponding
message based on the specified
3. **Iteration Logic (Repetitive Flow)**:
- Iteration logic involves loops that repeat a set of instructions.
- Two common loop structures:
- **Repeat-For Structure**:
- Form: `Repeat for i = A to N by I: [Module]`
- The loop executes the module from `A` to `N`, incrementing by `I`.
- Example: Using a `for` loop in C/C++ or Java.
- **Repeat-While Structure**:
- Form: `Repeat while condition: [Module]`
- The loop continues as long as the specified condition holds true.
- Example: Implementing a `while` loop in C++.
#include <iostream>
int main() {
int count = 1; // Initialize a counter
// Execute the loop while the condition (count <= 5) is true
while (count <= 5) {
std::cout << "Iteration " << count << ": Hello, World!" << std::endl;
count++; // Increment the counter
return 0;
In this example:
- We initialize a counter variable `count` to 1.
- The `while` loop runs as long as `count` is less than or equal to 5.
- Inside the loop, we print a message and increment the counter.
- The loop will execute 5 times, printing "Hello, World!" for each iteration.
HOMEWORK:
What is the difference between a while loop and a do-while loop?
FUNCTIONS
1. **Functions**:
- Functions are subprograms designed to perform a specific task and return a value.
- They can take input parameters (arguments) and compute a result.
- Example function definition:
int times(int x, int y) {
int p = 0;
while (y > 0) {
if (y % 2 == 0) {
y /= 2;
x *= 2;
} else {
p += x;
y--;
return p;
```
- Functions are used as operations within expressions:
int i = times(3, i + 2) + 1;
2. **Procedures**:
- Procedures are subprograms designed to perform a series of commands without returning a
value.
- They can also take input parameters.
- Example procedure definition:
void factors(int x) {
int f = 2;
while (x != 1) {
if (x % f == 0) {
cout << f << endl;
x /= f;
} else {
f++;
```
- Procedures are used as statements:
factors(i);
3. **Parameter Passing**:
- Parameters can be passed by value (call-by-value) or by reference (call-by-reference).
- Call-by-value makes a copy of the argument, while call-by-reference passes the memory
location.
- Example:
void p(int x, int& y) {
// Code for p
4. **Benefits of Subprograms**:
- Increases readability: Programs are better structured and easier to understand.
- Enables program design abstraction.
- Facilitates code reuse.
Functions allow us to break down complex tasks into smaller, reusable chunks of code. We'll
cover both basic function examples and more advanced concepts.
1. **Basic Function Example**:
- A simple function that displays a text message:
#include <iostream>
using namespace std;
// Function declaration
void greet() {
cout << "Hello there!";
int main() {
// Calling the function
greet();
return 0;
- Output:
Hello there!
2. **Function with Parameters**:
- A function that takes parameters (arguments):
#include <iostream>
using namespace std;
// Function to display a number
void displayNum(int n1, float n2) {
cout << "The int number is " << n1 << endl;
cout << "The double number is " << n2 << endl;
int main() {
int num1 = 5;
double num2 = 5.5;
// Calling the function with arguments
displayNum(num1, num2);
return 0;
- Output:
The int number is 5
The double number is 5.5
3. **Function with Return Value**:
- A function that computes the sum of two integers and returns the result:
#include <iostream>
using namespace std;
// Function to add two numbers
int add(int a, int b) {
return a + b;
int main() {
int x = 10, y = 20;
// Calling the function and storing the result
int result = add(x, y);
cout << "Sum: " << result << endl;
return 0;
- Output:
Sum: 30
4. **Function Templates**:
- A template function that works with different data types:
#include <iostream>
using namespace std;
// Template function to find the maximum of two values
template <typename T>
T max(T a, T b) {
return (a > b) ? a : b;
int main() {
int intMax = max(10, 20);
double doubleMax = max(3.14, 2.71);
cout << "Max int: " << intMax << endl;
cout << "Max double: " << doubleMax << endl;
return 0;
- Output:
Max int: 20
Max double: 3.14
HOMEWORK:
i. What is the difference between a function and a procedure?
ii. Can you give me an example of passing parameters by reference in C++?
iii. How can I use subprograms to improve my code's efficiency?
// END OF LEC IV
