C Programming Data Structures 4th Edition E.

Balagurusamy pdf download

https://ebookgate.com/product/c-programming-data-structures-4th-
edition-e-balagurusamy/

Get Instant Ebook Downloads – Browse at https://ebookgate.com

Instant digital products (PDF, ePub, MOBI) available
Download now and explore formats that suit you...

Programming in ANSI C 6th Edition E. Balagurusamy

https://ebookgate.com/product/programming-in-ansi-c-6th-edition-e-
balagurusamy/

ebookgate.com

Computer Programming 1st Edition E. Balagurusamy

https://ebookgate.com/product/computer-programming-1st-edition-e-
balagurusamy/

ebookgate.com

C Programming Program design including data structures

5ed. Edition Malik D.S.

https://ebookgate.com/product/c-programming-program-design-including-
data-structures-5ed-edition-malik-d-s/

ebookgate.com

Data Structures and Algorithms in C 4th Edition Adam

Drozdek

https://ebookgate.com/product/data-structures-and-algorithms-in-c-4th-
edition-adam-drozdek/

ebookgate.com
C Programming Program Design Including Data Structures 7th
Edition D. S. Malik

https://ebookgate.com/product/c-programming-program-design-including-
data-structures-7th-edition-d-s-malik/

ebookgate.com

C Programming Program Design Including Data Structures 6th

Edition D. S. Malik

https://ebookgate.com/product/c-programming-program-design-including-
data-structures-6th-edition-d-s-malik/

ebookgate.com

Data Structures and Other Objects Using C 4th Edition

Michael Main

https://ebookgate.com/product/data-structures-and-other-objects-
using-c-4th-edition-michael-main/

ebookgate.com

Data Structures Using C 2nd Edition D. S. Malik

https://ebookgate.com/product/data-structures-using-c-2nd-edition-d-s-
malik/

ebookgate.com

Data Structures Other Objects using Java 4th Edition

Michael Mann

https://ebookgate.com/product/data-structures-other-objects-using-
java-4th-edition-michael-mann/

ebookgate.com
 As per the
Revised
Syllabus Effective
August 2007

C Programming
and
Data Structures
Fourth Edition
About the Author
E Balagurusamy, former Vice Chancellor, Anna University, Chennai, is currently Member, Union
Public Service Commission, New Delhi. He is a teacher, trainer, and consultant in the fields of Informa-
tion Technology and Management. He holds an ME (Hons) in Electrical Engineering and Ph.D in
Systems Engineering from the Indian Institute of Technology, Roorkee. His areas of interest include
Object-Oriented Software Engineering, Electronic Business, Technology Management, Business
Process Re-engineering, and Total Quality Management.
A prolific writer, he has authored a large number of research papers and several books. His best
selling books, among others include:
· Programming in C#, 2/e
· Programming in Java, 3/e
· Object-Oriented Programming with C++, 4/e
· Programming in BASIC, 3/e
· Programming in ANSI C, 4/e
· Numerical Methods
· Reliability Engineering
A recipient of numerous honours and awards, he has been listed in the Directory of Who’s Who of
Intellectuals and in the Directory of Distinguished Leaders in Education.
 As per the
Revised
Syllabus Effective
August 2007

C Programming
and
Data Structures
Fourth Edition

E Balagurusamy
Member, UPSC
New Delhi

Tata McGraw-Hill Publishing Company Limited

NEW DELHI
McGraw-Hill Offices
New Delhi New York St Louis San Francisco Auckland Bogotá Caracas
Kuala Lumpur Lisbon London Madrid Mexico City Milan Montreal
San Juan Santiago Singapore Sydney Tokyo Toronto
Published by the Tata McGraw-Hill Publishing Company Limited,
7 West Patel Nagar, New Delhi 110 008.

Copyright © 2009, by Tata McGraw-Hill Publishing Company Limited.

No part of this publication may be reproduced or distributed in any form or by any means, electronic, mechanical,
photocopying, recording, or otherwise or stored in a database or retrieval system without the prior written permis-
sion of the publishers. The program listings (if any) may be entered, stored and executed in a computer system, but
they may not be reproduced for publication.
This edition can be exported from India only by the publishers,
Tata McGraw-Hill Publishing Company Limited.
ISBN-13: 978-0-07-0084759
ISBN-10: 0-07-0084750
Managing Director—Ajay Shukla
General Manager: Publishing—SEM & Tech Ed: Vibha Mahajan
Sponsoring Editor—Shalini Jha
Senior Copy Editor—Dipika Dey
Junior Manager—Production, Anjali Razdan
Marketing General Manager—Higher Education & Sales: Michael J. Cruz
Product Manager—SEM & Tech Ed: Biju Ganesan
Controller—Production: Rajender P. Ghansela
Asst. General Manager— Production: B. L. Dogra

Information contained in this work has been obtained by Tata McGraw-Hill, from sources believed to be
reliable. However, neither Tata McGraw-Hill nor its authors guarantee the accuracy or completeness of any
information published herein, and neither Tata McGraw-Hill nor its authors shall be responsible for any
errors, omissions, or damages arising out of use of this information. This work is published with the under-
standing that Tata McGraw-Hill and its authors are supplying information but are not attempting to render
engineering or other professional services. If such services are required, the assistance of an appropriate
professional should be sought.

Typeset at Script Makers, 19, A1-B, DDA Market, Paschim Vihar, New Delhi 110 063, and printed at Shakti
Packers, 5C/9, New Rohtak Road, Karol Bagh, New Delhi-110 005
Cover: SDR Printers
DALZCRBFRAALX
 Contents

Foreword xi
Preface xiii
Road Map to the Syllabus xv
The C99 Standard xvii

UNIT I
1. Algorithms 1.3–1.15
1.1 Introduction ......................................................................................................................... 1.3
1.1.1 Algorithm/pseudocode .......................................................................................... 1.3
1.1.2 Flow Chart............................................................................................................ 1.4
1.2 Three Basic Operations ....................................................................................................... 1.5
1.2.1 Sequence .............................................................................................................. 1.5
1.2.2 Selection ............................................................................................................... 1.6
1.2.3 Iteration .............................................................................................................. 1.13
Review Questions and Exercises ..................................................................................... 1.14
2. Overview of C 2.1–2.12
2.1 Introduction ......................................................................................................................... 2.1
2.2 Importance of C .................................................................................................................. 2.1
2.3 Sample C Programs ............................................................................................................. 2.2
2.4 Program Development Steps ............................................................................................... 2.5
2.5 Structure of a C Program .................................................................................................... 2.9
Review Questions and Exercises ..................................................................................... 2.11
3. Constants, Variables, and Data Types 3.1–3.26
3.1 Introduction ........................................................................................................................ .3.1
3.2 Character Set ....................................................................................................................... 3.1
3.3 C Tokens ............................................................................................................................. 3.1
3.4 Keywords and Identifiers .................................................................................................... 3.2
3.5 Constants ............................................................................................................................. 3.3
3.6 Variables ............................................................................................................................. 3.7
3.7 Basic Data Types and Sizes ................................................................................................ 3.8
3.8 Declaration of Variables ................................................................................................... 3.11
3.9 Assigning Values to Variables .......................................................................................... 3.14
3.10 Defining Symbolic Constants ........................................................................................... 3.21
Review Questions and Exercises ................................................................................... 3.24
vi Contents
4. Operators and Expressions 4.1–4.22
4.1 Introduction ......................................................................................................................... 4.1
4.2 Arithmetic Operators .......................................................................................................... 4.1
4.3 Relational Operators ........................................................................................................... 4.4
4.4 Logical Operators ............................................................................................................... 4.5
4.5 Assignment Operators ......................................................................................................... 4.5
4.6 Increment and Decrement Operators .................................................................................. 4.7
4.7 Conditional Operator .......................................................................................................... 4.8
4.8 Bitwise Operators ............................................................................................................... 4.8
4.9 Special Operators ................................................................................................................ 4.9
4.10 Arithmetic Expressions ..................................................................................................... 4.11
4.11 Evaluation of Expressions ................................................................................................ 4.11
4.12 Precedence of Arithmetic Operators ................................................................................. 4.12
4.13 Some Computational Problems ......................................................................................... 4.14
4.14 Type Conversions in Expressions ..................................................................................... 4.15
4.15 Operator Precedence and Associativity ............................................................................ 4.18
Case Studies ..................................................................................................................... 4.19
Review Questions and Exercises ..................................................................................... 4.20
5. Managing Input and Output Operations 5.1–5.25
5.1 Introduction ......................................................................................................................... 5.1
5.1.1 Input/Output Statements and Header Files ........................................................... 5.1
5.2 Reading a Character ............................................................................................................ 5.2
5.3 Writing a Character ............................................................................................................ 5.4
5.4 Formatted Input ................................................................................................................... 5.5
5.5 Formatted Output .............................................................................................................. 5.14
Case Studies ..................................................................................................................... 5.21
Review Questions and Exercises ..................................................................................... 5.24
6. Decision Making and Branching 6.1–6.29
6.1 Introduction ......................................................................................................................... 6.1
6.2 Decision Making with If Statement .................................................................................... 6.1
6.3 Simple If Statement ............................................................................................................. 6.2
6.4 The If K Else Statement ..................................................................................................... 6.5
6.5 Nesting of If ... Else Statements .......................................................................................... 6.7
6.6 The Else If Ladder ............................................................................................................ 6.11
6.7 The Switch and Break Statements .................................................................................... 6.13
6.8 The ? : Operator ................................................................................................................ 6.17
6.9 The Goto Statement .......................................................................................................... 6.20
6.9.1 Label .................................................................................................................. 6.20
Case Studies ..................................................................................................................... 6.22
Review Questions and Exercises ..................................................................................... 6.26
7. Decision Making and Looping 7.1–7.30
7.1 Introduction ......................................................................................................................... 7.1
7.2 The While Statement ........................................................................................................... 7.3
7.3 The Do Statement ................................................................................................................ 7.4
 Contents vii
7.4 The For Statement ............................................................................................................... 7.6
7.5 Jumps in Loops ................................................................................................................. 7.14
7.6 Structured Programming ................................................................................................... 7.20
Case Studies ..................................................................................................................... 7.21
Review Questions and Exercises ..................................................................................... 7.27

UNIT II

8. Arrays 8.3–8.31
8.1 Introduction ......................................................................................................................... 8.3
8.2 One-Dimensional Arrays .................................................................................................... 8.3
8.3 Two-Dimensional Arrays.................................................................................................... 8.8
8.4 Initializing Two-Dimensional Arrays ............................................................................... 8.13
8.5 Multidimensional Arrays .................................................................................................. 8.15
Case Studies ..................................................................................................................... 8.17
Review Questions and Exercises ..................................................................................... 8.28
9. Handling of Character Strings 9.1–9.23
9.1 Introduction ......................................................................................................................... 9.1
9.2 Declaring and Initializing String Variables ........................................................................ 9.2
9.3 Reading Strings from Terminal ........................................................................................... 9.2
9.4 Writing Strings to Screen .................................................................................................... 9.5
9.5 Arithmetic Operations on Characters ................................................................................. 9.8
9.6 Putting Strings Together ................................................................................................... 9.10
9.7 Comparison of Two Strings .............................................................................................. 9.12
9.8 String-Handling Functions ................................................................................................ 9.13
9.9 Table of Strings ................................................................................................................. 9.15
Case Studies ..................................................................................................................... 9.18
Review Questions and Exercises ..................................................................................... 9.22
10. User-Defined Functions 10.1–10.50
10.1 Introduction ....................................................................................................................... 10.1
10.1.1 Standard Library Functions ................................................................................ 10.1
10.2 Need for User-Defined Functions ..................................................................................... 10.4
10.3 A Multi-Function Program ................................................................................................ 10.5
10.4 The Form of C Functions .................................................................................................. 10.7
10.5 Return Values and their Types .......................................................................................... 10.8
10.6 Calling a Function ............................................................................................................. 10.9
10.7 Category of Functions ..................................................................................................... 10.10
10.8 No Arguments and no Return Values ............................................................................. 10.10
10.9 Arguments but no Return Values .................................................................................... 10.12
10.10 Arguments with Return Values ....................................................................................... 10.14
10.11 Handling of Non-Integer Functions ................................................................................ 10.18
10.12 Nesting of Functions ....................................................................................................... 10.21
10.13 Recursion ........................................................................................................................ 10.22
10.14 Functions with Arrays ..................................................................................................... 10.23
10.15 The Scope and Lifetime of Variables in Functions—Storage Classes ............................ 10.26
viii Contents
10.16 ANSI C Functions ........................................................................................................... 10.36
10.17 The Preprocessor ............................................................................................................. 10.39
10.18 ANSI Additions .............................................................................................................. 10.42
Case Study ...................................................................................................................... 10.45
Review Questions and Exercises ................................................................................. 10.49

UNIT III

11. Pointers 11.3–11.32

11.1 Introduction ....................................................................................................................... 11.3
11.2 Understanding Pointers ..................................................................................................... 11.3
11.3 Accessing the Address of a Variable ................................................................................ 11.5
11.4 Declaring and Initializing Pointers ................................................................................... 11.6
11.5 Accessing a Variable Through its Pointer ........................................................................ 11.7
11.6 Pointer Expressions .......................................................................................................... 11.9
11.7 Pointer Increments and Scale Factor—Address Arithmetic ............................................ 11.11
11.8 Pointers and Arrays......................................................................................................... 11.12
11.9 Pointers and Character Strings ........................................................................................ 11.15
11.10 Pointers and Functions .................................................................................................... 11.17
11.11 Pointers and Structures ................................................................................................... 11.23
Case Studies ................................................................................................................... 11.25
Review Questions and Exercises ................................................................................... 11.31

UNIT IV

12. Structures and Unions 12.3–12.25

