Programming In Ansi C PDF
E. Balagurusamy
Programming In Ansi C
Master C Programming with Clarity and Practical
Examples.
Written by Bookey
Check more about Programming In Ansi C Summary
Listen Programming In Ansi C Audiobook
About the book
"Programming in ANSI C" by E. Balagurusamy offers a
comprehensive introduction to the C programming language,
catering to both beginners and experienced programmers
seeking to enhance their skills. The book meticulously covers
fundamental concepts, syntax, and best practices, utilizing
clear explanations and practical examples to demystify
complex topics. With a focus on ANSI C standards, readers
will gain a solid understanding of programming principles,
effective coding techniques, and the importance of good
programming practices, equipping them to develop robust
software solutions. Whether for academic purposes or
self-study, this guide serves as an essential resource for
mastering C programming.
About the author
E. Balagurusamy is a renowned educator, author, and
computer scientist, widely recognized for his significant
contributions to the field of programming and computer
science education in India. With a robust academic
background, he has held prestigious positions in various
technical institutions, where he has influenced countless
students through his innovative teaching methods and
comprehensive curriculum development. Balagurusamy's
extensive experience in programming languages, particularly
in C, has culminated in the authorship of several popular
textbooks, including "Programming in ANSI C," which serves
as a vital resource for learners and educators alike. His clear,
concise writing style and commitment to making complex
concepts accessible have established him as a leading figure in
the realm of computer science literature.
Summary Content List
Chapter 1 : 7 The ooc Preprocessor
Chapter 2 : 8 Dynamic Type Checking
Chapter 3 : 9 Static Construction
Chapter 4 : 10 Delegates
Chapter 5 : 11 Class Methods
Chapter 6 : 12 Persistent Objects
Chapter 7 : 13 Exceptions
Chapter 8 : 14 Forwarding Messages
Chapter 9 : A ANSI-C Programming Hints
Chapter 10 : B The ooc Preprocessor
Chapter 11 : C Manual
Chapter 1 Summary : 7 The ooc
Preprocessor
Section
Content
1.1 Introduction to ooc
The ooc preprocessor simplifies coding by adhering to established conventions and
produces ANSI-C translatable output.
1.2 Class Description Example
Example of a "Point" class is presented, focusing on structure and attributes needed
for effective preprocessor functionality.
1.3 Generation of Interface and
Representation Files
ooc generates interface and representation files, manipulating methods' parameter lists
for proper integration.
1.4 Implementation Challenges
Challenges include managing null pointers and variables when overriding methods in
subclasses.
1.5 Design Conclusions
The Point class illustrates essential design principles like clear syntax and efficient file
generation for the preprocessor.
1.6 Preprocessing Steps and Strategy
Details the processing workflow and showcases how ooc maintains code modularity
and conventions through reporting.
1.7 Handling Base Classes
Discusses handling of root classes, emphasizing unique code patterns and universal
application of preprocessor rules.
1.8 Examples: List, Queue, and Stack Practical implementations of List, Queue, and Stack demonstrate how ooc facilitates
Implementation
class creation and inheritance.
1.9 Exercises
Encourages readers to experiment with concepts to reinforce learning and application
of the ooc preprocessor.
Chapter 1: The ooc Preprocessor - Enforcing a
Coding Standard
The chapter discusses the challenges and solutions in
maintaining coding standards when implementing class
structures in programming, focusing on the design of an
auxiliary preprocessor called "ooc" aimed at enforcing
coding conventions established in a prior chapter.
1.1 Introduction to ooc
- The ooc preprocessor simplifies the coding process by
adhering to established conventions while not introducing a
new programming language, as it produces output directly
translatable to ANSI-C.
1.2 Class Description Example
- The chapter presents a class description example using the
"Point" class, highlighting the structure and attributes needed
for the preprocessor to function effectively, such as object
components and linking methods.
1.3 Generation of Interface and Representation Files
- ooc is designed to generate necessary interface and
representation files from the provided class descriptions. The
methods’ parameter lists are manipulated for proper
integration, with examples illustrating how this is practically
achieved.
1.4 Implementation Challenges
- Several complexities arise when generating implementation
files, including safeguarding against null pointers and
variable management when methods are overridden in
subclasses.
1.5 Design Conclusions
- The study of the Point class illustrates the practical design
principles crucial for the preprocessor's effectiveness, such as
clear syntax for class descriptions and efficient generation of
related files.
1.6 Preprocessing Steps and Strategy
- The processing workflow is detailed, showcasing how ooc
can generate specific programming constructs while
maintaining code modularity and adherence to programming
conventions through a report generation mechanism.
1.7 Handling Base Classes
- The chapter concludes with a discussion on the handling of
root classes like Object and Class, emphasizing the unique
code patterns that arise in these situations, and illustrating
how the same preprocessor rules can be applied universally.
1.8 Examples: List, Queue, and Stack
Implementation
- Finally, practical implementations for standard data
structures—List, Queue, and Stack—are provided as
examples of how ooc facilitates easy class creation and
inheritance while maintaining coding efficiency.
1.9 Exercises
- The chapter ends with practical exercises encouraging
readers to experiment with the concepts discussed,
reinforcing the learning experience and application of the ooc
preprocessor in various contexts.
The chapter encapsulates the essence of how a preprocessor
like ooc can serve as a powerful tool in maintaining coding
standards while fostering an efficient and structured
development process in C programming.
Chapter 2 Summary : 8 Dynamic Type
Checking
8 Dynamic Type Checking — Defensive
Programming
8.1 Technique
Dynamic type checking is necessary in situations where
objects are accessed as `void *`, creating risks of handling
incorrect or nonexistent objects. For example, invoking a
method without confirming the object's type can cause severe
errors. To mitigate this, a system of dynamic type checking is
proposed, which includes a way to ascertain if an object
belongs to a specific class through methods such as `isA()`
and `isOf()`. The `cast()` method is introduced to suppress
functionality if an object is not of the expected class,
replacing `assert()` for safety.
8.2 An Example — list
An example program demonstrates how to use type checking
with a list that can store various geometrical objects like
circles and points. The program features functions to add,
display, and remove objects from the list while using `cast()`
to ensure objects are valid before operations.
8.3 Implementation
The `isA()` and `isOf()` methods are straightforward,
focusing on checking object classes. A naive implementation
of `cast()` is based on `isOf()` but needs refinement to avoid
null pointers leading to errors. The concepts behind these
methods enforce a coding standard that mandates careful type
checking when dereferencing.
8.4 Coding Standard
The coding standard emphasizes the frequent use of `cast()`
within methods to ensure the integrity of dereferenced
objects. Specific calls to `cast()` must be applied during
object imports, promoting the use of defensive programming
by ensuring method parameters are validated upon entry.
8.5 Avoiding Recursion
Implementing `cast()` using `isOf()` can result in infinite
recursion as it relies on previously validated methods. An
effective solution is proposed, utilizing magic numbers in
class descriptions, thus ensuring that valid pointers
correspond to objects and can be reliably checked.
8.6 Summary
`void *` types provide flexibility but necessitate runtime type
checking to ensure method parameters are valid objects. A
system of new methods, `isA()`, `isOf()`, and `cast()`, allows
programmers to determine object types and handle potential
mistakes proactively, promoting defensive programming
principles.
8.7 Exercises
A series of exercises encourages exploring the implications
of class checks, evaluating efficiency considerations around
magic numbers, and improving the existing dynamic type
checking methodology to boost robustness while maintaining
efficient code.
Example
Key Point:Importance of Dynamic Type Checking in
Polymorphism
Example:Consider a scenario where you develop a game
that dynamically loads different character classes like
`Warrior` and `Mage`. Each character has unique
abilities activated via method calls. If you call an ability
like `castSpell()` on a `Warrior` object without
confirming its type, you risk a crash as it tries to execute
methods that don't exist for that class. Incorporating
dynamic type checking ensures that when you retrieve
characters from a general `void *` list, you verify their
type using methods like `isA()` or `cast()`. This prevents
such errors and guarantees that only appropriate
methods are invoked.
Critical Thinking
Key Point:Dynamic type checking significantly
enhances safety in programming by validating object
types at runtime.
Critical Interpretation:While the author's advocacy for
dynamic type checking presents a valuable strategy in
programming, one must note that the reliance on such
methods may inadvertently introduce performance
overhead and complexity into the code. There are
instances in programming where static type checking
could achieve similar safety with less runtime cost, as
discussed in works like 'Types and Programming
Languages' by Benjamin C. Pierce. Furthermore, this
practice may not be universally applicable across all
programming paradigms or projects, warranting a
critical examination of its appropriateness based on
specific context and requirements.
Chapter 3 Summary : 9 Static
Construction
Static Construction — Self-Organization
Initialization
Class descriptions are long-lived and ideally initialized at
compile time. Only the class descriptions for Object and
Class are statically initialized; others are generated
dynamically through constructors. The chapter describes how
to ensure that class descriptions are initialized properly by
creating functions that handle this task, such as initPoint()
and initCircle(), which are called at the beginning of the
program's execution.
Initializer Lists — munch
To solve challenges regarding static constructor calls, the
chapter introduces an array (initializers[]) that collects all
initialization function addresses. These functions are called
in the main() function to ensure that all necessary class
descriptions are initialized. This approach requires a utility,
called "munch," which generates an array of initialization
functions by examining the program's symbol table to ensure
all init-functions are included.
Functions for Objects
A more efficient solution involves using macros and
rethinking how object references are created. The proposed
macro (Class(x)) checks if a class description exists and
initializes it if not. This change emphasizes the need for each
class description to have its own initialization function,
allowing for smooth integration and automatic handling of
initialization order.
Implementation
Implementing these changes requires modifying how class
descriptions are referenced throughout the program. Instead
of static pointers, function calls to initialization functions
Install
Bookey
App tochanging
Unlockdeclarations
Full Textfrom
and
should
be used.
This involves
Audio
pointers to function calls, which
ensures that when a class
description is needed, it is ready to be used. Adjustments are
Chapter 4 Summary : 10 Delegates
Section
Summary
10 Delegates - Callback
Functions
A chapter focused on callback functions, their implementation, and advantages, particularly in
application frameworks.
10.1 Callbacks
Discusses object method referencing, the importance of runtime method checks, and examples of
ANSI-C functions that use callbacks.
10.2 Abstract Base
Classes
Explains how dynamically linked methods enable callback communication and the limitations of
requiring subclasses to implement all methods.
10.3 Delegates
Introduces delegates, which allow clients to specify handling capabilities for callbacks,
facilitating interaction with host objects.
10.4 An Application
Framework - Filter
Describes the Filter class framework for command line processing, using callback functions to
minimize code duplication.
10.5 The respondsTo
Method
Presents the respondsTo() method for identifying object capabilities dynamically while ensuring
type safety.
10.6 Implementation
Discusses implementation details for respondsTo(), including method pointers and adjustments in
class structure for client needs.
10.7 Another application sort
Highlights the development of a sort filter application that demonstrates flexibility through the
delegate pattern.
10.8 Summary
Summarizes the chapter's focus on object relationships, dynamic method linking, and the benefits
of delegates over traditional patterns.
10.9 Exercises
Concludes with exercises aimed at exploring callback structures, file handling robustness,
responses, and sorting performance optimizations.
10 Delegates - Callback Functions
10.1 Callbacks
An object typically references its class description, which in
turn points to dynamically linked methods. It is crucial to
determine if an object can respond to a specific method at
runtime to prevent program crashes. This is particularly
relevant in callback functions, where notifications are sent to
clients about events affecting them. Clients can register their
own callback functions for events that matter to them,
allowing for a flexible and forgiving interface. Examples
from ANSI-C include functions like `bsearch()`, `qsort()`,
and `atexit()` that utilize callback functions.
10.2 Abstract Base Classes
Using dynamically linked methods simplifies communication
through callbacks by allowing methods to be called based on
object identity and not just method names. However, to
facilitate this communication, an abstract base class must
declare necessary methods that client subclasses must
implement. While abstract base classes can encapsulate
calling conventions, they may impose limitations and require
all classes in the hierarchy to implement all defined methods,
which can lead to an inflexible architecture.
10.3 Delegates
Delegates redefine the callback scenario by allowing a client
object to inform the host of its capabilities for handling
specific callbacks. This involves the host checking what
callback methods the delegate can handle before making
calls. An example implementation involves a text filter
program that counts lines and characters from input.
Delegates help streamline the interaction between a filter
object and a specific client implementation.
10.4 An Application Framework - Filter
The Filter class serves as a framework for command line
processing, handling common tasks across filter programs.
The `mainLoop()` method processes command line
arguments and uses callback functions to manage interactions
with client-specific logic. This design pattern minimizes code
duplication and sets foundational rules for developing
various applications.
10.5 The respondsTo Method
The `respondsTo()` method allows objects to identify
capabilities based on a string tag, returning the appropriate
method if it exists in the class description. It ensures that a
delegate can dynamically respond to requests from the host
object while maintaining type safety and avoiding
unnecessary restrictions from abstract base classes.
10.6 Implementation
To implement `respondsTo()`, class descriptions need to
incorporate pointers to methods along with associated tags
for easier identification. Adjustments in the class structure
facilitate this method's functionality, ensuring clients can
access the methods they need seamlessly.
10.7 Another application - sort
The architecture allows for the development of a sort filter
application that can handle line sorting based on
command-line specifications. Methods for handling input
files, line collection, and sorting are implemented,
demonstrating the flexibility provided by the delegate
pattern.
10.8 Summary
This chapter emphasized the importance of relationships
between objects and their class descriptions, how callback
methods can be dynamically linked and efficiently queried,
and the advantages of using delegates over traditional
callback functions or abstract base classes. Delegates allow
applications to maintain flexibility while providing structured
interaction through application frameworks.
10.9 Exercises
The chapter concludes with exercises that encourage further
exploration of callback structures, robustness in file handling,
potential improvements in implementing the `respondsTo()`
method, and performance optimizations in sorting
implementations.
Example
Key Point:Utilizing Callback Functions for Dynamic
Interaction
Example:Imagine you're building a notification system
for a blog. Whenever a new post is published, users who
have registered their email address want to receive a
notification. By employing callback functions, you set
up a system where users can define their notification
preferences—SMS, email, or push notifications. As the
programmer, you define the general framework that
enables these notifications, but it's the users who 'call
back' your method to specify how they want to receive
updates. This flexibility avoids crashes by ensuring that
the system dynamically checks which notification
methods are available at runtime, enhancing the user
experience while maintaining program stability.
Critical Thinking
Key Point:The Advantages and Limitations of
Delegates in Programming
Critical Interpretation:The chapter illustrates how
delegates enhance the flexibility of callback functions,
yet readers should critically assess the author's claim
that this approach is universally superior. It is important
to consider that not all programming scenarios benefit
from delegates; traditional methods may be more
suitable depending on the complexity and requirements
of the software being developed. Thus, while
Balagurusamy presents a persuasive case for delegates,
contrasting viewpoints may arise from examining
specific use cases in programming literature, such as
"Design Patterns: Elements of Reusable Object-Oriented
Software" by Gamma et al., which outlines when certain
patterns may not apply effectively.
Chapter 5 Summary : 11 Class Methods
Chapter 5: Class Methods - Plugging Memory Leaks
Introduction to Memory Management
This chapter emphasizes the importance of recycling
dynamically allocated memory to prevent memory leaks,
which often indicate deeper algorithmic issues in programs.
It introduces methods from object-oriented programming that
can mitigate such leaks.
Example of Memory Leak
The chapter presents a scenario using a calculator program
where a syntax error causes memory leaks due to lost
references to dynamically allocated nodes in an expression
tree. The MallocDebug application is suggested for
identifying memory leaks, with limitations noted in its
detection process.
Class Methods Defined
Class methods are introduced as methods applied to class
descriptions rather than to individual object instances. The
chapter advocates for a system where allocation methods
such as new() and reclamation methods like delete() are
defined in class descriptions to streamline memory
management and track allocated nodes.
Implementing Class Methods
The process of distinguishing class methods from
dynamically linked methods is discussed, illustrating how
they can be designed and called through class descriptions.
The chapter examines the advantages of this approach, such
as reducing memory overhead by storing methods in class
descriptions rather than in individual objects.
Programming Savvy: Constructing a Class
Hierarchy
The chapter demonstrates building a class hierarchy for a
calculator with nodes representing different components of
an expression tree. The Node class serves as an abstract base
for different node types—maintaining a linear list of nodes
for reclamation purposes.
Symbol Table Implementation
A symbol table is implemented to manage symbol entries,
distinguishing them by their types and functionalities. The
implementation involves the creation of base classes for
symbols such as Var, Const, Global, and Function, using
inheritance for shared methods.
Memory Leak Prevention Techniques
Techniques to reclaim memory, including the use of a linked
list structure for nodes, are depicted to facilitate the safe
release of memory in case of errors during execution.
Summary of Class Methods
Class methods provide a structured means of managing
memory allocation and deallocation in programs. They
enable flexibility and efficiency by encapsulating memory
management at the class level, allowing for easier debugging
and maintenance while preventing memory leaks.
Exercises
The chapter closes with exercises aimed at reinforcing
understanding of class methods, memory management, and
the implications of method linkage in object-oriented
programming.
Example
Key Point:The significance of implementing class
methods for efficient memory management in
programming.
Example:Imagine you’re developing a complex graphics
editing software. Every time you create a new shape,
you allocate memory for it. Without proper
management, those shapes linger in memory even after
you delete them from your project, causing crashes and
slowdowns. By implementing class methods such as
new() and delete() directly within your shape classes,
you efficiently manage these allocations and ensure that
when shapes are no longer needed, their memory is
reclaimed instantly, preserving system performance and
making your code more reliable.
Chapter 6 Summary : 12 Persistent
Objects
12 Persistent Objects - Storing and Loading Data
Structures
Introduction
This chapter discusses the concept of persistent objects in
object-oriented programming, which refers to objects that
can be stored in files and retrieved across application
sessions. The chapter outlines methods for storing and
loading objects, focusing on the implementation of the
`puto()` and `geto()` methods for various classes.
12.1 An Example
The example provided involves a calculator that can save and
load variable values and function definitions. By
implementing commands like `save` and `load`, the
calculator can retain user-defined functions and variables
between sessions.
Save Functionality
: The `save` command with no arguments stores all
definitions into a predefined file.
Load Functionality
: The `load` command retrieves the saved definitions,
demonstrating that they can be restored to previous states.
12.2 Storing Objects - puto()
The `puto()` method is utilized for writing the representation
of an object to a file. Each class can implement its version of
`puto()`, which should call its superclass’s `puto()` to
maintain a consistent output format.
Output Structure
: The output begins with the object's class name followed by
its instance variables.
Install Bookey App to Unlock Full Text and
Implementation
: Example implementationsAudio
for classes `Var` and `Symbol`
are provided, demonstrating how to structure the output
Chapter 7 Summary : 13 Exceptions
13 Exceptions — Disciplined Error Recovery
This chapter focuses on error recovery techniques in
ANSI-C, particularly through the use of `setjmp()` and
`longjmp()`. These functions provide a way to manage
control flow during error scenarios without excessively
complicating code.
13.1 Strategy
When an error occurs (like failure to load a function
definition in a calculator), it necessitates cleanup actions
before issuing an error message. The process involves:
- Setting up an error handler.
- Executing a risky action.
- If the risky action fails, invoking the error handler to
perform necessary cleanup.
This is illustrated with a simple model using `setjmp()` to set
an error recovery point, and `longjmp()` to return control
when an error is encountered.
13.2 Implementation – Exception
An “Exception” class is introduced that enables nested
exception handling. The class manages a stack of `jmp_buf`
values, allowing the handler to be specific to each operation.
Exception objects must be created and deleted in reverse
order of their creation, ensuring proper resource
management.
Key functions and mechanisms include:
- `cause()`: Triggers the exception handling process from
within the code.
- `catch()`: A macro to invoke `setjmp()`, allowing for clean
integration with exception handling.
13.3 Examples
The chapter provides practical examples using exception
handling in a calculator. For instance, error messages are
modified to utilize the `cause()` function for exception
management. The nesting of exception handlers is also
shown, where an exception in deeper levels propagates
upwards for handling, maintaining control flow integrity.
13.4 Summary
Modern languages like Eiffel and C++ introduce specific
syntax for managing exceptions. The key principles
discussed include establishing handlers prior to risky actions,
nesting handlers, and appropriately chaining exception
management. The chapter reinforces that, while ANSI-C may
not natively support complex exception syntax, it can
effectively implement similar functionality via `setjmp()` and
a custom Exception class.
13.5 Exercises
The text encourages further contemplation on the
implementation of exception handling, particularly regarding
resource management and the implications of potential
memory leaks. It summarizes key considerations for
maintaining order during exception processing and the
necessary precautions when utilizing `setjmp()` to avoid
invalid states during control flow transfers.
Chapter 8 Summary : 14 Forwarding
Messages
14 Forwarding Messages: A GUI Calculator
14.1 The Idea
This section introduces the concept of forwarding messages
in object-oriented programming. The selector mechanism
allows dynamic linking of methods and error handling when
methods are not applicable to a specific object. A revised
selector for the `add()` method demonstrates how to forward
calls to appropriate handlers when the method is unavailable.
14.2 Implementation
This portion outlines the implementation details of message
forwarding, including modifying existing reporting
mechanisms to handle selectors that do not understand
method calls. A new `forward()` method is dynamically
defined to handle these calls, ensuring smooth object
interactions.
14.3 Object-Oriented Design by Example
Using the example of a calculator, the design focuses on
identifying key objects like display, computing chip, and
buttons. An object-oriented approach is adopted to structure
the calculator's components, facilitating interaction between
them while maintaining a clean separation of responsibilities.
14.4 Implementation — Ic
Here, the `Ic` class serves as an abstract base for handling
incoming information. The `gate()` method processes
incoming messages, and subclasses can override this
behavior as needed. The `wire()` method connects objects,
allowing for dynamic changes in how objects communicate.
14.5 A Character-Based Interface — curses
This section discusses integrating the calculator with the
`curses` library to manage character-based terminals. Class
hierarchies are developed around `curses` components like
windows to facilitate user interactions, with a focus on
maintaining clean interfaces.
14.6 A Graphical Interface — Xt
The transition to a graphical environment using the X
Window System (X11) is explored. The section details the
creation of widget classes that wrap around the X toolkit,
allowing the calculator to utilize buttons and displays in a
graphical format while managing complex event handling.
14.7 Summary
The chapter summarizes the design and implementation of a
calculator that works across different platforms (text-based
and GUI). Key concepts include object encapsulation,
message forwarding, and design reuse, emphasizing the
advantages of a message-driven architecture over traditional
inheritance.
14.8 Exercises
Exercises stimulate further engagement with the concepts,
encouraging readers to explore wrapping libraries for other
GUI toolkits and refining the event handling in the context of
user interfaces.
Chapter 9 Summary : A ANSI-C
Programming Hints
Summary of Chapter 9: ANSI-C Programming
Hints
Introduction to ANSI-C
This chapter provides a concise overview of the ANSI-C
standard developed to extend the original C programming
language. It emphasizes innovations that benefit
object-oriented programming using ANSI-C.
A.1 Names and Scope
ANSI-C allows names of arbitrary length, reserving those
starting with an underscore for libraries. Introduces the
concept of static names for local visibility, with examples
demonstrating how forward references can be correctly
declared.
A.2 Functions
Functions may be declared with parameter names in ANSI-C
but this does not affect the names in definitions. Prototypes
allow compilers to enforce type checking for arguments.
A.3 Generic Pointers — void
*
All pointer types can be assigned to `void *`, bypassing type
checking. Pointer arithmetic isn't applicable to `void *`, and
specific format specifications are necessary for pointer
operations in print statements.
A.4 ‘const’
The `const` qualifier prevents assignments to a variable after
its initialization, while allowing typecasting to override this.
It impacts the behavior of pointers and how structures
encapsulating constants are handled.
A.5 typedef and const
Install Bookey App to Unlock Full Text and
Audio
`typedef` creates type aliases
but does not behave like
macros. The interplay with `const` qualifiers may cause
Chapter 10 Summary : B The ooc
Preprocessor
Summary of Chapter 10: The ooc Preprocessor Hints on awk Programming
Introduction to AWK and ooc Preprocessor
AWK, a programming language originating from UNIX, has
evolved to include new features and variations like POSIX
standard and implementations (gawk, nawk, etc.). This
chapter discusses the ooc preprocessor's implementation,
which is based on AWK and assumes familiarity with the
language.
B.1 Architecture
The ooc preprocessor is a shell script that facilitates the
execution of AWK programs, managing command arguments
and module storage. It generates C code by collecting
information from class description files and is designed with
modularization and report generation in mind.
B.2 File Management — io.awk
This module manages file access, keeps track of open files,
reads input lines, and handles errors. It allows for a central
storage location for various reports and class descriptions,
using a stack to manage file opening and closing procedures.
B.3 Recognition — parse.awk
The parse.awk module extracts a database from class
description files, utilizing several internal functions to
process declarations and method definitions. It implements
simple parsing mechanisms for recognizing class structures.
B.4 The Database
A database is created to track class descriptions, methods,
and declarations. The information is organized into arrays to
facilitate access during the code generation process, ensuring
that necessary details are retained for reports and outputs.
B.5 Report Generation — report.awk
This module handles the loading and output generation of
reports, managing formatting and controlling line numbers.
Reports can be customized, and an efficient mechanism for
processing is established through the identification of groups
within the report structure.
B.6 Line Numbering
To assist with error tracing during compilation, the
preprocessor generates #line stamps linking output to
original source files. This feature is controlled by a global
variable and focuses on maintaining performance despite the
complexity of input file relationships.
B.7 The Main Program — main.awk
The main program processes command-line arguments,
differentiating between report files and class descriptions,
and initiates the preprocessing sequence. It gathers class
details necessary for generating method headers and
managing dependencies.
B.8 Report Files
Reports are organized into multiple files based on
functionality to streamline maintenance. Each file caters to
specific command-line options, allowing only the relevant
reports to load at runtime.
B.9 The ooc Command
The ooc command processes various reports and
descriptions, acting as a filter to output generated code to the
standard output. Users can invoke it with different options
and targets, with error handling for incorrect usage embedded
within the command script.
This summary encapsulates the key components and
functionalities of the ooc preprocessor within the context of
awk programming, providing users with a concise overview
of its architecture and usage.
Chapter 11 Summary : C Manual
Chapter 11 Summary: Programming in ANSI C
Appendix C: Manual
This appendix provides UNIX manual pages detailing the
`ooc` preprocessor and associated classes from the book.
C.1 Commands
munch
: Generates a sorted list of class function pointers from a
provided nm listing, outputting a C source definition for an
array of class functions.
ooc
: An awk-based program for object-oriented coding in ANSI
C.
-
Parameters
: Accepts various options such as generating header files,
preprocessing source files, and controlling debug output.
Class Description Files
: Define class structures and methods, supporting static and
dynamic linkage.
Lexical Conventions
: Clarifies how input is processed, including comment
removal, line concatenation, and identifier rules.
Class Description File Structure
:
- Format includes metadata, component declarations, and
method definitions with static, dynamic, and class methods.
Preprocessing
: Describes transformations for `ooc`, including method
headers and parameter handling.
Report Files
: Contains fragments of code used by `ooc`, which can be
customized for specific implementations through unique
report names.
Environment
: Lists the file paths where `ooc` searches for class
descriptions and associated files.
C.2 Functions
retrieve()
: Reads an object from a file, requiring class function
pointers generated by `munch`.
C.3 Root Classes
Class Overview
:
Object
: The root class, with methods for memory management and
type checking.
Class
: The root metaclass, describing other classes and containing
method information.
Exception Class
: Manages exception handling with a stack of handlers.
C.4 GUI Calculator Classes
- Overview of GUI classes for a calculator application,
including event handling and input/output management.
Event Class
: Represents user inputs like keyboard actions.
Ic Class
: Base for I/O objects managing data reception and output
through wired connections to other objects.
Xt Class
: Wraps X Toolkit widgets for graphical applications,
supporting functionality like creating and managing GUI
elements.
Bibliography
: References ANSI standards, key texts on C programming,
and documentation related to the tools and processes
discussed in the chapter.
Best Quotes from Programming In Ansi
C by E. Balagurusamy with Page
Numbers
View on Bookey Website and Generate Beautiful Quote Images
Chapter 1 | Quotes From Pages 76-92
1.ooc is certainly not intended to introduce a new
programming language — we are still working
with ANSI -C and the output from ooc is exactly
what we would write by hand as well.
2.Once ooc has digested a class description, it has enough
information to generate the interface and the representation
file.
3.It is wise to design a command as a filter, i.e., to require
explicit i/o redirection to create a file...
4.If we want to trace selector calls, for example, we simply
insert a trace line into the selector body in the reports file,
and the trace will be generated all over.
5.There is hardly an excuse for duplicating code.
Chapter 2 | Quotes From Pages 93-103
1.Every assignment of a generic void * value to a
pointer to some structure is suspect to begin with,
and its legality ought to be verified.
2.The function is also used for safely dereferencing pointers
upon import to a method or selector: struct Circle * self =
cast(Circle, _self);
3.The whole point of defensive programming is to recognize
that programmers are likely to make mistakes and to limit
how long a mistake can go unrecognized.
4.With the change to all selectors and with the convention of
using %casts in all methods, we account for all objects
passed as parameters: their pointers are checked upon
import to the callee.
5.cast() is designed to strike a balance between efficiency for
correct programs and (early) detection of flaws.
Chapter 3 | Quotes From Pages 104-111
1.Our problem is that we need to call Class_ctor()
and the other metaclass constructors to hide the
details of inheritance when initializing a class
description.
2.Therefore, in this chapter we look at mechanisms which
automatically prevent this problem.
3.Static objects such as class descriptions would normally be
initialized at compile time.
4.In order to avoid trivial but hard to diagnose errors, we
should provide a mechanism which performs these function
calls automatically — our programs should be
self-organizing.
5.The array names[] is used because each name must be
emitted twice.
Chapter 4 | Quotes From Pages 112-125
1.Being able to ask makes for a more forgiving
interface.
2.Delegates are preferable to registering callback functions
and to abstract base classes for defining the communication
between a host and a client.
3.An application framework consists of one or more objects
which provide the typical structure of an application.
4.If we want to communicate with a client in the style of a
callback function, we have to postulate an abstract base
class with the necessary communication methods.
5.The catch is that all methods of an abstract base class must
be implemented for the client because they will be called.
Chapter 5 | Quotes From Pages 126-142
1.If a program loses track of a byte here and there it
will probably not make a whole lot of difference.
However, memory leaks are usually indicative of
algorithmic errors.
2.All resources acquired by a program should be properly
recycled.
3.Designing a reclamation mechanism is a much more
systematic approach for solving this problem.
4.Just like other methods, class methods can have static or
dynamic linkage.
5.Defining new() as a class method for Object rather than as
a method with static linkage for Class permits redefining
new() for subtrees of the class hierarchy.
Chapter 6 | Quotes From Pages 143-157
1.If the output is designed well enough, we should be
able to recreate the objects from it... We call such
objects persistent.
2.Writing and reading a strictly tree-structured,
self-contained set of objects can be accomplished with
puto(), retrieve(), and matching geto methods.
3.Implementing persistence requires two dynamically linked
methods and a function to drive the loading process: int
puto (const _self, FILE * fp); void * geto (_self, FILE *
fp); void * retrieve (FILE * fp);
4.It helps that when a Fun symbol is created we need not yet
supply the defining expression.
Chapter 7 | Quotes From Pages 158-165
1.Thirteen seems quite appropriate as the chapter
number for coping with misfortune.
2.If we get lost inside a single function, the much maligned
goto is a boon for bailing out.
3.A strategy is necessary: if our calculator has trouble
loading a function definition, we run into a typical error
recovery problem.
4.An exception handling smells of goto with all its
unharnessed glory.
5.The Exception class provides a clean, encapsulated
mechanism to nest exception handlers and thus to nest one
protected risky action inside another.
6.However, a language should definitely support nesting the
ranges where an exception handler is effective, and it must
be possible to chain exception handling.
Chapter 8 | Quotes From Pages 166-188
1.An elegant solution can be had at a fraction of the
cost.
2.Objects are identified by looking at the problem. An object
is given certain responsibilities to carry out. This leads to
other objects which collaborate in carrying out the work.
3.Message forwarding permits objects to act as if they
belonged to two classes at the same time, but we do not
incur the overhead and complexity of multiple inheritance.
4.We can set up a computing chip, a display, and any number
of buttons, and connect them.
5.Ic is mostly an abstract base class, but its methods can
access its pointer to another object to which information
must be sent.
6.If we want to test this setup with character input from a
keyboard, we will have to wrap every character as an Event
and offer it to each Button.
7.The key idea for this application is the Ic class with the
capability of receiving, changing, and routing information.
8.Using accelerators is perhaps not the most natural way to
map key presses into input to our calculators.
9.We have to design some wrapper classes to merge the
external library with our class hierarchy.
10.Message forwarding helps to create a general solution that
can be reused in multiple environments.
Chapter 9 | Quotes From Pages 189-196
1.const is a qualifier indicating that the compiler
should not permit an assignment. This is quite
different from truly constant values.
2.The results of certain operations: size_t result of sizeof
ptrdiff_t difference of two pointers.
3.A pointer to a function can be a structure component.
4.assert(condition); If condition is false, this macro call
terminates the program with an appropriate error message.
5.When a macro is defined with parameters, ANSI -C only
recognizes its invocation if the macro name appears before
a left parenthesis.
Chapter 10 | Quotes From Pages 197-204
1.‘The basic idea was to make things easier to read
and more efficient by duplicating some decisions in
the reports called by the selector report and by
separating the reports for the root class and the
other classes.’
2.‘The design goal is that the awk program contain as little
information about the generated code as possible.’
3.‘The complete name is then set into FILENAME and FNR
is reset.’
4.‘Debugging modules will eventually return status with an
END clause.’
5.‘If the awk variable makefile is set by the ooc command
script, the report –M is generated for each class name
specified as an argument.’
Chapter 11 | Quotes From Pages 205-221
1.Object is the root class; all classes and metaclasses
have Object as their ultimate superclass.
2.A metaclass object describes a class, i.e., it contains the
class name, a pointer to the class’ super class description,
the size of an object in the class, and information about all
dynamically linked methods which can be applied to
objects of the class.
3.If a method m does not have static linkage, there are two
selectors: m with the same parameters as the method
selecting the method defined for self, and super_m with an
explicit class description as an additional first parameter.
4.A Button object contains a text which is sent out in
response to certain inputs.
5.The calculator is a simple, precedence-free, finite state
machine: the first set of digits defines a first operand; the
first operator is saved; more digits define another operand;
if another operator is received, the saved operator is
executed and the new operator is saved.
Programming In Ansi C Questions
View on Bookey Website
Chapter 1 | 7 The ooc Preprocessor| Q&A
1.Question
What is the purpose of the ooc preprocessor as discussed
in the chapter?
Answer:The purpose of the ooc preprocessor is to
help enforce coding standards and maintain class
structures in a programming project using ANSI-C.
It generates necessary interface and representation
files based on simple class descriptions, thus
simplifying the coding process and reducing the
potential for errors in program structure.
2.Question
How does the ooc preprocessor assist in changing coding
conventions?
Answer:The ooc preprocessor allows for easy updates to
coding conventions by generating code based on
standardized class descriptions. If rules are modified, such
changes can be implemented by altering the class description
rather than changing every instance of the code manually.
3.Question
What functionality does the chapter highlight about the
ooc preprocessor?
Answer:The ooc preprocessor can generate method headers,
import and check object parameters, and create selectors and
initialization functions. This assists developers in
maintaining coherent structure and functionality in their
object-oriented code.
4.Question
Can you describe the relationship between the Point and
Circle class examples mentioned in the text?
Answer:Point serves as a foundational class example that is
more complex and includes statically and dynamically linked
methods, while Circle is a simpler subclass that extends Point
without the need for additional methods. This demonstrates
how listed classes can build upon each other.
5.Question
What are the benefits of using a report generation system
as part of the ooc preprocessor?
Answer:Using a report generation system simplifies
maintaining and modifying class hierarchies, as it centralizes
coding standards into reports. Changes to method
implementations or selectors can be made in one place and
automatically reflected throughout the codebase.
6.Question
Why is it significant that Object and Class can be defined
with specific syntaxes within the class description, as
mentioned?
Answer:The unique syntax for Object and Class indicates
their foundational role in the class hierarchy, allowing the
ooc preprocessor to recognize their special properties and
handle their relationships correctly during code generation.
7.Question
In what way does the ooc preprocessor help new classes
such as List, Stack, and Queue?
Answer:The ooc preprocessor facilitates the creation of these
new classes by allowing developers to focus on the specific
implementation details while adhering to well-defined
interfaces and structures, thus reducing development time
and potential errors.
8.Question
What aspect of the ooc preprocessor design allows it to
maintain flexibility across different projects?
Answer:By allowing report files to be modified or
specialized for different projects without modifying the core
functionality of the ooc preprocessor itself, it maintains
flexibility. This enables various teams to adjust their coding
standards without being bound to a rigid structure.
9.Question
What example is given to illustrate how parameter
checking and imports are handled by the ooc
preprocessor?
Answer:The chapter demonstrates this with methods like
`addFirst()` and `addLast()` in the List class, where
parameter checking is essential for ensuring that proper
objects are handled correctly, showcasing how the ooc
preprocessor aids in maintaining code reliability.
10.Question
How does the chapter conclude, and what future exercises
are suggested?
Answer:The chapter concludes with the suggestion to
experiment with combining classes like Queue with graphical
objects such as Point and Circle for practical applications,
promoting further exploration of the concepts introduced and
the capabilities of the ooc preprocessor.
Chapter 2 | 8 Dynamic Type Checking| Q&A
1.Question
What is dynamic type checking and why is it important in
programming?
Answer:Dynamic type checking is the process of
verifying the type of an object at runtime, ensuring
that the operations performed on it are appropriate
for its type. It is important because it helps prevent
errors related to type mismatches, which can lead to
unpredictable behavior or crashes in a program.
Without dynamic type checking, a program might
manipulate objects incorrectly, causing significant
issues during execution.
2.Question
How does the cast() method improve safety in type
manipulation?
Answer:The cast() method is designed to safely convert a
generic pointer to a specific object type. It checks if the
object is of the correct class before allowing the conversion.
If the object does not belong to the specified class, cast()
terminates the program, preventing potential errors that could
arise from incorrect type usage.
3.Question
What role do the methods isA() and isOf() play in type
safety?
Answer:The isA() method checks if an object is an instance
of a specified class, while isOf() determines if an object is of
the specified class or any of its subclasses. Together, they
provide a mechanism for verifying object types, helping to
enforce type safety and reducing the possibility of runtime
errors.
4.Question
Describe the significance of using magic numbers in
object-oriented programming as mentioned in the
chapter.
Answer:Magic numbers are unique values added to each
object to help identify valid object instances. This serves as a
safeguard against using arbitrary pointers mistakenly. In this
context, magic numbers ensure that any pointer being
dereferenced points to a properly initialized object, thus
enhancing robustness in dynamic type checks.
5.Question
What is the reason behind avoiding recursion in the
implementation of cast()?
Answer:Recursion in the implementation of cast() can lead to
infinite loops because cast() relies on functions like isOf()
and classOf(), which themselves might call cast(). This
creates a cycle where each call continuously checks the
conditions that remain unfulfilled, resulting in a stack
overflow. To prevent this, the implementation needs careful
control of which checks are performed in the function.
6.Question
What are the advantages of a coding standard that
enforces the use of cast() and other safety checks?
Answer:A coding standard that mandates the use of cast()
and related safety checks promotes defensive programming
practices. It minimizes the risk of errors by ensuring that all
type conversions are validated, making the code more
reliable and easier to debug. By standardizing the use of
these methods, it creates consistency across the codebase,
facilitating maintenance and collaboration among developers.
7.Question
How does the chapter suggest handling the dereferencing
of object pointers?
Answer:The chapter suggests that whenever an object pointer
is to be dereferenced, it should first be passed through the
cast() method. This approach ensures that the pointer is of the
correct type, thereby avoiding potential illegal memory
access or other errors associated with improper type
handling.
8.Question
Explain how exception handling is implemented in the
cast() method to manage bad pointers.
Answer:In the cast() method, a signal handler is set up to
catch illegal memory access attempts, like SIGSEGV and
SIGBUS signals. This allows the program to gracefully
handle situations where a bad pointer is dereferenced, instead
of causing unexpected crashes or undefined behavior.
9.Question
Why might it be necessary to implement isOf() in a way
that avoids infinite recursion?
Answer:To avoid infinite recursion in the implementation of
isOf(), it is necessary to ensure that it does not call functions
(like cast() or classOf()) that may invoke isOf() again. This
requires careful management of how checks are conducted,
focusing on maintaining the integrity of the function call
stack while performing type verifications.
10.Question
What does the chapter imply about the importance of
testing and validation in programming?
Answer:The chapter implicitly highlights that testing and
validation are critical components of programming. By
introducing methods like cast(), isA(), and isOf() alongside a
defensive coding standard, it emphasizes the importance of
anticipating errors and ensuring that code behaves correctly
even in unforeseen circumstances. This proactive approach to
error management is vital for building robust software.
Chapter 3 | 9 Static Construction| Q&A
1.Question
Why is it important to ensure that class descriptions are
initialized before they are used?
Answer:Class descriptions are fundamental
components in object-oriented programming that
define the structure and behavior of objects. If a
class description is not initialized before use, it can
lead to undefined behavior, errors, and crashes,
complicating the debugging process and reducing
the reliability of the code. The chapter emphasizes
the need for mechanisms that automatically prevent
this initialization issue.
2.Question
What is the role of the init functions like initPoint() and
initCircle() in the self-organization of class descriptions?
Answer:init functions such as initPoint() and initCircle() are
responsible for ensuring that the class descriptions are
instantiated correctly and only once. They check whether the
respective class description exists before attempting to create
it, thereby preventing potential runtime errors associated with
using uninitialized class descriptions. This design upholds
proper hierarchy and order in initialization, ensuring that
object-oriented principles are respected.
3.Question
How does the concept of static and dynamic initialization
differ, and what is its significance?
Answer:Static initialization refers to initializing objects at
compile time, ensuring they persist as long as the program
runs, while dynamic initialization occurs at runtime. This
distinction is significant because static initialization can lead
to difficult maintenance issues, especially when class
hierarchies evolve or change. The chapter advocates dynamic
initialization for flexibility and maintainability, emphasizing
the use of initialization functions to manage these
complexities.
4.Question
What is the purpose of the 'munch' utility described in
the chapter, and how does it aid initialization?
Answer:The 'munch' utility serves to automate the collection
and referencing of initialization functions across the
program. By scanning the symbol tables of linked modules, it
generates an array of pointers to these functions, which can
be called at the start of the main program. This process
ensures that all required class descriptions are initialized
correctly and in order, thereby providing a self-organizing
behavior to the application.
5.Question
Discuss the advantages and potential pitfalls of using
macros for initialization as opposed to initialization
functions.
Answer:Using macros can provide a more efficient and inline
way to handle initialization since they replace direct object
references with a call to the corresponding init function. The
advantages include reducing function call overhead and
improving performance. However, pitfalls arise in terms of
readability and potential for error, especially if the macro
naming conflicts with other identifiers. Macros also may
obscure the underlying logic, making debugging more
challenging compared to using explicit function calls.
6.Question
Describe how the proposed structure for initialization
functions reflects object-oriented principles.
Answer:The proposed structure for initialization functions
reflects object-oriented principles by emphasizing
encapsulation and the management of class hierarchies. Each
class description is initialized through specific functions that
adhere to the inheritance structure, ensuring dependencies are
resolved correctly before usage. This systematic approach to
initialization aligns with encapsulation by keeping
implementation details hidden and easily manageable, while
still adhering to the principles of polymorphism and dynamic
behavior in object-oriented programming.
7.Question
How can one ensure that class descriptions and their
respective initializers are managed efficiently in a large
application?
Answer:To manage class descriptions and initializers
efficiently in a large application, one can adopt a
combination of automated tools like the 'munch' utility for
gathering initializers, along with a well-structured coding
convention that uses macros or dedicated initialization
functions. Implementing a clear order of initialization,
prioritizing superclass constructors, and maintaining clean
interfaces for class descriptions all contribute to an organized
and maintainable application architecture.
Chapter 4 | 10 Delegates| Q&A
1.Question
What is the purpose of callback functions in
programming?
Answer:Callback functions allow different parts of a
program to communicate and respond to events,
making the program more dynamic and flexible.
They enable the management of operations such as
updating user interfaces or handling asynchronous
events.
2.Question
How do delegates improve upon traditional callback
functions?
Answer:Delegates enhance traditional callback functions by
allowing a client object to specify which methods it can
respond to, creating a more tailored and flexible interaction.
This approach allows multiple clients to provide different
functionalities without being bound by a common name
space.
3.Question
What role do abstract base classes play in the context of
callback functions?
Answer:Abstract base classes are used to define a standard
interface for callbacks within a hierarchy of classes.
However, they can impose limitations by requiring all
subclasses to implement all methods, regardless of their
relevance to each specific subclass.
4.Question
Why might one prefer using delegates over abstract base
classes?
Answer:Delegates provide more flexibility as they allow
clients to implement only the methods relevant to their
operations, avoiding the constraints of a fixed method
structure imposed by abstract base classes. This reduces
unnecessary implementation and aligns better with
application needs.
5.Question
What is the main function of the respondsTo() method in
the code?
Answer:The respondsTo() method dynamically checks if a
delegate can handle specific callback requests by returning a
suitable function pointer if the requested method exists,
enabling the host object to call the correct method on the
delegate.
6.Question
Can you explain the significance of the tag system used in
the delegates pattern?
Answer:The tag system allows flexibility in method
identification within the class description, enabling a more
dynamic binding of functions to calls. Tags can be defined
directly in the class interface, which can simplify method
matching and enhance runtime adaptability.
7.Question
How does the Filter class exemplify the concept of an
application framework?
Answer:The Filter class provides a standard structure for
managing command-line input and processing for various
filter programs. It encapsulates common functionality while
allowing specific application logic to be implemented by
delegating tasks to client-defined methods.
8.Question
What are some potential exercises suggested at the end of
the chapter?
Answer:1. Consider designing a general solution for
command-line argument parsing that handles non-standard
formats. 2. Modify existing callback methods to correctly
handle binary file input. 3. Explore optimizations in
managing file memory mapping.
9.Question
How do delegates offer a more elegant solution than
traditional callback functions?
Answer:By allowing the delegate to specify which methods it
handles, delegates prevent clients from implementing
extraneous methods and provide a cleaner way to manage
interactions. This design pattern accommodates evolving
application requirements without the baggage of rigid
structure.
10.Question
In what scenarios could the application framework
concept be beneficial beyond the examples given?
Answer:Application frameworks can streamline the
development of complex applications by providing reusable
components and structure for handling common tasks, such
as data input/output, error handling, and common user
interface elements across diverse applications.
Chapter 5 | 11 Class Methods| Q&A
1.Question
What is a memory leak and how does it indicate
algorithmic errors in programming?
Answer:A memory leak occurs when a program
loses track of dynamic memory that it has allocated,
leading to inefficient memory usage. It indicates
algorithmic errors because it suggests that the
program does not handle unusual inputs properly or
is poorly designed, resulting in lost references to
dynamically allocated memory. This could cause
unexpected behavior as the program runs.
2.Question
How can class methods be employed to combat memory
leaks?
Answer:Class methods, particularly a custom 'new()' method,
can be used to manage memory allocation more effectively
by keeping track of allocated memory in a structure. This
provides a systematic approach to reclaiming memory when
errors occur, ensuring that all resources are properly
recycled.
3.Question
What is the purpose of the reclaim() method introduced
in class Node?
Answer:The reclaim() method is designed to traverse a list of
allocated nodes and free their memory when an error occurs.
This encapsulation within the base class Node allows all
derived classes to benefit from memory management,
effectively preventing memory leaks across the entire
expression tree.
4.Question
What is the relationship between new() and delete()
methods in the context of class methods?
Answer:The new() method is responsible for allocating
memory and initializing objects, while the delete() method is
responsible for cleaning up resources, invoking destructors,
and returning memory to the system. Both methods can be
overwritten to add custom behavior related to memory
management, especially in maintaining class hierarchies.
5.Question
Why is it important to handle constructors and
destructors properly even when using class methods?
Answer:Proper handling of constructors and destructors is
crucial because they ensure that all resources are
appropriately initialized and cleaned up. If a constructor is
omitted or left empty while the new() method does too much,
it can lead to broken invariants and undefined behaviors. The
responsibilities of allocation and initialization need to be
balanced to maintain a consistent life cycle for objects.
6.Question
How does the memory management strategy using class
methods improve program efficiency?
Answer:Using class methods for memory management
allows for more controlled and efficient allocation and
reclamation of memory. By encapsulating memory tracking
within the class description, we avoid memory leaks and
improve the overall stability of the program as objects are
created and destroyed in a managed manner.
7.Question
Explain the implementation of a symbol table using the
Symtab class structure. What are its key functions?
Answer:The Symtab class structure is used to implement a
symbol table that holds symbols by name. Key functions
include 'install()', which adds or replaces symbols within the
table, and 'screen()', which finds or creates symbols by name.
This structure uses an internal search function to maintain an
array of symbols and ensures efficient access and
modification.
8.Question
What challenges arise from using dynamic linkage for
methods like delete()?
Answer:Using dynamic linkage for methods like delete() can
complicate how memory is handled. Specific arguments that
are required in some contexts may not be available in others,
leading to potential errors or inefficiencies, as the function
may not know how to handle all object types consistently.
Chapter 6 | 12 Persistent Objects| Q&A
1.Question
What are persistent objects and why are they important
in programming?
Answer:Persistent objects are data structures that
can be saved to files and restored later, allowing
them to exist beyond the runtime of an application.
They are vital in programming because they enable
data retention, making applications more
user-friendly and allowing for the continuation of
tasks without the loss of state.
2.Question
How can one implement saving and loading functionality
for a calculator's variables and functions?
Answer:In the example provided, the calculator can save
variables and function definitions using a `save` command
that writes these definitions to a file (e.g., 'value.stb').
Similarly, it can restore these definitions using a `load`
command that reads from the same file, thus enabling the
user to retrieve their previous calculations and definitions
without re-entering them.
3.Question
What is the significance of the `puto()` and `geto()`
methods in object persistence?
Answer:The `puto()` method is responsible for writing an
object's state to a file, while `geto()` reads this state back into
an object. Together, they ensure that an object's data can be
stored and reconstructed accurately, thereby facilitating the
persistence of objects between program executions.
4.Question
Explain how the `retrieve()` function operates in the
context of loading objects. What are its steps?
Answer:The `retrieve()` function reads the object's class
name from a stream, locates the corresponding class
description, allocates memory for the object, and invokes the
`geto()` method to populate the object's data. This process
ensures that each object loaded is correctly associated with
its class and initialized with the proper values.
5.Question
Why must the `load()` method be carefully designed,
specifically regarding input protection?
Answer:The `load()` method needs careful design to protect
against incorrect modifications of input files. Since it
reconstructs objects, any tampering could lead to attempts to
load invalid data or corrupted objects, which could cause
runtime errors. Therefore, validation checks must be
implemented to ensure that only valid objects are loaded.
6.Question
What challenges can arise with references in function
definitions when using persistent storage?
Answer:When dealing with references in function
definitions, a challenge arises if the referenced functions or
variables have not been defined at the time of loading. This
leads to situations where the program may encounter
undefined symbols, which could result in errors during
execution if the appropriate error handling is not in place.
7.Question
How can the `puto()` function assist in debugging?
Answer:The `puto()` function can serve a dual purpose by
not only saving the state of persistent objects but also
providing a formatted output of an object's state. This
capability is useful during debugging because developers can
inspect the output to verify object states and catch
discrepancies in their applications.
8.Question
What is a container class and why does its proper
management matter in object persistence?
Answer:A container class is a type of class that manages
other objects, usually holding multiple instances of those
objects. Proper management is crucial in object persistence to
ensure that when these container objects are saved and
restored, their contents are accurately maintained and
re-associated, preventing issues such as duplicate or broken
references.
9.Question
What programming techniques can be employed to
validate symbol names when loading a symbol table?
Answer:To validate symbol names during the loading
process, programming techniques can include checking the
types of symbols being loaded, verifying that the expected
attributes (lexical values) match, and implementing exception
handling to deal with discrepancies, such as attempting to
load a symbol that has an incorrect class or is undefined.
10.Question
In what situation would it be necessary to utilize the
`move()` method?
Answer:The `move()` method is necessary when transferring
the state of an existing object to a new one, particularly if the
source object is to be deleted afterward. It's designed to
facilitate safe transfer without leaving dangling pointers or
corrupted states in the application.
Chapter 7 | 13 Exceptions| Q&A
1.Question
What is the purpose of using setjmp() and longjmp() in
error handling?
Answer:The setjmp() and longjmp() functions are
used in C to handle errors by allowing the program
to jump back to a saved state (set by setjmp()) when
an error occurs (triggered by longjmp()). This helps
manage control flow during error recovery without
deeply nested function calls.
2.Question
How does the example of a calculator illustrate nested
exception handling?
Answer:In the calculator example, nested exception handling
is illustrated through functions that call each other and handle
errors at different levels. When a file loading error occurs,
the cleanup function is executed before returning to the main
error handler, demonstrating how exceptions can be managed
hierarchically.
3.Question
What might go wrong if longjmp() is called from an
inactive function?
Answer:If longjmp() is called from an inactive function, the
program's control flow can become corrupted, potentially
leading to undefined behavior or program crashes, since the
stack frame of the target function would no longer be valid.
4.Question
What are the limitations of using setjmp() in ANSI-C?
Answer:setjmp() has several limitations in ANSI-C; it can
only be used in specific contexts and cannot be mixed with
certain constructs (like a compound statement). This restricts
where and how it can be called and complicates exception
handling.
5.Question
Why is it necessary to delete exception objects in the
reverse order of their creation?
Answer:Deleting exception objects in reverse order ensures
that the stack of active exception handlers remains intact.
This order is crucial for maintaining the proper functioning
of the exception handling mechanism, allowing the correct
cleanup and restoration of control flow.
6.Question
What are the three choices after a risky action causes an
exception, as discussed in the chapter?
Answer:Upon completion of an exception handler, the three
choices are: 1. terminate both the handler and the risky
action, 2. resume the risky action at the point of the
exception, or 3. retry the part of the risky action that caused
the exception.
7.Question
How does the macro 'catch()' differ from a regular call to
setjmp()?
Answer:The 'catch()' macro encapsulates the call to setjmp()
within a method that also arms the exception object, adhering
to the restrictions imposed by ANSI-C and enabling easier
management of exception handlers at various nesting levels.
8.Question
In what scenarios could cause() return without executing
a longjmp()?
Answer:cause() could return without executing a longjmp() if
the input conditions fail, such as when the exception stack is
empty, or if the current exception object is not armed,
indicating that no active handler is available to respond to the
exception.
9.Question
Why is exception handling considered 'horrible and
incomprehensible' in the provided switch-case example?
Answer:The provided example is considered 'horrible and
incomprehensible' due to its complex nesting of exception
handling, which can lead to confusion regarding control flow
and difficult debugging. The intertwining of handlers makes
it hard to track which actions correspond to which errors.
10.Question
What is the significance of using a hidden stack to
manage exception objects?
Answer:Using a hidden stack to manage exception objects
allows for a structured way to handle nested exceptions,
ensuring that they can be properly armed and released in the
correct order, providing a clean and encapsulated method for
error management in complex code.
Chapter 8 | 14 Forwarding Messages| Q&A
1.Question
What is the primary disadvantage of using multiple
inheritance in object-oriented programming, especially in
GUI applications?
Answer:Multiple inheritance can lead to complexity
and ambiguity in code, making it harder to manage
and maintain. It also increases the risk of
inconsistencies, as different base classes may define
similar but incompatible methods. The text suggests
that an elegant alternative, like message forwarding,
can achieve similar outcomes with less complexity.
2.Question
How does the method 'forward()' improve the flexibility
of object-oriented design in the calculator application
discussed?
Answer:The 'forward()' method allows objects to handle
messages they do not understand by redirecting them to other
objects or methods. This creates a dynamic linkage between
objects, letting them appear as if they belong to multiple
classes without the overhead of multiple inheritance.
3.Question
What are the roles of the key components identified in the
calculator's object-oriented design?
Answer:The main components include:
- **Display**: acts as an information sink that shows results
to the user.
- **Computing Chip (Calc)**: processes inputs and performs
calculations, acting as an information filter and state
manager.
- **Buttons**: serve as input sources, sending commands to
the computing chip based on user interactions.
4.Question
Why is the exercise of wrapping libraries like 'curses' into
a suitable class hierarchy considered interesting?
Answer:Wrapping libraries into a class hierarchy allows for
better integration with object-oriented design principles,
making code more modular and reusable. It can also help
hide the complexity of the underlying library, simplifying the
interface for users and maintaining separation between the
application logic and library intricacies.
5.Question
What approach does the chapter suggest for dealing with
incompatible graphical environments when designing the
calculator application?
Answer:The chapter suggests using an object-oriented
approach with message forwarding to manage connections
between different graphical user interfaces. This helps in
decoupling the application design from the specifics of the
GUI implementation, allowing for a consistent underlying
logic regardless of the interface.
6.Question
Explain how the algorithm defined for the computing
chip (Calc) operates in accordance with the
message-driven design. What are its limitations?
Answer:The Calc component is driven by events; it reacts to
each input as it arrives and processes it immediately. Its
design is straightforward and focuses on processing input in a
bottom-up manner. However, this approach limits the ability
to implement complex input parsing techniques like
recursive descent, as it requires the processing to occur in
response to incoming messages in real-time.
7.Question
What distinguishes the X11 solution from the curses
implementation regarding user interface design in the
calculator application?
Answer:The X11 solution allows for a richer and more
flexible graphical user interface (GUI) that can manipulate
visual elements like buttons and labels effectively, taking
advantage of the underlying X toolkit. In contrast, the curses
implementation is more limited, as it deals with text-based
terminals and lacks support for complex graphical features.
8.Question
How do the design patterns used in the calculator
application reflect the principles of object-oriented design
like encapsulation and modularity?
Answer:The design patterns encourage encapsulation by
defining clear object responsibilities (e.g., display, calculator
logic, buttons) and modularity, allowing components to be
developed and tested independently. Each object interacts
with others through well-defined interfaces (like gate() and
wire()), promoting maintainability and reusability.
9.Question
In what way does the chapter suggest using dynamically
linked methods to avoid the limitations of static method
definitions?
Answer:By using dynamically linked methods, the
application can adjust its functionality at runtime, enabling
classes to handle messages appropriately without needing to
know their context or parent classes in advance. This allows
for more flexible and adaptive designs that can incorporate
additional functionalities or handle different scenarios
seamlessly.
10.Question
What is an example of how the button components in the
calculator can handle user inputs effectively, according to
the object-oriented design discussed?
Answer:Buttons are designed as information filters that react
to specific events (like mouse clicks or key presses). When a
Button receives an Event object, it checks if the event's data
matches its text label. If it does, the Button forwards this
information, typically causing the corresponding action on
the computing chip, thus effectively managing user inputs.
Chapter 9 | A ANSI-C Programming Hints| Q&A
1.Question
What is the significance of the ANSI-C standard
compared to the original C language defined by Dennis
Ritchie?
Answer:The ANSI-C standard introduced
important changes and extensions to the original C
language, improving its functionality and usability
for programmers. It established a more structured
and standardized approach to programming in C,
allowing for features like function prototypes, which
provided type checking for function arguments and
improved error handling.
2.Question
Why should function declarations in ANSI-C include
parameter names according to the book?
Answer:Including parameter names in function declarations
in ANSI-C, while optional, enhances code readability and
clarity. It makes it easier to understand the purpose of each
parameter when reading the function declaration, which is
particularly useful for maintaining and debugging the code.
3.Question
How do generic pointers work in ANSI-C and why should
type checking be considered carefully?
Answer:In ANSI-C, any pointer type can be assigned to a
generic pointer (void *). This provides flexibility; however, it
disables type checking, which can lead to potential errors if
the programmer is not cautious. It's crucial to ensure that the
correct type is used when dereferencing, to avoid runtime
errors or undefined behaviors.
4.Question
What role does the 'const' qualifier play in ANSI-C
programming?
Answer:The 'const' qualifier in ANSI-C indicates that a
variable's value should not be changed after initialization. It
provides a way to protect variables from unintended
modifications, thus helping maintain program integrity and
ensuring that certain data remains constant throughout its
lifetime.
5.Question
What is the purpose of asserting conditions with the
assert.h library as mentioned in the chapter?
Answer:The assert.h library allows programmers to check
conditions at runtime, and if an asserted condition is false, it
terminates the program with an error message. This is useful
for debugging, as it helps identify logical errors during
development rather than encountering them in production.
6.Question
What are the memory management functions defined in
stdlib.h, and what does each one do?
Answer:The memory management functions in stdlib.h
include:
- calloc: allocates a block of memory for an array and
initializes it to zero.
- malloc: allocates a specified amount of uninitialized
memory.
- realloc: adjusts the size of memory block, potentially
moving it to a new location if necessary.
- free: releases allocated memory back to the system. Proper
use of these functions is essential for efficient memory
management.
7.Question
Explain the use of variable argument lists as described in
stdarg.h and their importance in function definitions.
Answer:Variable argument lists allow functions to accept a
variable number of arguments, enhancing flexibility. The
stdarg.h library provides macros such as va_start, va_arg, and
va_end to manage these arguments. This is particularly
useful in functions like printf, where the number of inputs
can vary.
8.Question
How does ANSI-C handle structures and their
components?
Answer:ANSI-C allows structures to group different data
types into a single unit. Components of structures are
accessed using the dot (.) operator for structure variables and
the arrow (->) operator for pointers to structures, promoting
organized and efficient data management.
9.Question
What can be concluded about the handling of pointers to
functions and structures in ANSI-C?
Answer:Pointers to functions and structures can enhance
modularity and reuse in ANSI-C. By declaring pointers to
functions, programmers can create flexible interfaces and
callback mechanisms, while pointers to structures allow for
manipulation of data without the need to copy the entire
structure.
Chapter 10 | B The ooc Preprocessor| Q&A
1.Question
What is the main purpose of the ooc preprocessor as
described in this chapter?
Answer:The primary purpose of the ooc
preprocessor is to simplify the process of developing
and managing code in the awk programming
language by providing a structured approach to
handle class descriptions and generate necessary C
code components. It facilitates modularization,
report generation, and file management, allowing
developers to maintain their projects more
efficiently.
2.Question
How does ooc differentiate between various files and
manage them?
Answer:ooc uses a shell script that manages file operations
through a stack mechanism where file names and line
numbers are recorded. It utilizes a search path, OOCPATH, to
locate all necessary files and maintains a FileStack[] for
managing open files, ensuring that file operations are
efficiently controlled while processing class description files.
3.Question
What are the key functions of the io.awk module?
Answer:The io.awk module is responsible for file
management operations such as opening and closing files,
reading lines without comments or interruptions, and
handling errors. It maintains an efficient workflow through
functions like openFile() for opening files, closeFile() for
closing them, and get() for reading lines. It also provides
error handling functions to manage execution states.
4.Question
What design concepts underpin the implementation of the
ooc preprocessor?
Answer:The implementation of the ooc preprocessor is based
on modularization and report generation as its central design
concepts. This approach allows individual components to be
developed and maintained separately, facilitating cleaner and
more organized code generation while generating structured
reports that can be modified without altering the core awk
program.
5.Question
How does the ooc preprocessor handle debugging within
awk?
Answer:Debugging in the ooc preprocessor is achieved by
loading specific debugging modules that can be controlled
using pattern clauses. Once the command line processing is
complete, debugging statements can be inputted and
executed, allowing developers to inspect the workflow and
outputs, thus facilitating a more manageable debugging
process.
6.Question
What is the significance of the report generation in ooc?
Answer:Report generation in ooc serves to produce output
that is vital for understanding the structure and components
of the code being processed. It allows the output to be
dynamically tailored based on the contents of the report files,
facilitating easier integration between different code
components while ensuring that developers can maintain a
clear overview of class relations and method declarations.
7.Question
What role does the main.awk module play in the ooc
preprocessor workflow?
Answer:The main.awk module serves as the entry point for
processing commands in ooc. It handles the initialization of
the program, processes command-line arguments to
determine which reports and class descriptions to load, and
dictates the sequence of these operations, ensuring that all
necessary components are correctly processed before final
output.
8.Question
How does the ooc command facilitate the generation of
different outputs?
Answer:The ooc command allows for multiple output types
to be generated in a single execution by processing
arguments that dictate the required outputs. It can handle
interface files, representation files, dependency generation
for makefiles, and handle preprocessing for various
implementation files all at once, making it a versatile tool for
developers.
9.Question
What are the advantages of using multiple report files in
the ooc preprocessor?
Answer:Using multiple report files simplifies maintenance
and allows for targeted loading and processing of only the
necessary reports based on command-line options. This
modular approach reduces resource overhead and enhances
the efficiency of the development process by ensuring that
only relevant reports are accessed while keeping project
scope manageable.
10.Question
How does the ooc preprocessor address issues related to
line numbering and error tracking in C compilation?
Answer:The ooc preprocessor incorporates #line stamps into
the output code, which are used by the C compiler to relate
its error messages back to the original source files. These
stamps are selectively generated based on report requests,
ensuring that mapping between output lines and source files
is maintained, facilitating easier debugging and error
resolution during compilation.
Chapter 11 | C Manual| Q&A
1.Question
What are the main purposes of the commands mentioned
in this appendix, such as 'munch' and 'ooc'?
Answer:The command 'munch' processes a nm
listing to generate a C source file that defines a
null-terminated array of class function pointers,
making retrieval straightforward. The 'ooc'
command serves as a preprocessor that facilitates
object-oriented programming in ANSI C by reading
class definitions and handling code generation for
corresponding class methods and their structures.
2.Question
How do the class description files support the concept of
inheritance in object-oriented programming?
Answer:Class description files categorize classes and their
relationships, clearly defining superclasses and allowing for
subclassing practices. Methods can be specified as either
static or dynamically linked, which facilitates the inheritance
of methods and properties from superclasses.
3.Question
Can you explain the significance of the 'responsesTo()'
method mentioned in the text?
Answer:The 'respondsTo()' method is essential for dynamic
method dispatch, allowing the program to determine if a
certain object can execute a given method based on its tag.
This flexible method interaction is foundational in
implementing polymorphism within the class architecture.
4.Question
What is the role of the 'allocate' function in the context of
class descriptions?
Answer:The 'allocate' function is crucial for memory
management; it reserves memory for an object of a specified
class and sets the class description pointer accordingly,
ensuring that each new object is associated with its correct
class type and structure.
5.Question
Describe the concept of metaclass and its importance in
the context provided.
Answer:A metaclass is a special class that defines the
structure and behaviors of a class itself, essentially serving as
a blueprint for classes. The text emphasizes that every class
has a corresponding metaclass, and metaclasses maintain
information about their instances, facilitating dynamic
method binding and inheritance.
6.Question
What does 'C preprocessor is applied to the output of ooc'
imply regarding preprocessing and object-oriented
coding in C?
Answer:It implies that the preprocessor directives should be
used to conditionally compile the code that originates from
the 'ooc' outputs rather than the inputs. This highlights a
separation between the object-oriented coding process and
traditional C preprocessing techniques, ensuring clarity and
avoiding potential conflicts.
7.Question
How do the lexical conventions enhance the usability of
class description files?
Answer:The lexical conventions simplify the syntax by
removing comments, gluing lines, and managing whitespace,
allowing programmers to focus on the functionality and
structure of the code rather than syntax issues. This results in
clearer, more maintainable class definitions.
8.Question
What are some practical applications of the classes and
methods described in this appendix?
Answer:The classes and methods described can be utilized to
build robust applications, such as GUI programs or complex
systems that require object-oriented design patterns.
Specifically, the integration of event handling and user
interface elements showcases how these principles can be
applied in real-world applications.
9.Question
Explain the relationship between the 'Object' class and
the 'Exception' class as described.
Answer:The 'Object' class is the root class from which all
objects inherit, providing fundamental properties and
methods, while the 'Exception' class is designed to manage a
stack of exception handlers, allowing for controlled error
management in programs built on this framework, thus
enhancing robustness.
10.Question
How does the 'gateway()' function in the 'Ic' class support
input/output operations?
Answer:The 'gateway()' function processes input items and
routes them through its output pin based on specified criteria,
allowing derived classes to implement custom processing
logic. This flexibility allows for varied data handling while
maintaining a consistent external interface.
Programming In Ansi C Quiz and Test
Check the Correct Answer on Bookey Website
Chapter 1 | 7 The ooc Preprocessor| Quiz and Test
1.The ooc preprocessor introduces a completely new
programming language.
2.The chapter discusses the implementation challenges
related to null pointers and variable management.
3.The ooc preprocessor cannot generate interface and
representation files from class descriptions.
Chapter 2 | 8 Dynamic Type Checking| Quiz and
Test
1.Dynamic type checking is essential when dealing
with objects accessed as `void *` to prevent severe
errors.
2.The `cast()` method is an enhancement that always allows
operations on any object type without validation.
3.Using magic numbers in class descriptions is discouraged
to avoid potential errors and improves dynamic type
checking.
Chapter 3 | 9 Static Construction| Quiz and Test
1.Class descriptions for Object and Class are
statically initialized, while others are initialized
dynamically through constructors.
2.The proposed macro 'Class(x)' neglects the initialization of
class descriptions, making management less efficient.
3.The chapter advocates for using static pointers for
referencing class descriptions across the program.
Chapter 4 | 10 Delegates| Quiz and Test
1.Callback functions allow clients to register their
own functions for events that matter to them,
creating a flexible interface.
2.Abstract base classes always make the architecture of an
application more flexible and do not impose any limitations
on subclasses.
3.The respondsTo() method helps ensure that a delegate can
identify which methods it can handle based on a string tag
and maintains type safety.
Chapter 5 | 11 Class Methods| Quiz and Test
1.Dynamically allocated memory should not be
recycled to avoid memory leaks.
2.Class methods are applied to class descriptions instead of
individual object instances.
3.The MallocDebug application is perfect for detecting all
types of memory leaks without any limitations.
Chapter 6 | 12 Persistent Objects| Quiz and Test
1.The `puto()` method is used for reading data from
a file and filling an object's attributes.
2.The `load` command retrieves saved definitions and can
restore objects to their previous states, allowing data
persistence across sessions.
3.The `retrieve()` function is responsible for saving an
object's state to a file after creation.
Chapter 7 | 13 Exceptions| Quiz and Test
1.The chapter discusses error recovery techniques in
ANSI-C using functions `setjmp()` and `longjmp()`
to manage control flow during errors.
2.An 'Exception' class in this chapter allows the error
handling stack to grow in any order, simplifying resource
management.
3.The chapter suggests that while modern languages such as
C++ provide specific syntax for exceptions, ANSI-C can
implement similar functionality without any additional
complexity.
Chapter 8 | 14 Forwarding Messages| Quiz and Test
1.The section on object-oriented design by example
in the chapter focuses on identifying key objects
like display, computing chip, and buttons for a
calculator.
2.The `forward()` method is implemented to directly handle
all method calls without any error handling mechanism in
the forwarding messages section.
3.The chapter information suggests that the calculator only
operates with a character-based interface and does not
support graphical interfaces.
Chapter 9 | A ANSI-C Programming Hints| Quiz
and Test
1.ANSI-C allows names of arbitrary length,
reserving those starting with an underscore for
libraries.
2.Pointer arithmetic is applicable to `void *` in ANSI-C.
3.The `const` qualifier allows assignments to a variable after
its initialization.
Chapter 10 | B The ooc Preprocessor| Quiz and Test
1.The ooc preprocessor is a shell script that
generates C code by collecting information from
class description files.
2.The parse.awk module is responsible for managing file
access and tracking open files.
3.The reports generated by the ooc preprocessor can be
customized and organized into multiple files based on
functionality.
Chapter 11 | C Manual| Quiz and Test
1.The `ooc` program is meant for procedural
programming in ANSI C.
2.The root class in the ooc framework is called Object.
3.Report files in the `ooc` environment cannot be customized
for specific implementations.