C++ Exception Handling Quiz

Chapter 1: Preliminaries

• Programming languages are crucial for expressing ideas and solving complex problems.
• Studying programming languages improves ability to learn new languages, choose appropriate ones, understand implementation significance, and advance computing.
• Programming domains include expert systems (decision-making), natural language processing (interactions), and computer vision (understanding images).
• Other programming domains include internet, numerical mathematics, programming education, relational database querying, software prototyping, symbolic mathematics, systems design, text processing, theorem proving, video game programming, video processing, application scripting, array programming, artificial intelligence reasoning, cloud computing, computational statistics, contact management software, e-commerce, financial time-series analysis, general-purpose applications, and image processing.
• Key criteria for evaluating languages include readability (ease of understanding), writability (ease of creation), reliability (conformance to specs), and cost (total cost of use).
• Readability depends on simplicity of features, orthogonality (combining constructs), and control statements (well-known).
• Writability depends on simplicity, support for abstraction, and expressivity (convenient operations).
• Reliability depends on type checking, exception handling, and lack of aliasing (distinct references).
• Evaluation criteria (costs) include programmer training, program writing efficiency, compilation speed, execution speed, compiler availability, reliability impact on cost, and program maintenance.
• Other factors include portability (ease of moving programs) and generality (applicability to various tasks).
• Factors influencing language design include computer architecture (like von Neumann) and programming methodologies (shifting from process to data orientation, now object-oriented) that lead to changes in programming languages.
• The von Neumann architecture, where data and instructions reside in memory, and the CPU fetches both, forms a basis for imperative languages.
• Programming methodologies influence language design, impacting programming paradigms and extensions.
• Implementation methods involve compilation (translates to machine code), pure interpretation (interpreting code directly), hybrid implementation (compromise, including intermediate languages like Java bytecode), and just-in-time (initially translating to intermediate form then compiling).
• Preprocessors are used to expand macros and include code from other files, prior to compilation.
• A programming environment is the collection of tools used in software development and consists of several tools, such as IDEs.

Chapter 2: Describing Syntax and Semantics

• Syntax describes the form/structure of expressions, statements, and program units.
• Semantics describes the meaning of expressions, statements, and program units.
• Both syntax and semantics define a language formally.
• Language definition is needed for users, designers, and implementers.
• A sentence is a string of characters over a particular alphabet forming a language.
• A lexeme is the lowest level syntactic unit.
• A token is a category/group of lexemes.
• Grammars (recognizers and generators) are used to formally define languages.
• Context-Free Grammars were developed by Chomsky to describe the syntax of natural languages.
• Backus-Naur Form (BNF) is a metalanguage equivalent to context-free grammars and a common means of describing another language (syntax).
• BNF uses nonterminals (abstractions) and terminals (basic units like lexemes or tokens).
• Rules are combinations of terminals and nonterminals to describe how to compose the sentences.
• Derivations show how rules are applied to generate a sentence from a start symbol.
• A sentential form is any string in a derivation.
• A sentence/legal string terminates with only terminal symbols.
• Parse trees are hierarchical representations of derivations that demonstrate syntactic structure.
• An ambiguous grammar has more than one parse tree for a single sentence in the language.

Chapter 3: Data Types

• A data type is a collection of data objects and predefined operations.
• A descriptor is the collection of the attributes of a variable.
• An object is an instance of a data type.
• Basic design issues of data types include defining and specifying the operations that can be performed on the data type.
• Primitive data types are not defined in terms of other data types, they are basic.
• Examples of primitive data types include integer, floating-point, Boolean, character, complex, and decimal.

Chapter 4: Names, Bindings, Type Checking, and Scopes

• Imperative languages are abstractions of von Neumann architecture.
• Variables are memory cells with attributes: name, address, value, type, lifetime, and scope.
• Names are strings of characters used to identify entities and typically consist of letters, digits, and underscores.
• Design issues for names include whether they are case sensitive, length limits, and the use of special words (keywords/reserved words).
• Variable categories by lifetime include static (bound before execution, throughout), stack-dynamic (bound when declared), explicit heap-dynamic(allocated and deallocated explicitly), and implicit heap-dynamic (allocations and deallocations implied by assignments).
• Scope is the range of statements where a name is visible in a program (its binding).
• Static scope means names are resolved by their textual position.
• Blocks define static scopes.
• Dynamic scope references names from calling sequences rather than textual position.
• Referencing environments are the collection of all names visible in a statement depending on type of scope.

Chapter 5: Statement-Level Control Structures

• Control structures determine the order of statement execution.
• Selection statements control the choice between two or more execution paths, e.g. (if-then-else), (multiple-way if-elseif-else), (switch).
• Iterative statements allow the repeated execution of a statement or block of statements. Different kinds of iterators exist like (while), (for).
• Unconditional Branching uses statements such as (goto) to transfer control to a different part of the program, typically considered less readable, but some languages support it, as in, switch.
• Guarded commands can be a way to evaluate multiple conditions without forcing an ordering.

Chapter 6: Subprograms

• Subprograms are collections of statements that define parameterized computations, facilitating code reuse.
• Subprograms have a single entry point and execution returns to the calling program when the subprogram finishes.
• Parameters (both formal and actual) are used to pass data into and out of subprograms.
• Parameter passing modes (in, out, inout) may define how parameters are handled by the subprogram.
• Subprogram types, e.g., procedure (computations return no value) and function (computations return a value).

Chapter 6: Expressions and Assignment Statements

• Expressions are the fundamental way to specify computations, consisting of operators, operands, parentheses, and function calls.
• Important design issues for arithmetic expressions include operator precedence rules, operator associativity rules, order of operand evaluation, (possible) side effects, and mixed-mode expressions.
• Assignments are fundamental to imperative languages, and involve assigning a value to a variable. Different kinds of assignment statements exist including conditional and compound assignment operators.

Chapter 14: Exception Handling and Event Handling

• Exception handling is a mechanism to deal with unusual/unforeseen events or errors.
• In languages without exception handling, an error halts program execution.
• With exception handling, exceptional events are caught, handled, and the program execution resumes.
• Design issues for exception handling include how handlers are specified, how exceptions are bound to handlers, what happens after handler has executed, and how user defined exceptions are specified.
• Exception propagation refers to how exceptions are handled when an exception occurs in one part of the code and propagation continues to the next level in the call stack.
• Different types of exceptions are defined according to languages and need for specific handling, e.g., checked exceptions vs unchecked exceptions.
• Exception handling in Java is different than C++ but has some common concepts.
• Event handling mechanisms are different from exception handling mechanisms, designed to handle external events (like user interaction).
• Event handling is useful in GUI programming and user interface design.

Test your knowledge on C++ exception handling and related concepts. This quiz covers evaluation criteria, type checking, operator overloading, and the specifics of exception handling in C++. Challenge yourself and see how well you understand the complexities of programming languages!