12.1 Introduction ....................................................................................................................... 12.3
12.2 Structure Definition—Declaring Structures ..................................................................... 12.3
12.3 Giving Values to Members ............................................................................................... 12.5
12.4 Structure Initialization ...................................................................................................... 12.6
12.5 Comparison of Structure Variables ................................................................................... 12.8
12.6 Arrays of Structures .......................................................................................................... 12.8
12.7 Arrays within Structures ................................................................................................. 12.11
12.8 Structures within Structures—Nested Structures ............................................................ 12.12
12.9 Structures and Functions ................................................................................................. 12.15
12.10 Unions ............................................................................................................................. 12.17
12.11 Size of Structures ............................................................................................................ 12.19
12.12 Bit Fields ......................................................................................................................... 12.19
Case Study ...................................................................................................................... 12.21
Review Questions and Exercises ................................................................................. 12.24

UNIT V

13. File Management in C 13.3–13.22

13.1 Introduction ....................................................................................................................... 13.3
13.2 Defining and Opening a File ............................................................................................. 13.7
 Contents ix
13.3 Closing a File .................................................................................................................... 13.8
13.4 Input/Output Operations on Files ...................................................................................... 13.9
13.5 Error Handling During I/O Operations ........................................................................... 13.12
13.6 Random Access to Files .................................................................................................. 13.14
13.7 Command Line Arguments ............................................................................................. 13.17
Case Study ...................................................................................................................... 13.19
Review Questions and Exercises ................................................................................... 13.21

UNIT VI

14. Data Structures 14.3–14.21

14.1 Introduction to Data Structures ......................................................................................... 14.3
14.2 Stacks ................................................................................................................................ 14.3
14.3 Queues .............................................................................................................................. 14.6
14.4 Circular Queues .............................................................................................................. 14.10
14.5 Applications of Stacks .................................................................................................... 14.11
Review Questions and Exercises ................................................................................... 14.21

UNIT VII

15. Dynamic Memory Allocation and Linked Lists 15.3–15.47

15.1 Introduction ....................................................................................................................... 15.3
15.2 Dynamic Memory Allocation ............................................................................................ 15.3
15.3 Linked Lists ...................................................................................................................... 15.9
15.3.1 Self-Referential Structure .................................................................................. 15.9
15.3.2 Singly Linked List ............................................................................................ 15.10
15.4 Advantages of Linked Lists ............................................................................................ 15.12
15.5 Types of Linked Lists...................................................................................................... 15.12
15.6 Pointers Revisited ........................................................................................................... 15.14
15.7 Basic List Operations...................................................................................................... 15.15
15.8 Application of Linked Lists ............................................................................................ 15.24
15.9 Circular Linked Lists ...................................................................................................... 15.25
15.10 Doubly Linked Lists ....................................................................................................... 15.25
15.11 Doubly Linked List Operations ...................................................................................... 15.26
15.12 Doubly Linked Circular Lists ......................................................................................... 15.35
15.13 Stacks and Queues using Linked List ............................................................................. 15.36
Case Studies ................................................................................................................... 15.40
Review Questions and Exercises ................................................................................... 15.46
16. Binary Trees and Graphs 16.1–16.25
16.1 Binary Trees—Representation and Terminology .............................................................. 16.1
16.2 Binary Tree Traversal ....................................................................................................... 16.2
16.3 Graphs ............................................................................................................................... 16.8
16.4 Graph Representation in C ................................................................................................ 16.9
16.5 Graph Traversal .............................................................................................................. 16.13
Review Questions and Exercises ................................................................................. 16.24
x Contents

UNIT VIII

17. Sorting and Searching Techniques 17.3–17.25

17.1 Introduction ....................................................................................................................... 17.3
17.2 Sorting ............................................................................................................................... 17.3
17.2.1 Sorting Efficiency .............................................................................................. 17.4
17.2.2 Exchange Sorting—Bubble Sort ........................................................................ 17.5
17.2.3 Exchange Sorting—Quick Sort .......................................................................... 17.7
17.2.4 Selection Sort ................................................................................................... 17.11
17.2.5 Merge Sort........................................................................................................ 17.13
17.2.6 Simple Insertion sort ........................................................................................ 17.15
17.2.7 Shell Sort .......................................................................................................... 17.17
17.3 Searching ........................................................................................................................ 17.18
17.3.1 Linear Search ................................................................................................... 17.18
17.3.2 Binary Search ................................................................................................... 17.20
17.3.3 Indexed Sequential Search ............................................................................... 17.23
Review Questions ........................................................................................................... 17.24
Appendix A
ASCII Values of Characters .......................................................................................A.1
Appendix B
Multiple Choice Questions .............................................................................. B.1–B.9
Appendix C
Solved Question Papers – C Programming and Data Structures
(May/June 2008) ............................................................................................... C.1–C.76
Bibliography .......................................................................................................................B.1
Chapter
1
Foreword

It gives me great pleasure to introduce C Programming and Data Structures by Dr E Balagurusamy,

publication of which heralds the completion of a book that caters completely and effectively to the
students of JNTU.
The need for a good textbook for this subject can be easily understood. Numerous books are available
to the students for the subject, but almost none of them have the right combination of simplicity, rigour,
pedagogy and syllabus compatibility. These books usually do not address one or more of the specific
problems faced by students of this subject in JNTU. There has always been a need for a good book
relevant to the requirements of the students and dealing with all aspects of the course. I am sure that the
present book will be able to fill this void.
The book has been organized and executed with lot of care and dedication. The author has been an
outstanding teacher and a pioneer of IT education in India. A conscious attempt has been made to
simplify concepts to facilitate better understanding of the subject.
Dr Balagurusamy deserves our praise and thanks for accomplishing this trying task. McGraw-Hill
Education, a prestigious publishing house, also deserves a pat on the back for doing an excellent job.

DR K. RAJAGOPAL
Vice-Chancellor
Jawaharlal Nehru Technological University
Hyderabad
Chapter
1
Preface

C is a general-purpose structured programming language that is powerful, efficient and compact. C

combines the features of high-level language with the elements of the assembler and is thus close to both
man and machine. The growth of C during the last few years has been phenomenal. It has emerged as the
language of choice for most applications due to speed, portability and compactness of code. It has now
been implemented on virtually every sort of computer, from micro to mainframe.
For many years, the de facto standard for implementing the language has been the original C Refer-
ence Manual by Kernighan and Ritchie published in 1978. During these years of growth and popularity,
C has undergone many changes. Numerous different features and facilities have been developed and
marketed. This has resulted in minor problems in terms of portability of programs. Consequently, the
American National Standard Institute (ANSI) constituted a committee to look into the language features
and produce a more comprehensive and unambiguous definition of C. The result is ANSI C. Most com-
pilers have already adopted ANSI standards.
This book incorporates all the features of ANSI C that are essential for a C programmer. The ANSI
standards are explained in detail in appropriate places. For the convenience of readers, these places
have been noted in the text by a special mention. A major highlight of this revised edition is the
inclusion of updated information on compiler C99 standard, with relevant theory and programs.
Another important addition in this edition is Appendix C containing 2008 solved question papers (4 sets).
The concept of ‘learning by example’ has been stressed throughout the book. Every important feature of
the language is treated in depth followed by a complete program example to illustrate its use. Case studies
at the end of the chapters not only describe the common ways in which C features are put together but
also show real-life applications. Wherever necessary, pictorial descriptions of concepts are included to
facilitate better understanding.
This book contains more than 100 examples and programs. All the programs have been tested using
compilers compatible to both UNIX and MS-DOS operating systems and, wherever appropriate, the
nature of output has been discussed. These programs also demonstrate the general principles of a good
programming style. 200 multiple choice questions are given to help the students test their conceptual
understanding of the subject.
The book also offers detailed discussions on Data Structures, Standard Library Functions,
Bit Fields, Linked Lists, Doubly Linked Lists, Queues, Stacks and Graphs with sample codes and
algorithms. Chapter 17 provides comprehensive information on Sorting and Searching techniques. Both
these topics are explained with sample codes. The various pros and cons of each of these techniques are
also covered.
xiv Preface
This edition comes with a CD which provides
More than 600 objective/review/debugging questions (8 units)
100 Programming exercises
Model question paper
2006 and 2007 solved question paper
Computer programs for lab
The objective of the supplementry CD is to make the students learn the programming language and
enable them to write their own programs using C and data structures.
The author is grateful to Mr A Rama Rao, Layola Institute of Technology & Management, Guntur
and Mr P Chenna Reddy, JNTU College of Engineering, Pulivendula for their useful comments and
suggestions.

E BALAGURUSAMY
Chapter
1
Road Map to the Syllabus
(Effective from August 2007)

Jawaharlal Nehru Technological University Hyderabad

I Year B.Tech T P C
4 0 6
C Programming and Data Structures
Objectives
· To make the student learn a programming language.
· To teach the student to write programs in C to solve the problems.
· To introduce the student to simple linear and non-liner data structures such as lists, stacks,
queues, trees and graphs.
Syllabus
Unit I
Algorithm / pseudo code, flowchart, program development steps, structure of C program, a simple C
program, identifiers, basic data types and sizes, constants, variables, arithmetic, relational and logical
operators, increment and decrement operators, conditional operator, bit-wise operators, assignment
operators, expressions, type conversions, conditional expressions, precedence and order of evaluation.
Input-output statements, statements and blocks, if and switch statements, loops- while, do-while and
for statements, break, continue, goto and labels, programming examples.

CHAPTER 1 – ALGORITHMS
CHAPTER 2 – OVERVIEW OF C
CHAPTER 3 – CONSTANTS, VARIABLES, AND DATA TYPES
Go To CHAPTER 4 – OPERATORS AND EXPRESSIONS
CHAPTER 5 – MANAGING INPUT AND OUTPUT OPERATIONS
CHAPTER 6 – DECISION MAKING AND BRANCHING
CHAPTER 7 – DECISION MAKING AND LOOPING

Unit II
Designing structured programs, functions, basics, parameter passing, storage classes- extern, auto,
register, static, scope rules, block structure, user-defined functions, standard library functions, recursive
functions, header files, C preprocessor, C program examples.

CHAPTER 7 – DECISION MAKING AND LOOPING

Go To
CHAPTER 10 – USER-DEFINED FUNCTIONS
xvi Road Map to the Syllabus
Unit III
Arrays- concepts, declaration, definition, accessing elements, storing elements, arrays and functions,
two-dimensional and multi-dimensional arrays, applications of arrays. pointers- concepts, initialization
of pointer variables, pointers and function arguments, address arithmetic, character pointers and
functions, pointers to pointers, pointers and multidimensional arrays, dynamic memory managements
functions, command line arguments, C program examples.

CHAPTER 8 – ARRAYS
Go To CHAPTER 9 – HANDLING OF CHARACTER
STRINGS
CHAPTER 11 – POINTERS
Unit IV
Derived types- structures- declaration, definition and initialization of structures, accessing structures,
nested structures, arrays of structures, structures and functions, pointers to structures, self-referential
structures, unions, typedef, bitfields, C program examples.

CHAPTER 12 – STRUCTURES AND UNIONS

Go To CHAPTER 15 – DYNAMIC MEMORY ALLOCATION
AND LINKED LISTS
Unit V
Input and output – concept of a file, text files and binary files, streams, standard I/o, formatted I/o, file
I/o operations, error handling, C program examples.

Go To CHAPTER 13 – FILE MANAGEMENT IN C

Unit VI
Searching – linear and binary search methods, sorting – bubble sort, selection sort, insertion sort, quick
sort, merge sort.

CHAPTER 17 – SORTING AND SEARCHING

Go To
TECHNIQUES

Unit VII
Introduction to data structures, singly linked lists, doubly linked lists, circular list, representing stacks
and queues in C using arrays and linked lists, infix to post fix conversion, postfix expression evaluation.
CHAPTER 14 – DATA STRUCTURES
Go To CHAPTER 15 – DYNAMIC MEMORY ALLOCATION
AND LINKED LISTS
Unit VIII
Trees- binary trees, terminology, representation, traversals, graphs—terminology, representation, graph
traversals (dfs and bfs)

Go To CHAPTER 16 – BINARY TREES AND GRAPHS

 The C99 Standard

Computer languages are not static; they evolve, reacting to changes in methodologies, applications gen-
erally accepted practices, and hardware. C is no exception. In the case of C, two evolutionary paths were
set in motion. The first is the continuing development of the C language. The second is C++, for which
C provided the starting point. While most of the focus of the past several years has been on C++, the
refinement of C has continued unabated.
For example, reacting to the internationalization of the computing environment, the original C89
standard was amended in 1995 to include various wide-character and multibyte functions. Once the
1995 amendment was complete, work began on updating the language, in general. The end result is, of
course, C99. In the course of creating the 1999 standard, each element of the C language was thoroughly
reexamined, usage patterns were analyzed, and future demands were anticipated. As expected, C's rela-
tionship to C++ provided a backdrop for the entire process. The resulting C99 standard is a testimonial
to the strengths of the original. Very few of the key elements of C were altered. For the most part, the
changes consist of a small number of carefully selected additions to the language and the inclusion of
several new library functions. Thus C is still C!
Here we will examine those features added by C99, and the few differences between C99 and C89.

C99

Perhaps the greatest cause for concern that accompanies the release of a new language standard is the
issue of compatibility with its predecessor. Does the new specification render old programs obsolete?
Have important constructs been altered? Do I have to change the way that I write code? The answers to
these types of questions often determine the degree to which the new standard is accepted and, in the
longer term, the viability of the language itself. Fortunately, the creation of C99 was a controlled, even-
handed process that reflects the fact that several experienced pilots were at the controls. Put simply: If
you liked C the way it was, you will like the version of C defined by C99. What many programmers
think of as the world's most elegant programming language, still is! In this chapter we will examine the
changes and additions made to C by the 1999 standard. Many of these changes were mentioned in
passing in Part One. Here they are examined in closer detail. Keep in mind, however, that as of this
writing, there are no widely used compilers that support many of C99’s new features. Thus, you may
need to wait a while before you can ‘test drive’ such exciting new constructs as variable-length arrays,
restricted pointers, and the long long data type.
xviii The C99 Standard
C89 vs. C99: AN OVERVIEW

