Multiple inheritance

Abstract: Preface. 1. Introduction. Overview. Syntax Notation. Evolution of C++. Acknowledgements. 2. Lexical Conventions. Tokens. Comments. Identifiers. Keywords. Literals. Implementation Dependencies. 3. Basic Concepts. Declarations and Definitions. Scopes. Program and Linkage. Start and Termination. Storage Classes. Types. Lvalues. Name Spaces. Numerical Limits. 4. Standard Conversions. Integral Promotions. Integral Conversions. Float and Double. Floating and Integral. Arithmetic Conversions. Pointer Conversions. Reference Conversions. Pointers to Members. Arithmetic Conversions. 5. Expressions. Primary Expressions. Postfix Expressions. Unary Operators. Explicit Type Conversion. Pointer-to-Member Operators. Multiplicative Operators. Additive Operators. Shift Operators. Relational Operators. Equality Operators. Bitwise AND Operator. Bitwise Exclusive OR Operator. Bitwise Inclusive OR Operator. Logical AND Operator. Logical OR Operator. Conditional Operator. Assignment Operators. Comma Operator. Constant Expressions. 6. Statements. Labeled Statement. Expression Statement. Compound Statement, or Block. Selection Statements. Iteration Statements. Jump Statements. Declaration Statement. Ambiguity Resolution. 7. Declarations. Specifiers. Enumeration Declarations. Asm Declarations. Linkage Specifications. Linkage Specifications. Type-safe Linkage. Limitations. 8. Declarators. Type Names Meaning of Declarators. Function Definitions. Initializers. Pointers to Members. 9. Classes. Class Names. Class Members. Member Functions. Static Members. Unions. Bit-Fields. Nested Class Declarations. Local Class Declarations. Local Type Names. Interfaces. 10. Derived Classes. Multiple Base Classes. Virtual Functions. Abstract Classes. Summary of Scope Rules. Single Inheritance. Multiple Inheritance. Multiple Inheritance and Casting. Multiple Inheritance and Implicit Conversion. Virtual Base Classes. Virtual Base Classes and Casting. Single Inheritance and Virtual Functions. Multiple Inheritance and Virtual Functions. Instantiation of Virtual Functions. Virtual Base Classes with Virtual Functions. Renaming. 11. Member Access Control. Access Specifiers. Access Specifiers for Base Classes. Access Declarations. Friends. Protected Member Access. Access to Virtual Functions. Multiple Access. General Ideas. Per Class Protection. Access Control. 12. Special Member Functions. Constructors. Temporary Objects. Conversions. Destructors. Free Store. Initialization. Constructors and Destructors. Copying Class Objects. Temporary Elimination. Access Control and Special Functions. Summary of Member, Friend, and Special Functions. 13. Overloading. Declaration Matching. Argument Matching. Address of Overload Function. Overloaded Operators. 14. Templates. Templates. Class Templates. Type Equivalence. Function Templates. Declarations and Definitions. Member Function Templates. Friends. Static Members and Variables. 15. Exception Handling. Exception Handling. Throwing an Exception. Constructors and Destructors. Handling and Exception. Exception Specifications. Special Functions. Exceptions and Access. 16. Preprocessing. Phases of Preprocessing. Trigraph Sequences. Macro Definition and Expansion. File Inclusion. Conditional Compilation. Line Control. Error Directive. Pragmas. Null Directive. Predefined Names. C++ Constructs versus #define. Compatibility. Classic C Preprocessing. 17. Grammar Summary. Keywords. Expressions. Declarations. Declarators. Class. Statements. Preprocessor. Templates. Exception. 18. Compatibility. Extensions. C++ and ANSI C. Anachronisms. ANSI/ISO Resolutions. Index. 0201514591T04062001

Abstract: There are two major ways of structuring data in programming languages. The first and common one, used for example in Pascal, can be said to derive from standard branches of mathematics. Data are organized as Cartesian products (i.e., record types), disjoint sums (i.e., unions or variant types), and function spaces (i.e., functions and procedures). The second method can be said to derive from biology and taxonomy. Data are organized in a hierarchy of classes and subclasses, and data at any level of the hierarchy inherit all the attributes of data higher up in the hierarchy. The top level of this hierarchy is usually called the class of all objects; every datum is an object and every datum inherits the basic properties of objects, e.g., the ability to tell whether two objects are the same or not. Functions and procedures are considered as local actions of objects, as opposed to global operations acting over objects. These different ways of structuring data have generated distinct classes of programming languages, and induced different programming styles. Programming with taxonomically organized data is often called objectoriented programming, and has been advocated as an effective way of structuring programming environments, data bases, and large systems in general. The notions of inheritance and object-oriented programming first appeared in Simula 67 (Dahl, 1966). In Simula, objects are grouped into classes and classes can be organized into a subclass hierarchy. Objects are similar to records with functions as components, and elements of a class can appear wherever elements of the respective superclasses are expected. Subclasses inherit all the attributes of their superclasses. In Simula, the issues are somewhat complicated by the use of objects as coroutines, so that communication between objects can be implemented as message passing between processes. Smalltalk (Goldberg, 1983) adopts and exploits the idea of inheritance, with some changes. While stressing the message-passing paradigm, a

