Applying Modular Techniques
A real-life problem is complex and big. If a monolithic solution is developed it poses these problems −
- Difficult to write, test and implement one big program
- Modifications after the final product is delivered is close to impossible
- Maintenance of program very difficult
- One error can bring the whole system to a halt
To overcome these problems, the solution should be divided into smaller parts called modules. The technique of breaking down one big solution into smaller modules for ease of development, implementation, modification and maintenance is called modular technique of programming or software development.
Advantages of Modular Programming
Modular programming offers these advantages −
- Enables faster development as each module can be developed in parallel
- Modules can be re-used
- As each module is to be tested independently, testing is faster and more robust
- Debugging and maintenance of the whole program easier
- Modules are smaller and have lower level of complexity so they are easy to understand
Identifying the Modules
Identifying modules in a software is a mind boggling task because there cannot be one correct way of doing so. Here are some pointers to identifying modules −
- If data is the most important element of the system, create modules that handle related data.
- If service provided by the system is diverse, break down the system into functional modules.
- If all else fails, break down the system into logical modules as per your understanding of the system during requirement gathering phase.
For coding, each module has to be again broken down into smaller modules for ease of programming. This can again be done using the three tips shared above, combined with specific programming rules. For example, for an object oriented programming language like C++ and Java, each class with its data and methods could form a single module.
Step-by-Step Solution
To implement the modules, process flow of each module must be described in step by step fashion. The step by step solution can be developed using algorithms or pseudocodes. Providing step by step solution offers these advantages −
- Anyone reading the solution can understand both problem and solution.
- It is equally understandable by programmers and non-programmers.
- During coding each statement simply needs to be converted to a program statement.
- It can be part of documentation and assist in program maintenance.
- Micro-level details like identifier names, operations required, etc. get worked out automatically
Control Structures
As you can see in the above example, it is not necessary that a program logic runs sequentially. In programming language, control structures take decisions about program flow based on given parameters. They are very important elements of any software and must be identified before any coding begins.
Algorithms and pseudocodes help analysts and programmers in identifying where control structures are required.
Control structures are of these three types −
Decision Control Structures
Decision control structures are used when the next step to be executed depends upon a criteria. This criteria is usually one or more Boolean expressions that must be evaluated. A Boolean expression always evaluates to “true” or “false”. One set of statements is executed if the criteria is “true” and another set executed if the criteria evaluates to “false”. For example, if statement
Selection Control Structures
Selection control structures are used when program sequence depends upon the answer to a specific question. For example, a program has many options for the user. The statement to be executed next will depend on the option chosen. For example, switch statement, case statement.
Repetition / Loop Control Structures
Repetition control structure is used when a set of statements in to be repeated many times. The number of repetitions might be known before it starts or may depend on the value of an expression. For example, for statement, while statement, do while statement, etc.
As you can see in the image above, both selection and decision structures are implemented similarly in a flowchart. Selection control is nothing but a series of decision statements taken sequentially.
Here are some examples from programs to show how these statements work −
if statement
An if statement consists of a Boolean expression followed by one or more statements.
Syntax
The syntax of an ‘if’ statement in C programming language is −
if(boolean_expression) {
/* statement(s) will execute if the boolean expression is true */
}
If the Boolean expression evaluates to true, then the block of code inside the ‘if’ statement will be executed. If the Boolean expression evaluates to false, then the first set of code after the end of the ‘if’ statement (after the closing curly brace) will be executed.
An if statement can be followed by an optional else statement, which executes when the Boolean expression is false.
Syntax
The syntax of an if…else statement in C programming language is −
if(boolean_expression) {
/* statement(s) will execute if the boolean expression is true */
} else {
/* statement(s) will execute if the boolean expression is false */
}
If the Boolean expression evaluates to true, then the if block will be executed, otherwise, the else block will be executed.
#include <stdio.h>
int main()
{
int age;
printf("Enter your age:");
scanf("%d",&age);
if(age >=18)
{
printf("You are eligible for voting");
}
else
{
printf("You are not eligible for voting");
}
return 0;
}
Output:
Enter your age:14
You are not eligible for voting
switch statement
A switch statement allows a variable to be tested for equality against a list of values. Each value is called a case, and the variable being switched on is checked for each switch case.
Syntax
The syntax for a switch statement in C programming language is as follows −
switch(expression) {
case constant-expression :
statement(s);
break; /* optional */
case constant-expression :
statement(s);
break; /* optional */
/* you can have any number of case statements */
default : /* Optional */
statement(s);
}
The following rules apply to a switch statement −
- The expressionused in a switch statement must have an integral or enumerated type, or be of a class type in which the class has a single conversion function to an integral or enumerated type.
- You can have any number of case statements within a switch. Each case is followed by the value to be compared to and a colon.
- The constant-expressionfor a case must be the same data type as the variable in the switch, and it must be a constant or a literal.
- When the variable being switched on is equal to a case, the statements following that case will execute until a breakstatement is reached.
- When a breakstatement is reached, the switch terminates, and the flow of control jumps to the next line following the switch statement.
- Not every case needs to contain a break. If no breakappears, the flow of control will fall through to subsequent cases until a break is reached.
- A switchstatement can have an optional default case, which must appear at the end of the switch. The default case can be used for performing a task when none of the cases is true. No break is needed in the default case.
#include <stdio.h>
int main() {
int num = 8;
switch (num) {
case 7:
printf("Num variable Value is 7");
break;
case 8:
printf("Num variable Value is 8");
break;
case 9:
printf("Num variable Value is 9");
break;
default:
printf("Out of range");
break;
}
return 0;
}
Output:
Num variable Value is 8
Another switch statement example using char datatype.
#include <stdio.h>
int main()
{
char ch='b';
switch (ch)
{
case 'd':
printf("Case is d ");
break;
case 'b':
printf("Case is b ");
break;
case 'c':
printf("Case is c ");
break;
default:
printf("Default ecase");
}
return 0;
}
Output:
Case is b
When the above code is compiled and executed, it produces the following result −
Well done
Your grade is B
It is possible to have a switch as a part of the statement sequence of an outer switch. Even if the case constants of the inner and outer switch contain common values, no conflicts will arise.