There are three general categories of changes between C89 and C99:
· Features added to C89
· Features removed from C89
· Features that have been changed or enhanced
Many of the differences between C89 and C99 are quite small, and clarify nuances of the C language.
This book will concentrate on the larger changes that affect the way programs are written.

Features Added

Perhaps the most important features added by C99 are the new keywords:
· inline
· restrict
_Bool
_Complex
_Imaginary
Other major additions include
· Variable-length arrays
· Support for complex arithmetic
· The long long int data type
· The //comment
· The ability to intersperse code and data
· Additions to the preprocessor
· Variable declarations inside the for statement
· Compound literals
· Flexible array structure members
· Designated initializers
· Changes to the printf( ) and scanf( ) family of functions
· The _ _func_ _ predefined identifier
· New libraries and headers
Most of the features added by C99 are innovations created by the standardization committee, of
which many were based on language extensions offered by a variety of C implementations. In a few
cases, however, features were borrowed from C++. The inline keyword and // style comments are exam-
ples. It is important to understand that C99 does not add C++-style classes, inheritance, or member
functions. The consensus of the committee was to keep C as C.

Features Removed

The single most important feature removed by C99 is the ‘'implicit int’ rule. In C89, in many cases when
no explicit type specifier is present, the type int is assumed. This is not allowed by C99. Also removed
is implicit function declaration. In C89, if a function was not declared before it is used, an implicit
declaration is assumed. This is not supported by C99. Both of these changes may require existing code
to be rewritten if compatibility with C99 is desired.
 The C99 Standard xix
Features Changed

C99 incorporates several changes to existing features. For the most part, these changes expand features
or clarify their meaning. In a few cases, the changes restrict or narrow the applicability of a feature.
Many such changes are small, but a few are quite important, including:
· Increased translation limits
· Extended integer types
· Expanded integer type promotion rules
· Tightening of the return statement
As it affects existing programs, the change to return has the most significant effect because it might
require that code be rewritten slightly.
Throughout the remainder of this chapter, we will examine the major differences between C89 and
C99.

RESTRICT-QUALIFIED POINTERS

One of the most important innovations in C99 is the restrict type qualifier. This qualifier applies only to
pointers. A pointer qualified by restrict is initially the only means by which the object it points to can be
accessed. Access to the object by another pointer can occur only if the second pointer is based on the
first. Thus, access to the object is restricted to expressions based on the restrict-qualified pointer.
Pointers qualified by restrict are primarily used as function parameters, or to point to memory allocated
via malloc( ). The restrict qualifier does not change the semantics of a program. By qualifying a
pointer with restrict, the compiler is better able to optimize certain types of routines by making the
assumption that the restrict-qualified pointer is the sole means of access to the object. For example, if
a function specifies two restrict-qualified pointer parameters, the compiler can assume that the pointers
point to different (that is, non-overlapping) objects. For example, consider what has become the classic
example of restrict: the memcpy( ) function.
In C89, it is prototyped as shown here:
void *memcpy(void *str1, const void *str2, size_t size);
The description for memcpy( ) states that if the objects pointed to by str1 and str2 overlap, the
behaviour is undefined. Thus, memcpy( ) is guaranteed to work for only non-overlapping objects. In
C99, restrict can be used to explicitly state in memcpy( )’s prototype what C89 must explain with
words.
Here is the C99 prototype for memcpy( ):
void *memcpy
(void * restrict str1, const void * restrict str2, size_t size);
By qualifying str1 and str2 with restrict, the prototype explicitly asserts that they point to non-overlap-
ping objects. Because of the potential benefits that result from using restrict, C99 has added it to the
prototypes for many of the library functions originally defined by C89.

Inline

C99 adds the keyword inline, which applies to functions. By preceding a function declaration with
inline, you are telling the compiler to optimize calls to the function. Typically, this means that the
xx The C99 Standard
function’s code will be expanded in line, rather than called. However, inline is only a request to the
compiler, and can be ignored. Specifically, C99 states that using inline ‘suggests that calls to the func-
tion be as fast as possible.’ The inline specifier is also supported by C++, and the C99 syntax for inline
is compatible with C++.
To create an in-line function, precede its definition with the inline keyword. For example, in the
following program, calls to the function max( ) are optimized:
#include <stdio.h>
inline int max(int a, int b)
{
return a > b ? a : b;
}
int main(void)
{
int x=5, y=10;
printf("Max of %d and %d is: %d\n", x, y, max(x, y));
return 0;
}
For a typical implementation of inline, the preceding program is equivalent to this one:
#include <stdio.h>
int main(void)
{
int x=5, y=10;
printf("Max of %d and %d is: %d\n", x, y, (x>y ? x : y));
return 0;
}
The reason that inline functions are important is that they help you create more efficient code while
maintaining a structured, function-based approach. As you probably know, each time a function is
called, a significant amount of overhead is generated by the calling and return mechanism. Typically,
arguments are pushed onto the stack and various registers are saved when a function is called, and then
restored when the function returns. The trouble is that these instructions take time.
However, when a function is expanded in line, none of those operations occur. Although expanding
function calls in line can produce faster run times, it can also result in larger code size because of
duplicated code. For this reason, it is best to inline only very small functions. Further, it is also a good
idea to inline only those functions that will have significant impact on the performance of your program.
Remember: Although inline typically causes a function’s code to be expanded in line, the com-
piler can ignore this request or use some other means to optimize calls to the function.

NEW BUILT-IN DATA TYPES

C99 adds several new built-in data types. Each is examined here.
 The C99 Standard xxi
_Bool

C99 adds the _Bool data type, which is capable of storing the values 1 and 0 (true and false). _Bool is
an integer type. As many readers know, C++ defines the keyword bool, which is different from _Bool.
Thus, C99 and C++ are incompatible on this point. Also, C++ defines the built-in Boolean constants
true and false, but C99 does not. However, C99 adds the header <stdbool.h>, which defines the macros
bool, true, and false. Thus, code that is compatible with C/C++ can be easily created.
The reason that _Bool rather than bool is specified as a keyword is that many existing C programs
have already defined their own custom versions of bool. By defining the Boolean type as _Bool, C99
avoids breaking this preexisting code. However, for new programs, it is best to include <stdbool.h> and
then use the bool macro.

_Complex and _Imaginary

C99 adds support for complex arithmetic, which includes the keywords _Complex and _Imaginary,
additional headers, and several new library functions. However, no implementation is required to imple-
ment imaginary types, and freestanding implementations (those without operating systems) do not have
to support complex types. Complex arithmetic was added to C99 to provide better support for numerical
programming.
The following complex types are defined:
· float _Complex
· float _Imaginary
· double _Complex
· double _Imaginary
· long double _Complex
· long double _Imaginary
The reason that _Complex and _Imaginary, rather than complex and imaginary, are specified as
keywords, is that many existing C programs have already defined their own custom complex data types
using the names complex and imaginary. By defining the keywords _Complex and _Imaginary, C99
avoids breaking this preexisting code.
The header <complex.h> defines (among other things) the macros complex and imaginary, which
expand to Complex and _Imaginary. Thus, for new programs, it is best to include <complex.h> and
then use the complex and imaginary macros.

The long long Integer Types

C99 adds the long long int and unsigned long long int data types. A long long int has a range of at
least–(263–1) to 263–1. An unsigned long long int has a minimal range of 0 to 264–1. The long long
types allow 64-bit integers to be supported as a built-in type.

Array Enhancements

C99 has added two important features to arrays: variable length and the ability to include type qualifiers
in their declarations.
xxii The C99 Standard
Variable-Length Arrays

In C89, array dimensions must be declared using integer constant expressions, and the size of an array is
fixed at compile time. C99 changes this for certain circumstances. In C99, you can declare an array
whose dimensions are specified by any valid integer expression, including those whose value is known
only at run time. This is called a variable-length array (VLA). However, only local arrays (that is,
those with block scope or prototype scope) can be of variable length.
Here is an example of a variable-length array:
void f(int dim1, int dim2)
{
int matrix[dim1] [dim2]; /* a variable-length, 2-D array */
/* . . . */
}
Here, the size of matrix is determined by the values passed to f( ) in dim1 and dim2. Thus, each call to
f( ) can result in matrix being created with different dimensions.
It is important to understand that variable-length arrays do not change their dimensions during their
lifetime. (That is, they are not dynamic arrays.) Rather, a variable-length array can be created with a
different size each time its declaration is encountered.
You can specify a variable-length array of an unspecified size by using * as the size.
The inclusion of variable-length arrays causes a small change in the sizeof operator. In general, sizeof is
a compile-time operator. That is, it is normally translated into an integer constant whose value is equal
to the size of the type or object when a program is compiled. However, when it is applied to a variable-
length array, sizeof is evaluated at run time. This change is necessary because the size of a variable-
length array cannot be known until run time.
One of the major reasons for the addition of variable-length arrays to C99 is to support numeric
processing. Of course, it is a feature that has widespread applicability. But remember, variable-length
arrays are not supported by C89 (or by C++).

Use of Type Qualifiers in an Array Declaration

In C99 you can use the keyword static inside the brackets of an array declaration when that declaration
is for a function parameter. It tells the compiler that the array pointed to by the parameter will always
contain at least the specified number of elements. Here is an example:
int f(char str [static 80])
{
// here, str is always a pointer to an 80-element array
// . . .
}
In this example, str is guaranteed to point to the start of an array of chars that contains at least 80
elements.
You can also use the keywords restrict, volatile, and const inside the brackets, but only for function
parameters. Using restrict specifies that the pointer is the sole initial means of access to the object.
 The C99 Standard xxiii
Using const states that the same array is always pointed to (that is, the pointer always points to the same
object). The use of volatile is allowed, but meaningless.

Single-Line Comments

C99 adds the single-line comment to C. This type of comment begins with // and runs to the end of
the line.
For example:
// This is a comment
int i; // this is another comment
Single-line comments are also supported by C++. They are convenient when only brief, single-line
remarks are needed. Many programmers use C’s traditional multiline comments for longer descriptions,
reserving single-line comments for “play-by-play” explanations.
Interspersed Code and Declarations In C89, within a block, all declarations must precede the first
code statement. This rule does not apply for C99.
For example:
#include <stdio.h>
int main(void)
{
int i;
i = 10;
int j; // wrong for C89; OK for C99 and C++
j = i;
printf(“%d %d”, i, j);
return 0;
}
Here, the statement i = 10; comes between the declaration of i and the declaration of j. This is not
allowed by C89. It is allowed by C99 (and by C++). The ability to intersperse declarations and code is
widely used in C++.
Adding this feature to C makes it easier to write code that will be used in both environments.

PREPROCESSOR CHANGES

C99 makes a number of small changes to the preprocessor.

Variable Argument Lists

Perhaps the most important change to the preprocessor is the ability to create macros that take a variable
number of arguments. This is indicated by an ellipsis (. . .) in the definition of the macro. The built-in
preprocessing identifier _ _VA_ARGS_ _ determines where the arguments will be substituted.
xxiv The C99 Standard
For example, given this definition
#define MyMax(. . .) max(__VA_ARGS__)
this statement
MyMax(a, b);
is transformed into
max(a, b);

There can be other arguments prior to the variable ones. For example, given
#define compare(compfunc, . . .) compfunc(__VA_ARGS__)
this statement
compare(strcmp, “one”, “two”);
is transformed into
strcmp(“one”, “two”);
As the example shows, _ _VA_ARGS_ _ is replaced by all of the remaining arguments.

The _Pragma Operator

C99 includes another way to specify a pragma in a program: the _Pragma operator. It has the following
general form:
_Pragma (“directive”)
Here, directive is the pragma being invoked. The addition of the _Pragma operator allows pragmas to
participate in macro replacement.

Built-in Pragmas

C99 defines the following built-in pragmas:

Pragma Meaning
STDC FP_CONTRACT ON/OFF/DEFAULT When on, floating-point expressions are
treated as indivisible units that are handled
by hardware-based methods. The default
state is implementation defined.
STDC FENV_ACCESS ON/OFF/DEFAULT Tells the compiler that the floating-point en-
vironment might be accessed. The default
state is implementation defined.
STDC CX_LIMITED_RANGE ON/OFF/DEFAULT When on, tells the compiler that certain for-
mulas involving complex values are safe. The
default state is off.
You should refer to your compiler’s documentation for details concerning these pragmas.
 The C99 Standard xxv
Additional Built-in Macros

C99 adds the following macros to those already supported by C89:

_ _STDC_HOSTED_ _ 1 if an operating system is present.

_ _STDC_VERSION_ _ 199901L or greater. Represents version of C.

_ _STDC_IEC_559_ _ 1 if IEC 60559 floating-point arithmetic is supported.

_ _STDC_IEC_599_COMPLEX_ _ 1 if IEC 60559 complex arithmetic is supported.

_ _STDC_ISO_10646_ _ A value of the form yyyymmL that states the year and
month of the ISO/IEC 10646 specification supported by the
compiler.

Declaring Variables within a for Loop