Abstract: Preface. 1. Introduction. C++: An Evolving Language. Handling Complexity with Idioms. Objects for the Nineties. Design and Language. 2. Data Abstraction and Abstract Data Types. Classes. Object Inversion. Constructors and Destructors. Inline Functions. Initialization of Static Data Members. Static Member Functions. Scoping and const. Initialization Ordering of Global Objects, Constants, and Static Class Members. Enforcement of const for Class Object Member Functions. Pointers to Member Functions. Program Organization Conventions. 3. Concrete Data Types. The Orthodox Canonical Class Form. Scoping and Access Control. Overloading: Redefining the Semantics of Operators and Functions. Type Conversion. Reference Counting: Making Variables Use "Magic Memory." Operators new and delete. Separating Initialization from Instantiation. 4. Inheritance. Simple Inheritance. Scoping and Access Control. Constructors and Destructors. Class Pointer Conversion. Type Selector Fields. 5. Object-Oriented Programming. C++ Run-Time Type Support: Virtual Functions. Destructor Interaction and Virtual Destructors. Virtual Functions and Scoping. Pure Virtual Functions and Abstract Base Classes. Envelope and Letter Classes. Functors: Functions as Objects. Multiple Inheritance. The Inheritance Canonical Form. 6. Object-Oriented Design. Types and Classes. The Activities of Object-Oriented Design. Object-Oriented Analysis and Domain Analysis. Object and Class Relationships. Subtyping, Inheritance and Forwarding. Rules of Thumb for Subtyping, Inheritance, and Independence. 7. Reuse and Objects. All Analogies Break Down Somewhere. Design Reuse. Four Code Reuse Mechanisms. Parameterized Types, or Templates. Private Inheritance: Does Inheritance Support Reuse? Storage Reuse. Interface Reuse: Variants. Reuse, Inheritance, and Forwarding. Architectural Alternatives for Source Reuse. Generalizations on Reuse and Objects. 8. Programming with Exemplars in C++. An Example: Employee Exemplars. Exemplars and Generic Constructors: The Exemplar Community Idiom. Autonomous Generic Constructors. Abstract Base Exemplars. Toward a Frame Exemplar Idiom. A Word About Notation. Exemplars and Program Administration. 9. Emulating Symbolic Language Styles in C++. Incremental C++ Development. Symbolic Canonical Form. An Example: A General Collection Class. Code and Idioms To Support Incremental Loading. Garbage Collection. Primitive Type Encapsulation. Multi-Methods under the Symbolic Idiom. 10. Dynamic Multiple Inheritance. An Example: A Multi-Technology Window System. Caveats. 11. Systemic Issues. Static System Design. Dynamic System Design. Appendix A: C in a C++ Environment. Function Calls. Function Parameters. Function Prototypes. Call-by-Reference Parameters. Variable Number of Parameters. Function Pointers. The const Type Modifier. Interfacing with C Code. Appendix B: Shapes Program: C++ Code. Appendix C: Reference Return Values from Operators. Appendix D: Why Bitwise Copy Doesn't Work. Why Member-by-Member Copy Isn't a Panacea. Appendix E: Symbolic Shapes. Appendix F: Block-Structured Programming in C++. What is Block-Structured Programming? Basic Building Blocks for Structured C++ Programming. An Alternative for Blocks with Deeply Nested Scopes. Implementation Considerations Block-Structure Video Game Code. Index. 0201548550T04062001

Abstract: Object-oriented programming is a practical and useful programming methodology that encourages modular design and software reuse. Most object-oriented programming languages support data abstraction by preventing an object from being manipulated except via its defined external operations. In most languages, however, the introduction of inheritance severely compromises the benefits of this encapsulation. Furthermore, the use of inheritance itself is globally visible in most languages, so that changes to the inheritance hierarchy cannot be made safely. This paper examines the relationship between inheritance and encapsulation and develops requirements for full support of encapsulation with inheritance.