CS 247: Software Engineering Principles. Modules

Transcription

1 CS 247: Software Engineering Principles Modules Readings: Eckel, Vol. 1 Ch. 2 Making and Using Objects: The Process of Language Translation Ch. 3 The C in C++: Make: Managing separate compilation Ch. 10 Name Control: Namespaces U Waterloo CS247 (Spring 2017) p.1/21

2 Program Decomposition ADT1.cpp ADT2.cpp main.cpp U Waterloo CS247 (Spring 2017) p.2/21

3 Program Decomposition ADT1.cpp ADT2.cpp main.cpp class B {... }; B *b_obj; Problem: a module may refer to classes, variables, types, functions, constants that are defined in other modules. - Must be declared or defined before use. U Waterloo CS247 (Spring 2017) p.3/21

4 Program Decomposition // nonlocal declarations class A {... }; int foo (); extern int i; extern const int j; ADT1.cpp ADT2.cpp main.cpp // nonlocal declarations class B {... }; int bar (); extern int k; Problem: a module may refer to classes, variables, types, functions, constants that are defined in other modules. - Must be declared or defined before use. Approach #1: Programmer of each module can declare (not define) the non-global names used by his / her module. U Waterloo CS247 (Spring 2017) p.4/21

5 // export local definitions class B {... }; int bar (); extern int k; Program Decomposition ADT1.h ADT2.h #include ADT1.h #include ADT1.h #include ADT2.h ADT1.cpp #include ADT1.h #include ADT2.h ADT2.cpp main.cpp #include ADT1.h #include ADT2.h #include <iostream> Approach #2: Put all of the declarations needed by other modules that "use" our module into a Header File. - Any module that refers to a nonlocal name from our module must #include our module's header file. - The preprocessor replaces each #include statement with the contents of the specified header. U Waterloo CS247 (Spring 2017) p.5/21

6 #ifndef RATIONAL_H #define RATIONAL_H #include <iostream> class Rational { public: Rational (int numer = 0, int denom = 1); ~Rational (); Rational (const Rational&); Rational& operator= ( const Rational& ); int numerator() const; int denominator() const; private: int numerator_; int denominator_; void reduce(); }; // Constructor for user-provided values // Copy Constructor // Assignment // Accessor // Accessor // Arithmetic Operations Rational operator+ (const Rational&, const Rational&); Rational operator* (const Rational&, const Rational&); // Comparison Operations bool operator== (const Rational&, const Rational&); bool operator!= (const Rational&, const Rational&); bool operator< (const Rational&, const Rational&); bool operator<= (const Rational&, const Rational&); bool operator> (const Rational&, const Rational&); bool operator>= (const Rational&, const Rational&); // Streaming Operations std::ostream& operator<< (std::ostream &sout, const Rational &r); std::istream& operator>> (std::istream &sin, Rational &s); #endif

7 Duplicate Header Inclusions // export local definitions class B {... }; int bar (); extern int k; ADT1.h ADT2.h #include ADT1.h #include ADT1.h #include ADT2.h ADT2.cpp Problem: Compilation of a single source file may include the same header declarations multiple times. U Waterloo CS247 (Spring 2017) p.7/21

8 Header Guard #ifndef RATIONAL_H #define RATIONAL_H // class Rational declaration and related functions go here... #endif U Waterloo CS247 (Spring 2017) p.8/21

9 Circular Dependencies A circular dependency occurs when two or more header files depend on each other. #include ADT2.h ADT1.h ADT2.h #include ADT1.h U Waterloo CS247 (Spring 2017) p.9/21

10 Forward Declarations ADT1.h... class ADT2; class ADT1 { friend class ADT2; int data_; ADT1 *next_; }; ADT2.h... class ADT1; class ADT2 { ADT1 *s; }; A forward declaration notifies compiler that data or function will be declared/defined in the future. Use forward declarations to break circular header dependencies. U Waterloo CS247 (Spring 2017) p.10/21

11 Namespace Etiquette Never place a using directive (using namespace X)... Inside of a header file: header could be included in any number of other files, affects the set of names visible in those files. Before an #include directive in an implementation file: affects the set of names visible in the subsequent header. U Waterloo CS247 (Spring 2017) p.11/21

12 The Build Process C++ Source Code cpp (preprocessor) Header Header Files Files Header Files Preprocessed Source Code cc1plus (compiler) Assembly Code Libraries Libraries Libraries as (assembler) Object Code ld (linker) Object Code Object Other Code Object Code Files Executable Program U Waterloo CS247 (Spring 2017) p.12/21