C99 enhances the for loop by allowing one or more variables to be declared within the initialization
portion of the loop. A variable declared in this way has its scope limited to the block of code controlled
by that statement. That is, a variable declared within a for loop will be local to that loop. This feature
has been included in C because often the variable that controls a for loop is needed only by that loop. By
localizing this variable to the loop, unwanted side effects can be avoided.
Here is an example that declares a variable within the initialization portion of a for loop:
#include <stdio.h>
int main(void)
{
// declare i within for
for(int i=0; i < 10; i++)
printf(“%d ”, i);
return 0;
}
Here, i is declared within the for loop, rather than prior to it.
As mentioned, a variable declared within a for is local to that loop. Consider the following program.
Notice that the variable i is declared twice: at the start of main( ) and inside the for loop.
#include <stdio.h>
int main(void)
{
int i = -99;
// declare i within for
for(int i=0; i < 10; i++)
printf(“%d”, i);
printf(“\n”);
xxvi The C99 Standard
printf(“Value of i is: %d”, i); // displays-99
return 0;
}
This program displays the following:
0123456789
Value of i is: -99
As the output shows, once the for loop ends, the scope of the i declared within that loop ends. Thus, the
final printf( ) statement displays –99, the value of the i declared at the start of main( ).
The ability to declare a loop-control variable inside the for has been available in C++ for quite some
time, and is widely used. It is expected that most C programmers will do the same.

Compound Literals

C99 allows you to define compound literals, which are array, structure, or union expressions designat-
ing objects of the given type. A compound literal is created by specifying a parenthesized type name,
which is then followed by an initialization list, which must be enclosed between curly braces. When the
type name is an array, its size must not be specified. The object created is unnamed.
Here is an example of a compound literal:
double *fp = (double[]) {1.0, 2.0, 3.0};
This creates a pointer to double, called fp, which points to the first of a three-element array of double
values.
A compound literal created at file scope exists throughout the lifetime of the program. A compound
literal created within a block is a local object that is destroyed when the block is left.

Flexible Array Structure Members

C99 allows you to specify an unsized array as the last member of a structure. (The structure must have
at least one other member prior to the flexible array member.) This is referred to as a flexible array
member. It allows a structure to contain an array of variable size. The size of such a structure returned
by sizeof does not include memory for the flexible array.
Typically, memory to hold a structure containing a flexible array member is allocated dynamically,
using malloc( ). Extra memory must be allocated beyond the size of the structure to accommodate the
desired size of the flexible array.
For example, given
struct mystruct {
int a;
int b;
float fa[]; // flexible array
};
the following statement allocates room for a 10-element array:
 The C99 Standard xxvii
struct mystruct *p;
p = (struct mystruct *) malloc(sizeof(struct mystruct) + 10 *
sizeof(float));
Since sizeof(struct mystruct) yields a value that does not include any memory for fa, room for the 10-
element array of floats is added by the expression
10 * sizeof(float)
when malloc( ) is called.

Designated Initializers

A new feature of C99 that will be especially helpful to those programmers working with sparse arrays is
designated initializers. Designators take two forms: one for arrays and one for structures and unions.
For arrays, the following form is used,
[index] = val
where index specifies the element being initialized to the value val. For example:
int a[10] = { [0] = 100, [3] = 200 };
Here, only elements 0 and 3 are initialized.
For structure or union members, the form used is:
. member-name
Using a designator with a structure allows an easy means of initializing only selected members of a
structure.
For example:
struct mystruct {
int a;
int b;
int c;
} ob = { .c = 30, .a = 10 };
Here, b is uninitialized.
Using designators also allows you to initialize a structure without knowing the order of its members.
This is useful for predefined structures, such as div_t, or for structures defined by some third party.

Additions to the printf( ) and scanf( ) Family of Functions

C99 adds to the printf( ) and scanf( ) family of functions the ability to handle the long long int and
unsigned long long int data types. The format modifier for long long is ll.
For example, the following fragment shows how to output a long long int and an unsigned long long
int:
long long int val;
unsigned long long int u_val;
printf(“%lld %llu”, val, val2);
xxviii The C99 Standard
The II can be applied to the d, i, o, u, and x format specifiers for both printf( ) and scanf( ).
C99 adds the hh modifier, which is used to specify a char argument when using the d, i, o, u, or x
format specifiers. Both the ll and hh specifiers can also be applied to the n specifier.
The format specifiers a and A, which were added to printf( ), cause a floating-point value to be
output in a hexadecimal format. The format of the value is
[-]0xh.hhhhp+d
When A is used, the x and the p are uppercase. The format specifiers a and A were also added to
scanf( ), and read a floating-point value.
In a call to printf( ), C99 allows the 1 modifier to be added to the %f specifier (as in %lf), but it has
no effect. In C89, %lf is undefined for printf( ).

NEW LIBRARIES IN C99

C99 adds several new libraries and headers. They are shown here:
Header Purpose
<complex.h> Supports complex arithmetic.
<fenv.h> Gives access to the floating-point status flags and other
aspects of the floating-point environment.
<inttypes.h> Defines a standard, portable set of integer type names.
Also supports functions that handle greatest-width inte-
gers.
<iso646.h> Added in 1995 by Amendment 1. Defines macros that
correspond to various operators, such as && and ^.
<stdbool.h> Supports Boolean data types. Defines the macros bool,
true, and false, which help with C++ compatibility.
<stdint.h> Defines a standard, portable set of integer type names.
This header is included by <inttypes.h>.
<tgmath.h> Defines type-generic floating-point macros.
<wchar.h> Added in 1995 by Amendment 1. Supports multibyte and
widecharacter functions.
<wctype.h> Added in 1995 by Amendment 1. Supports multibyte and
widecharacter classification functions.

The _ _func_ _ Predefined Identifier

C99 defines _ _func_ _, which specifies the name (as a string literal) of the function in which
_ _func_ _ occurs.
For example:
void StrUpper(char *str)
 The C99 Standard xxix
{
static int i = 0;
i++;
printf(“%s has been called %d time(s).\n”, __func__, i);
while(*str) {
*str = toupper(*str);
str++;
}
}
When called the first time, StrUpper( ) will display this output:
StrUpper has been called 1 time(s).

INCREASED TRANSLATION LIMITS

The term ‘translation limits’ refers to the minimum number of various elements that a C compiler must
be able to handle. These include such things as the length of identifiers, levels of nesting, number of case
statements, and number of members allowed in a structure or union. C99 has increased several of these
limits beyond the already generous ones specified by C89.
Here are some examples:
Limit C89 C99
Nesting levels of blocks 15 127
Nesting levels of conditional inclusion 8 63
Significant characters in an internal identifier 31 63
Significant characters in an external identifier 6 31
Members of a structure or union 127 1023
Arguments in a function call 31 127

Implicit int No Longer Supported

Several years ago, C++ dropped the implicit int rule, and with the advent of C99, C follows suit. In C89,
the implicit int rule states that in the absence of an explicit type specifier, the type int is assumed. The
most common use of the implicit int rule was in the return type of functions. In the past, C programmers
often omitted the int when declaring functions that returned an int value.
For example, in the early days of C, main( ) was often written like this:
main ()
{
/* . . . */
}
xxx The C99 Standard
In this approach, the return type was simply allowed to default to int. In C99 (and in C++) this default no
longer occurs, and the int must be explicitly specified, as it is for all of the programs in
this book.
Here is another example. In the past a function such as
int isEven(int val)
{
return !(val%2);
}
would often have been written like this:
/* use integer default */
isEven (int val)
{
return !(val%2);
}
In the first instance, the return type of int is explicitly specified. In the second, it is assumed by default.
The implicit int rule does not apply only to function return values (although that was its most
common use).
For example, for C89 and earlier, the isEven( ) function could also be written like this:
isEven(const val)
{
return ! (val%2);
}
Here, the parameter val also defaults to int—in this case, const int. Again, this default to int is not
supported by C99.
Note Technically, a C99-compatible compiler can accept code containing implied ints after re-
porting a warning error. This allows old code to be compiled. However, there is no requirement
that a C99-compatible compiler accept such code.

Implicit Function Declarations Have Been Removed

In C89, if a function is called without a prior explicit declaration, then an implicit declaration of that
function is created. This implicit declaration has the following form:
extern int name( );
Implicit function declarations are no longer supported by C99.
Note Technically, a C99-compatible compiler can accept code containing implied function dec-
larations after reporting a warning error. This allows old code to be compiled. However, there is
no requirement that a C99-compatible compiler accept such code.
 The C99 Standard xxxi
Restrictions on return

In C89, a function that has a non-void return type (that is, a function that supposedly returns a value)
could use a return statement that did not include a value. Although this creates undefined behaviour, it
was not technically illegal. In C99, a non-void function must use a return statement that returns a
value. That is, in C99, if a function is specified as returning a value, any return statement within it must
have a value associated with it. Thus, the following function is technically valid for C89, but invalid for
C99:
int f(void)
{
/* . . . */
return ; // in C99, this statement must return a value
}

Extended Integer Types

C99 defines several extended integer types in <stdint.h>. Extended types include exact-width, mini-
mum-width, maximum-width, and fastest integer types.
Here is a sampling:

Extended Type Meaning

int16_t An integer consisting of exactly 16 bits

int_least16_t An integer consisting of at least 16 bits
int_fast32_t Fastest integer type that has at least 32 bits
intmax_t Largest integer type
uintmax_t Largest unsigned integer type
The extended types make it easier for you to write portable code.
For loop changes In a for-loop, the first expression may be a declaration, with a scope encompassing
only the loop.
for (decl; pred; inc)
stmt;
is equivalent to:
{
decl;
for (; pred; inc)
stmt;
}
Type specifiers or data types Type specifiers: new combinations added for:
· _Bool
· float _Complex, double _Complex, long double _Complex
· signed and unsigned long long int.
xxxii The C99 Standard
New type long long (signed and unsigned), at least 64 bits wide.
Note: It seems that these type specifiers may occur in any order, e.g, _Complex double long
or signed long int long would be legal.
The implementation of the complex types is defined by the standard to use cartesian coordinates (real
and imaginary part), i.e. forbids an implementation using polar coordinates (distance from [0,0] and an
angle). Furthermore, the same paragraph also specifies that a complex type has the same alignment
requirements as an array of two elements of the corresponding floating types, the first must be the real
part and the second the imaginary part.
Objects of the new boolean type _Bool may have one of the two values zero or one.

Format Modifiers for Printf( ) Added by C99

C99 adds several format modifiers to printf( ): hh, ll, j, z, and t. The hh modifier can be applied to d, i,
o, u, x, X, or n. It specifies that the corresponding argument is a signed or unsigned char value or, in
the case of n, a pointer to a signed char variable. The ll modifier also can be applied to d, i, o, u, x, X,
or n. It specifies that the corresponding argument is a signed or unsigned long long int value or, in the
case of n, a pointer to a long long int. C99 also allows the l to be applied to the floating-point specifiers
a, A, e, E, f, F, g, and G, but it has no effect. The j format modifier, which applies to d, i, o, u, x, X, or
n, specifies that the matching argument is of type intmax_t or uintmax_t. These types are declared in
<stdint.h> and specify greatest-width integers. The z format modifier, which applies to d, i, o, u, x, X,
or n, specifies that the matching argument is of type size_t. This type is declared in <stddef.h> and
specifies the result of sizeof.
The t format modifier, which applies to d, i, o, u, x, X, or n, specifies that the matching argument is of
type ptrdiff_t. This type is declared in <stddef.h> and specifies the difference between two pointers.

Sample code

#include <stdio.h>
int main(void)
{
/* This prints ''this is a test" left justified
in 20 character field.
*/
printf(“%-20s”, “this is a test”);
/* This prints a float with 3 decimal places in a 10
character field. The output will be " 12.235".
*/
printf(“%10.3f”, 12.234657);
return 0;
}

Changes to the Integer Promotion Rules

C99 enhances the integer promotion rules. In C89, a value of type char, short int , or an int bit-field can
be used in place of an int or unsigned int in an expression. If the promoted value can be held in an int,
the promotion is made to int; otherwise, the original value is promoted to unsigned int.
 The C99 Standard xxxiii
In C99, each of the integer types is assigned a rank. For example, the rank of long long int is greater
than int, which is greater than char, and so on. In an expression, any integer type that has a rank less
than int or unsigned int can be used in place of an int or unsigned int.

THE PRINTF( ) FORMAT SPECIFIERS

Code Format
%a Hexadecimal output in the form 0xh.hhhhp+d (C99 only).
%A Hexadecimal output in the form 0Xh.hhhhP+d (C99 only).
%c Character.
%d Signed decimal integers.
%i Signed decimal integers.
%e Scientific notation (lowercase e).
%E Scientific notation (uppercase E).
%f Decimal floating point.
%F Decimal floating point (C99 only; produces uppercase INF, INFINITY,
or NAN when applied to infinity or a value that is not a number. The %f
specifier produces lowercase equivalents.)
%g Uses %e or %f, whichever is shorter.
%G Uses %E or %F, whichever is shorter.
%o Unsigned octal.
%s String of characters.
%u Unsigned decimal integers.
%x Unsigned hexadecimal (lowercase letters).
%X Unsigned hexadecimal (uppercase letters).
%p Displays a pointer.
%n The associated argument must be a pointer to an integer. This specifier
causes the number of characters written (up to the point at which the
%n is encountered) to be stored in that integer.
%% Prints a percent sign.

RESTRICT-QUALIFIED POINTERS

The C99 standard has added a new type qualifier that applies only to pointers: restrict. A pointer
qualified by restrict is initially the only means by which the object it points to is accessed. Access to the
object by another pointer can occur only if the second pointer is based on the first. Thus, access to the
object is restricted to expressions based on the restrict-qualified pointer. Pointers qualified by restrict
are primarily used as function parameters or to point to memory allocated via malloc( ). By qualifying
a pointer with restrict, the compiler is better able to optimize certain types of routines. For example, if
a function specifies two restrict-qualified pointer parameters, then the compiler can assume that the
pointers point to different (that is, non-overlapping) objects. The restrict qualifier does not change the
semantics of a program.
xxxiv The C99 Standard

