yikes Flashcards
Who made c++
Bjarne Stroustrup
C++11 was the first standard released by the ISO group for the C++ language.
The first ISO standard for the C++ programming language was C++98, released in 1998.
The C standard library is included in the standard C++ library.
T
A C++ program can contain and compile well-written C code.
T
C++ programs are first compiled to intermediate “O-code” files.
T
The GCC compiler (ported to MinGW) is the only C++ compiler that adheres to the ISO
standards.
F
Atomic types (like int) cannot be initialized using ( ) as objects are.
F
The long double type uses extended precision in C++.
T
The var keyword uses type inference to type variables in C++.
F
Dividing a non-zero double type value by zero causes a run-time error.
F
C++ style casts are templated.
T
The memory consumed by a reference depends on whether you are using a 32-bit or a 64-
bit compiler.
F
A reference cannot be assigned to nullptr.
T
It is not legal to have a pointer to an atomic type variable, like an int.
F
The operator, &, acts to de-reference a pointer.
F
The operator, ->, combines de-referencing and membership when used with a pointer.
T
By using pointer arithmetic it is possible to read memory locations that have not been
assigned to variables.
T
A C++ array will not allow you to supply index values that are out of range of the array.
F
A struct can only contain members that are all of the same type.
F
The operator, |, is the same as ||, except that it does not use short-circuit evaluation.
F
The assignment operator, =, returns the value being assigned.
T
In a Boolean expression a non-zero integer will be considered as false.
F
A pointer that has been assigned to nullptr will be evaluated as being true.
F
The goto statement is legal syntax in C++.
T
A vector collection from the STL cannot use [ ] to access members.
F
The vector member function, .at(), can be used on the LHS of an assignment statement.
T
The string member function, .at(), will throw an exception of an attempt is made to access
a character beyond the size of the string.
T
The STL string class is immutable.
F
Programs that have implementation code in the header, or *.h, file will not compile.
F
If const is used at the end of a member function declaration then that function cannot
change the values contained in the attributes of its own class.
T
The #pragma once pre-compiler directive can be used to prevent the re-declaration of a
header file’s contents.
T
Only one class can be implemented at a time in a *.cpp file.
F
Only exceptions that extend std::Exception can be thrown.
F
Constructors should always be declared as const.
F
Passing by constant reference is usually the best way to pass an argument into a function.
T
The initialization section in a constructor’s implementation can be used to carry out error
checking on the arguments supplied to the constructor.
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 to identify names from that namespace.
T
Ambiguities can result from using the “using” keyword for too many namespaces.
T
A default constructor is invoked with a set of empty brackets, ( ).
F
Variables cannot be declared outside a function or class.
F
It is bad practice to return a reference to a variable that is local to the function returning it.
T
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 cannot 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 expressions to work with overloaded binary
operators.
T
Conversion constructors can allow mixed type expressions 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 values.
T
To differentiate between pre- and post-increment operator overloadings, the post-
increment version must have an un-used int type parameter.
T
An overloaded pre-increment function will run faster than the equivalent overloaded post-
increment version.
T
Coding both a conversion constructor and an overloaded conversion operator for the same
type can lead to an ambiguity.
T
Member functions declared as “explicit” cannot be automatically invoked to help evaluate
mixed type expressions.
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
Program instructions are stored on the heap.
F
The new operator provides a pointer to a structure stored on the heap.
T
A function can 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 heap memory cannot be allocated.
F
The delete operator can also be used to delete an array allocated on the heap.
F
A “memory leak” is a result 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 uninitialized pointer will not cause a problem because this pointer will automatically be nullptr after declaration.
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
Polymorphism must be enabled by declaring the parent class version of the function of
interest to be virtual.
T
You can overload an inherited function by using the same function name and a different
parameter list in the child class.
F
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 hierarchy.
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
Template declarations are able to restrict possible types supplied to the template in code.
F
Templated functions are typed and 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
The “CLI” in C++/CLI stands for “Common Language Interpreter”.
Common language infrastructure
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
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 - DLL file
Managed code in C++/CLI requires the use of handles and gcnew instead of pointers and
new.
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
An agile team expects to be coding, designing and testing all at the same time.
T
System architecture details are described in the RAD.
F
Functional requirements must describe “how well” a feature must be implemented by the
system.
F
A git repository only stores the newest version of any file. Older versions are deleted.
F
Any use of a git repository requires an internet connection.
F
The SDD cannot change once it has been written.
F
It is good practice to provide a comment for every git commit to provide the reason for the
commit.
T
A git repository relies on the use of a centralized server to store all files.
F
The creation of a branch in a git repository allows you to choose a subset of the available
files to work on.
T
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
Design goals are extracted from Non-Functional requirements.
T
The 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.
T
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