13 Separate Compilation Because linking is a separate process, can rebuild the program by: - recompiling only the files that have changed, - linking together the object files. g++-5 -std=c++14 -c main.cpp g++-5 -std=c++14 -c ADT2.cpp g++-5 -std=c++14 -c ADT1.cpp g++-5 -std=c++14 ADT1.o ADT2.o main.o -o exec # linking U Waterloo CS247 (Spring 2017) p.13/21

14 Compilation Dependencies If a file F changes, need to recompile F and all files that depend on F the executable depends on.o files the.o files depend on.cpp files the.cpp files depend on.h files Example: main.cpp: #include "ADT1.h" a.out ADT1.h: #include "ADT2.h" ADT1.cpp: #include "ADT1.h" main.o main.cpp ADT1.o ADT1.cpp ADT2.o ADT2.cpp ADT2.h: class ADT1 ADT2.cpp: #include "ADT2.h" ADT1.h ADT2.h U Waterloo CS247 (Spring 2017) p.14/21

15 Automated Builds Goal: Want a fully automated build system that: is sure to incorporate all updated source files into executable, is incremental and rebuilds only what has changed, automatically derives the dependency relationships among files. U Waterloo CS247 (Spring 2017) p.15/21

16 Make make is a UNIX command that uses (1) build instructions and file dependencies provided in a [Mm]akefile, and (2) file timestamps to decide which files to recompile/rebuild. Example (partial) Makefile: # A comment program: main.o ADT1.o ADT2.o # dependency graph tab g++ main.o ADT1.o ADT2.o -o program # build rule U Waterloo CS247 (Spring 2017) p.16/21

17 Makefile program : main.o ADT1.o ADT2.o # default target g++-5 -std=c++14 -g -Wall main.o ADT1.o ADT2.o -o program main.o : main.cpp ADT1.h g++-5 -std=c++14 -g -Wall -c main.cpp -o main.o ADT1.o : ADT1.cpp ADT1.h ADT2.h g++-5 -std=c++14 -g -Wall -c ADT1.cpp -o ADT1.o ADT2.o : ADT2.cpp ADT2.h ADT1.h g++-5 -std=c++14 -g -Wall -c ADT2.cpp -o ADT2.o U Waterloo CS247 (Spring 2017) p.17/21

18 Makefile with Macros Makefile is more reusable if rules can be defined in terms of macros that are set at the top of the file. CXX = g++-5 -std=c++14 # = specifies a new macro CXXFLAGS = -g -Wall -Werror -Wextra -Wpedantic OBJECTS = main.o ADT1.o ADT2.o EXEC = program.exe ${EXEC} : ${OBJECTS} # ${ } expand the macro ${CXX} ${CXXFLAGS} ${OBJECTS} -o ${EXEC} main.o : main.cpp stack.h ${CXX} ${CXXFLAGS} -c main.cpp U Waterloo CS247 (Spring 2017) p.18/21

19 Implicit Rules CXX = g++-5 -std=c++14 # variables and initialization CXXFLAGS = -g -Wall -Werror -Wextra -Wpendantic OBJECTS = main.o stack.o node.o EXEC = program ${EXEC} : ${OBJECTS} # default target ${CXX} ${CXXFLAGS} ${OBJECTS} -o ${EXEC} # gmake knows how to build.o files; just list dependencies main.o : main.cpp stack.h stack.o : stack.cpp stack.h node.h node.o : node.cpp node.h stack.h clean : # second target rm -rf ${OBJECTS} ${EXEC} gmake has implicit rules for processing files with specific suffixes and when special variable names are used. Target clean removes files that can be rebuilt (to save space). U Waterloo CS247 (Spring 2017) p.19/21

20 Automatically Derive Dependencies CXX = g++-5 -std=c++14 # variables and initialization CXXFLAGS = -g -MMD -Wall -Werror -Wextra -Wpedantic # builds dependency lists in.d files OBJECTS = main.o stack.o node.o DEPENDS = ${OBJECTS:.o=.d} # substitute ".o" with ".d" EXEC = program ${EXEC} : ${OBJECTS} ${CXX} ${CXXFLAGS} ${OBJECTS} -o ${EXEC} clean : rm -rf ${DEPENDS} ${OBJECTS} ${EXEC} -include ${DEPENDS} # reads the.d files and reruns # dependencies g++ flag -MMD generates a dependency graph for user source files. U Waterloo CS247 (Spring 2017) p.20/21

21 Take Aways Recognition The benefits of modular design The benefits of separate compilation Comprehension Principle of Separation of Concerns Principle of Information Hiding Application Construct a program s module dependency diagram Specify C++ header files Use interfaces/modules and forward declarations to reduce modular dependencies Create basic Makefiles that derive header dependencies U Waterloo CS247 (Spring 2017) p.21/21