1. /* Write a program to test the given string is palindrome or not. implement the program
by using _Bool datatype */
#include<stdio.h>
#include<string.h>
enum _Bool{false,true}; // _Bool DataType which is capable of
storing the vales 0 and 1
enum _Bool IsPalindrome(char string[]) // _Bool datatype
{
int left,right,len=strlen(string);
enum _Bool matched=true; // _Bool datatype
if(len==0)
return 0;
left=0;
right=len-1;
/* Compare the first and last letter,second & second last & so
on */
while(left<right&&matched)
{
if(string[left]!=string[right])
matched=false;
else
{
left++;
right--;
}
}
return matched;
}

int main()
{
char string[40];
clrscr();
printf("****Program to test if the given string is a
palindrome****\n");
printf("Enter a string:");
scanf("%s",string);
if(IsPalindrome(string))
printf("The given string %s is a palindrome\n",string);
else
printf("The given string %s is not a palindrome\n",string);
getch();
return 0;
}
 The C99 Standard xxxv

2. /* In C89, within a block, all declarations must precede the first code statement. This rule
does not apply for C99 */
#include<stdio.h>
int main(void)
{
int i;
i=10;
int j; //wrong for c89; ok for c99
j=i;
clrscr();
printf("%d %d",i,j);
return 0;
getch();
}
3. /* Write a program to print the signed and unsigned numbers by using C99 standards*/
#include<stdio.h>
int main(void)
{
int i= -99;
{
for(int i=0; i<10; i++) //declare i within for
printf("%d",i);
printf("\n");
}
printf("Value of i is: %d",i); //display-99
return 0;
}
4. /* Write a program to open the file by using C99 standards */
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
FILE *fp;
if((fp=fopen("test","wb"))==NULL);
{
printf("cannot open file.\n");
exit(1);
fprintf(fp,"this is a test %d %f", 10,20.01); // fprintf
fclose(fp);
return 0;
}
}
xxxvi The C99 Standard

5. /* Write a C program that uses functions to perform the following operations by using
C99 standards(_Complex, _Imaginary):
(i) Reading a complex number
(ii) Writing a complex number
(iii) Addition of two complex numbers
(iv) Multiplication of two complex numbers
(Note: represent complex number using a structure.) */
#include<stdio.h>
#include<math.h>
#include<complex.h>

void _Complex(int opern);

struct comp
{
double realpart;
double _Imaginary;
};

