2019 Solutions T/F Flashcards
C++ was developed by Ken Thompson and Dennis Ritchie
F
The C standard library is included in the standard C++ library
T
C++11 was the first standard released by the ISO group for the C++ language
F
A C++ program can contain a compile well-written code.
T
C++ programs are first compiled to intermediate “o-code” files.
T
Hubert likes little boy wieners
T
Atomic types like int cant be initialized using () as objects are
F
o-code files need to be processed to executables before being sent to the OS for execution
T
Dividing a non-zero double type value by zero causes a run-time error
F
The var keyword uses type inference to type variables in C++
F
The GCC compiler is hte only c++ compiler that adheres to the ISO standards
F
The long double type uses extended precision in C++
T
It is not legal to have a pointer to an atomic type variable, like an int
F
C++ style casts are templated
T
The operator -> combines dereferencing and membership when used with a pointer
T
A reference cannot be assigned to a nullptr
T
The memory consumed by a reference depends on where you are using a 32-bit or a 64-bit compiler
F
By using pointer arithmetic it is possible to read memory locations that have not been assigned to variables
T
The operateor & acts to dereference a pointer
F
A struct can only contain members that are all of the same type
F
The STL string class is immutatable
F
A C++ array will not allow you to supply index values that are out of range of the array
F
A vector collection from the stl cannot use [] to access members
F
The operator | is the same as || except that it doesnto ues short circuit evalaution
F
Only one class can be implemented at a time in a *.cpp file
F
The string member .at() will throw an exception of an attempt is made to access a character beyond the size of the string
T
In a boolean expression a non zero integer will be consider as false
F
The assignment operator returns the value being assigned
T
The goto statement is legal syntax in C++
T
Constructors should always be declared as const
F
A pointer that has been assigned to nullptr will be evaluated as being true
F
The vector member function .at() can be used on the LHS of an assignment statement
T
A default constructor is invoked with a set of empty brackers ()
F
Ambiguities can result from using the “using” keyword for too many namespaces
T
Programs that have implementation code in the header or *.h file will not compile
F
If const is used at the ned of a member function declaration then that function cannot chang ethe values contained in the attributes of its own class.
T
The #pragma once pre compiler directive can be used to prevent the redeclaration of a header files contents
T
Passing by constant reference is usually the best way to pass an argument into a function
T
The initialization section in a constructors implementation can be used to carry out error checking on the arguments supplied to the constructor
F
It is bad practice to return a reference to a variable that is local to the function returning it
T
Only exceptions that extend std::Exception can be thrown
F
The *.cpp file containing the implementation of the declarations contained in a header, or *.h file must have an #include statement for that header file
T
If a single namespace is used with the “using” keyword then the scope resolution operator will not be needed t identify names from that namespace
T
Variables cannot be declared outside a function or class
F
Local variables cannot be declared as static
F
Default arguments must be assigned in a function prototype or declaration only
T
C++ does not allow the definition of lambda functions
F
Inline functions must be implemented in the header file
T
You cannoty change the precedence of an operator by overloading it
T
Assignment operators must be overloaded as non member functions
F
Conversion constructors can allow mixed type excpressions to work with overloaded binary operators
T
Non member friend functions are able to invoke accessors on arguments of the class type they are friends to in order to obtain their attribute vaoues
T
To differentaite between pre and post incremenet operator overloadings the post incremembt version must have an unused int type parameter
T
An overloaded pre icrement function will run faster than the equivalent overloaded post increment version
T
Codnig both a conversion constructor and an overloaded conversion opreator for the same type can lead to an ambiguity
T
Member functions declared as explicit cannot be automaticalyl invoked to hepl evaluated mixed type expression
T
Function objects can be created by overloading the [] brackets
F
The amount of memory used by your program on the heap or free store is fixed at compilation time
F
The new operator provides a ptr to a structure stored on the heap
T
Porgram instructions are stored on the heap
F
A function cdan return a stable pointer to a local variable provided that variable is stored on the heap
T
New or new[] will return a nullptr if memory on the heap cannot be allocated
F
The delete operator can also be used to delete an array allocated on th eheap
F
A memory leak is ar esult of not properly deleting a heap allocated structure
T
Memory leaks tend to manifest more often for long running programs
T
The delete operator will automatically set a pointer to nullptr after deletion
F
Deleting an unitialized pointer will not cause a problem because this pointer will automatically be a null ptr after deletion
F
Passing a child class instance by value into a function using a parent type parameter will result in object slicing
T
A dynamic_cast<type> throws an exception if a pointer cannot be cast to the specified type</type>
T
Copy constructors and overloaded assignment operator implementations are also responsible for preventing the aliasing of object contents
T
The use of private as a base class access modifier will not change the access of members inherited from the base class
F
C+= does not allow for multiple inheritance
F
You can overload an inherited function by using the same function name and a different parameter list in the child class
F
Polymorphism must be enabled by declaring the parent class version of the function of interest to be virtual
T
Static binding is determined by the pointer type at compilation
T
Pure virtual function declarations must be implemented by the class that declares them
F
Use of the heap in any class in a hierarchy requires a virtual destructor be declared in the base class of that hreiarchy
T
In a hierarchy that uses the heap, a child class copy constructor needs to invoke the parent class copy constructor
T
A virtual function that overrides a parent class version of itself can also change the default arguments used by the parent class version F
F
Template declarations are able to restrict possible types supplied to the template in code
F
Templated functions are type dand built with that type during compilation in order to minimize execution times
T
Templates can only be written to accept a single type
F
Smart pointers implement “nearly complete” automatic garbage collection.
t
It is possible to have many unique_ptr<> pointers pointing to the same object on the heap.
f
The operators, * and ->, can still be used with smart pointers from the STL.
t
The function make_unique<>() does not require the use of the new operator to put the
object being pointed to on the heap.
t
You still have to invoke the delete operator to start the destruction process of a smart
pointer.
f
The “CLI” in C++/CLI stands for “Common Language Interpreter”.
f
A CIL file created by the CLR in C++/CLI is not only too many acronyms, but is also written
as executable binary code in a *.exe file.
f
Managed code in C++/CL Irequires the use of handles and gcnew instead of pointers and
new.
t
An agile team expects to be coding, designing and testing all at the same time.
t
Any programming language used in .NET must follow the CLS rules which includes the
mandated use of shared object types for what ISO C++ considers atomic types.t
t
Functional requirements must describe “how well” a feature must be implemented by the
system.
f
System architecture details are described in the RAD.
f
A git repository only stores the newest version of any file. Older versions are deleted.f
f
Any use of a git repository requires an internet connection.f
f
The SDD cannot change once it has been written.f
f
It is good practice to provide a comment for every git commit to provide the reason for the
commit.
t
The creation of a branch in a git repository allows you to choose a subset of the available
files to work on.
t
A git repository relies on the use of a centralized server to store all files.
f
____ A UML Statechart diagram is used to display the possible states of an object used for
polymorphism.
f
A UML Sequence diagram is used to display the dynamic interactions of objects along a
timeline.
t
A Sequence diagram must be initiated by an actor (typically a “human”).
t
A UML Class diagram presents a static view of classes in a system, their members and the
inheritance structure.t
t
Design goals are extracted from Non-Functional requirements.
t
fThe goal of a good code structure design is to have strong coupling between systems and
weak cohesion within each system.
f
If issue progress is not tracked using changing time estimates then the burndown chart
shown by Jira will be meaningless.
t
User stories are always translated into Jira as a single issue.
f
Task type issues that are not completed in a sprint are deleted and then re-created for the
next sprint.
f
In order for an issue to be created it must be assigned to a sprint.
f
Issue priorities must be assigned once activity is underway for that issue.
f
Gantt charts are used by Jira for sprint planning purposes.
f
A sprint should always result in a demonstrable deliverable.
t
A SCRUM meeting is the same as what students call a “Codeathon”.
f
It is possible to create a link from an issue in Jira to a file in Bitbucket.
t
Branches in Bitbucket should be merged back to the master when a sprint is completed.
t
It is common practice for a team to have more than one sprint underway at the same time.
f
Many of our teams faced the problem of excessive merge conflicts in their repositories as
a result of too many people working on the same files at the same time.
All of our teams planned, carried out and recorded the results of thorough integration
testing on their product before their presentations.
F
Most teams that split up into sub-teams (back-end and GUI, for example) faced integration
issues right before their presentations usually due to poor communications between the
sub-teams.
T
None of our teams had any difficulty using their git repositories.
F
