Back Matter

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Appendix A: Acquiring, Building, and Executing pdCalc

This appendix explains how to acquire and build pdCalc, the program described in this book.

A.1 Getting the Source Code

The source code for pdCalc is hosted on Apress’s GitHub repository:

https://github.com/Apress/practical-cplusplus-design-2e

From the GitHub site, you have two options for downloading the source code. The first option is to use a git client (https://git-scm.com/) and clone the repository to your local computer. For those familiar with managing source code with git, this is the preferred source code acquisition method. Using git to clone the repository will enable you to pull periodic bug updates from the online repository. Maybe you’ll even decide to contribute a bug fix to pdCalc yourself! The second option for acquiring the source code is to download a single zip file of pdCalc from GitHub. Obviously, downloading a single zip file makes updating the source code significantly more challenging than using git if you have made any local changes.

A.2 Dependencies

Now that you have the source code, you’ll probably want to build and execute pdCalc and its unit test suite. Before that can be accomplished, however, you’ll need to ensure that you have an appropriate toolchain. Intentionally, pdCalc requires very few external dependencies, all of which can be obtained for Linux, Windows, or Mac OS X at no cost. In order to build pdCalc, you will need a modern C++ compiler (C++20 compliant), Qt (version 5 or 6), and CMake.

As someone willing to have read this book, you probably already have or know how to get a C++ compiler. Unfortunately, at the time of writing, only one major compiler, Microsoft’s Visual C++ (MSVC), sufficiently supports the C++20 standard to build pdCalc. Fortunately, however, Microsoft provides a free version of Visual Studio (VS), Community Edition, which is downloadable from their website (https://visualstudio.microsoft.com). The current version of Visual Studio is 2019, with version VS 2022 currently in preview. For Visual Studio 2019, you’ll need at least version 16.10 to build the code as is.

On the Windows platform, Qt and its IDE, Qt Creator, can be downloaded from www.qt.io/download. Once you are on the website, select the version that is licensed appropriately for your use. pdCalc is distributed under the GPL version 3, so the open source edition of Qt is compatible. From there, download and execute the Qt Online Installer. If you don’t already have a Qt account, you’ll need to create one first. When you’re ready to install Qt, ensure you select the MSVC 2019 (32 or 64 bit, as appropriate) binaries for installation. While not strictly necessary, I highly recommend also installing Qt Creator. Please be patient with the download. Qt, with its many modules, is a powerful but very sizable package.

If you’ve written a lot of cross-platform C++ code, you’ve probably already encountered CMake. If it is not already installed on your system, it can be acquired from the CMake website: https://cmake.org. Building pdCalc with CMake is described in Section A.3.

For the first edition of this book, pdCalc was built with Qt’s own qmake tool. While qmake is still supported in Qt 6, the preferred build system for Qt 6 is CMake. I therefore chose to “upgrade” pdCalc’s build system from qmake to CMake. Additionally, even though CMake did not support automatic detection of C++ modules when this book was written, I found CMake to be more accommodating than qmake in compiling C++ modules. Admittedly, this ease of use may reflect more on my experience with each tool than with each tool’s actual flexibility.

A.3 Building pdCalc

pdCalc uses CMake for its build system and QTest for its unit test framework. Other good alternatives for unit testing are boost test, cppunit, or Google Test. QTest was used to avoid adding any additional dependencies. To build pdCalc, you can either configure and compile at the command line or use Qt Creator. Both build methods rely on CMake. Therefore, before discussing how to build pdCalc, a brief explanation of how CMake operates is warranted.

Using CMake to build a solution is a two-step process involving both CMake and a build tool such as ninja or make. CMake itself does not directly call the compiler and linker. Rather, CMake is simply a cross-platform build file generator. Therefore, in the first step of the build process, CMake reads its CMakeLists.txt configuration files and produces files native to the build tool you specified. This step needs to be performed before the first build and subsequently only after changes requiring modification to configuration files (e.g., the addition of a new source file). In the second step, the object code is built using your specified build tool, which, in turn, calls the compiler and linker. For pdCalc, on a Windows system, I set up the CMake configuration files to use Visual Studio’s nmake, which will, in turn, use the MSVC compiler and linker. Alternatively, it should be fairly easy to modify the CMakeLists.txt files to build with Visual Studio directly or with its command line build tool, msbuild. The main problems you will likely encounter are in the post build steps required to copy files (e.g., the plugin file and some testing files) to the proper build directories.

Now that you understand how CMake works, let’s examine how to build pdCalc using either Qt Creator or the command line. Since MSVC is the only compiler currently capable of building pdCalc, only Windows instructions are given. Once they reach a level of maturity capable of compiling pdCalc, the build processes using GCC and clang should be similar. In particular, though, you will need to modify the CMakeLists.txt files to manually account for module interface files and compiler options. I’ve provided an initial framework for working with both GCC and clang in the top-level CMake configuration file.

A.3.1 Using Qt Creator

If your preference is to use Qt Creator, most of the complexity of using CMake will be hidden from you. First, you need to ensure that Qt Creator is configured to use nmake (make if you are attempting to use GCC or clang). To begin, simply launch the IDE and click Tools->Options... from the menu. This will display the Qt Creator options dialog. If it is not already selected, select the Kits tab. If you have a valid C++ compiler and Qt installed, you should see at least one desktop kit in the auto-detected list. Highlight the kit you intend to use. Toward the bottom of this kit’s options, you should see the ability to set the CMake Generator. If it is not already set to NMake Makefiles, click Change... and select NMake Makefiles as your generator and click Ok. You are now ready to open pdCalc’s project.

Go to the File menu and open the CMakeLists.txt file located at the top level of pdCalc’s source tree. The first time you open a CMake project file with Qt Creator, you will be presented with a configuration list asking you which kit to target (you may only have one option). Select a kit that is configured to use either Qt 5 or 6, a C++20-conforming compiler, and a properly configured CMake generator. If you expand the Details button for your selected Qt version, you will be given the option to configure pdCalc for Debug, Release, and a few other configurations. Select the configurations you wish to build, and, optionally, modify the default location for your out-of-source build. Once you have selected your configuration options, click the Configure Project button. Qt Creator will then configure your project. You can always change both your build and execute configuration options later through the Projects tab on the left (the wrench icon) in Qt Creator.

After Qt Creator configures your project, you will be presented with the edit mode for the project. The edit mode of Qt Creator is a good tool for exploring the source code. The complete source tree will appear in an expandable tree control on the left side of the display, and individual files can be opened by clicking on them. The source tree for pdCalc is described in Appendix B.

Qt Creator works similarly to any other fully featured IDE you have probably used, and a complete description of its usage is beyond the scope of this appendix (see http://doc.qt.io/qtcreator for its full manual). However, I will highlight a few quick features to help get you started. If you don’t like Qt Creator, pdCalc should work with any IDE that can understand CMake projects. You also have the option of using any IDE or text editor to view and modify the source code and then using the command line for compiling and debugging.

The first shortcut to learn is choosing which configuration of your project you want to build and run. These options are selected by the monitor icon in the lower left corner of the display. It will currently be labeled with the active project (pdCalc if it’s the only project loaded) and the current configuration (e.g., Debug or Release). If you click this monitor icon, a pane will open, allowing you to select which configuration you wish to build and which executable you wish to run. For pdCalc, you’ll have four executable options: pdCalc, pdCalc-simple-cli, pdCalc-simple-gui, and testDriver. pdCalc runs the full version of pdCalc (the GUI by default), pdCalc-simple-cli runs the simple CLI constructed at the end of Chapter 5, pdCalc-simple-gui runs the simple GUI constructed at the end of Chapter 6, and testDriver runs the unit test suite. If you want to change the build or run configuration options, you can click the Projects button (folder icon) on the left side of the display to open the configuration panel. Clicking the Edit button will bring you back to edit mode.

pdCalc can be built either through the Build menu or by clicking the hammer icon (at least that’s what it looks like to me) on the lower left side of the display. If you want to watch the compiler output as it builds, click the Compile Output button on the bottom of your screen. If you have any build issues, they can be found on the Issues tab of the same information panel. Clicking on one of these issues should take you to the offending line of source code. Hopefully, pdCalc will build for you with no issues, no warnings, and no errors. If you have build problems, see the “Troubleshooting” section.

A.3.2 Using the Command Line

If Qt Creator is not for you, pdCalc can be built directly at the command line. The first step in building at the command line is, of course, launching the command shell. While this may seem obvious, what might not be obvious is that you need to specifically launch the Visual Studio command shell, usually located in the start menu with a name like “x64 Native Tools Command Prompt for VS 2019.” I always build in 64-bit mode, but I suspect pdCalc will build correctly if you choose the 32-bit shell and have all of the appropriate 32-bit libraries installed.

Once you have launched a VS command shell, you are ready to configure CMake and then compile. CMake supports out-of-source builds, which is the recommended strategy. Simply create a build directory for each configuration of pdCalc that you wish to build, change your path to the build directory, and issue the following command:

CMake -G"NMake Makefiles" $PATH_TO_PDCALC

where $PATH_TO_PDCALC must be replaced by the path to the CMakeLists.txt file in pdCalc’s root directory. If Qt is in your environment path variable, CMake should produce all the files needed to build pdCalc. If you receive an error indicating that CMake could not find Qt, you will need to either add the Qt bin directory to your path or manually specify how to find Qt by setting the CMAKE_PREFIX_PATH variable. For example, on my Windows machine, to use 64-bit Qt 5, I would instead call CMake as follows:

cmake -G"NMake Makefiles" -DCMAKE_PREFIX_PATH="c:Qt5.15.2msvc2019_64" $PATH_TO_PDCALC

You can also issue additional options to CMake during this initial configuration phase, or you can reconfigure CMake later. CMake configuration options are issued using the -D switch. For example, to use Qt 6 (the configuration defaults to Qt 5), you would issue the following command:

cmake -G"NMake Makefiles" -DPDCALC_QT_VERSION=6 $PATH_TO_PDCALC

The other option you may wish to specify at the command line is which configuration you want to build. By default, CMake will configure the project to build the Debug configuration. If instead you wanted to configure CMake to build Release, you would issue the following command:

cmake -G"NMake Makefiles" -DCMAKE_BUILD_TYPE=Release $PATH_TO_PDCALC

If it’s not obvious, you can combine multiple CMake options on one line, and you can reissue separate options on successive calls to CMake. Your configuration options are saved in a CMake cache file in the build tree.

The preceding command triggers CMake to descend the pdCalc directory tree recursively reading each configuration file and writing a corresponding makefile. If everything executes normally, the output from the preceding command should be a sequence of lines informing you about detected compiler configurations and features ending with a statement informing you that build files have been written. After these makefiles are written, pdCalc can be built by issuing the build command nmake in the same top-level directory from which the CMake command was issued. The code should build cleanly without errors.

A.4 Executing pdCalc

pdCalc, pdCalc-simple-cli, and pdCalc-simple-gui and the unit test suite can be executed from Qt Creator, the command line, or double-clicking the executable (if all of your executable paths are correctly set). Let’s look at the details for the first two options. Hopefully, double-clicking is self-explanatory.

A.4.1 Using Qt Creator

Using Qt Creator, the currently selected executable can be started by pressing the green triangular run button in the lower left corner. The green triangle with the magnifying glass will start the executable in Qt Creator’s interactive debugger. If the source code is out of date, the project will be built before execution begins. If you currently have the testDriver executable selected, the unit test suite will execute, and its output will appear in the Application Output information panel. Hopefully, you will see details of individual tests passing with a final message of “All tests passed.” If you currently have either the pdCalc or pdCalc-simple-gui executable selected, the GUI should launch. If you have the pdCalc-simple-cli executable selected, the CLI will launch in the Application Output information panel. However, you cannot interact with the CLI using this panel, making this mode of executing the CLI rather useless.

A.4.2 Using the Command Line

pdCalc is configured to build all executables in the bin directory and all shared libraries in the lib directory. Therefore, in Windows, pdCalc’s lib directory must be added to the path before the executables are launched. For example, for a command line execution of pdCalc on Windows, one must first issue the following command:

path=%path%;$PATH_TO_PDCALC_LIB

where $PATH_TO_PDCALC_LIB must be replaced by the relative or absolute path to the pdCalc lib directory. As an example, $PATH_TO_PDCALC_LIB can be set to ..lib for the relative path if executing pdCalc from the bin directory. Of course, an alternative is to simply copy the DLLs into the same location as the executables.

A build of pdCalc creates four executables: pdCalc, pdCalc-simple-cli, pdCalc-simple-gui, and testPdCalc (all have an .exe extension in Windows).

testPdCalc runs the unit test suite; it is a command line only program. As each unit test runs, you will see the names of the individual tests, the passage or failure of each test, and some statistics for each unit test suite. If all of the tests pass, an “All tests passed” message will be issued as the final output.

The pdCalc executable launches the complete calculator. It can be launched with the --gui option to run the graphical user interface, the --cli option to run the command line interface, or the --batch option to run the calculator in batch mode. Batch operation requires an input file and, optionally, an output file. pdCalc can also be given the --help option to see a listing of the various modes of operation. If no command line option is given, pdCalc defaults to launching the GUI.

The pdCalc-simple-cli executable launches the simple CLI built at the end of Chapter 5. The pdCalc-simple-gui executable launches the simple GUI built at the end of Chapter 6. Strictly speaking, both of these executables are unnecessary. They are provided merely as a convenience to the reader to be able to run pdCalc before it reaches feature complete status. In agile terms, these feature-incomplete executables provide stages of a minimum viable product.

A.5 Troubleshooting

Despite considerable effort to ensure trouble-free building of pdCalc, I still find that every different combination of Qt, CMake, environment variables, operating system, and probably the weather manages to create some new, wonderful build error. If you encounter build or runtime errors, I encourage you to make an effort to diagnose and correct them yourself. Diagnosing and correcting build errors is a skill worth acquiring. It will also give you a greater appreciation for the thankless soul on your team tasked with maintaining your cross-platform build system. Often, the problem is as trivial as conflicting compiler versions or incorrect/missing paths.

Finally, I do understand that it can be extremely frustrating to invest time (and possibly money) on a new book and find that you cannot build the accompanying source code per the author’s instructions. If you’ve tried unsuccessfully to fix a build or runtime error yourself and find yourself ready to throw your computer (or this book!) out of the nearest window, just send me an email ([email protected]). I’ll do my best to get you up and running as quickly and as painlessly as possible.

Appendix B: Organization of the Source Code

The easiest way to explore the source code is through an IDE such as Qt Creator. However, this appendix is provided as a navigational guide to the source code tree. In addition to the source code files listed in the following tables, the source tree also contains CMake project files, a few assorted configuration files, and a few baseline files for regression tests.

The root level in the source code tree contains the root level CMakeLists.txt file and two directories, src and test, which contain the source code for pdCalc and the unit tests, respectively. Let’s look at these directories separately.

B.1 The src Directory

The src directory subdivides into six directories: 3rdParty, app, utilities, backend, ui, and plugins. The 3rdParty directory contains the single instance of third-party code provided with pdCalc. The app directory is a folder for containing the pdCalc, pdCalc-simple-cli, and pdCalc-simple-gui directories. The utilities directory contains utility classes for pdCalc. The backend directory contains the stack module, the command dispatcher module, and all of the plugin management functionality. The ui directory is a folder for containing the user interface components, including both the CLI and the GUI. Finally, the plugins directory houses the single plugin included with pdCalc. Let’s now look at the files contained in each directory.

B.1.1 The 3rdParty Directory

The 3rdParty directory contains the single third-party tool required by pdCalc, cppcoro’s generator.hpp. While this file is only included in a single source file, Tokenizer.m.cpp in the utilities directory, it was placed in its own directory to clearly delineate code that is part of pdCalc versus code that is external to pdCalc.

B.1.2 The app/pdCalc Directory

The pdCalc directory contains the source code that compiles into the pdCalc executable. Notably, this directory contains the main() function located in main.cpp, which is the entry point into the application.

B.1.3 The app/pdCalc-simple-cli Directory

The pdCalc-simple-cli directory contains the source code that compiles into the simple CLI-only executable defined at the end of Chapter 5. This directory contains a single file, main.cpp.

B.1.4 The app/pdCalc-simple-gui Directory

The pdCalc-simple-gui directory contains the source code that compiles into the simple GUI-only executable defined at the end of Chapter 6. This directory contains a single file, main.cpp.

B.1.5 The utilities Directory

The utilities directory contains generic, reusable components, none of which are specifically associated with the calculator’s logic. Table B-1 lists the files contained in the utilities directory.

Table B-1

Source files in the utilities directory

Module Interface Files

Exception.m.cpp

Observer.m.cpp

Publisher.m.cpp

Tokenizer.m.cpp

Utilities.m.cpp

B.1.6 The backend Directory

The backend directory contains all of the “business logic” for the calculator. From the model-view-controller perspective, this directory contains the model and the controller. The backend directory also contains all of the logic for loading and managing plugins as well as the observer intermediary classes. Table B-2 lists the files contained in the backend directory.

Table B-2

Source files in the backend directory

Module Interface Files	Implementation Files
AppObservers.m.cpp	Command.cpp
Command.m.cpp	CommandInterpreter.cpp
CommandDispatcher.m.cpp	PlatformFactory.cpp
CommandInterpreter.m.cpp	PosixFactory.cpp
CommandManager.m.cpp	StackPluginInterface.cpp
CommandFactory.m.cpp	StoredProcedure.cpp
CoreCommands.m.cpp	WindowsFactory.cpp
DynamicLoader.m.cpp
PlatformFactory.m.cpp
Plugin.m.cpp
PluginLoader.m.cpp
PosixDynamicLoader.m.cpp
PosixFactory.m.cpp
Stack.m.cpp
StackPluginInterface.m.cpp
StoredProcedure.m.cpp
WindowsDynamicLoader.m.cpp
WindowsFactory.m.cpp

B.1.7 The ui Directory

The ui directory contains the source code for the user interface module, including both the CLI and the GUI. Notably, this is the only directory in pdCalc that contains traditional header files (excluding the test suite). Table B-3 lists the source files found in the ui directory.

Table B-3

Source files in the ui directory

Header Files	Module Interface Files	Implementation Files
CommandButton.h	Cli.m.cpp	CommandButton.cpp
Display.h	UserInterface.m.cpp	Display.cpp
GuiModel.h		GuiModel.cpp
InputWidget.h		InputWidget.cpp
LookAndFeel.h		LookAndFeel.cpp
MainWindow.h		MainWindow.cpp
StoredProcedureDialog.h		StoredProcedureDialog.cpp

B.1.8 The plugins Directory

The plugins directory is a placeholder directory for the source code for plugins to pdCalc. It only includes one subdirectory, hyperbolicLnPlugin, which contains the source code for the hyperbolic functions and natural logarithm plugin developed in this book. The only source file in the hyperbolicLnPlugin directory is HyperbolicLnPlugin.cpp. The source code implementing plugin loading and plugin management is all contained in the backend directory.

B.2 The test Directory

The test directory is the home directory for all of the unit tests for pdCalc. This directory is simply a container for the following subdirectories, each of which tests the shared library corresponding to its name: utilitiesTest, backendTest, uiTest, and pluginsTest. The testDriver directory contains the code necessary to instantiate the tests, add them to the test manager, and execute the test suite. While I like to believe that I have been diligent in testing pdCalc thoroughly, I am certain of two things: I could have tested the code more, and bugs will be found after publication. We now detail the contents of each of the directories under test.

B.2.1 The testDriver Directory

The testDriver directory contains a single source file, main.cpp. This file sets up the QTest environment and registers all of the individual test modules. main.cpp compiles into the testPdCalc.exe executable, which is responsible for running all of the unit tests.

B.2.2 The utilitiesTest Directory

The utilitiesTest directory contains the files necessary for testing the utilities module. The files contained in this directory are listed in Table B-4.

Table B-4

Source files in the utilitiesTest directory

Header Files	Implementation Files
PublisherObserverTest.h	PublisherObserverTest.cpp
TokenizerTest.h	TokenizerTest.cpp

B.2.3 The backendTest Directory

The backendTest directory contains the source code for testing the backend shared library of pdCalc. The files contained in this directory can be found in Table B-5. In addition to the source code files, the directory also contains a hypotenuse file containing a test stored procedure and the files plugins.unix.pdp and plugins.unix.win, which are plugin loader files for the two respective operating systems.

Table B-5

Source files in the backendTest directory

Header Files	Implementation Files
CommandInterpreterTest.h	CommandInterpreterTest.cpp
CommandManagerTest.h	CommandManagerTest.cpp
CommandFactoryTest.h	CommandFactoryTest.cpp
CoreCommandsTest.h	CoreCommandsTest.cpp
PluginLoaderTest.h	PluginLoaderTest.cpp
StackTest.h	StackTest.cpp
StoredProcedureTest.h	StoredProcedureTest.cpp

B.2.4 The uiTest Directory

The uiTest directory contains the source code files necessary for testing the user interface. The files contained in this directory can be found in Table B-6. In addition to the source files, the uiTest directory contains a subdirectory, testCases. The testCases directory contains input files and output baselines used in testing the command line interface.

Table B-6

Source files in the backendTest directory

Header Files	Implementation Files
CliTest.h	CliTest.cpp
DisplayTest.h	DisplayTest.cpp

B.2.5 The pluginsTest Directory

The pluginsTest directory contains the source files for testing the single plugin included with pdCalc, the hyperbolic functions, and natural logarithm plugin. These tests are contained in the following two source files: HyperbolicLnPluginTest.h and HyperbolicLnPluginTest.cpp.

References

[1] Cmake. https://cmake.org/.
[2] fmtlib/fmt: A modern formatting library. https://github.com/fmtlib/fmt.
[3] vector<bool>{true, true, false}; The creations of a mad(dening) template specialization. https://vector-of-bool.github.io/.
[4] Alfred V. Aho, Moica S. Lam, Ravi Sethi, and Jeffrey D. Ullman. Compilers: Principles, Techniques, and Tools. Addison-Wesley, Boston, Massachusetts, second edition, 2007.
[5] Andrei Alexandrescu. Modern C++ Design: Generic Programming and Design Patterns Applied. Addison-Wesley, Boston, Massachusetts, 2001.
[6] Lewis Baker. Asymmetric transfer: Some thoughts on programming, C++, and other things. https://lewissbaker.github.io/.
[7] Lewis Baker. cppcoro: A library of C++ coroutine abstractions for the coroutines TS. https://github.com/lewissbaker/cppcoro.
[8] Grady Booch, Robert A. Maksimchuk, Michael W. Engel, Bobbi J. Young, Jim Conallen, and Kelli A. Houston. Object-Oriented Analysis and Design with Applications. Addison-Wesley, Boston, Massachusetts, third edition, 2007.
[9] Grady Booch, James Rumbaugh, and Ivar Jacobson. The Unified Modeling Language User Guide. Addison-Wesley, Boston, Massachusetts, 1999.
[10] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. Introduction to Algorithms. The MIT Press, Cambridge, Massachusetts, third edition, 2009.
[11] Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley, Boston, Massachusetts, 1995.
[12] Free Software Foundation, Inc. GNU Public Licence version 3, June 2007. www.gnu.org/licenses/gpl.html.
[13] Nicolai M. Josuttis. The C++ Standard Library: A Tutorial and Reference. Addison-Wesley, Upper Saddle River, New Jersey, second edition, 2012.
[14] Brian W. Kernighan and Rob Pike. The Practice of Programming. Addison-Wesley, Reading, Massachusetts, 1999.
[15] Donald E. Knuth. The Art of Computer Programming: Volume 1, Fundamental Algorithms. Addison-Wesley, Boston, Massachusetts, third edition, 1997.
[16] Donald E. Knuth. The Art of Computer Programming: Volume 2, Seminumerical Algorithms. Addison-Wesley, Boston, Massachusetts, third edition, 1998.
[17] Donald E. Knuth. The Art of Computer Programming: Volume 3, Sorting and Searching. Addison-Wesley, Boston, Massachusetts, third edition, 1998.
[18] Stanley B. Lippman. Inside The C++ Object Model. Addison-Wesley, Reading, Massachusetts, 1996.
[19] Stanley B. Lippman and Jos´ee Lajoie. C++ Primer. Addison-Wesley, Reading, Massachusetts, third edition, 1998.
[20] Steve McConnell. Code Complete. Microsoft Press, Redmond, Washington, second edition, 2004.
[21] Scott Meyers. More Effective C++. Addison-Wesley, Boston, Massachusetts, 1996.
[22] Scott Meyers. Effective STL. Addison-Wesley, Boston, Massachusetts, 2001.
[23] Scott Meyers. Effective C++. Addison-Wesley, Boston, Massachusetts, third edition, 2005.
[24] Scott Meyers. Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14. O’Reilly, Beijing, China, 2015.
[25] Eric Niebler. Range-v3: User Manual. https://ericniebler.github.io/range-v3/.
[26] Eric Niebler. Standard ranges. https://ericniebler.com/2018/12/05/standard-ranges/.
[27] Martin Reddy. API Design For C++. Morgan Kaufmann, Amsterdam, The Netherlands, 2011.
[28] Suzanne Robertson and James Robertson. Mastering the Requirements Process. Addison-Wesley, Upper Saddle River, New Jersey, second edition, 2006.
[29] Diomidis Spinellis. Code Quality: The Open Source Perspective. Addison-Wesley, Boston, Massachusetts, 2006.
[30] Bjarne Stroustrup. The C++ Programming Language. Addison-Wesley, Upper Saddle River, New Jersey, fourth edition, 2013.
[31] Herb Sutter. Exceptional C++. Addison-Wesley, Boston, Massachusetts, 2000.
[32] Herb Sutter. More Exceptional C++. Addison-Wesley, Boston, Massachusetts, 2002.
[33] Herb Sutter. Exceptional C++ Style. Addison-Wesley, Boston, Massachusetts, 2005.
[34] Herb Sutter and Andrei Alexandrescu. C++ Coding Standards: 101 Rules, Guidelines, and Best Practices. Addison-Wesley, Boston, Massachusetts, 2005.
[35] Alexander Tarliner. Developer Testing: Building Quality into Software. Addison-Wesley, Boston, Massachusetts, 2016.
[36] Karl E. Wiegers. Software Requirements. Microsoft Press, Redmond, Washington, 2003.
[37] Wikipedia. Liskov substitution principle. https://en.wikipedia.org/wiki/Liskov_substitution_principle.
[38] Wikipedia. Model-view-controller. https://en.wikipedia.org/wiki/Model-View-Controller.

Index

Abstract factory pattern

Adapter pattern

Aggregation

Alternative GUI layout

Analysis

Any

Architectural patterns

Architecture

model-view-controller

multi-tiered

n-tiered

three-tiered

Author contact

Batch

Binary command

Bridge pattern-C++

SeePimpl

CLI

SeeCommand line interface

Cloning

CMake

Cohesion

CommandButton

abstraction

design

interface

Command data

Command dispatcher

Command factory

Command hierarchy

Command interpreter

Command line interface

class

design

implementation

requirements

Command manager

Command pattern

abstract

applied

Command registration

Complex numbers

Composite pattern

Composition

Concepts

Coroutines

Coupling

Covariance

Decomposition

Dependency inversion

Deque

Design patterns

Display

design

improved design

poor design

Dynamic skinning

Encapsulation

Event data

Events

Facade pattern

Factory function

SeeFactory pattern

Factory method

SeeFactory pattern

Factory pattern

Final keyword

Flow control

Format

Function, standard

Generator

GitHub

Graphical user interface

declarative style

imperative style

modularization

requirements

Graphic calculator

Graphic user interface building

GUI

SeeGraphical user interface

Has-a relationship

Help function

High DPI scaling

HP48S

I, J, K

IDE

SeeIntegrated development environment

If initialization

Implements-a relationship

Inheritance

InputWidget

design

interface

Integrated development environment

Interfaces

Is-a relationship

Lambda expressions

Language selection

Liskov Substitution Principle

Look-and-feel

LSP

SeeLiskov Substitution Principle

MainWindow

Mobile device interface

Model-GUI

Model-view-controller

SeeArchitecture

Modularity

Modules (C++20)

Modules (pdCalc)

Motivation

Move semantics

Multi-platform design

abstract factory

build system

factory function

libraries

preprocessor directives

Multi-tiered architecture

SeeArchitecture

MVC

SeeArchitecture

Noexcept keyword

Nonvirtual interface pattern

n-tiered architecture

SeeArchitecture

NVI

SeeNonvirtual interface pattern

Object-oriented design

Observer

Observer pattern

Optional

Override keyword

Owning semantics

P, Q

Patterns

SeeArchitectural patterns; Design patterns

pdCalc

building

command line

Qt Creator

executing

command line

Qt Creator

external dependencies

troubleshooting

Perfect forwarding

Pimpl

Plain old data

Plugin example

implementation

interface

Plugin incorporation

injection

Plugin interface

adding GUI buttons

allocation/deallocation

API versioning

command

command discovery

stack availability

Plugin loading

platform specific functions

Plugin management system

Plugin retrofitting

Plugins

C++ rules

definition

fundamental problems

POD

SeePlain old data

Postcondition

Postfix notation

Precondition

Principle of least astonishment

SeePrinciple of least surprise

Principle of least surprise

Prototype pattern

Proxy pattern

Publisher

RAII

SeeResource allocation is initialization

Ranges

Redo

SeeUndo

Requirements

Requires clause

Resource allocation is initialization

Reverse Polish Notation

RPN

SeeReverse Polish Notation

Sharing semantics

Shift state

Signals

Singleton pattern

Slots

Stack

data structure

module

STL

Stored procedures

design

user interface

Strategy pattern

String view

Structured bindings

Target audience

Testing

Three-tiered architecture

SeeArchitecture

Tokenizer

Type erasure

Unary command

Undo

implementation

strategy

Uniform initialization

Unique_ptr destruction semantics

Unit testing

SeeTesting

Use cases

User interface

abstraction

events

module

observers

Variables

Variadic templates

Variant

Views

W, X, Y, Z

Wrapper pattern

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.

Table of Contents for Back Matter

Create new playlist

Sign In

Sign Up

Table of Contents for
Back Matter