void main()
{
int opern;
clrscr();
printf("\n\n \t\t\t***** MAIN MENU *****");
printf("\n\n Select your option: \n1 : ADD\n2 : MULTIPLY\n0 :
EXIT \n\n\t\t Enter your Option [ ]\b\b");

scanf("%d",&opern);

switch(opern)
{
case 0:
exit(0);
case 1:
case 2:
_Complex(opern);
default:
main();
}

void _Complex(int opern)

 The C99 Standard xxxvii

{
struct comp w1, w2, w;
printf("\n Enter two Complex Numbers (x+iy):\n Real Part of
First Number:");
scanf("%lf",&w1.realpart);
printf("\n Imaginary Part of First Number:");
scanf("%lf",&w1._Imaginary);
printf("\n Real Part of Second Number:");
scanf("%lf",&w2.realpart);
printf("\n Imaginary Part of Second Number:");
scanf("%lf",&w2._Imaginary);
switch(opern)
{
/*addition of complex number*/
case 1:
w.realpart = w1.realpart+w2.realpart;
w._Imaginary = w1._Imaginary+w2._Imaginary;
break;

/*multiplication of complex number*/

case 2:
w.realpart=(w1.realpart*w2.realpart)-
(w1._Imaginary*w2._Imaginary);

w._Imaginary=(w1.realpart*w2._Imaginary)+(w1._Imaginary*w2.realpart);
break;
}

if (w._Imaginary>0)
printf("\n Answer = %lf+%lfi",w.realpart,w._Imaginary);
else
printf("\n Answer = %lf%lfi",w.realpart,w._Imaginary);
getch();
main();
}
6. /* Write a program to find the maximum number by using C99 standards(inline keyword)
*/
#include <stdio.h>
inline int max(int a, int b) // inline keyword
{
return a > b ? a : b;
xxxviii The C99 Standard

}
int main(void)
{
int x=5, y=10;
printf("Max of %d and %d is: %d\n", x,y,max(x,y));

return 0;
}
7. /* Write a C program to generate Pascal's Triangle by using C99 standards */
#include<stdio.h>
#include<conio.h>

void main()
{
int bin,q,r;
clrscr();
bin=1;
q=0;

printf("Rows you want to input:");

scanf("%d",&r);

printf("\nPascal's Triangle:\n");

while(q<r)
{
for(int p=40-3*q;p>0;--p) // declare p with in for
printf(" ");
for(int x=0;x<=q;++x) // declare x with in for
{
if((x==0)||(q==0))
bin=1;
else
bin=(bin*(q-x+1))/x;
printf("%6d",bin);
}

printf("\n");
++q;
}
getch();
}
 The C99 Standard xxxix

8. /* Write a C program to generate all the prime numbers between 1 and n, where n is a
value supplied by the user by using C99 standards.(long long int,declare variables with in
for loop) */
#include <stdio.h>

void main()
{
long long int no,check; // long long int
clrscr();
printf("<-----------------------PRIME NO. SERIES--------------
---------->");
printf("\n\n\n\t\t\tINPUT THE VALUE OF N: ");
scanf("%d",&no);
printf("\n\nTHE PRIME NO. SERIES B/W 1 TO %lld : \n\n",no);

for(int counter = 1; counter <= no; counter++) // declare

counter with in for
{
check = 0;
//THIS LOOP WILL CHECK A NO TO BE PRIME NO. OR NOT.

for(int counter1 = counter-1; counter1 > 1 ; counter1--)

if(counter%counter1 == 0)
{
check++; // INCREMENT CHECK IF NO. IS NOT A PRIME NO.
break;
}
if(check == 0)
printf("%d\t",counter);
}
getch();
}
9. /* Write a program to print text and numbers by using C99 standards */
#include<stdio.h>
int main(void)
{
printf("%-20s","this is a test"); // left justified
printf("%10.3f",12.234657);
return 0;
}
xl The C99 Standard

10. /* Write a program for addition of matrices by using the restrict keyword */
void fadd(double a[static restrict 10],
const double b[static restrict 10]) // restrict keyword, restricrts a and b
{
int i;
for(i=0; i<10; i++)
{
if(a[i] < 0.0)
return;
a[i] += b[i];
}
return;
}
11. /* Write a C program to find the roots of a quadratic equation by using format modifiers
in C99. */
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{
float a,b,c,root1,root2;
clrscr();
printf("\n Enter values of a,b,c for finding roots of a qua-
dratic eq:\n");
scanf("%f%f%f",&a,&b,&c);
/*checking condition*/
if(b*b>4*a*c)
{
root1=-b+sqrt(b*b-4*a*c)/2*a;
root2=-b-sqrt(b*b-4*a*c)/2*a;
printf("\n*****ROOTS ARE*****\n");
printf("\nroot1=%1.3f\nroot2=%1.2f",root1,root2); //format
modifiers for printf()
}
else
printf("\n Imaginary Roots.");
getch();
}
 The C99 Standard xli

12. /* Write a C program to find the sum of individual digits of a positive integer by using long
long int in C99 standards*/
#include<stdio.h>
#include<conio.h>
void main()
{
long long int num, k=1, sum=0; // long long int
clrscr();
printf("Enter the number whose digits are to be added:");
scanf("%lld",&num);
while(num!=0)
{
k=num%10;
sum=sum+k;
k=num/10;
num=k;
}
printf("Sum of the digits:%lld",sum);
getch();
}
UNIT I
Chapter
1
Algorithms

1.1 INTRODUCTION

There is a tremendous similarity between the human actions and the way a computer performs various
functions. Nicholas Wirth—the inventor of a computer language—‘Pascal’ used to say “A program is
equal to algorithm + data”. In the next few chapters, we will explore the meaning of these terms; first
learning about and clearly analyzing human actions and then showing how computers also act similarly,
thereby demystifying the complexity that surrounds computers.
We perform hundreds of activities during a day. An activity could be anything from brushing teeth to
making tea and from going to work to having dinner. There are two basic ways to describe in detail, any
of these activities:
1. By describing the process step-by-step—called as algorithm.
2. By representing the various steps in the form of a diagram—called as flow chart.

1.1.1 Algorithm/pseudocode

The term algorithm is very popular in the computer literature. An algorithm is also called pseudocode.
At first, it might sound very complex. However, it is very simple to understand. In fact, we all perform
hundreds of algorithms in our daily life without even realizing it!
Algorithm is the step-by-step method of performing any task. When we break up a big task into
smaller steps, what we actually do is to create an algorithm. In other words, we perform hundreds of
algorithms. Brushing teeth, making tea, getting ready for school or office, are all different algorithms.
For example, when making a cup of tea, we follow the algorithm as shown in Fig. 1.1 (with a few
variations, of course!).
An interesting observation: Many steps can be further sub-divided into still smaller sub-steps. For
example, we can write an algorithm for Step 1 (Boil water) by writing detailed steps for boiling water.
However, it is up to an individual as to how detailed steps one should describe. Each step can be called
as an instruction. Also, we can notice that steps 4 and 5 can be executed in parallel, i.e. we can boil
milk while we wait. In actual life, there is a tremendous amount of parallelism in many of our actions.
We normally hear, see and feel simultaneously to comprehend a situation. Within this also, when we see
1.4 C Programming and Data Structures
a picture, for example, actually we see millions of spots of the picture to generate an image on our retina
while we compare all dots in parallel with already stored millions of images to identify an object instan-
taneously! Therefore, parallel computing was developed to speed up things and ultimately try to
imitate human actions in artificial intelligence. We need not discuss these in detail in later chapters,
but continue with serial algorithms for now.
Begin
1. Boil water.
2. Put tea powder in the kettle.
3. Pour boiled water in the kettle.
4. Wait for three minutes.
5. Boil milk.
6. Put boiled milk in a cup.
7. Add sugar to the cup.
8. Empty the kettle in the cup.
9. Stir the cup with a spoon.
End

Fig. 1.1 Algorithm for making tea

1.1.2 Flow Chart

There is another way to write the steps involved in any process. This is by making use of various
symbols. The symbols form a diagram that represents the steps in a pictorial fashion similar to an
algorithm. This is also very easy to understand. Such a diagram is called flow chart. In its simplest
form, a flow chart consists of a series of rectangles connected to each other by arrows. The rectangles
represent the various steps and the arrows designate the flow. A flow chart for our tea-making example
could be drawn as in Fig. 1.2.

Fig. 1.2 Flow chart for making tea

 Algorithms 1.5
As can be seen, these are very primary concepts that we learn since childhood. We learn to make tea
by observing someone making tea: just like any other activity. Thus, the algorithm for making tea was
recorded in our brain long back somewhere deep—in our memory. There is another part of our memory
which stores the details of our current activity or thoughts. Whenever we want to make tea, somehow
this algorithm is brought back from our deep memory into the current memory (i.e. it is ‘remembered’)
and then it is actually executed. This concept of storing something in memory, retrieving it back in the
current memory (i.e. ‘remembering’ it) whenever needed and actually performing a task is very primi-
tive, yet extremely important, as we shall see, due to its similarity with computers.

1.2 THREE BASIC OPERATIONS

The tea-making algorithm and flow chart discussed earlier were quite simple. One step followed another
in a sequential fashion. However, things are not so simple in real life! There are so many ifs and buts.
For example, consider the following statements:
∑ If it is 9 am, I must go to the office.
∑ If it is raining, take your umbrella with you.
∑ Read each line and say it loudly until the end of this page.
How do we take care of such things in an algorithm and a flow chart? And how many different kinds
of situations we must cater to? This section attempts to answer these questions.
In general, the steps in an algorithm can be divided in three basic categories as listed below:
∑ Sequence—A series of steps that we perform one after the other
∑ Selection—Making a choice from multiple available options
∑ Iteration—Performing repetitive tasks
These three basic categories of activities combined in different ways can form the basis for describ-
ing any algorithm. It might sound surprising initially. But it is true. Think of any situation in our daily
life and try to fit it in one of the three categories: it works!
Let us now look at each of the categories in more detail.

1.2.1 Sequence

A sequence is a series of steps that we follow in any algorithm without any break, i.e. unconditionally.
The algorithm for making tea described in Fig. 1.1 belongs to this category. Figure 1.3 describes another
algorithm in this category for ‘boiling water’. What this means is that we have exploded further the step
or instruction 1 in the algorithm for making tea given in Fig. 1.1. We can explode all such steps in Fig.
1.1 in the following way.
Begin
1. Take a utensil.
2. Take the utensil to the water tap.
3. Open the tap.
4. Fill the utensil with water.
5. Close the tap.
6. Put the utensil on the gas or in the oven.
7. Start the gas or the oven.
8. Wait until the water boils.
9. Switch off the gas or the oven.
End

Fig. 1.3 Algorithm for boiling water

1.6 C Programming and Data Structures

We will not draw the flow chart for boiling water. It should be clear by now that it is a matter of
writing all of the above 9 steps in rectangles one after the other; each connected to its successor by an
arrow.

1.2.2 Selection

We will quickly realize that only ‘sequence’ is not good enough to express an algorithm. Quite a few of
our actions depend on certain events. Thus, there is a need to be able to make a choice from many
available options. Therefore, there is a process of selection. A selection statement generally takes the
form as shown in Fig. 1.4.
1. If
2. Then
3. End-if

Fig. 1.4 Selection

We take so many decisions, small and big, in our daily life without even realizing it. For example, if
it is hot, we switch on the fan. We can depict this selection process as shown in Fig. 1.5.
1. If it is hot
2. Then switch on the fan
3. End-if

Fig. 1.5 Example of a selection

Note that End-if is an additional step that indicates the end of the selection process. A question may
be asked: is End-if really necessary? Let us illustrate this by the following selection process that does
not have an End-if. Refer to Fig. 1.6.
1. If the guest wants tea
2. Then make tea
3. Offer biscuits

Fig. 1.6 Importance of End-if

What do we do if the guest does not want tea? Do we offer him biscuits? It is not clear from the
selection process described above. It can be argued and proved either way. That is, we are not sure
whether the Offer biscuits portion is a part of our If condition or not. A miserly person would always say
that he considers Offer biscuits as a part of the condition, and hence would only offer biscuits to some-
one who wants tea! Hence, it is always better to end a selection process with an End-if to avoid any
confusion at least for our algorithms. Different computer programming languages have different con-
ventions.
The position and placement of End-if instructions can change the meaning of the entire algorithm as
shown in Fig. 1.7 (a) and 1.7 (b). Let us study the algorithm shown in Fig. 1.7 (a). If the guest wants tea,
the algorithm will execute step 2 after step 1 (i.e. make tea), then fall through step 3 and then step 4 (i.e.
offer biscuits). Thus, if the guest wants tea, he gets the biscuits, too! Now, let us trace the algorithm if
the guest does not want tea. In this case, the algorithm will follow step 3 after step 1 (i.e. skip the tea)
and then fall through step 4 (i.e. offer biscuits). Thus, biscuits will be offered regardless of tea. If we
study algorithm shown in Fig. 1.7 (b), we will notice that biscuits are offered only with tea. If the guest
Another Random Scribd Document
with Unrelated Content
The Project Gutenberg eBook of An geöffneter
Tür
 This ebook is for the use of anyone anywhere in the United
States and most other parts of the world at no cost and with
almost no restrictions whatsoever. You may copy it, give it away
or re-use it under the terms of the Project Gutenberg License
included with this ebook or online at www.gutenberg.org. If you
are not located in the United States, you will have to check the
laws of the country where you are located before using this
eBook.

Title: An geöffneter Tür

Author: Clara Sudermann

Release date: September 14, 2019 [eBook #60293]

Most recently updated: October 17, 2024

Language: German

Credits: Produced by the Online Distributed Proofreading Team

at
http://www.pgdp.net

*** START OF THE PROJECT GUTENBERG EBOOK AN GEÖFFNETER

TÜR ***
 An geöffneter Tür
von

Clara Sudermann

Dritte Auflage

Fe l i x L e h m a n n Ve r l a g / B e r l i n W

Alle Rechte vom Verleger gewahrt

Copyright 1914 by Felix Lehmann
Verlagsbuchhandlung Berlin W 35
 An geöffneter Tür

Wie das sonderbar ist, ... eigentlich wie ein Traum. Ich sitze ganz
allein in einem Passantenzimmerchen des Glarner Hofs in Glarus. In
den Gartenanlagen vor meinem Fenster plätschert hinter
dickblätterigem Buschwerk das Wasser eines Springbrunnens. Das
wird heute mein Wiegenlied sein und mir einen guten Schlaf
bringen. Aber noch will ich nicht schlafen. Ich habe das Herz so voll.
Es ist ganz still im Hause und auf der Straße. Als ich vorhin am
Fenster stand, kam der Mond gerade hinter dem Glärnisch vor und
schüttete schimmernde Streifen über Schroffen und Halden und
Wasserfäden, die sich hinunterringeln. Da wurde der Riese lebendig
und bekam eine Stimme.
Ach, du lieber, geliebter Riese, ich verstehe ja deine Sprache, ich
fühle sie, und als Antwort möchte ich mich an dich hinanschmiegen,
dich ganz umfassen mit all deinen Gipfeln, deinen Abgründen und
den stillen, grünen Matten ...
Ich bin frei, und ich glaube an das Leben, an mein Leben, über
dem Jahre hindurch das Schwert hing!
Als heute vor vierzehn Tagen in Davos Dr. Herholz in mein Zimmer
kam und mir ganz ohne Vorbereitung sagte: »Fräulein Lydia, wir sind
so weit, rüsten Sie sich zur Heimfahrt,« ... da stand mir das Herz still
vor Schreck.
 Wie oft hatte ich mir diesen Augenblick ausgemalt, in dem der
lächelnde Henker vor mich treten und mir sagen würde wie schon so
vielen vor mir: »Sie sind als geheilt entlassen.«
Wie hatte ich in voller Fassung und Würde dieses Todesurteil
entgegennehmen wollen, auch lächelnd und dem Anschein nach den
lügnerischen Worten Glauben schenkend. Und nun ...?
Ich fühle jetzt noch die eiskalte Leere, die plötzlich um mich war.
Meine Jugend, meine armen vierundzwanzig Jahre schrien jammernd
um Hilfe. »Wie lange also noch, Doktor?« brachte ich endlich vor.
Doktor Herholz, übrigens einer der wenigen unter der Herde von
Ärzten, die mein Leben durchzieht, der mir immer gleichmäßig
freundliche Teilnahme gezeigt hat, nahm meine Hand und fühlte
gewohnheitsmäßig den Puls.
»Ruhig, ruhig – es ist Ernst, Fräulein Lydia,« sagte er und sah
mich treuherzig und froh an. »Sie brauchen nicht mißtrauisch zu
sein. Ich habe das aber bei Ihrer skeptischen Veranlagung
vorausgesehen und Ihnen den Krankheitsbericht seit der drittletzten
Injektion mitgebracht. Kommen Sie, sehen Sie selbst.«
Es flimmerte mir vor den Augen. Ich las wohl mechanisch ...
Gewicht ... Temperatur ... Sputum ... usw. Diese ganze entsetzliche
Reihenfolge, die tagaus, tagein Gedanken und Gespräche beherrscht
hatte, und ich mußte mich von dem günstigen Ergebnis überzeugen,
das ja meinen eigenen Wahrnehmungen entsprach. Aber hinter der
leise aufdämmernden Hoffnung sprangen die schwarzen Kreuzchen
auf, die in meinen Erinnerungsbüchern bei so vielen Namen stehen,
– Namen von armen Menschenkindern, mit denen ich ein Stückchen
Weg gemeinsam gemacht hatte, und denen fast allen einmal, wie
heute mir, verkündigt worden war: »Sie sind als geheilt entlassen.«
»Sie dürfen das nicht, Doktor,« sagte ich dann. »Es ist eine
überflüssige Grausamkeit. Das ist alles Täuschung, ein
vorübergehendes Aufflackern, ... ich weiß zu genau Bescheid, und
ich will mich nicht selbst betrügen und mir auch keine falschen
Erwartungen einimpfen lassen ...«
»Ich gebe Ihnen die ehrliche Versicherung, daß es Ihnen
verhältnismäßig gut geht, Fräulein Lydia. Natürlich sind Sie kein
Riese, – dürfen sich nie für ganz gesund halten, – müssen vorsichtig
und maßvoll in jeder Beziehung leben, – körperlich und geistig ...«
Und nun begann er einen ganzen Strom ärztlicher Weisheit über
mich zu ergießen. Mir war wunderlich dabei zumute. Ich
widerstrebte innerlich, aber hier und da fing etwas in seinen
Auseinandersetzungen an mir einzuleuchten, und endlich, als er von
den Gefahren eines Rückfalls, ja des »letalen Ausgangs« sprach, die
durch Erkältungen, Anstrengungen oder Erregungen herbeigeholt
werden könnten, denen aber durch Willenskraft und Überlegung
vorzubeugen war, – da schwankte ich schon in dem festen
Vornehmen, mich trügerischen Hoffnungen zu verschließen, und die
Möglichkeit, daß er die Wahrheit sprechen möchte, hob sich zaghaft
und verlangend in mir.
»Doktor, Sie begehen eine schwere Sünde, wenn Sie mich
betrügen. Sie könnten mich ruhig so weiter dämmern lassen. Es ist
ja gerade in Ihrem Sanatorium ganz vergnüglich. Man lebt so von
der Hand in den Mund und täuscht sich über vieles hinweg in der
schönen Natur ... Und Sie wissen ja, verlangen nach mir, um mich
noch pflegen und lieben zu können, wie das so üblich ist, tut zu
Hause niemand ...«
»Das weiß ich gar nicht,« sagte der gute Doktor etwas verlegen,
»aber es spricht auch gar nicht mit. Hören Sie doch zu. Wenn's so
wäre, wie Sie annehmen, wie es leider ja auch oft geschieht und aus
Menschlichkeit und tausend anderen Gründen geschehen muß –
erinnern Sie sich nicht an den Gebrauch in solchen Fällen? – Dann
führe ich den betreffenden Patienten doch zum Chef, und der weiß
mit seiner exorbitanten, sachlich scheinenden Beredsamkeit jedes
Bedenken ganz anders totzuschlagen als ich. Das wäre ihm auch bei
Ihnen eine Kleinigkeit gewesen. Sie kennen doch die leuchtenden
Augen, mit denen die vollkommen Überzeugten dann aus dem
heiligen Arbeitszimmer zu kommen pflegen, auch wenn Sie vorher
noch so mißtrauisch waren.« Das stimmte. Wie eine Bestätigung
dieser Worte glitt das Bild des Einen, Unvergeßlichen durch meine
Gedanken, der sich auch nie durch die berüchtigte Endunterhaltung
hatte täuschen lassen wollen, der dann doch beglückt
dahergekommen war wie alle die anderen und doch denselben Weg
gegangen war wie sie ...
»Sehen Sie, Fräulein Sargent,« sagte der Doktor weiter, »wir zwei
haben uns doch ganz hübsch eingelebt miteinander, der Chef weiß
das. Und als wir bei der letzten Konferenz gestern endgültig
feststellten, was wir eigentlich schon seit Monaten wissen, daß von
uns aus, im Augenblick nämlich, nichts mehr für Sie zu tun ist, sagte
er mir großmütigerweise: »»Sie können dem Wurm die Nachricht
bringen. Sie stehen ihr ja näher als ich, und wenn Sie wollen,
besorgen Sie auch die Korrespondenz mit den Angehörigen,«« –
was, nebenbei gesagt, bereits geschehen ist« ...
Nun wurde mir doch schwindlig, und – was soll ich es vor mir
selbst nicht eingestehen – eine ungeheure Freude brannte wie eine
Flamme in mir auf. Fassungslos warf ich mich dem guten Doktor an
den Hals und weinte, – weinte bis zum Vergehen ...
.... Und dann sind die Reisevorbereitungen gekommen, vor allem
der Briefwechsel mit den Meinen, der mich nicht sonderlich
enttäuschte, weil dieses brausende Glück, das aus dem Hinterhalt
über mich hergestürzt ist, ihm das Gegengewicht hielt.
Im Grunde benahm man sich genau so, wie ich es mir hatte
vorstellen können. Eine matte, etwas ungläubige Freude und
Verlegenheit, viel Verlegenheit. Man weiß augenscheinlich nicht, was
mit mir anfangen. Die ganze Familie sitzt in Gastein. Ob ich dorthin
kommen wolle, ob es ein geeigneter Ort als Übergang für mich
wäre. Die Kur könnte man nicht unterbrechen, Papa hätte sie so
nötig gebraucht, und meine Mutter dürfte ihn nicht verlassen.
 Natürlich bin ich ihnen mit der Idee entgegengekommen, daß ich
zuerst noch ein wenig für mich bleiben wolle, in einer gut
empfohlenen Schwarzwaldpension vielleicht, jedenfalls meine Kräfte
erst einmal erproben und die Welt mit den Augen der Gesundenden
sehen lernen. Und dieser Wunsch traf auch auf keinen Widerspruch.
– Seit ich mündig bin, habe ich mir ohnedies die sonst nötig und
standesgemäß gefundene Begleitung abgeschafft. – Und mein
Stiefvater schrieb mir sogar einen ganz herzlichen Brief. Er wolle mit
seinem vollen Titel – »der Ministerialdirektor imponiert auch in der
freien Schweiz« meint er irrtümlicherweise – mein Zimmer in dem
Züricher Hotel bestellen, in dem ich die erste Station machen sollte.
Und Mama? ...
Jedenfalls ist ihr eine Last von dem hin und her gezerrten Herzen
gefallen, und sie wird sicher mit der frohen Steigerung ihres Wesens,
die sie immer so liebenswürdig macht, die nächsten Wochen in
Gastein genießen.
Ich aber bin nach fröhlichem Abschied von Davos, – von dem
Hofrat, den ich gar nicht, dem Doktor Herholz, den ich sehr gern
mochte, heute früh abgereist und, einer plötzlichen Eingebung
folgend, in Weesen ausgestiegen und anstatt in Zürich in Glarus
gelandet.
Das ist so gekommen:
In meinem Coupé sprachen zwei Herren von einer gewaltigen
Arbeit, die man eben im Glarnerland, im Klöntal, unternähme. Man
staue einen großen Bergsee, mache sein Gefälle höher und gewänne
durch eine Leitung, die bis nach Zürich ginge, eine ungeheure Kraft,
die industriell verwertet werden solle.
Nie im Leben hatte ich etwas Ähnliches gehört und, ich weiß nicht,
als mir der Gedanke durch den Kopf schoß, was es nun alles für
mich auf der Welt zu sehen und zu erleben gäbe, war ich auch schon
entschlossen, mir diese Sache, die mir ganz ungeheuerlich erschien,
zu betrachten.
 Vielleicht hat bei diesem plötzlichen Entschluß auch ein klein
wenig die Abneigung gegen das in Zürich von dem
»Ministerialdirektor« bestellte Zimmer mitgesprochen, jedenfalls
sitze ich hier in Glarus mit meinem glücklicherweise ausreichenden
Handgepäck, während das große nach Zürich weitergereist ist.
Und ich freue mich ... Freue mich des einfachen Zimmers, das
man der einzelnen Dame ohne Koffer angewiesen hat, freue mich
meiner Selbständigkeit und meiner Einsamkeit. Ich möchte die
große, gierige Lebensfreude, die in mir rumort, hinausschreien, und
doch ist mir's gerade recht, daß kein Mensch da ist, in dem sie
wiederhallt.
Ich brauche niemand auf der Welt, wie mich niemand braucht.
Ich stelle mich ans Fenster, und der Glärnisch mit dem
Mondgeriesel über seiner machtvollen nächtigen Schönheit gibt mir,
was ich in diesem Augenblick nötig habe – so an der geöffneten Tür
zu Leben und Welt....

Nach traumlos durchschlafener Nacht ein halbes Erwachen voller

Beklemmung und Bangen. Vergebliches Suchen nach der heißen
Milch ... Die Hand greift nach dem Fieberthermometer ... Schwester
Marie ist nicht da ...
Ach, und dann die Seligkeit! ... Das ist ja alles vorbei für immer
oder – seien wir vernünftig – für lange Zeit ...
Ich habe gefrühstückt, einen Wagen bestellt, um ins Klöntal zu
fahren, und warte nur noch auf meinen grünen Schirm, dessen Stock
mir der Portier gestern zerbrochen hat, und den ich heute repariert
zurückerhalten soll.
Die Sonne liegt schon mit voller Glut auf den Bergen und in den
breiten, nüchternen Straßen der Stadt. Die Stimmung von gestern
abend ist's nicht, aber dafür zittert eine satte Sommerfreude in der
klaren Luft. Wär' ich nur schon draußen! ... Nein, so gut ist mir's
nicht geworden.
Eine Depesche. Da liegt sie neben mir auf dem Tisch und mahnt:
hinter den Bergen wohnen Leute, die sich wie ein Keil in das
drängen, was sich eben in mir zusammenfügen will aus dem
Durcheinander, das Krankheit und Einsamkeit in mir geschaffen
haben ... Natürlich Mama – natürlich sehr lang – das spart einen
versprochenen Brief, der nicht geschrieben wird, was der Ärmsten
dann doch wieder ein paar schlaflose Nächte macht....
»Warum Glarus? Bitte jetzt jedenfalls dortbleiben. Kommerzienrat
Hillmann, Jugendfreund deines Vaters, mit Sohn wollten dich Zürich
aufsuchen, kommen nun Glarus. Bitte herzlich aufnehmen. Näheres
brieflich. Soll ich Edina schicken? Treue Grüße. Mama.«
Unglaublich ..., unerhört ... Hätte ich doch auf den Schirm nicht
gewartet – dann wäre ich jetzt unterwegs, erst übermorgen
zurückgekommen, und die eiligen Herren, die die Familie mir auf den
Hals schickt, hätten das Nachsehen gehabt. Was können sie denn
von mir wollen? Ich habe zwar eine Verbindung mit »Hillmann«,
aber nur eine in Geldsachen, und ich weiß im Augenblick nicht
einmal, welcher Art.
Was hindert mich übrigens auch jetzt noch, einfach meiner Wege
zu gehen?
Mamas Bitte?
Nein ... Mama ist eine liebe, fremde Frau, die sich bereitwillig
unter das Joch des »Ministerialdirektors« geduckt hat und nur
manchmal aus ihrem behaglichen Nest nach ihrer verlassenen
Ältesten angstvoll hinüberstarrt ... Ach ..., ich klage sie nicht an. Ich
klage niemand an, aber ich habe sie mir alle abgewöhnt – jeden
einzeln und die ganze Familie zusammen.
Eine dunkle Erinnerung aus einem anderen Leben rührt hier und
da an mein Herz.
 In einem schönen Lande am blauen Meer, an dem Palmen stehen
– die Riviera – San Remo, wo mein armer Vater an der Schwindsucht
gestorben ist und auch begraben – war ich ein geliebtes und
vergöttertes Kind. Unzertrennlich von meiner traurigen Mutter, die
vor Sehnsucht und Gram um den Heimgegangenen fast verging.
Mein kleines Bett stand neben dem ihren, ich kletterte zu ihr, wenn
ich sie weinen hörte, kuschelte mich an sie, und dann schliefen wir
zusammen ein. Sie war sehr schön und gut, meine Mama – und
liebte mich sehr. Vielleicht ist das Übermaß an Liebe, das sie damals
auf mich geschüttet hat, das gewesen, was sich sonst auf ein ganzes
Leben verteilt.
Als ich sieben Jahre alt war, lernten wir den Ministerialdirektor
kennen, der aber damals noch Regierungsrat war. Ich begreife es
ganz gut, daß der energische, herrische Mann mit seiner
schnurgeraden, unanfechtbaren Korrektheit und meine weiche,
hochgestimmte und haltbedürftige Mutter sich so gut
zusammengefunden haben. Auch mein kleines Herz jubelte ihm
damals entgegen, denn Mama wurde zusehends heiter und glücklich
im Verkehr mit ihm, und ich selbst war sein großer Verzug ... Blieb
es auch eine kurze Zeit – in der neuen Häuslichkeit in Berlin sogar
noch, – bis der Alltag und eine große Geselligkeit mich allmählich
von ihm und auch von der Mutter abzudrängen begannen ... Zu
meinem maßlosen Erstaunen....
Edina erschien auf der Bildfläche. Mit ihrem Schweizer
Französisch, ihrer peinigenden Ordnungsliebe und der barbarischen
Strenge, wenn ich allein mit ihr war, doch – um gerecht zu sein –
auch mit einem im Grunde liebevollen Herzen und dem heißen
Wunsch, die ratlose kleine Entthronte zu entschädigen. Mama wurde
sogar ein ganz klein wenig eifersüchtig und wollte sie fortschicken.
Die gute Mama! Heute ist Edina ihr im Hause alles, und daß sie sie
mir herschicken will, ein Opfer, das die ganze Wirtschaft aus dem
Gleichgewicht brächte, wenn ich es annähme. Aber das tue ich nicht.
Ich brauche Edina nicht mehr, wenn ich mich auch damals an die
zankende kleine Französin klammerte. Damals, als sich das Herz
meiner Mutter langsam von mir abwendete, weil die Vergangenheit
versank – versinken sollte, und ich mit dem Gesicht eines, der auch
nicht mehr da sein durfte, als Mahner daran dastand.
Das ist ja wohl ganz einfach und nur menschlich, aber die junge,
heiße Kinderseele konnte sich in diesem wirren Rätsel nicht
zurechtfinden und wußte nicht wohin mit aller unerwünschten
Liebesfähigkeit. Dann kamen die kleinen Geschwister, und die habe
ich mit einer Seligkeit in mein banges Herz geschlossen, die ich
zuweilen heute noch nachempfinden kann. Und eine kurze Zeit
frohen Kinderglücks ist mir ja dann auch noch beschieden gewesen
unter den süßen, strampelnden Geschöpfchen, die die Arme nach
Liddy ausstreckten und sich heiser nach ihr schrien.
Und – da ich einmal diese alten Erinnerungen zurückrufe – mein
Stiefvater fing in dieser Zeit an, sich mehr als je mit mir zu
beschäftigen. Wohl seiner im Grunde gerechten Natur folgend – um
dann mit gutem Gewissen seine eigenen zwei mit der ganzen echten
Liebe zu überschütten – die er für mich natürlich nicht empfinden
konnte. Und noch einmal ist mein Herz für ihn aufgeglüht mit
unbeschreiblicher Anbetung. Ich habe wahrhaftig den bon Dieu, zu
dem ich abends meine prières sagen mußte, abgeschafft und den
heißgeliebten Papa an seine Stelle gesetzt.
Gott, Gott, was kann solch ein kleiner Mensch lieben und leiden,
und wie gut ist es, daß ich das alles in so jungen Jahren habe
abstreifen müssen! Wie hätte ich wohl mein hartes Schicksal, wie
dieses schwerste des letzten Jahres, tragen können, wenn Liebes-
und Leidensfähigkeit mit dem Alter noch gewachsen wären! ...
Als die erste Lungenentzündung kam, ist wohl das bißchen bleiche
Sonne aus meinem Kinderleben ganz verschwunden. Natürlich bin
ich sorgsam gepflegt worden, aber als ich genesen war, fiel mir das
blasse Entsetzen, von dem meine arme Mutter bei meinem leisesten
Hüsteln oder dem leichtesten Unwohlsein geschüttelt wurde, doch
als etwas Ungewöhnliches auf.
 Bei dem nächsten Katarrh, wie ihn Annie und Mia auch eben
durchgemacht hatten, wurde mein Bett aus dem Kinderzimmer
geschafft und meine Arbeitsstunden so gelegt, daß sie in die Zeit
fielen, in der die Kleinen wach waren und sonst mit mir gespielt
hatten. Ich durfte sie auch nicht mehr herzen und küssen wie früher,
und es schien mir, daß man mir aus dem Wege ging, wo ich mich
zeigte.
Natürlich war das eine übertriebene Ängstlichkeit und wohl auch
noch Sorge um mich dabei, aber das konnte ich nicht begreifen, und
eine furchtbare Verdüsterung kroch in mich hinein. Sie wuchs zu
einer grenzenlosen Verzweiflung an, die mich heute noch in der
Erinnerung erbeben läßt, als eines Tages mein Stiefvater mich
unsanft beiseite stieß, wie ich, das Verbot vergessend, die kleine Mia
in die Arme nahm und sie lachend und tollend abküßte.
Ach, dieser Blick, dieser eisige, böse Blick, der sich in mein Herz
bohrte, den ich nie, nie vergessen werde, wenn mein Stiefvater und
ich auch auf dem angenehmsten Verkehrsfuße stehen!
Ich glaube, jenes kleine Ereignis ist die Veranlassung gewesen,
daß man mich fortbrachte.
In ein Pensionat für lungenleidende Kinder. Nach Davos – mit
einer jungen, sanften, freundlichen Erzieherin. Man erwies dem
armen Ding damit zugleich eine Wohltat, denn sie war eine schwer
Leidende, und sie ist auch die erste geworden, deren Namen mit
einem schwarzen Kreuz in meinem Fremdenbuch den langen Zug
des Todes eröffnet hat, der von da an mein Leben geleitet.
Eine Heimat habe ich seitdem nicht mehr gehabt. Bis zur
Konfirmation das Pensionat mit seinen leidenden Insassen, meist
Waisen oder Halbwaisen wie ich. Daß man mich durch die
Übersiedelung aus dem Hause nach einem verseuchten Orte, – mich
und manche andere vermutlich in bester Absicht – erst aus der Welt
des Blühens in die des Vergehens gestoßen hat, ist mir übrigens
feste Überzeugung geworden. Ich habe mich wenigstens ohne die
Anzeichen der furchtbaren Krankheit, die ich ererbt haben sollte,
gehalten, bis ich vierzehn oder fünfzehn Jahre alt war. Die ersten
Fieberanfälle bei den rasch aufeinander folgenden Katarrhen waren
ein Geschenk für die erwachende Jungfrau.
Und damit hat das Wandern von Sanatorium zu Sanatorium und
jenen Hotels, in denen man Lungenkranke aufnimmt, begonnen –
unterbrochen durch einen kurzen Aufenthalt in der jeweiligen
Sommerfrische der Eltern, in Begleitung der eben lebenden
Erzieherin oder später Gesellschafterin, unter sorgfältiger
Beobachtung aller nur denkbaren Desinfektionsveranstaltungen,
unterbrochen durch einen mehrtägigen Besuch der Mutter, zuweilen
auch des Vaters, in meinem Winterasyl.
Ich kenne sie alle – Andreasberg, Badenweiler, Wehrawald –
Ospedaletti, Mentone, Nervi, San Remo – Davos und wieder Davos.
– Im Grunde, wenn das Fieber schlief, ein sorgloses Leben voll
äußeren Behagens. Ich bin nur in den teuersten und vornehmsten
Anstalten und Hotels gewesen, dank dem Reichtum von meinem
verstorbenen Vater her. Um mich herum ein buntes, internationales
Treiben, eine verzärtelte Kultur, viel unbeschützte Jugend neben den
lebenserfahrenen reiferen Leidensgenossen. Allen gemeinsam eine
gesteigerte Lebens- und Liebesgier und allen gemeinsam der Tod im
Nacken. Ich habe von allem gekostet, innerhalb der Grenzen, die ein
gewisses, wohl ererbtes Schicklichkeitsgefühl meinem Temperament
immer gezogen hat, und der Gesamtinhalt dieser Jugendjahre ist
überhitzter Flirt, überhitzte Fröhlichkeit, überhitzte Trauer und
Einsamkeit – Einsamkeit – Einsamkeit....
Mit einer kurzen Unterbrechung.
Ich taste jetzt manchmal mit scheuen Händen in dieser Erinnerung
herum, die mich noch vor einem Jahre bis dicht vor den Abgrund der
Selbstvernichtung riß.
Heute, in diesem Augenblick, ist es mir sogar beinahe Bedürfnis,
mir Walter Hertog hierher zu rufen, ihn vor mir zu sehen, wie ich ihn
in Arosa zuerst sah. Groß, schmalschulterig, damals noch sehr
aufrecht – ein Römerkopf mit brennenden Augen und einem Zug so
verbitterten Leidens um den schmallippigen Mund, daß mir jetzt
noch bange wird, wenn ich daran denke.
Wir haben uns sehr bald zusammengefunden.
Ich war der rechte Kamerad für einen, dessen schmerzvoller
Kampf gegen das Sterbensollen ein viel härterer war als der der
vergehenden Kreatur, den ich so oft mit angesehen hatte, denn bei
meinem neuen Freunde wurde er verschärft durch einen fressenden
Ehrgeiz, dem die Todeskrankheit plötzlich das Ziel entrissen hatte.
Hertog, obwohl auf dem Boden der bestehenden Staatsformen
stehend, hielt sich – wohl nicht mit Unrecht – für einen großen
sozialen Reformer. Er hatte eben als junger Assessor den ersten
Schritt getan, der ihn der Verwirklichung seiner Pläne zuführen
sollte, er war ins Ministerium berufen, und das Feld für seine offene
und heimliche Arbeitsgier lag frei vor ihm. Da hatte ihn die
Familienkrankheit, der er mit seinem eisernen Willen zu entwischen
hoffte, nach einer starken Influenza gepackt und niedergeworfen.
Zwei Jahre lang sind wir Weggenossen gewesen im Schwarzwald,
in den Schweizer Bergen und am Mittelländischen Meer.
Mein Gott – welch ein wildflackerndes Leben! – Und dabei
Liegestuhl an Liegestuhl!
Er hielt mich natürlich ganz und gar in seinem Bann. Er war ja so
weise wie niemand, den ich kannte. Er hatte den Dingen dieser Welt
auf den Grund geschaut. Er konnte das anscheinend Gute, mit dem
sie sich umkleideten, von ihnen reißen und ihr nacktes Skelett
offenbaren.
Alles war Moder – alles, was leuchtete, Verwesungserscheinung.
Der Tod beherrschte sein ganzes Denken, weil e r sich ihm verfallen
sah. Und mich mit ....
 Oft sprachen wir über das alles, bis sich das Fieber über uns warf.
Dann waren wir für Tage getrennt, und wenn wir uns wieder trafen,
fingen wir auch wieder an, das Leben zu zerteilen und zu verhöhnen.
Wir verspotteten jedes Gefühl, unser eigenes zuerst.
Denn natürlich – trotz allem – liebten wir uns.
An Frühlingsabenden, wenn in der Halle die Italiener »vorrei
morire« heruntertremolierten, dann kam es wohl, daß uns Jugend
und Rausch doch packten.
Wir liefen hinunter zu den Bambusbüschen oder zu den roten
Rosensträuchern, die eben aufblühen wollten, und lagen uns in den
Armen und küßten uns voller Leidenschaft.
An die Zukunft zu denken, hüteten wir uns. Wenn wir am Tage
über das süße Erlebnis der schwachen Stunde sprachen, fanden wir
großartige Worte, bald der Entsagung, bald des Hohnes.
Manchmal gingen wir in unseren Gesprächen auch bis auf das
Äußerste – die gänzliche Vereinigung in Rausch und Glut....
Einmal ganzes, volles Menschenglück ... einmal vor dem Tode....
Aber dann kam jedesmal eine große Abkühlung. Wir höhnten wohl
über die höhere Tochter und den Regierungsassessor – aber aus
ihnen herauskriechen konnten wir doch nicht....
Nach einer längeren Sommertrennung trafen wir uns in Davos
wieder.
Da fing es plötzlich an, ihm besser zu gehen. Ach wie hab' ich
jeden kleinen Fortschritt mit ihm erlebt und genossen! Wie hab' ich
für ihn gejubelt! Er selbst blieb lange Zeit ungläubig.
Bis eines Tages Dr. Herholz ihn zum Professor rief.
Da kam er denn glühend und mit leuchtenden Augen zu mir,
setzte sich an meinen Liegestuhl und sagte in staunender
Glückseligkeit nur immer vor sich hin: »Geheilt entlassen – geheilt
entlassen.«
Und dann hat er die Lehne meines Stuhls umklammert. Ich habe
mich aufgerichtet, seinen Kopf in meine Hände genommen, – und
habe ihn küssen wollen.... Und da – Aug' in Auge – sah ich in dem
seinen plötzlich etwas aufblitzen.... Bangigkeit – Furcht – Grauen....
Ein Blick, ähnlich wie jener, der meine Kindheit vergiftet hat,
damals, als ich mein Schwesterchen küssen wollte, und mein
Stiefvater mich zurückriß....
Er hat sich dann rasch losgemacht und allerlei gesprochen – von
der Ehrlichkeit, auf die unsere Freundschaft sich gründete – – er
hätte in der Tat eben ein wohl entschuldbares Gefühl von Furcht
gehabt – die Furcht des Genesenden vor dem Kranken – das wäre
etwas ganz Animalisches und hätte nichts mit unserem Seelenbund
zu tun ... ich solle das richtig und gütig auffassen ....
Nein und tausendmal nein. – Ich habe ihm äußerlich recht
gegeben und bin beherrscht und freundlich geblieben bis zum
Abschied. Aber nächtelang habe ich gewinselt wie ein geschlagener
Hund – und hab' ihn gehaßt und verwünscht und bin doch nicht von
ihm losgekommen, wie sehr ich auch nach einem Abschluß
gejammert habe....
Nun, der war ja bald da, ein ganz radikaler dazu....
Sechs Wochen später kam seine Todesnachricht.... Überarbeitung
– Lebensrausch – Erregungen – sagte man uns – alles vernichtende
Dinge für einen »geheilt Entlassenen«....
Gilt das nicht auch mir? Ahne ich nicht jetzt eben schon den
langsam aufstechenden Schmerz in den kranken Stellen? – Steigt
mir nicht eben schon der fade, flaue Geschmack des ausströmenden
Blutes in die Kehle? ... Nein, ich will nicht.... Ich habe mit dem Tode
jetzt nichts zu schaffen –, leben will ich – unter Lebenden will ich mir
meinen Platz suchen. Fort mit den Toten....
 Mamas Freunde sollen kommen – sie haben Fleisch und Blut und
werden die Schatten, unter denen ich hause, verscheuchen....
Ich werde keine einsame, mehrtägige Fahrt unternehmen, um
ihnen aus dem Wege zu gehen – ich will Stimmen hören, die nicht
aphonisch geworden sind, ich will mir von Dingen erzählen lassen,
die in der Welt des Lebens vorgehen.
Ich will auch den beiden Abgesandten der Familie zeigen, daß ich
zu den Gesunden gehöre.
Und darum hole ich mir jetzt Frische und Klarheit für meinen
etwas schwindelnden Kopf.... Mein Wagen steht vor der Tür – also
hinaus in die Sonne –, und um das neue Leben nicht mit einiger
Folgerichtigkeit zu beginnen –, an den schönen Bergsee, den sie
zwingen wollen, weitab von seiner heiligen Stille mit 45 000
Pferdekräften für sie zu arbeiten.

Also die Begegnung mit dem Kommerzienrat Hillman ist mir

geradezu ein Erlebnis geworden.
Meine Gedanken schwirren auf allen möglichen Lebensfeldern
umher und praktische, bange, kokette, glückverlangende
Erwägungen überstürzen sich in mir. Seit einer Stunde laufe ich in
dem kleinen hellen Salon, den ich mir habe geben lassen, hin und
her, unstet und ruhelos.
Nur wenn ich an dem blumenumrankten Eckspiegel haltmache,
schießt ein Gefühl von – ich kann nicht anders sagen – stolzem
Entzücken in mir auf. Ich habe eine hohe Freude an meiner
Schönheit. Sie ist, mit allem anderen, ein Erbteil meines Vaters. –
Und gerade jetzt, wo die Hoffnung neues Leben in mein Gesicht
gezaubert hat, dessen Züge ich so genau und so sachlich studiert
habe, – muß ich selbst staunen, welche Kraft und welchen Glanz
meine blauen Augen bekommen haben.
 Ich gleiche genau dem vielbewunderten letzten Bilde meines
armen Papa, dem das Schicksal die letzte Grausamkeit, den Verfall
durch die gräßliche Krankheit ersparte, indem es ihm einen
plötzlichen Tod bescherte.
Merkwürdig übrigens, daß Todesnähe und intensives
Lebensbewußtsein so gleiche Ausdrucksmittel haben können....
Vielleicht, weil beide die Blicke für noch Ungeschautes weiten?
Ach, ich fühle ja bei jedem Schritt, den ich im Verkehr mit der
lebendigen Welt mich vorwärts taste, daß Neues, Wunderbares auf
mich wartet, und ich muß für mich immer wieder auf das Bild
zurückkommen, daß ich an einer geöffneten Tür stehe, hinter der
viele Wege in das schöne, große, unbekannte Leben führen.
Welchen werde ich wählen unter den sonnen- und
mondglänzenden, den dämmerigen und den dunkeln? ...
Ob der Freund meines Vaters, der mich vorhin verlassen hat,
dieser weltkundige alte Mann mit den jungen, zärtlichen Augen
irgendwo als Wegweiser dastehen wird?
Es ist so merkwürdig, wie da plötzlich eine Brücke von dem alten
verschollenen Kinderland über die Gegenwart hinweg in die Zukunft
führt.
... Als der Kommerzienrat Hillmann pünktlich auf die Minute seiner
Anmeldung bei mir eintrat, hatte ich in demselben Augenblick ein
ganz deutliches Bild vor mir, dessen ich mir eigentlich nie klar
bewußt gewesen bin.
... Ein Balkon, von stark duftenden blauen Blumen überhangen,
ein Stückchen grauer Himmel, im Winde raschelnde Wedel einer
Dattelpalme, die hoch über das Haus ragt, – ein Liegestuhl mit
einem Kranken darin, der schwer atmet und hüstelt. Über ihn
gebeugt – dieser Mann, der eben eintrat, meine Hand festhielt und
mich anstarrte wie ich ihn.
 »Es ist geradezu wunderbar wie Sie ihm gleichen, liebes Kind,«
sagte er und nahm auch meine andere Hand.
Mir war's, als tauche hinter dem Forschen seiner herrschenden
dunklen Augen etwas wie Güte und Teilnahme auf, aber es rührte
mich nicht.
»Ich glaube Sie wiederzuerkennen, Herr Hillmann. Ich muß Sie an
der Riviera irgendwo, als kleines Kind gesehen haben,« sagte ich.
Wir setzten uns, und ein kleines Schweigen entstand....
»Sehr richtig, in San Remo,« sagte er dann, und das menschlich
Herzliche verschwand aus seinem Blick. Er war nun ganz der aufs
äußerste soignierte, gut erhaltene ältere Lebemann, ein Typ, den ich
– ach wie genau! – kenne, und mit dem ich immer gut fertig werde.
Diese Art Männer, die ihr Leben auf das Weib gestellt haben,
scheinen mir in der gewissen Abendbeleuchtung, die über ihrem
Wesen liegt, anziehend und rührend; sie sind dankbar für jedes
Lächeln, und nehmen jede Augenblicksstimmung als das, was sie ist,
ohne Versprechen für die Zukunft.... Und sie haben so viel von den
schauerlich-schönen Lebensgeheimnissen ergründet, die uns Junge
so mit Qual und Erwartung füllen – und sie lieben die Jugend mit
einer so schmerzlichen Liebe und wissen ohne Worte darüber zu
reden.
Ja, auch mein Gast und ich verständigten uns in diesem Sinne –
und ich will es gar nicht leugnen, daß mir bei seinen Blicken voll
sanfter und diskreter Bewunderung sehr wohl war.
Und dann gab er in liebenswürdiger und wohltuender Weise der
Freude Ausdruck, mich in so blühender Frische vor sich zu sehen.
Welche Überraschung das wohl für die Meinen sein würde, deren
noch ganz warme Grüße er mir übrigens zu bringen hätte – und die
schon jetzt ganz fassungslos wären vor Glück – meine Mutter
natürlich am meisten....
 »Sie zweifeln doch nicht daran, gnädiges Fräulein?« fragte er
vorwurfsvoll auf mein unwillkürliches Lächeln....
»Gott bewahre – aber – pardon, ich bin in Gedanken bei der
Depesche meiner Mutter, die mich etwas erregt und neugierig
gestimmt hat.« So ging ich nun aufs Ziel los.
»Ihre Frau Mutter hat Ihnen Andeutungen gemacht, um was es
sich handelt?«
»Nur über Ihre Jugendfreundschaft zu meinem Vater, und daß Sie
mich eigentlich in Zürich aufsuchen wollten.«
»Ja, aber merkwürdigerweise waren wir ohnedies auf dem Wege
nach Glarus. Ein großes technisches Unternehmen hier – interessiert
uns aus verschiedenen Gründen.«
»Wohl der See?« sagte ich in Gedanken....
»Ah – Sie wissen also doch, um was es sich zwischen uns
handelt?«
Ich war ganz betroffen. Nein, ich wußte gar nichts. War es ein
Zufall? – oder hatte irgendeine unbekannte Strömung mich mit sich
getragen? – Ich konnte mir zwischen den beiden Herren, dem
Klönthaler See und meiner armen Person nicht die mindeste
Beziehung denken.
Herr Hillmann warf mir wieder einen seiner weichen,
schmeichelnden Blicke zu und strich dann mit der feinen,
unberingten Hand über die Augen.
»Es ist keine leichte Sache,« sagte er, »mit einer geschäftlichen
Angelegenheit über Sie herzufallen. Der Geschäftsmann möchte
hinter dem Freund ganz und gar verschwinden.«
»Warum denn? Der Freund kann ja für den Geschäftsmann – wie
Sie sagen – sprechen.«
Welcome to Our Bookstore - The Ultimate Destination for Book Lovers
Are you passionate about books and eager to explore new worlds of
knowledge? At our website, we offer a vast collection of books that
cater to every interest and age group. From classic literature to
specialized publications, self-help books, and children’s stories, we
have it all! Each book is a gateway to new adventures, helping you
expand your knowledge and nourish your soul
Experience Convenient and Enjoyable Book Shopping Our website is more
than just an online bookstore—it’s a bridge connecting readers to the
timeless values of culture and wisdom. With a sleek and user-friendly
interface and a smart search system, you can find your favorite books
quickly and easily. Enjoy special promotions, fast home delivery, and
a seamless shopping experience that saves you time and enhances your
love for reading.
Let us accompany you on the journey of exploring knowledge and
personal growth!

ebookgate.com