CS计算机代考程序代写 compiler c++ 2021/8/8 Introduction | Modular Programming

2021/8/8 Introduction | Modular Programming

https://ict.senecacollege.ca/~oop244/pages/content/compi.html 1/8

ICT Home Outline Timeline Notes IPC Notes MySeneca Workshops Assignments Instructor

Software
Development

OOP244

Part A – Introduction

Modular Programming

Partition source code into modular solution
Compile modules on Linux and Windows platforms

“Decide which modules you want; partition the program so that data is hidden within modules” (Stroustrup, 1997)

Modules | Stages of Compilation | Example | Unit Tests | Debugging | Summary | Exercises

A modular design consists of a set of modules, which are developed and tested separately. Modular programming implements
modular designs and is supported by both procedural and object-oriented languages. The C programming language supports
modular design through library modules composed of functions. The stdio module provides input and output support, while
hiding its implementation details; typically, the implementation for scanf() and printf() ships in binary form with the
compiler. The stdio.h header file provides the interface, which is all that we need to complete our source code.

This chapter describes how to create a module in an object-oriented languages using C++, how to compile the source code for
each module separately and how to link the compiled code into a single executable binary. The chapter concludes with an
example of a unit test on a module.

MODULES

A well-designed module is a highly cohesive unit that couples loosely to other modules. The module addresses one aspect of the
programming solution and hides as much detail as practically possible. A compiler translates the module’s source code
independently of the source code for other modules into its own unit of binary code.

Consider the schematic of the Transaction application shown below. The main module accesses the Transaction module.
The Transaction module accesses the iostream module. The Transaction module defines the transaction functions
used by the application. The iostream module defines the cout and cin objects used by the application.

To translate the source code of any module the compiler only needs certain external information. This information includes the
names used within the module but defined outside the module. To enable this in C++, we store the source code for each module in
two separate files:

a header file – defines the class and declares the function prototypes
an implementation file – defines the functions and contains all of the logic

The file extension .h (or .hpp) identifies the header file. The file extension .cpp identifies the implementation file.

Note, however, that the names of the header files for the standard C++ libraries do not include a file extension (consider for
example, the header file for the cout and cin objects).

Welcome

Notes

Welcome to OO

Object Terminology

Modular Programming

Types Overloading

Dynamic Memory

Member Functions

Construction

Current Object

Member Operators

Class + Resources

Helper Functions

Input Output

Derived Classes

Derived Functions

Virtual Functions

Abstract Classes

Templates

Polymorphism

I/O Refinements

D C + Resources

Standards

Bibliography

Library Functions

ASCII Sequence

Operator Precedence

C++ and C

Workshops

Assignments

Handouts

Practice

Resources

https://ict.senecac.on.ca/
https://ict.senecacollege.ca/~oop244/index.html
http://www.senecacollege.ca/ssos/findwithoutsemester/oop244/sict
https://ict.senecacollege.ca/~oop244/pages/timeline.html
https://ict.senecacollege.ca/~oop244/pages/content/index.html
https://scs.senecac.on.ca/~ipc144/pages/content/index.html
https://my.senecacollege.ca/webapps/portal/frameset.jsp
https://ict.senecacollege.ca/~oop244/dynamic/workshops/index.html
https://ict.senecacollege.ca/~oop244/pages/assignments/index.html
https://ict.senecacollege.ca/~oop244/pages/instructors/index.html
https://ict.senecacollege.ca/~oop244/pages/content/compi_p.html
https://ict.senecacollege.ca/~oop244/pages/welco.html
https://ict.senecacollege.ca/~oop244/pages/content/index.html
https://ict.senecacollege.ca/~oop244/pages/content/langu.html
https://ict.senecacollege.ca/~oop244/pages/content/objec.html
https://ict.senecacollege.ca/~oop244/pages/content/compi.html
https://ict.senecacollege.ca/~oop244/pages/content/rudim.html
https://ict.senecacollege.ca/~oop244/pages/content/dynam.html
https://ict.senecacollege.ca/~oop244/pages/content/cppst.html
https://ict.senecacollege.ca/~oop244/pages/content/ctors.html
https://ict.senecacollege.ca/~oop244/pages/content/membe.html
https://ict.senecacollege.ca/~oop244/pages/content/overl.html
https://ict.senecacollege.ca/~oop244/pages/content/deepc.html
https://ict.senecacollege.ca/~oop244/pages/content/nonme.html
https://ict.senecacollege.ca/~oop244/pages/content/custo.html
https://ict.senecacollege.ca/~oop244/pages/content/inher.html
https://ict.senecacollege.ca/~oop244/pages/content/dfunc.html
https://ict.senecacollege.ca/~oop244/pages/content/inclu.html
https://ict.senecacollege.ca/~oop244/pages/content/abstr.html
https://ict.senecacollege.ca/~oop244/pages/content/param.html
https://ict.senecacollege.ca/~oop244/pages/content/adhoc.html
https://ict.senecacollege.ca/~oop244/pages/content/basic.html
https://ict.senecacollege.ca/~oop244/pages/content/dclas.html
https://ict.senecacollege.ca/~oop244/pages/content/ansis.html
https://ict.senecacollege.ca/~oop244/pages/content/bibli.html
https://ict.senecacollege.ca/~oop244/pages/content/libraries.html
https://ict.senecacollege.ca/~oop244/pages/content/ascii.html
https://ict.senecacollege.ca/~oop244/pages/content/prece.html
https://ict.senecacollege.ca/~oop244/pages/content/c_cpp.html
https://ict.senecacollege.ca/~oop244/dynamic/workshops/index.html
https://ict.senecacollege.ca/~oop244/pages/assignments/index.html
https://ict.senecacollege.ca/~oop244/pages/handouts/index.html
https://ict.senecacollege.ca/~oop244/pages/practice/index.html
https://ict.senecacollege.ca/~oop244/pages/resources/index.html

