Bjarne Stroustrup
Explanation
Bjarne Stroustrup created C++ at Bell Labs in 1985 by extending C with object-oriented features. Guido van Rossum is associated with Python, which was created later.
Near-assembly performance, manual memory control, and multiple programming paradigms
Explanation
C++ combines high performance close to assembly, manual memory control, and procedural, object-oriented, and generic programming. Automatic garbage collection is associated with languages such as Java rather than with C++'s core memory model.
Machine language is closest to hardware, while high-level languages are more abstract and human-readable.
Explanation
Machine language has the lowest abstraction and is closest to hardware, whereas high-level languages provide greater abstraction and readability. The other choices confuse abstraction with programming paradigms or application domains.
Object-oriented programming
Explanation
Object-oriented programming organizes code around objects that represent data and behavior. Procedural programming instead structures code primarily around procedures or routines.
Problem definition, algorithm design, coding, testing and debugging, documentation
Explanation
The cycle begins by defining the problem, then designs an algorithm, implements it through coding, tests and debugs the program, and documents the result. Coding follows the planning stages rather than preceding them.
To represent the planned solution with tools such as flowcharts and pseudocode
Explanation
Algorithm design specifies how to solve a problem and can use flowcharts and pseudocode before implementation. Identifying requirements belongs to problem definition, while translation and explanations occur in later development activities.
It translates source code, checks errors, optimizes it, and can produce an executable
Explanation
A compiler translates high-level C++ source code into machine-oriented code, checks errors, performs optimization, and may create an executable. A debugger instead executes code step by step to help inspect errors and behavior.
Preprocessing produces .i, compilation produces .s, assembly produces .o or .obj, and linking produces .exe
Explanation
C++ processing moves from the .cpp source through preprocessing to .i, compilation to .s, assembly to .o or .obj, and linking to an executable. The other sequences assign the file transformations to incorrect stages.
A linker combines object files and resolves references, while a loader places the executable in memory and starts it
Explanation
The linker combines object files, resolves external references, and creates an executable; the loader then places that executable in memory and starts it. Debugging, translation, variable storage, and preprocessing belong to other parts of development or execution.
A named memory location whose stored value can change during execution
Explanation
A variable is a named storage location in memory that holds a value capable of changing while the program runs. A constant represents a value not intended to change, while functions and keywords serve different purposes.
total_count2
Explanation
A valid C++ variable name may begin with a letter or underscore and may then contain letters, digits, and underscores, making total_count2 valid. The other choices begin with a digit, contain a space, or use a reserved keyword.
A local variable is declared inside a function or block, while a global variable is declared outside all functions
Explanation
A local variable is declared within a function or block, whereas a global variable is declared outside all functions. The distinction concerns declaration location and scope, not libraries, executables, or compilation stages.
Object-oriented programming combines data with methods in objects, while procedural programming separates data from functions
Explanation
Object-oriented programming binds data and methods together in objects, while procedural programming emphasizes functions with data separated from those functions. The other choices confuse programming paradigms with toolchain stages or reverse the central distinction.
Encapsulation, inheritance, polymorphism, and abstraction
Explanation
The four core OOP principles are encapsulation, inheritance, polymorphism, and abstraction. The other sets describe development processes or general programming elements rather than OOP principles.
It binds data and methods together while hiding internal implementation details
Explanation
Encapsulation organizes data with the methods that operate on it and hides internal implementation details from outside code. Creating class hierarchies describes inheritance, while executable creation and translation belong to the C++ toolchain.
A blueprint defining data and behavior
Explanation
A class encapsulates data members and member functions as a blueprint for objects, but it does not allocate memory for an individual object. The storage block describes an object, which is an instance created from the class.
It is an instance of a class that occupies memory
Explanation
An object is a class instance, so it occupies memory and can be manipulated through the class’s defined properties and behaviors. A type definition describes a class rather than representing a stored instance.
`pointer->value` and `object.value`
Explanation
The arrow operator accesses a member through a pointer, while the dot operator accesses a member through an object. The expression `pointer->value` is equivalent to `(*pointer).value`.
A matching `delete` to release its memory
Explanation
Heap objects created with `new` require a matching `delete` so their allocated memory is released and a memory leak is avoided. Stack objects follow automatic destruction when their scope ends.
The visibility of members from different program contexts
Explanation
An access specifier determines where class data members and member functions can be accessed. A data type instead describes the kind of value a member stores, not its visibility.
Inside its class, derived classes, and outside code
Explanation
Public members are available within the defining class, within derived classes, and from code outside the class. The restriction against outside access applies to private or protected members, not public ones.
Accessible in its class and derived classes, but not outside code
Explanation
Protected members can be used by the defining class and its derived classes, while external code cannot access them directly. Public members, unlike protected members, can be accessed from outside the class.
Private members are class-local; class defaults to private and struct to public
Explanation
Private members are accessible within their defining class, and C++ gives classes a default private access level while structs default to public. Derived classes and outside code therefore do not receive direct access to private members by default.
Memorize the answers with 48 flashcards on Introduction to C++ and OOP.
Who created C++ and when?
Bjarne Stroustrup created C++ in 1985.
Where was C++ created?
At Bell Labs.
What programming paradigms does C++ combine?
Object-oriented, generic, and procedural programming.
Read the complete study sheet on Introduction to C++ and OOP.
See study sheet →Import your course and AI generates quizzes with corrections in 30 seconds.
Quiz generator