Project topics and materials
Get Complete Project Material File(s) Now! »
object-oriented programming vs generic programming
Object-Oriented Programming (OOP) and Generic Programming (GP) propose two different approaches to design, implement, extend and maintain software, the former with an emphasis on dynamic behavior and the latter with a focus on static resolution. However, they share some similarities in their organization. OOP is a programming paradigm that is provided in different flavors, depending on the language. Some object-oriented features may or may not be present in a given Object-Oriented Language (OOL). In particular, some OOLs are class-less (or prototype-based). In this section, we only consider the OOP paradigm as implemented in C++, which is also present in most compiled and statically checked programming language, such as Java, C#, D, and Eiffel. Before comparing OOP and GP, we recall some important definitions about OOP.
Elements of Object-Oriented Programming
In (class-based) OOP, data types are implemented as classes, entities regrouping data and services acting on them, named respectively attributes and methods. In C++, attributes are called members, while methods are called member functions. Like many programming entities (functions, modules, etc.), a class can be decomposed in two parts: firstly, its interface or signature (called declaration in C++), which is made of its name, the names and types of its attributes, and the names of methods together with the name of their arguments and types thereof; and secondly, its implementation (called definition in C++), which contains the code of its methods.
A value having the type of a given class is called an instance or an object of that class. The action of creating such an object is called (class) instantiation. Class instantiation should not be confused with template instantiation, which is the process of creating an actual type or function from a template, presented in Section 2.1.1 (p. 31).
A class B may be derived from another class A, therefore acquiring A’s attributes and methods, in addition to its own attributes.
B is said to inherit from A. A is called a base class of B, while B is a subclass of A. This kind of relation between two classes is called implementation inheritance. B may provide its own implementation for a methods already present in A. This action is called (method) overriding. The overridden method is said to be polymorphic, as the code executed at run-time depends on the exact type of the object “owning” the method. Polymorphic methods are called virtual (member) functions in C++.
beyond generic programming: static metaprogramming
Templates have been introduced the C++ language to provide parameterized containers and routines in the first place. With the development of template libraries, and in particular the Standard Template Library, templates have helped shape the Generic Programming paradigm. C++ templates, however, have been found to exceed the scope of GP. As they have been designed as a powerful generating facility, they allowed new kinds of programming constructs performing various computations at compile-time known as static metaprogramming. This section presents this technique and some of its applications.
Table of contents :
Abstract
Résumé
Acknowledgments
Foreword
1 introduction
1.1 Context
1.1.1 Diversity of Image Types
1.1.2 Diversity of Users
1.1.3 Diversity of Use Cases
1.1.4 Diversity of Tools
1.2 Topic of the Thesis
1.3 Contributions
1.4 Contents of the Thesis
2 generic programming
2.1 Elements of Generic Programming
2.1.1 Generic Algorithms
2.1.2 Generic Data Types
2.1.3 Instantiation of C++ Templates
2.1.4 Generic Libraries
2.2 History of Generic Programming
2.2.1 CLU
2.2.2 Ada
2.2.3 C++, Templates and the Standard Template Library
2.3 Applications of Generic Programming
2.4 Concepts
2.4.1 Concept Definition
2.4.2 Concept Checking
2.5 Object-Oriented Programming vs Generic Programming
2.5.1 Elements of Object-Oriented Programming
2.5.2 Comparison of OOP and GP
2.6 Beyond Generic Programming: Static Metaprogramming
2.6.1 C++ Template Metaprogramming
2.6.2 Functions on Types and Traits Classes
3 a static c++ object-oriented programming (scoop) paradigm
3.1 Curiously Recurring Template Pattern
3.2 Generalized Curiously Recurring Template Pattern
3.3 The SCOOP Paradigm
3.3.1 Concepts
3.3.2 Implementation Classes
3.3.3 Algorithms
3.3.4 Concept-Checking and Other Compile-Time Constraints
3.3.5 Properties
3.3.6 Morphers
4 genericity in image processing
4.1 Motivation for Generic Image Processing Software
4.2 Design Choices
4.2.1 The Choice of SCOOP
4.2.2 The Choice of C++
4.3 Organization
4.3.1 General Architecture
4.3.2 Core Library
4.4 Concepts
4.4.1 Images
4.4.2 Sites
4.4.3 Site Sets
4.4.4 Iterators
4.4.5 Windows and Neighborhoods
4.5 Data Structures
4.5.1 Classical Data Structures
4.5.2 Graphs
4.5.3 Cell Complexes
4.6 Algorithms
4.6.1 Generic Algorithms
4.6.2 Type Deduction
4.6.3 Efficiency Considerations 1
4.6.4 Properties of Data Structures and Property- Based Overloading
4.7 Image Morphers
4.7.1 Domain Morphers
4.7.2 Value-Related Morphers
4.7.3 Identity Morphers
5 applications of generic image processing
5.1 A GenericWatershed Transform Implementation
5.1.1 Generic Morphological Segmentation Chain
5.1.2 Illustrations
5.2 A Generic Homotopic Thinning Implementation
5.2.1 Simple Point Characterization Implementation
5.2.2 Illustrations
6 conclusions
6.1 Contributions
6.1.1 A Programming Paradigm for Scientific Computing
6.1.2 A Proposal for an Architecture for Generic Image Processing
6.1.3 Design and Use of Non-Classical Data in Image Processing
6.1.4 Addressing Efficiency Issues using Generic Optimizations
6.1.5 Software Contributions
6.2 Reflexions
6.3 Perspectives
6.3.1 A Dynamic-Static Bridge
6.3.2 A New Implementation Language?
6.3.3 Parallel Computing
6.3.4 Impact on Image Processing
Publications
bibliography