2021/8/8 Introduction | Modular Programming

https://ict.senecacollege.ca/~oop244/pages/content/compi.html 2/8

Example

The implementation file for the main module includes the header files for itself (main.h) and the Transaction module
(Transaction.h). The main.h file contains definitions specific to the main module and the Transaction.h file
contains definitions specific to the Transaction module.

The implementation file for the Transaction module includes the header files for itself (Transaction.h) and the
iostream module. The Transaction.h file contains definitions specific to the Transaction module and the iostream
file contains definitions specific to the iostream module.

An implementation file can include several header files but DOES NOT include any other implementation file. Note the absence
of any direct connections between the implementation files.

We compile each implementation (*.cpp) file separately and only once. We do not compile header (*.h) files.

A compiled version of iostream’s implementation file is part of the system library.

STAGES OF COMPILATION

Comprehensive compilation consists of three independent but sequential stages (as shown in the figure below):

1. Preprocessor – interprets all directives creating a single translation unit for the compiler – (inserts the contents of all
#include header files), (substitutes all#define macros)

2. Compiler – compiles each translation unit separately and creates a corresponding binary version
3. Linker – assembles the various binary units along with the system binaries to create one complete executable binary

A MODULAR EXAMPLE

Consider a trivial accounting application that accepts journal transactions from the standard input device and displays them on the
standard output device. For presentation simplicity, the application does not perform any intermediate calculation.

The application design consists of two modules:

Main – supervises the processing of each transaction
Transaction – defines the input and output logic for a single transaction

Transaction Module

2021/8/8 Introduction | Modular Programming

https://ict.senecacollege.ca/~oop244/pages/content/compi.html 3/8

The transaction module defines a structure and functions for a single transaction

Transaction – holds the information for a single transaction in memory

The related functions are global functions

enter() – accepts transaction data from the standard input device
display() – displays transaction data on the standard output device

Transaction.h

The header file for our Transaction module defines our Transaction type and declares the prototypes for our two functions:

// Modular Example
// Transaction.h

struct Transaction {
int acct; // account number
char type; // credit ‘c’ debit ‘d’
double amount; // transaction amount
};

void enter(struct Transaction* tr);
void display(const struct Transaction* tr);

Note the UML naming convention and the extension on the name of the header file.

Transaction.cpp

The implementation file for our Transaction module defines our two functions. This file includes the system header file for
access to the cout and cin objects and the header file for access to the Transaction type.

// Modular Example
// Transaction.cpp

#include // for cout, cin
#include “Transaction.h” // for Transaction
using namespace std;

// prompts for and accepts Transaction data
//
void enter(struct Transaction* tr) {

cout << "Enter the account number : "; cin >> tr->acct;
cout << "Enter the account type (d debit, c credit) : "; cin >> tr->type;
cout << "Enter the account amount : "; cin >> tr->amount;
}

// displays Transaction data
//
void display(const struct Transaction* tr) {

cout << "Account " << tr->acct;
cout << ((tr->type == ‘d’) ? ” Debit $” : ” Credit $”) << tr->amount;
cout << endl; } Note the .cpp extension on the name of this implementation file Main Module The main module defines a Transaction object and accepts input and displays data for each of three transactions. main.h The header file for our Main module #defines the number of transactions: 2021/8/8 Introduction | Modular Programming https://ict.senecacollege.ca/~oop244/pages/content/compi.html 4/8 // Modular Example // main.h #define NO_TRANSACTIONS 3 main.cpp The implementation file for our Main module defines the main() function. We #include the header file to provide the definition of the Transaction type: // Modular Example // main.cpp #include "main.h" #include "Transaction.h" int main() { int i; struct Transaction tr; for (i = 0; i < NO_TRANSACTIONS; i++) { enter(&tr); display(&tr); } } Command Line Compilation Linux To compile our application on a Linux platform at the command line, we enter the following g++ -o accounting main.cpp Transaction.cpp The -o option identifies the name of the executable. The names of the two implementation files complete the command. To run the executable, we enter accounting Legacy Linux To compile an application that includes a C++11 feature on a legacy Linux installation, we may need to specify the standard option. For example, to access C++11 features on the GCC 4.6 installation on our matrix cluster, we write g++ -o accounting -std=c++0x main.cpp Transaction.cpp Options for versions 4.7 and later include c++11 and gnu++11. Visual Studio To compile our application at the command-line on a Windows platform using the Visual Studio compiler, we enter the command (To open the Visual Studio command prompt window, we press Start > All Programs and search for the prompt in the
Visual Studio Tools sub-directory. )

