Producing a Release Build
Problem
You want to produce a small, fast executable or dynamic library for distribution to your customers.
Solution
In general, to produce a release build you must
- Enable optimizations
- Enable the expansion of inline function
- Disable the generation of debugging information
Table 1-26 presents the compiler and linker options to enable optimization and inlining. There are no command-line options for disabling the generation of debugging information: when you build from the command line, debugging information is disabled by default. If you use the GCC toolset, however, you can decrease the size of executables and dynamics libraries by specifying the -s option to the linker.
|
Toolset |
Optimization |
Inlining |
|---|---|---|
|
GCC |
-O3 |
-finline-functions[14] |
|
Visual C++Intel |
-O2 |
-Ob1 |
|
Metrowerks |
-opt full |
-inline auto -inline level=8 |
|
Comeau (Unix) |
-O3 |
|
|
Comeau (Windows) |
Same as backend, but using a slash (/) instead of a dash (-) |
inlining |
|
Borland |
-O2 |
-vi |
|
Digital Mars |
-o+time |
Enabled by default |
[14] This option is enabled automatically when -O3 is specified.
Boost.Build provides a simple mechanism for producing a release build: simply add release to your target's requirements or use the command-line option variant=release, which can be abbreviated simply as release.
Some IDEs also provide a simple way to produce a release build. For instance, as I mentioned in Recipe 1.21, when you create a new project with Visual C++, the IDE generates debug and release configurations automatically. To request a release build, simply select Configuration Manager... from the Build menu and select Release as the active configuration. You can also select Release from the drop-down list of configurations on the standard toolbar. The next time you build your project, it will produce a release build.
Similarly, when you create a new project with CodeWarrior using one of Metrowerks's project templates, called stationery, the IDE generates debug and release targets automatically. The name of the release target may vary, but it should always contain the word "release" or "final." To request a release build, select Set Default Target from the Project menu, and then select the menu item corresponding to the release target. You can also select the release target from the drop-down list of targets on your project's window.
C++Builder does not support multiple build configurations for a single project, but it does provide an easy way produce a release build. To request a release build, go to Project Optionsimages/U2192.jpg border=0> Compiler and press Release. This will enable optimization and inlining and disable debugging information.
If you are using an IDE which doesn't provide preset debug and release configurations, such as Dev-C++, or if you need more control over your project's settings, refer to Tables 1-27 through 1-29.
|
IDE |
Configuration |
|---|---|
|
Visual C++ |
From your project's property pages, go to Configuration Properties |
|
CodeWarrior |
From the Target Settings Window, go to Code Generation |
|
C++Builder |
From Project Options, go to Compiler and select Speed under Code optimization. |
|
Dev-C++ |
See the entry for GCC in Table 1-26 and refer to Recipe 1.20. |
|
IDE |
Configuration |
|---|---|
|
Visual C++ |
From your project's property pages, go to Configuration Properties |
|
CodeWarrior |
From the Target Settings Window, go to Language Settings |
|
C++Builder |
From Project Options, go to Compiler and uncheck Disable inline expansions under Debugging. |
|
Dev-C++ |
See the entry for GCC in Table 1-26 and refer to Recipe 1.20. |
|
IDE |
Configuration |
|---|---|
|
Visual C++ |
From your project's property pages, go to Configuration Properties |
|
Metrowerks |
From the Target Settings Window, go to Language Settings |
|
C++Builder |
From Project Options, go to Compiler and uncheck Debug Information and Line Number Information. |
|
Dev-C++ |
Make sure that the command-line option -g has not been specified, as described in Recipe 1.20. |
Discussion
Most toolsets offer several options for optimization; some offer dozens. Which optimizations you choose depends heavily on the requirements of your project. In an embedded environment, for example, you may want to pick an optimization that produces a smaller executable at the expense of some speed. In other cases, speed may be paramount. Some optimizations will make your program faster on one platform but slower on another. You might even find that certain options make parts of your program faster and other parts slower.
While Table 1-26 and Table 1-27 present good general-purpose optimization options, for best results you should carefully consider your requirements, study your toolset's documentation, and conduct extensive tests.
This situation is similar with inlining, although toolsets usually provide fewer options for inlining than for other optimizations.
See Also
Recipe 1.21
Building C++ Applications
- Introduction to Building
- Obtaining and Installing GCC
- Building a Simple Hello, World Application from the Command Line
- Building a Static Library from the Command Line
- Building a Dynamic Library from the Command Line
- Building a Complex Application from the Command Line
- Installing Boost.Build
- Building a Simple Hello, World Application Using Boost.Build
- Building a Static Library Using Boost.Build
- Building a Dynamic Library Using Boost.Build
- Building a Complex application Using Boost.Build
- Building a Static Library with an IDE
- Building a Dynamic Library with an IDE
- Building a Complex Application with an IDE
- Obtaining GNU make
- Building A Simple Hello, World Application with GNU make
- Building a Static Library with GNU Make
- Building a Dynamic Library with GNU Make
- Building a Complex Application with GNU make
- Defining a Macro
- Specifying a Command-Line Option from Your IDE
- Producing a Debug Build
- Producing a Release Build
- Specifying a Runtime Library Variant
- Enforcing Strict Conformance to the C++ Standard
- Causing a Source File to Be Linked Automatically Against a Specified Library
- Using Exported Templates
Code Organization
- Introduction
- Making Sure a Header File Gets Included Only Once
- Ensuring You Have Only One Instance of a Variable Across Multiple Source Files
- Reducing #includes with Forward Class Declarations
- Preventing Name Collisions with Namespaces
- Including an Inline File
Numbers
- Numbers
- Introduction
- Converting a String to a Numeric Type
- Converting Numbers to Strings
- Testing Whether a String Contains a Valid Number
- Comparing Floating-Point Numbers with Bounded Accuracy
- Parsing a String Containing a Number in Scientific Notation
- Converting Between Numeric Types
- Getting the Minimum and Maximum Values for a Numeric Type
Strings and Text
- Strings and Text
- Introduction
- Padding a String
- Trimming a String
- Storing Strings in a Sequence
- Getting the Length of a String
- Reversing a String
- Splitting a String
- Tokenizing a String
- Joining a Sequence of Strings
- Finding Things in Strings
- Finding the nth Instance of a Substring
- Removing a Substring from a String
- Converting a String to Lower- or Uppercase
- Doing a Case-Insensitive String Comparison
- Doing a Case-Insensitive String Search
- Converting Between Tabs and Spaces in a Text File
- Wrapping Lines in a Text File
- Counting the Number of Characters, Words, and Lines in a Text File
- Counting Instances of Each Word in a Text File
- Add Margins to a Text File
- Justify a Text File
- Squeeze Whitespace to Single Spaces in a Text File
- Autocorrect Text as a Buffer Changes
- Reading a Comma-Separated Text File
- Using Regular Expressions to Split a String
Dates and Times
- Dates and Times
- Introduction
- Obtaining the Current Date and Time
- Formatting a Date/Time as a String
- Performing Date and Time Arithmetic
- Converting Between Time Zones
- Determining a Days Number Within a Given Year
- Defining Constrained Value Types
Managing Data with Containers
- Managing Data with Containers
- Introduction
- Using vectors Instead of Arrays
- Using vectors Efficiently
- Copying a vector
- Storing Pointers in a vector
- Storing Objects in a list
- Mapping strings to Other Things
- Using Hashed Containers
- Storing Objects in Sorted Order
- Storing Containers in Containers
Algorithms
- Algorithms
- Introduction
- Iterating Through a Container
- Removing Objects from a Container
- Randomly Shuffling Data
- Comparing Ranges
- Merging Data
- Sorting a Range
- Partitioning a Range
- Performing Set Operations on Sequences
- Transforming Elements in a Sequence
- Writing Your Own Algorithm
- Printing a Range to a Stream
Classes
- Classes
- Introduction
- Initializing Class Member Variables
- Using a Function to Create Objects (a.k.a. Factory Pattern)
- Using Constructors and Destructors to Manage Resources (or RAII)
- Automatically Adding New Class Instances to a Container
- Ensuring a Single Copy of a Member Variable
- Determining an Objects Type at Runtime
- Determining if One Objects Class Is a Subclass of Another
- Giving Each Instance of a Class a Unique Identifier
- Creating a Singleton Class
- Creating an Interface with an Abstract Base Class
- Writing a Class Template
- Writing a Member Function Template
- Overloading the Increment and Decrement Operators
- Overloading Arithmetic and Assignment Operators for Intuitive Class Behavior
- Calling a Superclass Virtual Function
Exceptions and Safety
- Exceptions and Safety
- Introduction
- Creating an Exception Class
- Making a Constructor Exception-Safe
- Making an Initializer List Exception-Safe
- Making Member Functions Exception-Safe
- Safely Copying an Object
Streams and Files
- Streams and Files
- Introduction
- Lining Up Text Output
- Formatting Floating-Point Output
- Writing Your Own Stream Manipulators
- Making a Class Writable to a Stream
- Making a Class Readable from a Stream
- Getting Information About a File
- Copying a File
- Deleting or Renaming a File
- Creating a Temporary Filename and File
- Creating a Directory
- Removing a Directory
- Reading the Contents of a Directory
- Extracting a File Extension from a String
- Extracting a Filename from a Full Path
- Extracting a Path from a Full Path and Filename
- Replacing a File Extension
- Combining Two Paths into a Single Path
Science and Mathematics
- Science and Mathematics
- Introduction
- Computing the Number of Elements in a Container
- Finding the Greatest or Least Value in a Container
- Computing the Sum and Mean of Elements in a Container
- Filtering Values Outside a Given Range
- Computing Variance, Standard Deviation, and Other Statistical Functions
- Generating Random Numbers
- Initializing a Container with Random Numbers
- Representing a Dynamically Sized Numerical Vector
- Representing a Fixed-Size Numerical Vector
- Computing a Dot Product
- Computing the Norm of a Vector
- Computing the Distance Between Two Vectors
- Implementing a Stride Iterator
- Implementing a Dynamically Sized Matrix
- Implementing a Constant-Sized Matrix
- Multiplying Matricies
- Computing the Fast Fourier Transform
- Working with Polar Coordinates
- Performing Arithmetic on Bitsets
- Representing Large Fixed-Width Integers
- Implementing Fixed-Point Numbers
Multithreading
- Multithreading
- Introduction
- Creating a Thread
- Making a Resource Thread-Safe
- Notifying One Thread from Another
- Initializing Shared Resources Once
- Passing an Argument to a Thread Function
Internationalization
- Internationalization
- Introduction
- Hardcoding a Unicode String
- Writing and Reading Numbers
- Writing and Reading Dates and Times
- Writing and Reading Currency
- Sorting Localized Strings
XML
- XML
- Introduction
- Parsing a Simple XML Document
- Working with Xerces Strings
- Parsing a Complex XML Document
- Manipulating an XML Document
- Validating an XML Document with a DTD
- Validating an XML Document with a Schema
- Transforming an XML Document with XSLT
- Evaluating an XPath Expression
- Using XML to Save and Restore a Collection of Objects
Miscellaneous
- Miscellaneous
- Introduction
- Using Function Pointers for Callbacks
- Using Pointers to Class Members
- Ensuring That a Function Doesnt Modify an Argument
- Ensuring That a Member Function Doesnt Modify Its Object
- Writing an Operator That Isnt a Member Function
- Initializing a Sequence with Comma-Separated Values
Index
EAN: 2147483647
Pages: 241
