Beginning C++ for Financial Analysts

Tyler J. Brough is Assistant Professor of Finance in the Jon M. Huntsman School of Business at Utah State University. He holds a PhD in Finance from the University of Arizona, an MS in Finance from the University of Illinois at Urbana-Champaign, and a BS in Economics from Brigham Young University. He has published research in empirical finance in Financial Management, the Journal of Banking and Finance, the Journal of Trading, and other highly regarded academic journals. He programs in C++ for his research in financial economics and econometrics. In addition, for the last three years he has developed and taught a course in computational finance, in which he teaches the C++ programming language to students who typically have little prior programming experience. As a researcher in financial economics, he has extensive experience programming in C++ for the processing of massive data sets and for intense numerical programming for econometric analysis and Monte Carlo simulation. As an end user of the C++ programming language, he has learned what matters for financial computation and how to use real examples from finance to motivate the learning of C++.

Chapter 1. Introduction to C++ in the Finance Industry * Why quantitative finance software is written in C++ * The C++11 language standard * Toolchains for C++ programmers: compilers, editors, IDEs Chapter 2. Variables, Data Types, and Standard Input/Output: The Simple Net Present Value Program * The simple net present value program * Declaring variables * Fundamental data types * Floating-point arithmetic in computational finance * Initializing variables * Type deduction in C++11 - The auto keyword - The decltype keyword * Variable scopes * std::string * Interacting with your program through standard input/output * Arithmetic operators * Constants * Enumerations Chapter 3. Control Structures and Loops: The Geometric Brownian Motion Simulation Program [How to adapt the simple net present program to handle multiple cash flows. How to use pseudo-random number generators. First example of Monte Carlo simulation.] * Introduction to flow control and branching concepts * The if statement - The else clause * The switch statement * while loops - do while loops - break and continue statements * for loops * Exception handling with try and catch blocks * Logical operators * The random header from the standard library for generating pseudo-random numbers * The Geometric Brownian motion simulation program Chapter 4. Creating User-Defined Functions: The Binomial and Black-Scholes European Option Pricing Engines * How to write and call new user-defined functions * How to pass data into our functions through the parameter list * How to create default values for parameters in the parameter list * How to overload a function definition * How to inline functions * The Binomial European option pricing engine * The Black-Scholes European option pricing engine Chapter 5. Arrays and Strings: The Binomial American Option Pricing Engine * Simple static arrays: Introducing the Binomial American option pricing engine program - Creating arrays - Indexing arrays * Multidimensional arrays - Creating multidimensional arrays - Indexing multidimensional arrays * Using std::string objects: Introducing the Portfolio Tracker program - Objects - The C-style strings - Creating string objects - Using std::string member functions Chapter 6. The Standard Template Library: The Path-Dependent Exotic Option Pricing Engine * Introduction to the Standard Template Library (STL) - Containers - Iterators - Algorithms - Templates * Using std::vector in the path-dependent exotic pricing engine program - Declaring vectors - Using the push_back member method - Indexing vectors - Understanding vector performance - List initialization - Other member methods * The other STL containers * valarray * Using std::array from C++11 instead of traditional arrays * Using STL algorithms - find - sort Chapter 7. References and Pointers: Improving Pricing Engine Efficiency * Using references to improving pricing engine efficiency - Creating references - Assessing referenced values - Changing referenced values * Passing by reference to functions * Returning references from functions * Using pointers - Declaring pointers - Pointer arithmetic - Dereferencing pointers * Pointers to objects * Passing pointers to functions * Returning pointers from functions * Function pointers * The relationship between pointers and references * Smart pointers from C++11 - The shared_ptr - The unique_ptr * The Monte Carlo pricing engine 2.0 Chapter 8. Creating User-Defined Types with Classes: The Option-Payoff Class * User-defined types with classes: The option payoff class - Structures - Unions - Classes * Member variables * Member functions * Constructor functions * Class access levels - Private - Public * Using static data members and methods * Destructor functions * The Monte Carlo option pricing engine 3.0 Chapter 9. Advanced Classes: The Option Classes * Aggregation: The VanillaOption and ExoticOption classes - Using object data members - Using STL container members * Operator functions and operator overloading * Dynamically allocating memory - Using the new operator - Using the delete operator - Avoiding memory leaks - Smart programmers and smart pointers * The this pointer * The Monte Carlo option pricing engine 4.0 Chapter 10. Polymorphism and Inheritance: The Pricing Engines Revisited * Class inheritance: The payoff class - Deriving from a base class - Using inherited members and methods * Access control under inheritance * Calling and overriding base class member methods - Calling base class constructor functions - Declaring virtual base class member methods - Overriding virtual base class member methods - Calling base class member methods * Abstract base classes * Polymorphism: The Monte Carlo and Binomial pricing engines revisited Chapter 11. Advanced Topics: Solvers, Implied and Stochastic Volatility * Generic programming and templates: the implied volatility solver - Function templates - Generic classes * The Heston stochastic volatility model and implied volatility * Design patterns * Tools for large projects * API design for libraries * Third party libraries used in computational finance * Advanced topics: Where to go from here