cl /Fe accounting main.cpp Transaction.cpp

The /Fe option identifies the name of the executable. The names of the two implementation files follow this option.

To run the executable, we enter

accounting

2021/8/8 Introduction | Modular Programming

https://ict.senecacollege.ca/~oop244/pages/content/compi.html 5/8

IDE Compilation

Integrated Development Environments (IDEs) are software development applications that integrate features for coding, compiling,
testing and debugging source code in different languages. The IDE used in this course is Microsoft’s Visual Studio.

Build and Execute

The following steps build and execute a modular application in Visual Studio 2013 or newer:

Start Visual Studio
Select New Project
Select Visual C++ -> Win32 -> Console Application
Enter Transaction Example as the Project Name | Select OK
Press Next
Check Empty Project | Press Finish
Select Project -> Add New Item
Select Header .h file | Enter Transaction as File Name | Press OK
Select Project -> Add New Item
Select Implementation .cpp file | Enter Transaction as File Name | Press OK
Select Project -> Add New Item
Select Header .h file | Enter main as File Name | Press OK
Select Project -> Add New Item
Select Implementation .cpp file | Enter main as File Name | Press OK
Select Build | Build Solution
Select Debug | Start without Debugging

The input prompts and the results of execution appear in a Visual Studio command prompt window.

UNIT TESTS

Unit testing is integral to modular programming. A unit test is a code snippet that tests a single assumption in a module or work
unit of a complete application. Each work unit is a single logical component with a simple interface. Functions and classes are
typical examples.

We use unit tests to examine the work units in an application and rerun the tests after each upgrade. We store the test suite in a
separate module.

Calculator Example

Consider a Calculator module that raises an integer to the power of an integer exponent and determines the integer exponent
to which an integer base has been raised to obtain a given result. The header file for the Calculator module includes the
prototypes for these two work units:

// Calculator.h
// …
int power(int, int);
int exponent(int, int);

The suite of unit tests for this module checks if the implementations return the expected results. The header file for the Tester
module contains:

// Tester.h

int testSuite(int BASE, int EXPONENT, int RESULT);

The implementation file for the Tester module contains:

// Tester.cpp

#include
using namespace std;
#include “Calculator.h”

int testSuite(int BASE, int EXPONENT, int RESULT) {
int passed = 0;

2021/8/8 Introduction | Modular Programming

https://ict.senecacollege.ca/~oop244/pages/content/compi.html 6/8

int result;
result = power(BASE, EXPONENT);
if (result == RESULT) {
cout << "Raise to Power Test Passed" << endl; passed++; } else { cout << "Raise to Power Test Failed" << endl; } result = exponent(RESULT, BASE); if (result == EXPONENT) { cout << "Find Exponent Test Passed" << endl; passed++; } else { cout << "Find Exponent Test Failed" << endl; } return passed; } A first attempt at implementing the Calculator module might look like: // Calculator.cpp #include "Calculator.h" int power(int base, int exp) { int i, result = 1; for (i = 0; i < exp; i++) result *= base; return result; } int exponent(int result, int base) { int exp = 0; while(result >= base) {
exp++;
result /= base;
}
return exp;
}

The following test main produces the results shown on the right:

// Test Main
// testmain.cpp

#include
using namespace std;
#include “Tester.h”

