- D Cookbook
- Table of Contents
- D Cookbook
- Credits
- Foreword
- About the Author
- About the Reviewers
- www.PacktPub.com
- Preface
- 1. Core Tasks
- Introduction
- Installing the compiler and writing a "Hello World" program
- Adding additional modules (files) to your program
- Using external libraries
- Building and processing arrays
- Using associative arrays to translate input
- Creating a user-defined vector type
- Using a custom exception type
- Understanding immutability
- Slicing a string to get a substring
- Creating a tree of classes
- 2. Phobos – The Standard Library
- Introduction
- Performing type conversions
- Finding the largest files in a directory
- Creating a network client and server
- Using Base64 to create a data URI
- Generating random numbers
- Normalizing a string and performing Unicode comparisons
- Searching with regular expressions
- Writing a digest utility
- Using the std.zlib compression
- Using the std.json module
- 3. Ranges
- Introduction
- Using ranges when implementing an algorithm
- Creating an input range
- Creating an output range
- Creating a higher-order range
- Putting a range interface on a collection
- Creating an input range over a tree structure
- Using runtime polymorphic (class) ranges
- Storing a range as a data member
- Sorting ranges efficiently
- Searching ranges
- Using functional tools to query data
- 4. Integration
- Introduction
- Calling the Windows API functions
- Removing the Windows console
- Making Linux system calls
- Writing part of a C program in D
- Interfacing with C++
- Using structs to mimic the C++ object structure
- Communicating with external processes
- Communicating with a dynamic scripting language
- Using Windows' COM
- 5. Resource Management
- Introduction
- Avoiding the garbage collector
- Making a reference-counted object
- Manually managing class memory
- Using scope guards to manage transactions
- Creating an array replacement
- Managing lent resources
- Creating a NotNull struct
- Using unique pointers
- Using RAII and handling the limitations of class destructors
- 6. Wrapped Types
- Introduction
- Creating a struct with reference semantics
- Simulating inheritance with structs
- Creating a ranged integer
- Creating an opaque handle type
- Creating a subtyped string for i18n
- Forwarding methods with opDispatch
- Creating a tagged dynamic type
- Creating a structure with two views into the same data
- Simulating multiple inheritance with mixin templates
- 7. Correctness Checking
- Introduction
- Using assertions and exceptions
- Using static asserts
- Using template constraints and static if
- Preventing memory corruption bugs with @safe
- Leveraging const-correctness
- Avoiding side effects of pure functions
- Verifying object invariants and pre- and post-conditions
- Unit testing your code
- Documenting your code with Ddoc
- Writing platform-specific code (versions) and per-client configuration modules
- 8. Reflection
- Introduction
- Getting dynamic runtime type information
- Getting a list of child classes
- Determining whether a module is available
- Getting a list of all methods or fields in a module or an object
- Inspecting function overloads
- Determining names, types, and default values of function parameters
- Getting components of complex types
- Using user-defined attributes
- Implementing a custom lint-style check for virtual functions
- Extending the runtime type information
- Creating a command-line function caller
- 9. Code Generation
- Introduction
- Creating user-defined literals
- Parsing a domain-specific language
- Generating data structures from text diagrams
- Automating dynamic calls with multiple dispatch
- Building a lookup table
- Using string parameters to change functions
- Wrapping instance methods
- Using opDispatch to generate properties
- Duck typing to a statically-defined interface
- 10. Multitasking
- 11. D for Kernel Coding
- 12. Web and GUI Programming
- Introduction
- Creating a dynamic website with cgi.d
- Creating a web API with web.d
- Parsing and modifying an HTML page with dom.d
- Accessing a SQL database
- Sending an e-mail
- Writing colored output to the console
- Getting real-time input from the terminal
- Working with image files
- Creating a graphics window to show a TV static demo
- Creating an OpenGL window
- A. Addendum
- Index
In this chapter, we will explore D's rich abstraction capabilities to wrap, extend, or constrain other types. We'll learn about:
- Creating a struct with reference semantics
- Simulating inheritance with structs
- Creating a ranged integer
- Creating an opaque handle type
- Creating a subtyped string for i18n
- Forwarding methods with
opDispatch - Creating a tagged dynamic type
- Creating a structure with two views into the same data
- Simulating multiple inheritance with mixin templates
D's struct has a wealth of possibilities. It is defined by the D spec as a way to "paint a data structure over hardware or an external type", and thus gives us various modeling tools that come without runtime or memory cost. We've already used or seen some of the techniques from this chapter earlier in the book.
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.