int main() {
int passed = 0;
passed += testSuite(5, 3, 125);
passed += testSuite(5, -3, 0.008);
cout << passed << " Tests Passed" << endl; } Raise to Power Test Passed Find Exponent Test Passed Raise to Power Test Failed Find Exponent Test Failed 2 Tests Passed The tester shows that this implementation does not handle negative-valued bases correctly and needs upgrading. Good Programming Practice It is good programming practice to write the suite of unit tests for the work units in a module as soon as we have defined the header file and before coding the bodies of the work units. As we complete implementation details, we continue testing our module to ensure that it produces the results that we expect and to identity the work that needs to be done. DEBUGGING TECHNIQUES 2021/8/8 Introduction | Modular Programming https://ict.senecacollege.ca/~oop244/pages/content/compi.html 7/8 Programming Errors Programming errors that require debugging skills are of two kinds: syntactic semantic Syntactic Errors Syntactic errors are errors that break the rules of the programming language. The most common syntactic errors in C++ language programs are: missing semi-colon after a struct or class definition unnecessary semi-colon terminator in a #define directive undeclared variable name or missing header file mismatched parentheses left-side of an assignment expression is not a defined memory location return statement is missing Semantic Errors Semantic errors are errors that fail to implement the intent and meaning of the program designer. The more common semantic errors are: = instead of == iteration without a body (for/while followed by a semi-colon) uninitialized variable infinite iteration incorrect operator order in a compound expression dangling else off-by-one iteration integer division and truncation mismatched data types & instead of && Idenfiying Errors Syntactic Errors Techniques for identifying syntactic errors include IDE intellisense compiler error messages (compiler output) comparing error messages from different compilers - some are more cryptic than others reading code statements (walkthroughs) Semantic Errors Techniques for identifying semantic errors include: vocalization - use your sense of hearing to identify the error (compound conditions) intermediate output - cout statements at critical stages walkthrough tables interactive debugging using Visual Studio IDE - integrated debugger for Windows OSs Eclipse IDE - integrated debugger for Linux OSs gdb - GNU debugger for gcc IDE Tracing Example The following steps trace through the execution of our Transaction application using the Visual Studio IDE debugger Select the file named main.cpp Move the cursor to the left-most column of the for statement in the main() function and left-click | This places a red dot in that column, which identifies a breakpoint Move the cursor to the left-most column of the closing brace for the function and left-click | This places a red dot in the column, which identifies another breakpoint Select Debug -> Start Debugging | Execution should pause at the first executable statement
Observe the values under the Locals tab in the Window below the source code
Press F10 and answer the three input prompts
Select the source code Window
Observe the values under the Locals tab in the Window below the source code

2021/8/8 Introduction | Modular Programming

https://ict.senecacollege.ca/~oop244/pages/content/compi.html 8/8

Press F10 3 times and note the value of i
Press F5, note where execution pauses and observe the value of i
Press F5 again to exit

The keystrokes for the various debugging options are listed next to the sub-menu items under the Debug menu.

SUMMARY

a module consists of a header file and an implementation file
a module’s header file declares the names that are exposed to client modules
a module’s implementation file defines the module’s logic
a module’s implementation file needs the header files of those modules that define classes or functions used in the
implementation file
the three stages of creating an executable are preprocessing, compiling, and linking
it is good practice to write the suite of unit tests for each module of an application before coding the module’s
implementation

EXERCISES

Upgrade the Calculator module to pass all of the tests and add further tests to improve robustness
Complete the Workshop on Compiling Modules
Read Wikipedia on Modular Programming

print this page Top

Previous: Object Terminology Next: Types, Overloading and References

ICT Home Outline Timeline

Notes IPC Notes MySeneca Workshops Assignments Instructor

Designed by Chris Szalwinski Copying From This Site Last Modified: 05/20/2017 11:50

https://ict.senecacollege.ca/~oop244/dynamic/workshops/w1.html
http://en.wikipedia.org/wiki/Modular_programming
https://ict.senecacollege.ca/~oop244/pages/content/compi_p.html
https://ict.senecacollege.ca/~oop244/pages/content/objec.html
https://ict.senecacollege.ca/~oop244/pages/content/rudim.html
https://ict.senecac.on.ca/
https://ict.senecacollege.ca/~oop244/index.html
http://www.senecacollege.ca/ssos/findwithoutsemester/oop244/sict
https://ict.senecacollege.ca/~oop244/pages/timeline.html
https://ict.senecacollege.ca/~oop244/pages/content/index.html
https://scs.senecac.on.ca/~ipc144/pages/content/index.html
https://my.senecacollege.ca/webapps/portal/frameset.jsp
https://ict.senecacollege.ca/~oop244/dynamic/workshops/index.html
https://ict.senecacollege.ca/~oop244/pages/assignments/index.html
https://ict.senecacollege.ca/~oop244/pages/instructors/index.html
https://ict.senecacollege.ca/~oop244/pages/copyright.html
http://creativecommons.org/licenses/by/2.5/ca/